text
stringlengths 15
267k
|
|---|
# -*- coding: utf-8 -*-
import unreal
import Utilities.Utils
def print_refs(packagePath):
print("-" * 70)
results, parentsIndex = unreal.PythonBPLib.get_all_refs(packagePath, True)
print ("resultsCount: {}".format(len(results)))
assert len(results) == len(parentsIndex), "results count not equal parentIndex count"
print("{} Referencers Count: {}".format(packagePath, len(results)))
def _print_self_and_children(results, parentsIndex, index, gen):
if parentsIndex[index] < -1:
return
print ("{}{}".format("\t" * (gen +1), results[index]))
parentsIndex[index] = -2
for j in range(index + 1, len(parentsIndex), 1):
if parentsIndex[j] == index:
_print_self_and_children(results, parentsIndex, j, gen + 1)
for i in range(len(results)):
if parentsIndex[i] >= -1:
_print_self_and_children(results, parentsIndex, i, 0)
def print_deps(packagePath):
print("-" * 70)
results, parentsIndex = unreal.PythonBPLib.get_all_deps(packagePath, True)
print ("resultsCount: {}".format(len(results)))
assert len(results) == len(parentsIndex), "results count not equal parentIndex count"
print("{} Dependencies Count: {}".format(packagePath, len(results)))
def _print_self_and_children(results, parentsIndex, index, gen):
if parentsIndex[index] < -1:
return
print ("{}{}".format("\t" * (gen +1), results[index]))
parentsIndex[index] = -2
for j in range(index + 1, len(parentsIndex), 1):
if parentsIndex[j] == index:
_print_self_and_children(results, parentsIndex, j, gen + 1)
for i in range(len(results)):
if parentsIndex[i] >= -1:
_print_self_and_children(results, parentsIndex, i, 0)
def print_related(packagePath):
print_deps(packagePath)
print_refs(packagePath)
def print_selected_assets_refs():
assets = Utilities.Utils.get_selected_assets()
for asset in assets:
print_refs(asset.get_outermost().get_path_name())
def print_selected_assets_deps():
assets = Utilities.Utils.get_selected_assets()
for asset in assets:
print_deps(asset.get_outermost().get_path_name())
def print_selected_assets_related():
assets = Utilities.Utils.get_selected_assets()
for asset in assets:
print_related(asset.get_outermost().get_path_name())
def print_who_used_custom_depth():
world = unreal.EditorLevelLibrary.get_editor_world()
allActors = unreal.GameplayStatics.get_all_actors_of_class(world, unreal.Actor)
print(len(allActors))
errorCount = 0
for actor in allActors:
comps = actor.get_components_by_class(unreal.PrimitiveComponent)
for comp in comps:
if comp.render_custom_depth:
errorCount += 1
# v = comp.get_editor_property("custom_depth_stencil_value")
# m = comp.get_editor_property("custom_depth_stencil_write_mask")
print("actor: {} comp: {} enabled Custom depth ".format(actor.get_name(), comp.get_name()))
# errorCount += 1
print("Custom Depth comps: {}".format(errorCount))
|
# -*- coding: utf-8 -*-
"""
选中材质执行
TODO: 原生 Python 不支持
"""
# Import future modules
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
__author__ = "timmyliang"
__email__ = "[email protected]"
__date__ = "2022-01-20 10:02:33"
# Import local modules
import unreal
from unreal import MaterialEditingLibrary as mat_lib
MP_OPACITY = unreal.MaterialProperty.MP_OPACITY
BLEND_TRANSLUCENT = unreal.BlendMode.BLEND_TRANSLUCENT
# for material in unreal.EditorUtilityLibrary.get_selected_assets():
# if not isinstance(material,unreal.Material):
# continue
# blend_mode = material.get_editor_property("blend_mode")
# if blend_mode != BLEND_TRANSLUCENT:
# continue
# # NOTE 这个是 第二个贴图节点
# material_path = material.get_full_name().split(' ')[-1]
# path = "%s:MaterialExpressionTextureSample_1" % material_path
# texture = unreal.load_object(None,path)
# if not texture:
# print("texture None : %s" % material_path)
# continue
# mat_lib.connect_material_property(texture, "A", MP_OPACITY)
# unreal.MaterialEditingLibrary.recompile_material(material)
def main():
vector_getter = mat_lib.get_material_instance_vector_parameter_value
vector_setter = mat_lib.set_material_instance_vector_parameter_value
# NOTES(timmyliang): 获取选中的资产
assets = unreal.EditorUtilityLibrary.get_selected_assets()
function_path = ""
material_function = unreal.load_asset(function_path)
for material in assets:
if not isinstance(material, unreal.Material):
continue
# num = mat_lib.get_num_material_expressions(material)
names = mat_lib.get_vector_parameter_names(material)
material_path = material.get_path_name()
for index, name in enumerate(names):
path = "{0}:MaterialExpressionVectorParameter_{1}".format(
material_path, index
)
vector_node = unreal.load_object(None, path)
function_node = mat_lib.create_material_expression(
material, unreal.MaterialExpressionMaterialFunctionCall
)
function_node.set_material_function(material_function)
# TODO protected attribute | cannot get node pos
vector_node.get_editor_property("MaterialExpressionEditorX")
# print(vector_node.get_editor_property("parameter_name"))
mat_lib.recompile_material(material)
mat_lib.layout_material_expressions(material)
if __name__ == "__main__":
main()
|
# Copyright Epic Games, Inc. All Rights Reserved.
"""
This script loads a capture data source of type footage, creates an identity with a passed command line argument frame number
As promoted frame. Initializes contour data from the config and runs the tracking pipeline for that frame.
The data is then used to conform the template mesh. The back-end AutoRig service is invoked to retrieve a DNA, which is applied
To the skeletal mesh. At which point the identity is prepared for performance.
The user must be connected to AutoRig service prior to running this script.
In addition, a frame number for a neutral pose must be supplied as an argument to the script
Specified names and paths are for illustratory purpose only, and script should be modified accordingly
"""
import unreal
import argparse
import sys
import time
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
# Following hard-coded paths are used for demonstration purpose when running this script directly
test_identity_asset_name = 'KU_Test_Identity'
def prepare_identity_for_performance(identity_asset : unreal.MetaHumanIdentity):
face: unreal.MetaHumanIdentityFace = identity_asset.get_or_create_part_of_class(unreal.MetaHumanIdentityFace)
face.run_predictive_solver_training()
print("Created Identity could now be used to process performance")
def process_autorig_service_response(dna_applied_success : bool):
global global_identity_asset_name, global_identity_storage_location
print("Cleaning up the delegate for '{0}'".format(global_identity_asset_name))
identity_asset = unreal.load_asset(global_identity_storage_location + '/' + global_identity_asset_name)
identity_asset.on_auto_rig_service_finished.remove_callable(process_autorig_service_response)
global_identity_asset_name = ''
if(dna_applied_success):
prepare_identity_for_performance(identity_asset)
else:
unreal.log_error("Failed to retrieve the DNA from Autorig service")
def create_identity_from_frame(neutral_frames : list, capture_source_asset_path : str, asset_storage_location : str, identity_asset_name : str):
global global_identity_asset_name, global_identity_storage_location
global_identity_asset_name = identity_asset_name
global_identity_storage_location = asset_storage_location
if not unreal.EditorAssetLibrary.does_asset_exist(capture_source_asset_path):
unreal.log_error(f"Could not locate Capture Data Source at provided location: {capture_source_asset_path}")
capture_data_asset = unreal.load_asset(capture_source_asset_path)
MetaHuman_identity_asset: unreal.MetaHumanIdentity = asset_tools.create_asset(asset_name=identity_asset_name, package_path=asset_storage_location,
asset_class=unreal.MetaHumanIdentity, factory=unreal.MetaHumanIdentityFactoryNew())
MetaHuman_identity_asset.get_or_create_part_of_class(unreal.MetaHumanIdentityFace)
if not MetaHuman_identity_asset.is_logged_in_to_service():
MetaHuman_identity_asset.log_in_to_auto_rig_service()
face: unreal.MetaHumanIdentityFace = MetaHuman_identity_asset.get_or_create_part_of_class(unreal.MetaHumanIdentityFace)
pose: unreal.MetaHumanIdentityPose = unreal.new_object(type=unreal.MetaHumanIdentityPose, outer=face)
face.add_pose_of_type(unreal.IdentityPoseType.NEUTRAL, pose)
pose.set_capture_data(capture_data_asset)
pose.load_default_tracker()
#Diese Variable ist dafür da, dass beim ersten Frame der Schleife das Attribut is_front_view = True gesetzt wird.
first_frame = True
MetaHuman_identity_asset.set_blocking_processing(True)
#Diese Schleife legt für jedes im Parameter angegebene Bild einen Frame in der Pose der MetaHumanIdentity an.
for i,nframe in enumerate(neutral_frames):
frame, index = pose.add_new_promoted_frame()
if first_frame:
frame.is_front_view = True
first_frame = False
frame.set_navigation_locked(True)
frame.frame_number = nframe
if unreal.PromotedFrameUtils.initialize_contour_data_for_footage_frame(pose, frame) :
image_path = unreal.PromotedFrameUtils.get_image_path_for_frame(capture_data_asset, pose.get_editor_property('camera'), nframe, True, pose.timecode_alignment)
#Retreiving image from disk and storing it in an array
image_size, local_samples = unreal.PromotedFrameUtils.get_promoted_frame_as_pixel_array_from_disk(image_path)
if(image_size.x > 0 and image_size.y > 0) :
# Make sure the pipeline is running synchronously with no progress indicators
show_progress = False
# Running tracking pipeline to get contour data for image retrieved from disk
MetaHuman_identity_asset.start_frame_tracking_pipeline(local_samples, image_size.x, image_size.y, frame, show_progress)
#Dieser Aufruf von conform() wird nach jedem erstellten Frame ausgeführt, da ansonsten die Tracker nicht richtig funktionieren.
face.conform()
else:
unreal.log_error("Failed to initialize contour data. Please make sure valid frame is selected")
print("Face has been conformed")
body: unreal.MetaHumanIdentityBody = MetaHuman_identity_asset.get_or_create_part_of_class(unreal.MetaHumanIdentityBody)
#Mit dieser Variable wird der Körpertyp des Avatares gesetzt.
body.body_type_index = 3
log_only_no_dialogue = True
if(MetaHuman_identity_asset.is_logged_in_to_service()):
print("Calling AutoRig service to create a DNA for identity")
MetaHuman_identity_asset.on_auto_rig_service_finished.add_callable(process_autorig_service_response)
add_to_MetaHuman_creator = True
MetaHuman_identity_asset.create_dna_for_identity(add_to_MetaHuman_creator, log_only_no_dialogue)
else:
unreal.log_error("Please make sure you are logged in to MetaHuman service")
def run():
parser = argparse.ArgumentParser(prog=sys.argv[0], description="Test initializing and tracking promoted frame with contour data")
parser.add_argument("--neutral-frame", nargs="*", type=int, required=True, help="Frame number that corresponds to neutral pose")
parser.add_argument("--capture-data-path", type=str, required=True, help="An absolute or relative path to capture data asset")
parser.add_argument("--storage-path", type=str, required=False, help="A relative content path where the assets should be stored, e.g. /project/-Data/")
args = parser.parse_args()
storage_location = '/Game/' if len(args.storage_path) == 0 else args.storage_path
path_to_capture_data = args.capture_data_path
create_identity_from_frame(args.neutral_frame, path_to_capture_data, storage_location, test_identity_asset_name)
if __name__ == "__main__":
run()
|
# coding: utf-8
import unreal
import time
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-vrm")
parser.add_argument("-rig")
parser.add_argument("-debugeachsave")
args = parser.parse_args()
#print(args.vrm)
######
with unreal.ScopedSlowTask(1, "Convert MorphTarget") as slow_task_root:
slow_task_root.make_dialog()
rigs = unreal.ControlRigBlueprint.get_currently_open_rig_blueprints()
print(rigs)
for r in rigs:
s:str = r.get_path_name()
ss:str = args.rig
if (s.find(ss) < 0):
print("no rig")
else:
rig = r
hierarchy = unreal.ControlRigBlueprintLibrary.get_hierarchy(rig)
h_con = hierarchy.get_controller()
print(unreal.SystemLibrary.get_engine_version())
if (unreal.SystemLibrary.get_engine_version()[0] == '5'):
c = rig.get_controller()
else:
c = rig.controller
g = c.get_graph()
n = g.get_nodes()
mesh = rig.get_preview_mesh()
morphList = mesh.get_all_morph_target_names()
morphListWithNo = morphList[:]
morphListRenamed = []
morphListRenamed.clear()
for i in range(len(morphList)):
morphListWithNo[i] = '{}'.format(morphList[i])
print(morphListWithNo)
bRemoveElement = False
if ("5." in unreal.SystemLibrary.get_engine_version()):
if ("5.0." in unreal.SystemLibrary.get_engine_version()):
bRemoveElement = True
else:
bRemoveElement = True
if (bRemoveElement):
while(len(hierarchy.get_bones()) > 0):
e = hierarchy.get_bones()[-1]
h_con.remove_all_parents(e)
h_con.remove_element(e)
h_con.import_bones(unreal.ControlRigBlueprintLibrary.get_preview_mesh(rig).skeleton)
h_con.import_curves(unreal.ControlRigBlueprintLibrary.get_preview_mesh(rig).skeleton)
dset = rig.get_editor_property('rig_graph_display_settings')
dset.set_editor_property('node_run_limit', 0)
rig.set_editor_property('rig_graph_display_settings', dset)
###### root
key = unreal.RigElementKey(unreal.RigElementType.NULL, 'MorphControlRoot_s')
space = hierarchy.find_null(key)
if (space.get_editor_property('index') < 0):
space = h_con.add_null('MorphControlRoot_s', space_type=unreal.RigSpaceType.SPACE)
else:
space = key
#a:unreal.RigUnit_CollectionItems = unreal.RigUnit_CollectionItems()
#print(a)
# 配列ノード追加
values_forCurve:unreal.RigVMStructNode = []
items_forControl:unreal.RigVMStructNode = []
items_forCurve:unreal.RigVMStructNode = []
for node in n:
#print(node)
#print(node.get_node_title())
# set curve num
if (node.get_node_title() == 'For Loop'):
#print(node)
pin = node.find_pin('Count')
#print(pin)
c.set_pin_default_value(pin.get_pin_path(), str(len(morphList)), True, False)
# curve name array pin
if (node.get_node_title() == 'Select'):
#print(node)
pin = node.find_pin('Values')
#print(pin)
#print(pin.get_array_size())
#print(pin.get_default_value())
values_forCurve.append(pin)
# items
if (node.get_node_title() == 'Collection from Items'):
if ("Type=Curve," in c.get_pin_default_value(node.find_pin('Items').get_pin_path())):
items_forCurve.append(node.find_pin('Items'))
elif (node.find_pin('Items').get_array_size() == 40):
items_forControl.append(node.find_pin('Items'))
print(items_forControl)
print(values_forCurve)
# reset controller
for e in reversed(hierarchy.get_controls()):
if (len(hierarchy.get_parents(e)) == 0):
continue
if (hierarchy.get_parents(e)[0].name == 'MorphControlRoot_s'):
#if (str(e.name).rstrip('_c') in morphList):
# continue
print('delete')
#print(str(e.name))
if (bRemoveElement):
h_con.remove_element(e)
# curve array
for v in values_forCurve:
c.clear_array_pin(v.get_pin_path(), False)
for morph in morphList:
tmp = "{}".format(morph)
c.add_array_pin(v.get_pin_path(), default_value=tmp, setup_undo_redo=False)
# curve controller
for morph in morphListWithNo:
name_c = "{}_c".format(morph)
key = unreal.RigElementKey(unreal.RigElementType.CONTROL, name_c)
settings = unreal.RigControlSettings()
settings.shape_color = [1.0, 0.0, 0.0, 1.0]
settings.control_type = unreal.RigControlType.FLOAT
try:
control = hierarchy.find_control(key)
if (control.get_editor_property('index') < 0):
k = h_con.add_control(name_c, space, settings, unreal.RigControlValue(), setup_undo=False)
control = hierarchy.find_control(k)
except:
k = h_con.add_control(name_c, space, settings, unreal.RigControlValue(), setup_undo=False)
control = hierarchy.find_control(k)
shape_t = unreal.Transform(location=[0.0, 0.0, 0.0], rotation=[0.0, 0.0, 0.0], scale=[0.001, 0.001, 0.001])
hierarchy.set_control_shape_transform(k, shape_t, True)
morphListRenamed.append(control.key.name)
if (args.debugeachsave == '1'):
try:
unreal.EditorAssetLibrary.save_loaded_asset(rig)
except:
print('save error')
#unreal.SystemLibrary.collect_garbage()
# eye controller
eyeControllerTable = [
"VRM4U_EyeUD_left",
"VRM4U_EyeLR_left",
"VRM4U_EyeUD_right",
"VRM4U_EyeLR_right",
]
# eye controller
for eyeCon in eyeControllerTable:
name_c = "{}_c".format(eyeCon)
key = unreal.RigElementKey(unreal.RigElementType.CONTROL, name_c)
settings = unreal.RigControlSettings()
settings.shape_color = [1.0, 0.0, 0.0, 1.0]
settings.control_type = unreal.RigControlType.FLOAT
try:
control = hierarchy.find_control(key)
if (control.get_editor_property('index') < 0):
k = h_con.add_control(name_c, space, settings, unreal.RigControlValue(), setup_undo=False)
control = hierarchy.find_control(k)
except:
k = h_con.add_control(name_c, space, settings, unreal.RigControlValue(), setup_undo=False)
control = hierarchy.find_control(k)
shape_t = unreal.Transform(location=[0.0, 0.0, 0.0], rotation=[0.0, 0.0, 0.0], scale=[0.001, 0.001, 0.001])
hierarchy.set_control_shape_transform(k, shape_t, True)
# curve Control array
with unreal.ScopedSlowTask(len(items_forControl)*len(morphListRenamed), "Add Control") as slow_task:
slow_task.make_dialog()
for v in items_forControl:
c.clear_array_pin(v.get_pin_path(), False)
for morph in morphListRenamed:
slow_task.enter_progress_frame(1)
tmp = '(Type=Control,Name='
tmp += "{}".format(morph)
tmp += ')'
c.add_array_pin(v.get_pin_path(), default_value=tmp, setup_undo_redo=False)
# curve Float array
with unreal.ScopedSlowTask(len(items_forCurve)*len(morphList), "Add Curve") as slow_task:
slow_task.make_dialog()
for v in items_forCurve:
c.clear_array_pin(v.get_pin_path(), False)
for morph in morphList:
slow_task.enter_progress_frame(1)
tmp = '(Type=Curve,Name='
tmp += "{}".format(morph)
tmp += ')'
c.add_array_pin(v.get_pin_path(), default_value=tmp, setup_undo_redo=False)
|
from pathlib import Path
from qtpy import QtWidgets, QtCore, QtGui
from ayon_api import get_folders_hierarchy
from ayon_core import (
resources,
style
)
from ayon_core.pipeline import get_current_project_name
from ayon_core.tools.utils import (
show_message_dialog,
PlaceholderLineEdit,
SquareButton,
)
from ayon_core.tools.utils import SimpleFoldersWidget
from ayon_unreal.api.pipeline import (
generate_sequence,
set_sequence_hierarchy,
)
import unreal
class ConfirmButton(SquareButton):
def __init__(self, parent=None):
super(ConfirmButton, self).__init__(parent)
self.setText("Confirm")
class FolderSelector(QtWidgets.QWidget):
"""Widget for selecting a folder from the project hierarchy."""
confirm_btn = None
def __init__(self, controller=None, parent=None, project=None):
if not project:
raise ValueError("Project name not provided.")
super(FolderSelector, self).__init__(parent)
icon = QtGui.QIcon(resources.get_ayon_icon_filepath())
self.setWindowIcon(icon)
self.setWindowTitle("Folder Selector")
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose, False)
self.setStyleSheet(style.load_stylesheet())
# Allow minimize
self.setWindowFlags(
QtCore.Qt.Window
| QtCore.Qt.CustomizeWindowHint
| QtCore.Qt.WindowTitleHint
| QtCore.Qt.WindowMinimizeButtonHint
| QtCore.Qt.WindowCloseButtonHint
)
content_body = QtWidgets.QWidget(self)
# Folders
folders_wrapper = QtWidgets.QWidget(content_body)
folders_filter_text = PlaceholderLineEdit(folders_wrapper)
folders_filter_text.setPlaceholderText("Filter folders...")
folders_widget = SimpleFoldersWidget(
controller=None, parent=folders_wrapper)
folders_widget.set_project_name(project_name=project)
folders_wrapper_layout = QtWidgets.QVBoxLayout(folders_wrapper)
folders_wrapper_layout.setContentsMargins(0, 0, 0, 0)
folders_wrapper_layout.addWidget(folders_filter_text, 0)
folders_wrapper_layout.addWidget(folders_widget, 1)
# Footer
footer_widget = QtWidgets.QWidget(content_body)
self.confirm_btn = ConfirmButton(footer_widget)
footer_layout = QtWidgets.QHBoxLayout(footer_widget)
footer_layout.setContentsMargins(0, 0, 0, 0)
footer_layout.addWidget(self.confirm_btn, 0)
# Main layout
content_layout = QtWidgets.QVBoxLayout(content_body)
content_layout.setContentsMargins(0, 0, 0, 0)
content_layout.addWidget(folders_wrapper, 1)
content_layout.addWidget(footer_widget, 0)
layout = QtWidgets.QVBoxLayout(self)
layout.addWidget(content_body, 1)
folders_filter_text.textChanged.connect(
self._on_filter_text_changed)
self._controller = controller
self._confirm_btn = self.confirm_btn
self._folders_widget = folders_widget
self.resize(300, 400)
self.show()
self.raise_()
self.activateWindow()
def _on_filter_text_changed(self, text):
self._folders_widget.set_name_filter(text)
def get_selected_folder(self):
return self._folders_widget.get_selected_folder_path()
def _create_level(path, name, master_level):
# Create the level
level_path = f"{path}/{name}_map"
level_package = f"{level_path}.{name}_map"
unreal.EditorLevelLibrary.new_level(level_path)
# Add the level to the master level as sublevel
unreal.EditorLevelLibrary.load_level(master_level)
unreal.EditorLevelUtils.add_level_to_world(
unreal.EditorLevelLibrary.get_editor_world(),
level_package,
unreal.LevelStreamingDynamic
)
unreal.EditorLevelLibrary.save_all_dirty_levels()
return level_package
def _create_sequence(
element, sequence_path, master_level,
parent_path="", parents_sequence=[], parents_frame_range=[]
):
"""
Create sequences from the hierarchy element.
Args:
element (dict): The hierarchy element.
sequence_path (str): The sequence path.
master_level (str): The master level package.
parent_path (str): The parent path.
parents_sequence (list): The list of parent sequences.
parents_frame_range (list): The list of parent frame ranges.
"""
name = element["name"]
path = f"{parent_path}/{name}"
hierarchy_dir = f"{sequence_path}{path}"
children = element["children"]
# Create sequence for the current element
sequence, frame_range = generate_sequence(name, hierarchy_dir)
sequences = parents_sequence.copy() + [sequence]
frame_ranges = parents_frame_range.copy() + [frame_range]
if children:
# Traverse the children and create sequences recursively
for child in children:
_create_sequence(
child, sequence_path, master_level, parent_path=path,
parents_sequence=sequences, parents_frame_range=frame_ranges)
else:
level = _create_level(hierarchy_dir, name, master_level)
# Create the sequence hierarchy. Add each child to its parent
for i in range(len(parents_sequence) - 1):
set_sequence_hierarchy(
parents_sequence[i], parents_sequence[i + 1],
parents_frame_range[i][1],
parents_frame_range[i + 1][0], parents_frame_range[i + 1][1],
[level])
if not parents_sequence:
parents_sequence = sequences
if not parents_frame_range:
parents_frame_range = frame_ranges
# Add the newly created sequence to its parent
set_sequence_hierarchy(
parents_sequence[-1], sequence,
parents_frame_range[-1][1],
frame_range[0], frame_range[1],
[level])
def _find_in_hierarchy(hierarchy, path):
"""
Find the hierarchy element from the path.
Args:
hierarchy (list): The hierarchy list.
path (str): The path to find.
"""
elements = path.split("/")
current_element = elements[0]
for element in hierarchy:
if element["name"] == current_element:
if len(elements) == 1:
return element
remaining_path = "/".join(elements[1:])
return _find_in_hierarchy(element["children"], remaining_path)
return None
def find_level_sequence(asset_content):
"""
Search level sequence already exists in the hierarchy
Args:
asset_content (list): List of asset contents
"""
has_level_sequence = []
ar = unreal.AssetRegistryHelpers.get_asset_registry()
for asset in asset_content:
content = ar.get_asset_by_object_path(asset).get_asset()
if content.get_class().get_name() == "LevelSequence":
has_level_sequence.append(content)
return has_level_sequence
def save_asset_and_load_level(asset_content, level_package, folder_selector):
"""Save asset contents and load master level thus close
folder selector
Args:
asset_content (list): List of asset contents
level_package (str): level package path
folder_selector(Object): folder selector widget
"""
for a in asset_content:
unreal.EditorAssetLibrary.save_asset(a)
# load the master level
unreal.EditorLevelLibrary.load_level(level_package)
folder_selector.close()
def _on_confirm_clicked(folder_selector, sequence_path, project):
selected_root = folder_selector.get_selected_folder()
sequence_root_name = selected_root.lstrip("/")
sequence_root = f"{sequence_path}/{sequence_root_name}"
asset_content = unreal.EditorAssetLibrary.list_assets(
sequence_root, recursive=False, include_folder=True)
hierarchy = get_folders_hierarchy(project_name=project)["hierarchy"]
# Find the sequence root element in the hierarchy
hierarchy_element = _find_in_hierarchy(hierarchy, sequence_root_name)
# Raise an error if the sequence root element is not found
if not hierarchy_element:
raise ValueError(f"Could not find {sequence_root_name} in hierarchy")
master_level_name = sequence_root_name.split("/")[-1]
master_level_path = f"{sequence_root}/{master_level_name}_map"
master_level_package = f"{master_level_path}.{master_level_name}_map"
if asset_content:
msg = (
f"The sequence hierarchy already created in {sequence_path}"
f"Loading level {master_level_package} from the path {master_level_path}."
)
show_message_dialog(
parent=None,
title="Loading level from the already-created shot structure",
message=msg,
level="info")
if not find_level_sequence(asset_content):
_create_sequence(
hierarchy_element, Path(sequence_root).parent.as_posix(),
master_level_package)
save_asset_and_load_level(
asset_content, master_level_package, folder_selector)
return
# Create the master level
unreal.EditorLevelLibrary.new_level(master_level_path)
# Start creating sequences from the root element
_create_sequence(
hierarchy_element, Path(sequence_root).parent.as_posix(),
master_level_package)
# List all the assets in the sequence path and save them
asset_content = unreal.EditorAssetLibrary.list_assets(
sequence_root, recursive=True, include_folder=False
)
save_asset_and_load_level(
asset_content, master_level_package, folder_selector)
def build_sequence_hierarchy():
"""
Builds the sequence hierarchy by creating sequences from the root element.
Raises:
ValueError: If the sequence root element is not found in the hierarchy.
"""
print("Building sequence hierarchy...")
project = get_current_project_name()
sequence_path = "/project/"
folder_selector = FolderSelector(project=project)
folder_selector.confirm_btn.clicked.connect(
lambda: _on_confirm_clicked(folder_selector, sequence_path, project)
)
|
import sys
import os
import unreal
PLUGIN_NAME = "SmartEditorTools"
plugin_base_dir = os.path.join(unreal.Paths.project_plugins_dir(), PLUGIN_NAME)
plugin_script_dir = os.path.join(plugin_base_dir, "Scripts")
if plugin_script_dir not in sys.path:
sys.path.append(plugin_script_dir)
from PrefixRules import PREFIX_RULES, get_prefix, needs_prefix
settings = unreal.get_default_object(unreal.SmartDeveloperSettings)
working_paths = [p.path for p in settings.pre_fix_asset_paths if p.path]
if not working_paths:
unreal.EditorDialog.show_message(
title="Path Error",
message="No paths are set in AutoDeveloperSettings.",
message_type=unreal.AppMsgType.OK
)
raise RuntimeError("Cannot get paths from AutoDeveloperSettings")
all_assets = []
for path in working_paths:
assets = unreal.EditorAssetLibrary.list_assets(path, recursive=True, include_folder=False)
all_assets += assets
preview_list = []
for asset_path in all_assets:
asset_data = unreal.EditorAssetLibrary.find_asset_data(asset_path)
asset = asset_data.get_asset()
asset_name = asset.get_name()
class_name = asset.get_class().get_name()
prefix = get_prefix(class_name)
if not prefix or asset_name.startswith(prefix + "_"):
continue
path_only = asset_path.rsplit("/", 1)[0] + "/"
new_name = f"{prefix}_{asset_name}"
new_path = path_only + new_name
preview_list.append((asset_path, new_path))
print(asset_path + "Junghyeon")
if not preview_list:
unreal.EditorDialog.show_message(
title="Result",
message="No assets found to apply prefixes.",
message_type=unreal.AppMsgType.OK
)
else:
preview_text = "Assets to be rename/project/"
for old, new in preview_list[:15]:
preview_text += f"{old} →\n {new}\n\n"
if len(preview_list) > 15:
preview_text += f"...and {len(preview_list)-15} more"
result = unreal.EditorDialog.show_message(
title="Confirm Prefix Rename",
message=preview_text + "\nDo you want to rename these assets?",
message_type=unreal.AppMsgType.YES_NO,
default_value=unreal.AppReturnType.NO
)
if result == unreal.AppReturnType.YES:
with unreal.ScopedSlowTask(len(preview_list), "Renaming Assets...") as slow_task:
slow_task.make_dialog(True)
changed_count = 0
for old_path, new_path in preview_list:
if unreal.EditorAssetLibrary.rename_asset(old_path, new_path):
unreal.log(f"[PrefixFix] Renamed {old_path} → {new_path}")
changed_count += 1
slow_task.enter_progress_frame(1)
if slow_task.should_cancel():
break
unreal.EditorDialog.show_message(
title="Completed",
message=f"Prefix applied successfully.\nTotal assets renamed: {changed_count}",
message_type=unreal.AppMsgType.OK
)
else:
unreal.EditorDialog.show_message(
title="Cancelled",
message="Operation was cancelled.",
message_type=unreal.AppMsgType.OK
)
|
import csv
import os
import unreal
def convert_obj_to_csv(obj_file_path, csv_file_path):
# Verifica che il file OBJ esista
if not os.path.exists(obj_file_path):
unreal.log_error(f"Il file {obj_file_path} non esiste.")
return
with open(obj_file_path, 'r') as obj_file:
lines = obj_file.readlines()
rows = []
index = 0
for line in lines:
if line.startswith('v'):
parts = line.split()
x = float(parts[1])
y = float(parts[2])
z = float(parts[3])
# Applica la riflessione sull'asse Y
y = -y
rows.append([index, x, y, z])
index += 1
try:
with open(csv_file_path, 'w', newline='') as csv_file:
writer = csv.writer(csv_file)
writer.writerow(['index', 'x', 'y', 'z']) # Headers with index
writer.writerows(rows)
unreal.log(f"File salvato come {csv_file_path}")
except Exception as e:
unreal.log_error(f"Errore durante il salvataggio del file CSV: {e}")
def main():
# Ottieni il percorso del progetto Unreal
project_content_dir = unreal.Paths.project_content_dir()
python_scripts_path = os.path.join(project_content_dir, 'PythonScripts')
# Definisci i percorsi relativi
obj_file_path = os.path.join(python_scripts_path, 'visualized_paths.obj')
csv_file_path = os.path.join(python_scripts_path, 'converted_paths.csv')
# Log dei percorsi per il debug
unreal.log(f"Percorso del file OBJ: {obj_file_path}")
unreal.log(f"Percorso del file CSV: {csv_file_path}")
convert_obj_to_csv(obj_file_path, csv_file_path)
if __name__ == "__main__":
main()
|
import unreal
# instances of unreal classes
editor_asset_lib = unreal.EditorAssetLibrary()
string_lib = unreal.StringLibrary()
# get all assets in source dir
source_dir = "/Game/"
include_subfolders = True
set_textures = 0
assets = editor_asset_lib.list_assets(source_dir, recursive=include_subfolders)
color_patterns = ["_ORM", "_OcclusionRoughnessMetallic", "_Metallic", "_Roughness", "_Mask"]
for asset in assets:
# for every asset check it against all the patterns
for pattern in color_patterns:
if string_lib.contains(asset, pattern):
# load the asset, turn off sRGB and set compression settings to TC_Mask
asset_obj = editor_asset_lib.load_asset(asset)
asset_obj.set_editor_property("sRGB", False)
asset_obj.set_editor_property("CompressionSettings", unreal.TextureCompressionSettings.TC_MASKS)
unreal.log("Setting TC_Masks and turning off sRGB for asset {}".format(asset))
set_textures += 1
break
unreal.log("Linear color for matching textures set for {} assets".format(set_textures))
|
# coding: utf-8
import unreal
# import AssetFunction_4 as af
# reload(af)
# af.generateColoredDirectories()
def generateColoredDirectories():
for x in range(40, 80):
dir_path = '/project/' + str(x)
linear_color = getGradientColor(x)
unreal.CppLib.set_folder_color(dir_path, linear_color)
unreal.EditorAssetLibrary.make_directory(dir_path)
def getGradientColor(x):
x = float(x) / 100
return unreal.LinearColor(x, 1-x, 1-x, 1)
|
from unreal_global import *
import unreal_utils
import unreal
@unreal.uclass()
class SampleActorAction(unreal.ActorActionUtility):
# @unreal.ufunction(override=True)
# def get_supported_class(self):
# return unreal.Actor
@unreal.ufunction(
static=True,
meta=dict(CallInEditor=True, Category="Sample Actor Action Library"),
)
def python_test_actor_action():
unreal.log("Execute Sample Actor Action")
@unreal.ufunction(
ret=str,
params=[str],
static=True,
meta=dict(CallInEditor=True, Category="Sample Actor Action Library"),
)
def python_test_actor_action_with_parameters(input_string):
result = "Execute Sample Actor Action with {}".format(input_string)
unreal.log("Execute Sample Actor Action with {}".format(input_string))
return result
# Unreal need a actual blueprint asset to be created and inherit from the new class for it to work
# unreal_utils.register_editor_utility_blueprint("SampleActorUtility", SampleActorAction)
|
import unreal
# 선택한 에셋을 가져옴
clicked_assets = unreal.EditorUtilityLibrary.get_selected_assets()
pathes: list[str] = []
for asset in clicked_assets:
assetpath = asset.get_path_name()
# print(assetpath)
splitpath = assetpath.split("/")[0:-1]
# print(splitpath)
resultpath = "/".join(splitpath)
print(resultpath)
print("------------------------------------------------------")
|
"""Asset processor for handling Unreal Engine assets."""
import unreal
from ..utils.logging_config import logger
from ..utils.constants import (
NAME_PATTERNS,
ACTOR_CHARACTER_MAPPING,
SEQUENCE_MAPPING,
MHID_MAPPING,
MOCAP_BASE_PATH
)
class AssetProcessor:
def __init__(self):
self.asset_registry = unreal.AssetRegistryHelpers.get_asset_registry()
self.asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
self.name_patterns = NAME_PATTERNS
self.actor_character_mapping = ACTOR_CHARACTER_MAPPING
def get_sub_paths(self, base_path, recurse=True):
"""Get all sub paths from a base path."""
return self.asset_registry.get_sub_paths(base_path, recurse=recurse)
def get_assets_by_path(self, path, recursive=True):
"""Get all assets in a path."""
return self.asset_registry.get_assets_by_path(path, recursive)
def get_available_folders(self):
logger.info("Fetching available folders...")
# Use the method signature as in Batch_Face_Importer_PUB_updated_v4.py
full_paths = self.get_sub_paths(MOCAP_BASE_PATH, recurse=True)
# Filter and clean paths to only show from "Mocap" forward
cleaned_paths = []
for path in full_paths:
if "Mocap" in path:
# Find the index of "Mocap" in the path
mocap_index = path.find("Mocap")
# Get everything from "Mocap" forward
cleaned_path = path[mocap_index:]
if self.folder_has_capture_data(path): # Still check using full path
cleaned_paths.append(cleaned_path)
logger.info(f"Found {len(cleaned_paths)} folders with capture data")
return cleaned_paths
def get_capture_data_assets(self, folder):
"""Get all capture data assets from a folder."""
logger.info(f"Searching for assets in folder: {folder}")
# Ensure the folder path is properly formatted
folder_path = str(folder)
# Remove base path prefix if it exists
if folder_path.startswith(f'{MOCAP_BASE_PATH}/'):
folder_path = folder_path[len(f'{MOCAP_BASE_PATH}/'):]
# Add the proper base path prefix
folder_path = f"{MOCAP_BASE_PATH}/{folder_path.strip('/')}"
logger.info(f"Searching with formatted path: {folder_path}")
search_filter = unreal.ARFilter(
package_paths=[folder_path],
class_names=["FootageCaptureData"],
recursive_paths=True, # Enable recursive search
recursive_classes=True
)
try:
assets = self.asset_registry.get_assets(search_filter)
logger.info(f"Found {len(assets)} assets in {folder_path}")
# Log each found asset for debugging
for asset in assets:
logger.info(f"Found asset: {asset.asset_name}") # Use 'asset_name' property
if not assets:
# Try alternative path format
alt_folder_path = folder_path.replace(MOCAP_BASE_PATH, '/Game/')
logger.info(f"Trying alternative path: {alt_folder_path}")
search_filter.package_paths = [alt_folder_path]
assets = self.asset_registry.get_assets(search_filter)
logger.info(f"Found {len(assets)} assets with alternative path")
return assets
except Exception as e:
logger.error(f"Error getting assets: {str(e)}")
return []
|
# coding: utf-8
import unreal
def createGenericAsset(asset_path='', unique_name=True, asset_class=None, asset_factory=None):
if unique_name:
asset_path, asset_name = unreal.AssetToolsHelpers.get_asset_tools().create_unique_asset_name(base_package_name=asset_path, suffix='')
if not unreal.EditorAssetLibrary.does_asset_exist(asset_path=asset_path):
path = asset_path.rsplit('/', 1)[0]
name = asset_path.rsplit('/', 1)[1]
return unreal.AssetToolsHelpers.get_asset_tools().create_asset(asset_name=name, package_path=path, asset_class=asset_class, factory=asset_factory)
return unreal.load_asset(asset_path)
def createGenericAsset_EXAMPLE():
base_path = '/project/'
generic_assets = [
[base_path + 'sequence', unreal.LevelSequence, unreal.LevelSequenceFactoryNew()],
[base_path + 'material', unreal.Material, unreal.MaterialFactoryNew()],
[base_path + 'world', unreal.World, unreal.WorldFactory()],
[base_path + 'particle_system', unreal.ParticleSystem, unreal.ParticleSystemFactoryNew()],
[base_path + 'paper_flipbook', unreal.PaperFlipbook, unreal.PaperFlipbookFactory()],
[base_path + 'data_table', unreal.DataTable, unreal.DataTableFactory()], # Will not work
]
for asset in generic_assets:
print createGenericAsset(asset[0], True, asset[1], asset[2])
# import AssetFunction_7 as af
# reload(af)
# af.createGenericAsset_EXAMPLE()
|
import unreal
##Intances classes of unreal engine
editor_util = unreal.EditorUtilityLibrary()
system_lib = unreal.SystemLibrary()
#get selected assets
selected_assets = editor_util.get_selected_assets()
num_assets = len(selected_assets)
#get class to chek if are texture
for asset in selected_assets:
asset_class = asset.get_class()
asset_name = system_lib.get_object_name(asset)
class_name = system_lib.get_class_display_name(asset_class)
if class_name == "Texture2D":
##texture = unreal.Texture2D(asset_name)
lod_bias = asset.get_editor_property('lod_bias')
if lod_bias == 0:
new_lod_bias = asset.set_editor_property('lod_bias', 1)
unreal.log("{} had a LOD Bias {} and it was change to 1".format(asset_name, lod_bias))
else:
unreal.log("{} has a LOD Bias {} and it was not changed".format(asset_name, lod_bias))
else:
unreal.log("The selected asset is not a texture, please be sure to select an asset of class Texture2D")
|
# SM Comp 콜리전 읽음
# landscape는 읽지 않음
# preset이 custom일때만 콜리전 채널 읽음
import unreal
selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
for actor in selected_actors:
# 랜드스케이프건너 뛰기 > 컴포넌트를 다읽어서 오래걸림. 로그 전쟁임
if isinstance(actor, unreal.Landscape):
print("오브젝트 {}는 랜드스케이프입니다. 건너뜁니다.".format(actor.get_actor_label()))
continue
components = actor.get_components_by_class(unreal.PrimitiveComponent)
for component in components :
component_name = component.get_name() #마지막에 호출할 컴포넌트 네임
if isinstance(component, unreal.StaticMeshComponent) : #스태틱 매쉬 컴포넌트만 읽어오기 이거 안하면 빌보드 컴포넌트 등 다 읽어옴
compcol_preset = component.get_collision_profile_name()
compcol_enabled = component.get_collision_enabled()
compcol_object = component.get_collision_object_type()
compcol_enabled_str = str(compcol_enabled).replace("CollisionEnabled.", "")
compcol_object_str = str(compcol_object).replace("CollisionChannel.ECC_", "")
print(">>>>>", actor.get_actor_label(), "<<<<<")
print(component_name, ">> Collision Presets <<" ,compcol_preset) # 콜리전 프리셋 프린트 Default = BlockAll
print(component_name, ">> Collision Enabled <<" , compcol_enabled_str)
print(component_name, ">> Object Type <<" ,compcol_object_str)
print("--------------------------------------------------------------------------------------------")
# collision preset 이 custom일때만 하위 채널 읽기
if compcol_preset == 'custom' :
for compcolchannel in unreal.CollisionChannel:
#모든 채널 읽기
response_type = component.get_collision_response_to_channel(compcolchannel)
print("Channel: {} >>>> {}".format(compcolchannel.get_display_name(), response_type.get_display_name()))
# 특정 채널 읽기
# if compcolchannel is unreal.CollisionChannel.ECC_GROUND :
# select_response_type = component.get_collision_response_to_channel(compcolchannel)
# print("Channel: {} >>>> {}".format(compcolchannel.get_display_name(), select_response_type.get_display_name()))
print("============================================================================================")
|
# This script describes a generic use case for the variant manager
import unreal
# Create all assets and objects we'll use
lvs = unreal.VariantManagerLibrary.create_level_variant_sets_asset("LVS", "/Game/")
lvs_actor = unreal.VariantManagerLibrary.create_level_variant_sets_actor(lvs)
if lvs is None or lvs_actor is None:
print ("Failed to spawn either the LevelVariantSets asset or the LevelVariantSetsActor!")
quit()
var_set1 = unreal.VariantSet()
var_set1.set_display_text("My VariantSet")
var_set2 = unreal.VariantSet()
var_set2.set_display_text("VariantSet we'll delete")
var1 = unreal.Variant()
var1.set_display_text("Variant 1")
var2 = unreal.Variant()
var2.set_display_text("Variant 2")
var3 = unreal.Variant()
var3.set_display_text("Variant 3")
var4 = unreal.Variant()
var4.set_display_text("Variant 4")
var5 = unreal.Variant()
var5.set_display_text("Variant 5")
# Adds the objects to the correct parents
lvs.add_variant_set(var_set1)
var_set1.add_variant(var1)
var_set1.add_variant(var2)
var_set1.add_variant(var3)
var_set1.add_variant(var4)
var_set1.add_variant(var5)
# Spawn a simple cube static mesh actor
cube = unreal.EditorAssetLibrary.load_asset("StaticMesh'/project/.Cube'")
spawned_actor = None
if cube:
location = unreal.Vector()
rotation = unreal.Rotator()
spawned_actor = unreal.EditorLevelLibrary.spawn_actor_from_object(cube, location, rotation)
spawned_actor.set_actor_label("Cube Actor")
else:
print ("Failed to find Cube asset!")
if spawned_actor is None:
print ("Failed to spawn an actor for the Cube asset!")
quit()
# Bind spawned_actor to all our variants
var1.add_actor_binding(spawned_actor)
var2.add_actor_binding(spawned_actor)
var3.add_actor_binding(spawned_actor)
var4.add_actor_binding(spawned_actor)
var5.add_actor_binding(spawned_actor)
capturable_props = unreal.VariantManagerLibrary.get_capturable_properties(spawned_actor)
print ("Capturable properties for actor '" + spawned_actor.get_actor_label() + "':")
for prop in capturable_props:
print ("\t" + prop)
# Capture all available properties on Variant 1
for prop in capturable_props:
var1.capture_property(spawned_actor, prop)
# Capture just materials on Variant 2
just_mat_props = (p for p in capturable_props if "Material[" in p)
for prop in just_mat_props:
var2.capture_property(spawned_actor, prop)
# Capture just relative location on Variant 4
just_rel_loc = (p for p in capturable_props if "Relative Location" in p)
rel_loc_props = []
for prop in just_rel_loc:
captured_prop = var4.capture_property(spawned_actor, prop)
rel_loc_props.append(captured_prop)
# Store a property value on Variant 4
rel_loc_prop = rel_loc_props[0]
print (rel_loc_prop.get_full_display_string())
spawned_actor.set_actor_relative_location(unreal.Vector(100, 200, 300), False, False)
rel_loc_prop.record()
# Move the target actor to some other position
spawned_actor.set_actor_relative_location(unreal.Vector(500, 500, 500), False, False)
# Can switch on the variant, applying the recorded value of all its properties to all
# of its bound actors
var4.switch_on() # Cube will be at 100, 200, 300 after this
# Apply the recorded value from just a single property
rel_loc_prop.apply()
# Get the relative rotation property
rel_rot = [p for p in capturable_props if "Relative Rotation" in p][0]
# Remove objects
lvs.remove_variant_set(var_set2)
lvs.remove_variant_set(var_set2)
var_set1.remove_variant(var3)
var5.remove_actor_binding(spawned_actor)
var1.remove_captured_property_by_name(spawned_actor, rel_rot)
|
# -*- coding: utf-8 -*-
"""
Created on Sat Feb 3 08:48:16 2024
@author: WillQuantique
"""
import unreal
import os
# Base directory in Unreal's format
base_directory = "/project/"
# Function to load a blueprint into the scene
def load_blueprint_into_scene(blueprint_path):
asset = unreal.EditorAssetLibrary.load_asset(blueprint_path)
if asset is None:
print(f"Failed to load asset at {blueprint_path}")
return None
actor = unreal.EditorLevelLibrary.spawn_actor_from_object(asset, unreal.Vector(126350,13740, 99890), unreal.Rotator(0, 0, 0))
return actor
# Function to unload a blueprint from the scene (used for MetaHumans BluePrints)
def unload_blueprint_from_scene(actor):
if actor:
unreal.EditorLevelLibrary.destroy_actor(actor)
# Function to load levels
def LoadLevel(path):
unreal.get_editor_subsystem(unreal.LevelEditorSubsystem).load_level(path)
# Main function to explore folders and handle the blueprint
def process_meta_humans(base_directory):
for x in range(1, 10): # Looping through HA001 to HA009
print( f"load {x}")
folder_name = f"HN00{x}"
folder_path = f"{base_directory}/{folder_name}"
# List all assets in the folder
assets = unreal.EditorAssetLibrary.list_assets(folder_path, recursive=False, include_folder=False)
for asset_path in assets:
# Assuming there's only one blueprint per folder, load it directly
print(f"Loading {asset_path}")
actor = load_blueprint_into_scene(asset_path)
# Here you can insert any operations you want to perform with the loaded blueprint
print("loaded ?")
# Note: Unreal's delay function is used in place of time.sleep() to not freeze the editor
print(f"Unloading {asset_path}")
#unload_blueprint_from_scene(actor)
def render_meta_humans(base_directory, camera):
for x in range(1,2): # Looping through HA001 to HA009
print( f"load {x}")
folder_name = f"HN00{x}"
folder_path = f"{base_directory}/{folder_name}"
# List all assets in the folder
assets = unreal.EditorAssetLibrary.list_assets(folder_path, recursive=False, include_folder=False)
for asset_path in assets:
print(f"Loading {asset_path}")
actor = load_blueprint_into_scene(asset_path)
capture_and_save_image(camera,folder_name, resolution=(1024, 1024))
print(f"Unloading {asset_path}")
#unload_blueprint_from_scene(actor)
# Assuming there's only one blueprint per folder, load it directly
def setup_camera_actor(location=unreal.Vector(20, 110, 180), rotation=unreal.Rotator(0, 0, -99)):
# Spawn a Camera Actor in the World
world = unreal.EditorLevelLibrary.get_editor_world()
camera_actor = unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.CineCameraActor, location, rotation)
return camera_actor
def capture_and_save_image(camera_actor, name,resolution=(1024, 1024)):
# Ensure the camera actor is valid and has a Scene Capture Component 2D
if not camera_actor:
print("Camera Actor is not valid")
return
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
# Find or create a Render Target
factory=unreal.TextureRenderTargetFactoryNew()
asset_class=unreal.TextureRenderTarget2D
render_target = asset_tools.create_asset(asset_name=f'{name}',
package_path=f'/project/',
asset_class=asset_class,
factory=factory,
calling_context = "name")
unreal.EditorAssetLibrary.save_loaded_asset(render_target)
# Attach a Scene Capture Component to the Camera Actor
scene_capture_component = unreal.SceneCaptureComponent2D()
#camera_actor.add_actor_component(scene_capture_component, "SceneCaptureComponent")
scene_capture_component.texture_target = render_target
scene_capture_component.capture_source = unreal.SceneCaptureSource.SCS_FINAL_COLOR_LDR
scene_capture_component.capture_scene()
# Note: Unreal does not directly support saving Render Targets to disk via Python.
# You would typically use the 'High Resolution Screenshot' tool or export the Render Target manually.
# This step requires manual action in the editor or custom C++ plugins to expose such functionality.
if __name__ == "__main__":
#camera = setup_camera_actor()
base_directory = r"/project/"
process_meta_humans(base_directory)
|
import unreal
from collections import deque
from collections.abc import Iterable
class PyTick():
_delegate_handle = None
_current = None
schedule = None
def __init__(self):
self.schedule = deque()
self._delegate_handle = unreal.register_slate_post_tick_callback(self._callback)
def _callback(self, _):
if self._current is None:
if self.schedule:
self._current = self.schedule.popleft()
else:
print ('Done jobs')
unreal.unregister_slate_post_tick_callback(self._delegate_handle)
return
try:
task = next(self._current)
if task is not None and isinstance(task, Iterable):
# reschedule current task, and do the new one
self.schedule.appendleft(self._current)
self._current = task
except StopIteration:
self._current = None
except:
self._current = None
raise
def take_all_cam_screenshots():
actorSubsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
level_actors = actorSubsystem.get_all_level_actors()
all_cameras = unreal.EditorFilterLibrary.by_class(
level_actors,
unreal.CameraActor
)
for cam in all_cameras:
camera_name = cam.get_actor_label()
unreal.AutomationLibrary.take_high_res_screenshot(1280, 720, camera_name, cam)
print ('Requested screenshot for '+ camera_name )
yield
py_tick = PyTick()
py_tick.schedule.append(take_all_cam_screenshots())
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
""" An example script that spawns some actors and then uses the API to
instantiate an HDA and set the actors as world inputs. The inputs are set
during post instantiation (before the first cook). After the first cook and
output creation (post processing) the input structure is fetched and logged.
"""
import unreal
_g_wrapper = None
def get_test_hda_path():
return '/project/.subnet_test_2_0'
def get_test_hda():
return unreal.load_object(None, get_test_hda_path())
def get_geo_asset_path():
return '/project/.Cube'
def get_geo_asset():
return unreal.load_object(None, get_geo_asset_path())
def get_cylinder_asset_path():
return '/project/.Cylinder'
def get_cylinder_asset():
return unreal.load_object(None, get_cylinder_asset_path())
def configure_inputs(in_wrapper):
print('configure_inputs')
# Unbind from the delegate
in_wrapper.on_post_instantiation_delegate.remove_callable(configure_inputs)
# Spawn some actors
actors = spawn_actors()
# Create a world input
world_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPIWorldInput)
# Set the input objects/assets for this input
world_input.set_input_objects(actors)
# copy the input data to the HDA as node input 0
in_wrapper.set_input_at_index(0, world_input)
# We can now discard the API input object
world_input = None
# Set the subnet_test HDA to output its first input
in_wrapper.set_int_parameter_value('enable_geo', 1)
def print_api_input(in_input):
print('\t\tInput type: {0}'.format(in_input.__class__))
print('\t\tbKeepWorldTransform: {0}'.format(in_input.keep_world_transform))
print('\t\tbImportAsReference: {0}'.format(in_input.import_as_reference))
if isinstance(in_input, unreal.HoudiniPublicAPIWorldInput):
print('\t\tbPackBeforeMerge: {0}'.format(in_input.pack_before_merge))
print('\t\tbExportLODs: {0}'.format(in_input.export_lo_ds))
print('\t\tbExportSockets: {0}'.format(in_input.export_sockets))
print('\t\tbExportColliders: {0}'.format(in_input.export_colliders))
print('\t\tbIsWorldInputBoundSelector: {0}'.format(in_input.is_world_input_bound_selector))
print('\t\tbWorldInputBoundSelectorAutoUpdate: {0}'.format(in_input.world_input_bound_selector_auto_update))
input_objects = in_input.get_input_objects()
if not input_objects:
print('\t\tEmpty input!')
else:
print('\t\tNumber of objects in input: {0}'.format(len(input_objects)))
for idx, input_object in enumerate(input_objects):
print('\t\t\tInput object #{0}: {1}'.format(idx, input_object))
def print_inputs(in_wrapper):
print('print_inputs')
# Unbind from the delegate
in_wrapper.on_post_processing_delegate.remove_callable(print_inputs)
# Fetch inputs, iterate over it and log
node_inputs = in_wrapper.get_inputs_at_indices()
parm_inputs = in_wrapper.get_input_parameters()
if not node_inputs:
print('No node inputs found!')
else:
print('Number of node inputs: {0}'.format(len(node_inputs)))
for input_index, input_wrapper in node_inputs.items():
print('\tInput index: {0}'.format(input_index))
print_api_input(input_wrapper)
if not parm_inputs:
print('No parameter inputs found!')
else:
print('Number of parameter inputs: {0}'.format(len(parm_inputs)))
for parm_name, input_wrapper in parm_inputs.items():
print('\tInput parameter name: {0}'.format(parm_name))
print_api_input(input_wrapper)
def spawn_actors():
actors = []
# Spawn a static mesh actor and assign a cylinder to its static mesh
# component
actor = unreal.EditorLevelLibrary.spawn_actor_from_class(
unreal.StaticMeshActor, location=(0, 0, 0))
actor.static_mesh_component.set_static_mesh(get_cylinder_asset())
actor.set_actor_label('Cylinder')
actor.set_actor_transform(
unreal.Transform(
(-200, 0, 0),
(0, 0, 0),
(2, 2, 2),
),
sweep=False,
teleport=True
)
actors.append(actor)
# Spawn a static mesh actor and assign a cube to its static mesh
# component
actor = unreal.EditorLevelLibrary.spawn_actor_from_class(
unreal.StaticMeshActor, location=(0, 0, 0))
actor.static_mesh_component.set_static_mesh(get_geo_asset())
actor.set_actor_label('Cube')
actor.set_actor_transform(
unreal.Transform(
(200, 0, 100),
(45, 0, 45),
(2, 2, 2),
),
sweep=False,
teleport=True
)
actors.append(actor)
return actors
def run():
# get the API singleton
api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
global _g_wrapper
# instantiate an asset with auto-cook enabled
_g_wrapper = api.instantiate_asset(get_test_hda(), unreal.Transform())
# Configure inputs on_post_instantiation, after instantiation, but before first cook
_g_wrapper.on_post_instantiation_delegate.add_callable(configure_inputs)
# Bind on_post_processing, after cook + output creation
_g_wrapper.on_post_processing_delegate.add_callable(print_inputs)
if __name__ == '__main__':
run()
|
# master分支：原始lession内容存档
import unreal
path = '/project/'
# path = '/project/-000-001'
def listAssets(path):
# 获取所有资产
assets = unreal.EditorAssetLibrary.list_assets(path, recursive=True, include_folder=False)
for asset in assets:
print(asset)
listAssets(path)
# get users selection of content and outliner
def getSelectionContentBrowser():
EUL = unreal.EditorUtilityLibrary
selectionAssets = EUL.get_selected_assets()
for item in selectionAssets:
print(item)
def getAllActors():
EAS = unreal.EditorActorSubsystem
actors = EAS.get_all_level_actors()
for item in actors:
print(item)
def getSelectedActors():
EAS = unreal.EditorActorSubsystem()
selectedActors = EAS.get_selected_level_actors()
for item in selectedActors:
print(item)
def getAssetClass():
EAL = unreal.EditorAssetLibrary()
assetPaths = EAL.list_assets('/project/')
# 与其说是返回资产本身，其实返回的是资产的相对路径：/project/.Shape_Cylinder
for assetPath in assetPaths:
assetData = EAL.find_asset_data(assetPath)
assetClass = assetData.asset_class_path # <Struct 'TopLevelAssetPath' (0x0000067A5656A8FC) {package_name: "/project/", asset_name: "Texture2D"}>
# assetClass = assetData.asset_class
# [Read-Only] The name of the asset’s class deprecated:
# Short asset class name must be converted to full asset pathname.
# Use AssetClassPath instead.
print(assetClass.asset_name) # Texture2D
def getAssetClass(classType):
EAL = unreal.EditorAssetLibrary()
# assetPaths = EAL.list_assets('/project/')
assetPaths = EAL.list_assets('/project/')
assets = []
for assetPath in assetPaths:
assetData = EAL.find_asset_data(assetPath)
assetClass = assetData.asset_class_path
if assetClass.asset_name == classType:
assets.append(assetData.get_asset())
# 这里的static mesh不是路径，不是名称，而是Object本身
# <Object '/project/.Ch19_nonPBR' (0x0000067A749DD200) Class 'SkeletalMesh'>
# for asset in assets:
# print(asset)
return assets
# 注意函数顺序
def getStaticMeshData():
staticMeshes = getAssetClass('StaticMesh')
for staticMesh in staticMeshes:
# asset_import_data 是 static mesh 的editor property
# assetImportData = staticMesh.get_editor_property('asset_import_data') # <Object '/project/.Floor_400x400:FbxStaticMeshImportData_23' (0x0000067A6A632000) Class 'FbxStaticMeshImportData'>
# fbxFilePath = assetImportData.extract_filenames() # ["D:/../../project/.FBX"]
# print(fbxFilePath)
lod_GroupInfo = staticMesh.get_editor_property('lod_group')
# 即使打印为 None，也并不代表没有lod，有可能用户使用了dcc创建了自定义的lod。这是一种判断确定是否使用通用lod的方案配置
# 这里的 lod_group 只表示 UE 针对 SM 自动生成的LOD信息
print(lod_GroupInfo)
if lod_GroupInfo == 'None':
# print(staticMesh.get_name())
if staticMesh.get_num_lods() == 1:
staticMesh.set_editor_property('lod_group','LargeProp') # 对于静态网格体实施LOD优化
# 平均数量
# 每个static mesh的每个lod的三角形数量
def getStaticMeshLODData():
PML = unreal.ProceduralMeshLibrary
staticMeshes = getAssetClass('StaticMesh')
for staticMesh in staticMeshes:
staticMeshTriCount = [] # 当前SM中三角形数量
numLODs = staticMesh.get_num_lods() # 当前static mesh ue自动生成的lod层级数量
for i in range(numLODs):
numSections = staticMesh.get_num_sections(i) # A section is a group of triangles that share the same material.
LodTriCount = 0
for j in range(numSections):
sectionData = PML.get_section_from_static_mesh(staticMesh,i,j)
sectionTriCount = len(sectionData[1]) / 3 # 当前section,三角形数量
LodTriCount += (int)(sectionTriCount) # 当前lod中三角形的数量
staticMeshTriCount.append(LodTriCount)
staticMeshReduction = [100] # 初始模型三角形占比100%
for i in range(1,len(staticMeshTriCount)):
staticMeshReduction.append((int)((staticMeshTriCount[i] / staticMeshTriCount[0]) * 100))
# staticMeshReduction = [str(item) + '%' for item in staticMeshReduction] # TODO:这是一种什么写法?这种写法会有什么好处?
# 后续可以删除三角形网格数量少于20%的lod，算是一种优化的手段了
# print(staticMesh.get_name())
# print(staticMeshTriCount) # python中的占位符,我不会用
# print(staticMeshReduction)
# print(".................")
# 按照LOD 1作为当前mesh多个lod之间的平均网格数
staticMeshLODData = []
LODData = (staticMesh.get_name() , staticMeshTriCount[0])
staticMeshLODData.append(LODData)
return staticMeshLODData
# 每个static mesh在场景中出现的次数
# 当前场景中的static mesh的资产lod的三角形面数，平均为多少
def getStaticMeshInstanceCounts():
levelActors = unreal.get_editor_subsystem(unreal.EditorActorSubsystem).get_selected_level_actors()
# TODO:如何获取下面挂的所有子物体？
staticMeshActors = []
staticMeshActorCounts = [] # 作为元组，存储actor和count
for levelActor in levelActors:
# print(levelActor.get_class()) # <Object '/project/.Actor' (0x00000BCCA9E41E00) Class 'Class'>
if(levelActor.get_class().get_name() == 'StaticMeshActor'):
staticMeshComponent = levelActor.static_mesh_component
staticMesh = staticMeshComponent.static_mesh
staticMeshActors.append(staticMesh.get_name())
# levelActor.get_name() #StaticMeshActor_13260
# 或者使用actor.get_actor_label()
# for staticMeshActor in staticMeshActors:
# print(staticMeshActor)
# 防止重复，输出当前actor在场景中出现的次数
# TODO:前缀一样作为相同的actor
processedActors = []
for staticMeshActor in staticMeshActors:
if staticMeshActor not in processedActors:
# print(staticMeshActor , staticMeshActors.count(staticMeshActor))
# 作为元组添加到list
actorCounts = (staticMeshActor , staticMeshActors.count(staticMeshActor))
staticMeshActorCounts.append(actorCounts)
processedActors.append(staticMeshActor)
# 排序
staticMeshActorCounts.sort(key=lambda a: a[1] , reverse=True)
# 按照每个item第二个元素排序
# 它告诉sort()方法使用列表中每个元素的第二个元素（索引为1）作为排序依据。
# 这里的a代表列表中的每个元素。
# TODO:lambda表达式
# The sort() function modifies the original list and does not return a new sorted list.
LODData = getStaticMeshLODData()
aggregateTriCounts = []
for i in range(len(staticMeshActorCounts)):
for j in range(len(LODData)):
if staticMeshActorCounts[i][0] == LODData[j][0]:
aggregateTriCount = (staticMeshActorCounts[i][0] , staticMeshActorCounts[i][1] * LODData[j][1])
aggregateTriCounts.append(aggregateTriCount)
aggregateTriCounts.sort(key = lambda a :a[1] , reverse= True)
if not aggregateTriCounts:
print("none")
for item in aggregateTriCounts:
print(item)
# 通过简单代码，查看unreal类之间的关系。比如，深挖static mesh component
# 善于使用dir/help
# 一键替换材质
def returnMaterialInfomationSMC():
levelActors = unreal.get_editor_subsystem(unreal.EditorActorSubsystem).get_all_level_actors()
testMat = unreal.EditorAssetLibrary.find_asset_data('/project/').get_asset()
# 到底啥时候用get_editor_subsustem啊？反正这里的library不用
# TODO:找到静态网格体，几种方法？
for levelActor in levelActors:
if(levelActor.get_class().get_name() == 'StaticMeshActor'):
staticMeshComponent = levelActor.static_mesh_component
# 一定要这样获取材质吗？
# actor -> SMactor -> staticMeshComponent -> material?
# materials = staticMeshComponent.get_materials()
# for material in materials:
# print(material.get_name())
# # TODO:复习try except语句
# try:
# for item in material.texture_parameter_values:
# print(item)
# # 如果有texture，会输出texture的路径
# except:
# pass
# print('___')
# 一键替换 Material
for i in range(staticMeshComponent.get_num_materials()):
staticMeshComponent.set_material(i,testMat)
# returnMaterialInfomationSMC()
|
#
# Copyright(c) 2025 The SPEAR Development Team. Licensed under the MIT License <http://opensource.org/project/>.
# Copyright(c) 2022 Intel. Licensed under the MIT License <http://opensource.org/project/>.
#
import os
import spear
import time
import unreal
delay_seconds = 5.0
post_tick_callback_handle = None
start_time_seconds = time.time()
file = __file__
def post_tick_callback(delta_time):
global post_tick_callback_handle, start_time_seconds, file
spear.log(f"post_tick_callback(delta_time={delta_time})") # don't use spear.log_current_function() because we want to print delta_time
elapsed_time_seconds = time.time() - start_time_seconds
if elapsed_time_seconds > delay_seconds:
spear.log("unreal.unregister_slate_post_tick_callback(...)")
unreal.unregister_slate_post_tick_callback(post_tick_callback_handle)
spear.log("unreal.AutomationLibrary.take_high_res_screenshot(...)")
screenshot = os.path.realpath(os.path.join(os.path.dirname(file), "screenshot.png"))
unreal.AutomationLibrary.take_high_res_screenshot(1024, 1024, screenshot)
# send message to outer Python script if a message queue named "take_screenshot" is available
spear.log("unreal.get_default_object(...)")
sp_message_queue_manager_default_object = unreal.get_default_object(unreal.SpMessageQueueManager)
if sp_message_queue_manager_default_object.has_queue("take_screenshot"):
spear.log("sp_message_queue_manager_default_object.push_message_to_back_of_queue(...)")
sp_message_queue_manager_default_object.push_message_to_back_of_queue("take_screenshot", f"Screenshot saved to path: {screenshot}")
if __name__ == "__main__":
spear.log("unreal.register_slate_post_tick_callback(...)")
post_tick_callback_handle = unreal.register_slate_post_tick_callback(post_tick_callback)
spear.log("Done.")
|
import unreal
import os
# Get the list of weapons from ADACA_extract
weapons_dir = "C:/project/"
weapons = [w.replace(".uasset", "") for w in os.listdir(weapons_dir) if w.startswith("Wep_") and w.endswith(".uasset")]
print(f"Weapons found: {weapons}")
package_path = "/project/"
factory = unreal.BlueprintFactory()
factory.set_editor_property("ParentClass", unreal.Actor)
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
for weapon in weapons:
print(f"Creating blueprint Actor class for {weapon}...")
new_asset = (asset_tools.create_asset(weapon, package_path, None, factory))
# unreal.EditorAssetLibrary.save_loaded_asset(new_asset)
|
import unreal
import os
import json
# SETTINGS
JSON_FOLDER = "/project/" # Folder to look for material JSON files
SAVE_MATERIALS_TO = "/project/" # Where to save generated materials
ROOT_DIR = "/Game" # Root directory to search for textures
# Helpers
def ensure_directory_exists(path):
if not unreal.EditorAssetLibrary.does_directory_exist(path):
unreal.EditorAssetLibrary.make_directory(path)
def find_texture_by_filename(root_dir, filename):
asset_registry = unreal.AssetRegistryHelpers.get_asset_registry()
asset_registry.scan_paths_synchronous([root_dir], True)
assets = asset_registry.get_assets_by_path(root_dir, recursive=True)
for asset in assets:
if asset.asset_class == "Texture2D" and str(asset.asset_name).lower() == filename.lower():
return asset.object_path
return None
def create_material(material_name, textures):
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
material_path = SAVE_MATERIALS_TO + "/" + material_name
ensure_directory_exists(SAVE_MATERIALS_TO)
if unreal.EditorAssetLibrary.does_asset_exist(material_path):
print(f"⚠️ Material {material_name} already exists, skipping creation.")
return unreal.load_asset(material_path)
material_factory = unreal.MaterialFactoryNew()
material = asset_tools.create_asset(material_name, SAVE_MATERIALS_TO, unreal.Material, material_factory)
print(f"🎨 Created new material: {material_name}")
x = -384
y = -200
y_spacing = 250
for param_name, texture_filename in textures.items():
short_name = os.path.basename(texture_filename).split(".")[0]
texture_path = find_texture_by_filename(ROOT_DIR, short_name)
if not texture_path:
print(f" - Texture not found for: {short_name}")
continue
texture = unreal.load_asset(texture_path)
if not texture:
print(f" - Failed to load asset: {texture_path}")
continue
tex_sample = unreal.MaterialEditingLibrary.create_material_expression(material, unreal.MaterialExpressionTextureSample, x, y)
tex_sample.texture = texture
param_name_lower = param_name.lower()
if "normal" in param_name_lower:
tex_sample.sampler_type = unreal.MaterialSamplerType.SAMPLERTYPE_NORMAL
unreal.MaterialEditingLibrary.connect_material_property(tex_sample, "RGB", unreal.MaterialProperty.MP_NORMAL)
elif "emissive" in param_name_lower:
unreal.MaterialEditingLibrary.connect_material_property(tex_sample, "RGB", unreal.MaterialProperty.MP_EMISSIVE_COLOR)
elif "ao" in param_name_lower or "rough" in param_name_lower or "metal" in param_name_lower:
unreal.MaterialEditingLibrary.connect_material_property(tex_sample, "RGB", unreal.MaterialProperty.MP_AMBIENT_OCCLUSION)
elif "basecolor" in param_name_lower or "diffuse" in param_name_lower or "albedo" in param_name_lower:
unreal.MaterialEditingLibrary.connect_material_property(tex_sample, "RGB", unreal.MaterialProperty.MP_BASE_COLOR)
print(f" - Added and connected TextureSample for {param_name} ({short_name})")
y += y_spacing
unreal.MaterialEditingLibrary.layout_material_expressions(material)
unreal.MaterialEditingLibrary.recompile_material(material)
unreal.EditorAssetLibrary.save_asset(material_path)
print(f"✅ Saved material: {material_name}")
return material
def process_json_materials(json_folder):
json_folder_path = unreal.Paths.convert_relative_path_to_full(unreal.Paths.project_content_dir()) + json_folder.replace("/Game", "")
if not os.path.exists(json_folder_path):
print(f"Folder does not exist: {json_folder_path}")
return
json_files = []
for root, dirs, files in os.walk(json_folder_path):
for file in files:
if file.endswith(".json") and "MAT" in file.upper():
json_files.append(os.path.join(root, file))
print(f"Found {len(json_files)} JSON material files to process.")
with unreal.ScopedSlowTask(len(json_files), "Generating Materials from JSON...") as task:
task.make_dialog(True)
for i, full_path in enumerate(json_files):
if task.should_cancel():
print("Material generation canceled.")
break
file = os.path.basename(full_path)
mat_name = os.path.splitext(file)[0]
material_path = SAVE_MATERIALS_TO + "/" + mat_name
task.enter_progress_frame(1.0, f"Processing {mat_name} ({i + 1}/{len(json_files)})")
# Skip if asset already exists
if unreal.EditorAssetLibrary.does_asset_exist(material_path):
print(f"⚠️ Skipping existing material: {mat_name}")
continue
try:
with open(full_path, 'r') as f:
data = json.load(f)
if "Textures" in data:
textures = data["Textures"]
create_material(mat_name, textures)
else:
print(f"❌ No 'Textures' section in {file}")
except Exception as e:
print(f"❌ Failed to process {file}: {str(e)}")
# Run
process_json_materials(JSON_FOLDER)
|
"""
This is a Blueprint Function Library
When initialized it will add function nodes to Unreal that may be used in Blueprint Graphs
Python based BP functions are currently suited towards Editor Utilities, giving more access
to technical artists and developers to create editor tools and macros
Blueprint Function Libraries rely heavily on decorators, this module focuses
on exposing most of the available practical options in individual examples
"""
import json
import os
from pathlib import Path
import unreal
from recipebook import (
editor_tools,
metadata,
utils
)
@unreal.uclass()
class PyDemoBPLibrary(unreal.BlueprintFunctionLibrary):
"""
Blueprint functions declared in this class will be available in Editor
"""
# --------- standard options --------- #
@unreal.ufunction(static=True)
def basic_function_test():
"""Python Blueprint Node -- run Python logic!"""
print("Running python!")
pass
@unreal.ufunction(static=True, params=[str])
def input_test(user_input = "cool!"):
"""Python Blueprint Node -- print the text input"""
print(f"Provided input: {user_input}")
@unreal.ufunction(static=True, ret=str)
def return_test():
"""Python Blueprint Node -- return a string!
returns:
str
"""
return "cool!"
@unreal.ufunction(static=True, params=[str, bool, int])
def multiple_input_test(in_str, in_bool, in_int):
"""Python Blueprint Node -- multiple inputs (string, bool, int)"""
print(f"{in_str} ({type(in_str)}) | {in_bool} ({type(in_bool)}) | {in_int} ({type(in_int)})")
@unreal.ufunction(static=True, ret=(int, bool, str))
def multiple_returns_test():
"""Python Blueprint Node -- Return (str, bool, int)
NOTE: the 'ret' decorator arg is reversed from the actual python return
"""
return "Awesome", True, 5
@unreal.ufunction(static=True, ret=unreal.Array(str), params=[unreal.Array(str)])
def sort_string_list_test(in_list):
"""
Python Blueprint Node -- Sort a list of strings,
useful for managing options in editor tools
"""
return sorted(in_list)
@unreal.ufunction(ret= str, pure=True, static=True)
def pure_function_test() -> str:
"""Python Blueprint Node -- Pure functions have no execution flow pin connectors,
a pure function is intended for getter functions that do not change the state of assets in Unreal
"""
return os.environ.get("USER", "unknown user")
# --------- metadata options --------- #
@unreal.ufunction(static=True, meta=dict(Category="recipebook | category | sorting"))
def meta_category_test():
"""Python Blueprint Node -- Category organizes this node in the BP Graph right click menu
Use | to create sub-groupings to further organize complex libraries or place them with
existing nodes in the BP Graph menu
"""
pass
@unreal.ufunction(static=True, meta=dict(KeyWords="random arbitrary keywords"))
def meta_keywords_test():
"""Python Blueprint Node -- KeyWords help the discovery of this node in the BP Graph right click menu"""
pass
@unreal.ufunction(static=True, meta=dict(CompactNodeTitle="UEPY"))
def meta_compact_name_test():
"""Python Blueprint Node -- CompactNodeTitle"""
pass
@unreal.ufunction(static=True, params=[unreal.Actor], meta=dict(DefaultToSelf="target_object"))
def meta_default_to_self_test(target_object):
"""Python Blueprint Node -- DefaultToSelf (The BP Class calling this Function)"""
print(f"target object: {target_object}")
pass
@unreal.ufunction(static=True, ret=(int, bool, str), meta=dict(HidePin="returnValue"))
def multiple_returns_fixed_test():
"""Python Blueprint Node -- Return (str, bool, int)"""
return "Awesome", True, 5
# --------- practical examples --------- #
@unreal.ufunction(
static=True, ret=unreal.Array(unreal.EditorUtilityObject),
params=[unreal.Array(unreal.EditorUtilityObject)],
pure=True, meta=dict(Category="recipebook | EUW | item data", DeterminesOutputType="array_to_match")
)
def get_item_data_for_euw(array_to_match=unreal.Array(unreal.EditorUtilityObject)):
"""
Python Blueprint Node -- Return the EUW Item Data,
array_to_match is used to manage the return type
this lets us return custom Blueprint Asset based classes directly
"""
# The template asset path for our item data
item_template_path = "/project/"
# use arbitrary icons from the icons python dir
fp = Path(__file__).parent
icon_dir = fp.joinpath("icons")
icons = {
icon.stem: str(icon.as_posix())
for icon in icon_dir.iterdir()
}
# get all of our managed assets (using the default arg for "is_managed_asset")
meta_query = {metadata.META_IS_MANAGED_ASSET: True}
assets = metadata.find_assets_by_metadata(meta_query, class_names=["Blueprint"])
if not assets:
return []
items = []
for asset in assets:
# Create a new Python instance of the template asset
item = utils.new_instance_from_asset(item_template_path)
name = metadata.get_metadata(asset, metadata.META_ASSET_NAME)
# feed the desired asset metadata into our item
item.set_editor_properties({
"name": name,
"type": metadata.get_metadata(asset, metadata.META_ASSET_TYPE),
"group": metadata.get_metadata(asset, metadata.META_ASSET_GROUP),
"version": metadata.get_metadata(asset, metadata.META_ASSET_VERSION),
"image_path": icons.get(name[-1])
})
items.append(item)
# return the list of ready-to-use item data in our EUW!
return items
@unreal.ufunction(
static=True, ret=unreal.Array(unreal.EditorUtilityObject),
params=[unreal.Array(unreal.EditorUtilityObject), str, str, str],
pure=True, meta=dict(Category="recipebook | EUW | item data", DeterminesOutputType="items")
)
def filter_item_data(items, type_filter, group_filter, name_filter):
"""Python Blueprint Node -- filter the given list of meta_item_data entries"""
# nested function to make the list comprehension cleaner
# only use the filter if it's valid, otherwise skip it (return True)
def check_filter_match(a, b): return str(a) == str(b) if a else True
return [
item
for item in items
if check_filter_match(type_filter, item.get_editor_property("type"))
and check_filter_match(group_filter, item.get_editor_property("group"))
and name_filter.lower() in str(item.get_editor_property("name")).lower()
]
@unreal.ufunction(
static=True, params=[str, unreal.Map(str, str)],
meta=dict(Category="recipebook | EUW | prefs")
)
def save_user_prefs(prefs_name, prefs_data):
"""Python Blueprint Node -- save some basic prefs data"""
# Convert the unreal Map to a json compliant dict
prefs = {
str(key): str(value)
for key, value in prefs_data.items()
}
# we'll save this file to the users' tmp dir under 'unreal/unreal_prefs_<pref>.json'
prefs_file = Path(
unreal.Paths.project_saved_dir(),
"pytemp",
f"unreal_prefs_{prefs_name}.json"
)
if not prefs_file.exists():
prefs_file.parent.mkdir(parents=True, exist_ok=True)
with prefs_file.open("w", encoding="utf-8") as f:
json.dump(prefs, f, indent=2)
@unreal.ufunction(
static=True, ret=unreal.Map(str, str), params=[str],
pure=True, meta=dict(Category="recipebook | EUW | prefs")
)
def load_user_prefs(prefs_name) :
"""Python Blueprint Node -- load some basic prefs data"""
# use the same path structure as the save and make sure it exists
prefs_file = Path(
unreal.Paths.project_saved_dir(),
"pytemp",
f"unreal_prefs_{prefs_name}.json"
)
if not prefs_file.exists():
return {}
# we can return the dict as-is, Unreal will convert it to a Map(str,str) for us
return json.loads(prefs_file.read_text())
@unreal.ufunction(
static=True, params=[unreal.EditorUtilityWidget],
meta=dict(Category="recipebook | EUW | prefs", DeterminesOutputType="editor_tool", DefaultToSelf="editor_tool")
)
def on_editor_tool_close(editor_tool):
"""Python Blueprint Node -- pass a widget's `self` reference to safely handle its Destruct
Unreal caches any currently open editor tools to a UE user prefs file.
During Unreal startup Unreal will open any tools listed in the UE user prefs
before Python has been initialized, before any Python nodes have been generated.
This function removes the editor tool from the UE user prefs and caches it separately,
allowing us to properly launch the tool after Python has been initialized
"""
# Get the asset path and pass it to the editor_tools module
editor_tool_path = str(editor_tool.get_class().get_outer().get_path_name())
editor_tools.on_editor_tool_close(editor_tool_path)
@unreal.ufunction(
static=True, params=[unreal.EditorUtilityWidget],
meta=dict(Category="recipebook | EUW | prefs", DeterminesOutputType="editor_tool", DefaultToSelf="editor_tool")
)
def remove_tool_from_unreal_prefs(editor_tool):
"""Python Blueprint Node -- pass a widget's `self` reference to remove it from the Unreal User Prefs INI"""
# Get the asset path and pass it to the editor_tools module
editor_tool_path = str(editor_tool.get_class().get_outer().get_path_name())
tool = unreal.find_asset(editor_tool_path)
unreal.PythonUtilsLibrary.clear_editor_tool_from_prefs(tool)
PyDemoBPLibrary()
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
""" Example script using the API to instantiate an HDA and set a landscape
input.
"""
import unreal
_g_wrapper = None
def get_test_hda_path():
return '/project/.hilly_landscape_erode_1_0'
def get_test_hda():
return unreal.load_object(None, get_test_hda_path())
def load_map():
return unreal.EditorLoadingAndSavingUtils.load_map('/project/.LandscapeInputExample')
def get_landscape():
return unreal.EditorLevelLibrary.get_actor_reference('PersistentLevel.Landscape_0')
def configure_inputs(in_wrapper):
print('configure_inputs')
# Unbind from the delegate
in_wrapper.on_post_instantiation_delegate.remove_callable(configure_inputs)
# Create a landscape input
landscape_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPILandscapeInput)
# Send landscapes as heightfields
landscape_input.landscape_export_type = unreal.HoudiniLandscapeExportType.HEIGHTFIELD
# Keep world transform
landscape_input.keep_world_transform = True
# Set the input objects/assets for this input
landscape_object = get_landscape()
landscape_input.set_input_objects((landscape_object, ))
# copy the input data to the HDA as node input 0
in_wrapper.set_input_at_index(0, landscape_input)
# We can now discard the API input object
landscape_input = None
def print_api_input(in_input):
print('\t\tInput type: {0}'.format(in_input.__class__))
print('\t\tbKeepWorldTransform: {0}'.format(in_input.keep_world_transform))
if isinstance(in_input, unreal.HoudiniPublicAPILandscapeInput):
print('\t\tbLandscapeAutoSelectComponent: {0}'.format(in_input.landscape_auto_select_component))
print('\t\tbLandscapeExportLighting: {0}'.format(in_input.landscape_export_lighting))
print('\t\tbLandscapeExportMaterials: {0}'.format(in_input.landscape_export_materials))
print('\t\tbLandscapeExportNormalizedUVs: {0}'.format(in_input.landscape_export_normalized_u_vs))
print('\t\tbLandscapeExportSelectionOnly: {0}'.format(in_input.landscape_export_selection_only))
print('\t\tbLandscapeExportTileUVs: {0}'.format(in_input.landscape_export_tile_u_vs))
print('\t\tbLandscapeExportType: {0}'.format(in_input.landscape_export_type))
input_objects = in_input.get_input_objects()
if not input_objects:
print('\t\tEmpty input!')
else:
print('\t\tNumber of objects in input: {0}'.format(len(input_objects)))
for idx, input_object in enumerate(input_objects):
print('\t\t\tInput object #{0}: {1}'.format(idx, input_object))
def print_inputs(in_wrapper):
print('print_inputs')
# Unbind from the delegate
in_wrapper.on_post_processing_delegate.remove_callable(print_inputs)
# Fetch inputs, iterate over it and log
node_inputs = in_wrapper.get_inputs_at_indices()
parm_inputs = in_wrapper.get_input_parameters()
if not node_inputs:
print('No node inputs found!')
else:
print('Number of node inputs: {0}'.format(len(node_inputs)))
for input_index, input_wrapper in node_inputs.items():
print('\tInput index: {0}'.format(input_index))
print_api_input(input_wrapper)
if not parm_inputs:
print('No parameter inputs found!')
else:
print('Number of parameter inputs: {0}'.format(len(parm_inputs)))
for parm_name, input_wrapper in parm_inputs.items():
print('\tInput parameter name: {0}'.format(parm_name))
print_api_input(input_wrapper)
def run():
# Load the example map
load_map()
# get the API singleton
api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
global _g_wrapper
# instantiate an asset with auto-cook enabled
_g_wrapper = api.instantiate_asset(get_test_hda(), unreal.Transform())
# Configure inputs on_post_instantiation, after instantiation, but before first cook
_g_wrapper.on_post_instantiation_delegate.add_callable(configure_inputs)
# Print the input state after the cook and output creation.
_g_wrapper.on_post_processing_delegate.add_callable(print_inputs)
if __name__ == '__main__':
run()
|
import unreal
#Access the editor's utility library and system library
level_library = unreal.EditorActorSubsystem()
system_lib = unreal.SystemLibrary()
editor_subsystem = unreal.UnrealEditorSubsystem()
# Get the currently opened level
current_level = editor_subsystem.get_editor_world()
#initialize the static mesh actor variable
static_mesh_name = ""
#Get the static mesh of the selected actor
selected_actor = level_library.get_selected_level_actors()
count = len(selected_actor)
if count == 1:
static_mesh = selected_actor[0].get_component_by_class(unreal.StaticMeshComponent)
if static_mesh and static_mesh.static_mesh:
static_mesh_name = static_mesh.static_mesh.get_name()
else:
print("ATENTION: The selected actor is not valid or does not have any StaticMeshComponent.")
exit()
else:
print("ATENTION: Please select only one actor at a time.")
exit()
# Get all actors in the level that have a static mesh component with the specific mesh
actors_with_sm = []
actors = unreal.GameplayStatics.get_all_actors_of_class(current_level, unreal.StaticMeshActor)
for actor in actors:
#Assuming the actor has a StaticMeshComponent
static_mesh_component = actor.get_component_by_class(unreal.StaticMeshComponent)
if static_mesh_component and static_mesh_component.static_mesh:
#Check if the static mesh's name matches what we are looking for
if static_mesh_name == static_mesh_component.static_mesh.get_name():
actors_with_sm.append(actor)
#print(actor)
#Select the actors in the editor
level_library.set_selected_level_actors(actors_with_sm)
#Output how many actors were selected
print("Selected {} actors with the StaticMeshComponent {}".format(len(actors_with_sm), static_mesh_name))
|
import unreal
# 라이트 액터를 서브 시퀀스에 연결
def link_light_actors_to_sequence(LIT_sub_sequence_path):
# EditorActorSubsystem의 인스턴스를 가져옵니다
editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
allActors = editor_actor_subsystem.get_all_level_actors()
# 특정 클래스 타입에 해당하는 모든 액터를 찾습니다
find_lightActor_classList = [unreal.DirectionalLight, unreal.SkyLight, unreal.PostProcessVolume, unreal.ExponentialHeightFog, unreal.SkyAtmosphere]
possessableActor_classList = []
for cls in find_lightActor_classList:
possessableActor_class = unreal.EditorFilterLibrary.by_class(allActors, cls)
print(f"Filtered Class : {possessableActor_class}")
possessableActor_classList.extend(possessableActor_class)
# 해당 타입이 없으면 Spawnable로 추가
spawnableActor_classList = []
for cls in find_lightActor_classList:
# 해당 클래스의 액터가 possessableActor_classList에 없으면 spawnable로 추가
if not any(isinstance(actor, cls) for actor in possessableActor_classList):
spawnableActor_classList.append(cls)
# Level에 있는 Actor를 Level에서 Sequence로 연결
sub_sequence = unreal.load_asset(LIT_sub_sequence_path, unreal.LevelSequence)
for cls in possessableActor_classList:
sub_sequence.add_possessable(cls)
print(f"{cls} has been created and linked to the sequence.")
# Level에 없는 Actor를 Spawnable로 추가
for cls in spawnableActor_classList:
sub_sequence.add_spawnable_from_class(cls)
print(f"{cls} has been created and linked to the sequence.")
# 변경 사항 저장
# unreal.EditorAssetLibrary.save_loaded_asset(sub_sequence)
# 문자열을 불리언 값으로 변환
def str_to_bool(s):
if s == "true":
return True
elif s == "false":
return False
else:
raise ValueError(f"Cannot convert {s} to a boolean value")
# 서브 시퀀스 에셋 이름 생성
def get_unique_asset_name(part, shot_name, project_name, ProjectName_CheckBox, directory):
# Unreal Engine의 에셋 경로 형식으로 변경
asset_directory = directory.replace("\\", "/") # ~/LIT
if ProjectName_CheckBox == "true":
base_name = f"{part}_SUB_{project_name}_{shot_name}" # LIT_SUB_2024_Enchantress_Shot_02_03
else:
base_name = f"{part}_SUB_{shot_name}" # LIT_SUB_Shot_02_03
# 초기 버전 번호 설정
counter = 2
asset_name = f"{base_name}_{counter:02d}" # LIT_SUB_Shot_02_03_01
# 디렉토리 내의 모든 에셋 경로를 가져옴
existing_assets = unreal.EditorAssetLibrary.list_assets(asset_directory)
# 에셋 경로에서 이름을 추출하여 확인
for asset_path in existing_assets:
asset = unreal.EditorAssetLibrary.load_asset(asset_path)
exist_asset_name = unreal.SystemLibrary.get_object_name(asset)
if exist_asset_name.startswith(base_name):
try:
# 버전 번호 추출 및 비교
version_str = exist_asset_name.split("_")[-1]
asset_counter = int(version_str)
counter = max(counter, asset_counter + 1)
except ValueError:
continue
# 최종 에셋 이름 생성
asset_name = f"{base_name}_{counter - 1:02d}"
asset_path = f"{asset_directory}/{asset_name}"
# 에셋이 이미 존재하면 메세지 표시 및 카운터 증가
if unreal.EditorAssetLibrary.does_asset_exist(asset_path):
exist_message = unreal.EditorDialog.show_message(
message_type=unreal.AppMsgType.YES_NO,
title="경고",
message=f"{base_name}_{counter - 1:02d} : 시퀀스가 이미 존재합니다.\n{base_name}_{counter:02d} : 이름으로 생성하시겠습니까?\n아니요를 선택하면 작업이 취소됩니다."
)
if exist_message == unreal.AppReturnType.YES:
asset_name = f"{base_name}_{counter:02d}"
else:
asset_name = "break"
return asset_name
def create_shot(ProjectSelected, ProjectName_CheckBox, LIT_CheckBox, FX_CheckBox, ANI_CheckBox):
# 프로젝트 선택 콤보박스에서 선택된 프로젝트 이름 가져오기
game_name = ProjectSelected
print(f"game_name : {game_name}")
# 최소 하나의 파트를 선택했는지 확인
if LIT_CheckBox == "false" and FX_CheckBox == "false" and ANI_CheckBox == "false":
unreal.EditorDialog.show_message(
message_type=unreal.AppMsgType.OK,
title="경고",
message="최소 하나의 파트를 선택해주세요."
)
return
# 체크박스 선택 여부 딕셔너리 생성
checkBox_dict = {
"LIT": str_to_bool(LIT_CheckBox),
"FX": str_to_bool(FX_CheckBox),
"ANI": str_to_bool(ANI_CheckBox)
}
partList = ["LIT", "FX", "ANI"]
partSelected = []
for part in partList:
if checkBox_dict[part]:
partSelected.append(part)
print(f"partSelected : {partSelected}")
# 새 레벨 시퀀스 에셋 생성
current_level_sequence = unreal.LevelSequenceEditorBlueprintLibrary.get_current_level_sequence()
shot_name = current_level_sequence.get_name()
print(f"shot_name : {shot_name}")
shot_path = current_level_sequence.get_path_name()
shot_package_path = "/".join(shot_path.split("/")[:-1]) #/project/
print(f"shot_package_path : {shot_package_path}")
# 상위 폴더 이름을 project_name으로 변수 추가
project_name = shot_package_path.split("/")[-2]
print(f"project_name : {project_name}")
for part in partSelected:
sub_package_path = shot_package_path + f"/Subsequence/{part}"
asset_name = get_unique_asset_name(part, shot_name, project_name, ProjectName_CheckBox, sub_package_path)
# 서브 시퀀스 에셋 생성
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
if asset_name == "break":
break
else:
sub_sequence_asset = asset_tools.create_asset(
asset_name=asset_name,
package_path=sub_package_path,
asset_class=unreal.LevelSequence,
factory=unreal.LevelSequenceFactoryNew()
)
# 메인 레벨 시퀀스 로드
main_sequence_path = shot_path
print(f"main_sequence_path : {main_sequence_path}")
main_sequence = unreal.load_asset(main_sequence_path, unreal.LevelSequence)
print(f"main_sequence : {main_sequence}")
# 메인 시퀀스에 서브시퀀스 트랙 추가
sub_track = main_sequence.add_track(unreal.MovieSceneSubTrack)
# 시작과 종료 프레임 가져오기
playback_range = main_sequence.get_playback_range()
print(f"playback_range : {playback_range}")
playback_start = playback_range.inclusive_start
playback_end = playback_range.exclusive_end
# 서브시퀀스 섹션 추가 및 설정
sub_section = sub_track.add_section()
sub_section.set_sequence(sub_sequence_asset)
sub_section.set_range(playback_start, playback_end) # 시작과 종료 프레임 설정
# part가 LIT일 경우, 서브 시퀀스에 라이트 액터 연결
if part == "LIT":
LIT_sub_sequence_path = sub_sequence_asset.get_path_name()
link_light_actors_to_sequence(LIT_sub_sequence_path)
|
# coding: utf-8
import unreal
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-vrm")
parser.add_argument("-rig")
parser.add_argument("-meta")
args = parser.parse_args()
print(args.vrm)
#print(dummy[3])
humanoidBoneList = [
"hips",
"leftUpperLeg",
"rightUpperLeg",
"leftLowerLeg",
"rightLowerLeg",
"leftFoot",
"rightFoot",
"spine",
"chest",
"upperChest", # 9 optional
"neck",
"head",
"leftShoulder",
"rightShoulder",
"leftUpperArm",
"rightUpperArm",
"leftLowerArm",
"rightLowerArm",
"leftHand",
"rightHand",
"leftToes",
"rightToes",
"leftEye",
"rightEye",
"jaw",
"leftThumbProximal", # 24
"leftThumbIntermediate",
"leftThumbDistal",
"leftIndexProximal",
"leftIndexIntermediate",
"leftIndexDistal",
"leftMiddleProximal",
"leftMiddleIntermediate",
"leftMiddleDistal",
"leftRingProximal",
"leftRingIntermediate",
"leftRingDistal",
"leftLittleProximal",
"leftLittleIntermediate",
"leftLittleDistal",
"rightThumbProximal",
"rightThumbIntermediate",
"rightThumbDistal",
"rightIndexProximal",
"rightIndexIntermediate",
"rightIndexDistal",
"rightMiddleProximal",
"rightMiddleIntermediate",
"rightMiddleDistal",
"rightRingProximal",
"rightRingIntermediate",
"rightRingDistal",
"rightLittleProximal",
"rightLittleIntermediate",
"rightLittleDistal", #54
]
humanoidBoneParentList = [
"", #"hips",
"hips",#"leftUpperLeg",
"hips",#"rightUpperLeg",
"leftUpperLeg",#"leftLowerLeg",
"rightUpperLeg",#"rightLowerLeg",
"leftLowerLeg",#"leftFoot",
"rightLowerLeg",#"rightFoot",
"hips",#"spine",
"spine",#"chest",
"chest",#"upperChest" 9 optional
"chest",#"neck",
"neck",#"head",
"chest",#"leftShoulder", # <-- upper..
"chest",#"rightShoulder",
"leftShoulder",#"leftUpperArm",
"rightShoulder",#"rightUpperArm",
"leftUpperArm",#"leftLowerArm",
"rightUpperArm",#"rightLowerArm",
"leftLowerArm",#"leftHand",
"rightLowerArm",#"rightHand",
"leftFoot",#"leftToes",
"rightFoot",#"rightToes",
"head",#"leftEye",
"head",#"rightEye",
"head",#"jaw",
"leftHand",#"leftThumbProximal",
"leftThumbProximal",#"leftThumbIntermediate",
"leftThumbIntermediate",#"leftThumbDistal",
"leftHand",#"leftIndexProximal",
"leftIndexProximal",#"leftIndexIntermediate",
"leftIndexIntermediate",#"leftIndexDistal",
"leftHand",#"leftMiddleProximal",
"leftMiddleProximal",#"leftMiddleIntermediate",
"leftMiddleIntermediate",#"leftMiddleDistal",
"leftHand",#"leftRingProximal",
"leftRingProximal",#"leftRingIntermediate",
"leftRingIntermediate",#"leftRingDistal",
"leftHand",#"leftLittleProximal",
"leftLittleProximal",#"leftLittleIntermediate",
"leftLittleIntermediate",#"leftLittleDistal",
"rightHand",#"rightThumbProximal",
"rightThumbProximal",#"rightThumbIntermediate",
"rightThumbIntermediate",#"rightThumbDistal",
"rightHand",#"rightIndexProximal",
"rightIndexProximal",#"rightIndexIntermediate",
"rightIndexIntermediate",#"rightIndexDistal",
"rightHand",#"rightMiddleProximal",
"rightMiddleProximal",#"rightMiddleIntermediate",
"rightMiddleIntermediate",#"rightMiddleDistal",
"rightHand",#"rightRingProximal",
"rightRingProximal",#"rightRingIntermediate",
"rightRingIntermediate",#"rightRingDistal",
"rightHand",#"rightLittleProximal",
"rightLittleProximal",#"rightLittleIntermediate",
"rightLittleIntermediate",#"rightLittleDistal",
]
for i in range(len(humanoidBoneList)):
humanoidBoneList[i] = humanoidBoneList[i].lower()
for i in range(len(humanoidBoneParentList)):
humanoidBoneParentList[i] = humanoidBoneParentList[i].lower()
######
reg = unreal.AssetRegistryHelpers.get_asset_registry();
##
rigs = unreal.ControlRigBlueprint.get_currently_open_rig_blueprints()
print(rigs)
for r in rigs:
s:str = r.get_path_name()
ss:str = args.rig
if (s.find(ss) < 0):
print("no rig")
else:
rig = r
#rig = rigs[10]
h_mod = rig.get_hierarchy_modifier()
#elements = h_mod.get_selection()
#sk = rig.get_preview_mesh()
#k = sk.skeleton
#print(k)
#print(sk.bone_tree)
#
#kk = unreal.RigElementKey(unreal.RigElementType.BONE, "hipssss");
#kk.name = ""
#kk.type = 1;
#print(h_mod.get_bone(kk))
#print(h_mod.get_elements())
### 全ての骨
modelBoneListAll = []
modelBoneNameList = []
#for e in reversed(h_mod.get_elements()):
# if (e.type != unreal.RigElementType.BONE):
# h_mod.remove_element(e)
for e in h_mod.get_elements():
if (e.type == unreal.RigElementType.BONE):
modelBoneListAll.append(e)
modelBoneNameList.append("{}".format(e.name).lower())
# else:
# h_mod.remove_element(e)
print(modelBoneListAll[0])
#exit
#print(k.get_editor_property("bone_tree")[0].get_editor_property("translation_retargeting_mode"))
#print(k.get_editor_property("bone_tree")[0].get_editor_property("parent_index"))
#unreal.select
#vrmlist = unreal.VrmAssetListObject
#vrmmeta = vrmlist.vrm_meta_object
#print(vrmmeta.humanoid_bone_table)
#selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
#selected_static_mesh_actors = unreal.EditorFilterLibrary.by_class(selected_actors,unreal.StaticMeshActor.static_class())
#static_meshes = np.array([])
## meta 取得
reg = unreal.AssetRegistryHelpers.get_asset_registry();
a = reg.get_all_assets();
if (args.meta):
for aa in a:
if (aa.get_editor_property("object_path") == args.meta):
v:unreal.VrmMetaObject = aa
vv = aa.get_asset()
if (vv == None):
for aa in a:
if (aa.get_editor_property("object_path") == args.vrm):
v:unreal.VrmAssetListObject = aa
vv = v.get_asset().vrm_meta_object
print(vv)
meta = vv
#v:unreal.VrmAssetListObject = None
#if (True):
# a = reg.get_assets_by_path(args.vrm)
# a = reg.get_all_assets();
# for aa in a:
# if (aa.get_editor_property("object_path") == args.vrm):
# v:unreal.VrmAssetListObject = aa
#v = unreal.VrmAssetListObject.cast(v)
#print(v)
#unreal.VrmAssetListObject.vrm_meta_object
#meta = v.vrm_meta_object()
#meta = unreal.EditorFilterLibrary.by_class(asset,unreal.VrmMetaObject.static_class())
print (meta)
#print(meta[0].humanoid_bone_table)
### モデル骨のうち、ヒューマノイドと同じもの
### 上の変換テーブル
humanoidBoneToModel = {"" : ""}
humanoidBoneToModel.clear()
### modelBoneでループ
#for bone_h in meta.humanoid_bone_table:
for bone_h_base in humanoidBoneList:
bone_h = None
for e in meta.humanoid_bone_table:
if ("{}".format(e).lower() == bone_h_base):
bone_h = e;
break;
print("{}".format(bone_h))
if (bone_h==None):
continue
bone_m = meta.humanoid_bone_table[bone_h]
try:
i = modelBoneNameList.index(bone_m.lower())
except:
i = -1
if (i < 0):
continue
if ("{}".format(bone_h).lower() == "upperchest"):
continue;
humanoidBoneToModel["{}".format(bone_h).lower()] = "{}".format(bone_m).lower()
if ("{}".format(bone_h).lower() == "chest"):
#upperchestがあれば、これの次に追加
bh = 'upperchest'
print("upperchest: check begin")
for e in meta.humanoid_bone_table:
if ("{}".format(e).lower() != 'upperchest'):
continue
bm = "{}".format(meta.humanoid_bone_table[e]).lower()
if (bm == ''):
continue
humanoidBoneToModel[bh] = bm
humanoidBoneParentList[10] = "upperchest"
humanoidBoneParentList[12] = "upperchest"
humanoidBoneParentList[13] = "upperchest"
print("upperchest: find and insert parent")
break
print("upperchest: check end")
parent=None
control_to_mat={None:None}
count = 0
### 骨名からControlへのテーブル
name_to_control = {"dummy_for_table" : None}
print("loop begin")
###### root
key = unreal.RigElementKey(unreal.RigElementType.SPACE, 'root_s')
space = h_mod.get_space(key)
if (space.get_editor_property('index') < 0):
space = h_mod.add_space('root_s', space_type=unreal.RigSpaceType.SPACE)
else:
space = key
key = unreal.RigElementKey(unreal.RigElementType.CONTROL, 'root_c')
control = h_mod.get_control(key)
if (control.get_editor_property('index') < 0):
control = h_mod.add_control('root_c',
space_name=space.name,
gizmo_color=[1.0, 0.0, 0.0, 1.0],
)
else:
control = key
h_mod.reparent_element(control, space)
parent = control
cc = h_mod.get_control(control)
cc.set_editor_property('gizmo_visible', False)
h_mod.set_control(cc)
for ee in humanoidBoneToModel:
element = humanoidBoneToModel[ee]
humanoidBone = ee
modelBoneNameSmall = element
# 対象の骨
#modelBoneNameSmall = "{}".format(element.name).lower()
#humanoidBone = modelBoneToHumanoid[modelBoneNameSmall];
boneNo = humanoidBoneList.index(humanoidBone)
print("{}_{}_{}__parent={}".format(modelBoneNameSmall, humanoidBone, boneNo,humanoidBoneParentList[boneNo]))
# 親
if count != 0:
parent = name_to_control[humanoidBoneParentList[boneNo]]
# 階層作成
bIsNew = False
name_s = "{}_s".format(humanoidBone)
key = unreal.RigElementKey(unreal.RigElementType.SPACE, name_s)
space = h_mod.get_space(key)
if (space.get_editor_property('index') < 0):
space = h_mod.add_space(name_s, space_type=unreal.RigSpaceType.SPACE)
bIsNew = True
else:
space = key
name_c = "{}_c".format(humanoidBone)
key = unreal.RigElementKey(unreal.RigElementType.CONTROL, name_c)
control = h_mod.get_control(key)
if (control.get_editor_property('index') < 0):
control = h_mod.add_control(name_c,
space_name=space.name,
gizmo_color=[1.0, 0.0, 0.0, 1.0],
)
#h_mod.get_control(control).gizmo_transform = gizmo_trans
if (24<=boneNo & boneNo<=53):
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.1, 0.1, 0.1])
else:
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1, 1, 1])
if (17<=boneNo & boneNo<=18):
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1, 1, 1])
cc = h_mod.get_control(control)
cc.set_editor_property('gizmo_transform', gizmo_trans)
cc.set_editor_property('control_type', unreal.RigControlType.ROTATOR)
h_mod.set_control(cc)
#h_mod.set_control_value_transform(control,gizmo_trans)
bIsNew = True
else:
control = key
if (bIsNew == True):
h_mod.reparent_element(control, space)
# テーブル登録
name_to_control[humanoidBone] = control
print(humanoidBone)
# ロケータ 座標更新
# 不要な上層階層を考慮
gTransform = h_mod.get_global_transform(modelBoneListAll[modelBoneNameList.index(modelBoneNameSmall)])
if count == 0:
bone_initial_transform = gTransform
else:
#bone_initial_transform = h_mod.get_initial_transform(element)
bone_initial_transform = gTransform.multiply(control_to_mat[parent].inverse())
h_mod.set_initial_transform(space, bone_initial_transform)
control_to_mat[control] = gTransform
# 階層修正
h_mod.reparent_element(space, parent)
count += 1
if (count >= 500):
break
|
# Copyright Epic Games, Inc. All Rights Reserved.
import os
import unreal
import flow.cmd
#-------------------------------------------------------------------------------
def get_uproject_from_dir(start_dir):
from pathlib import Path
start_dir = Path(start_dir)
for search_dir in (start_dir, *start_dir.parents):
with os.scandir(search_dir) as files:
try: project = next(x.path for x in files if x.name.endswith(".uproject"))
except StopIteration: continue
return project
raise EnvironmentError(f"Unable to find a .uproject from '{start_dir}'")
#-------------------------------------------------------------------------------
Arg = flow.cmd.Arg
Opt = flow.cmd.Opt
class Cmd(flow.cmd.Cmd):
def complete_platform(self, prefix):
yield from self.read_platforms()
def complete_variant(self, prefix):
yield from (x.name.lower() for x in unreal.Variant)
def __init__(self):
super().__init__()
self._project = None
self._context = None
def get_unreal_context(self):
session = self.get_noticeboard(self.Noticeboard.SESSION)
path = session["uproject"] or "."
self._context = self._context or unreal.Context(path)
return self._context
def read_platforms(self):
platforms = self.get_unreal_context().get_platform_provider()
yield from platforms.read_platform_names()
def get_platform(self, name=None):
ue_context = self.get_unreal_context()
platforms = ue_context.get_platform_provider()
if platform := platforms.get_platform(name):
return platform
available = ",".join(platforms.read_platform_names())
raise ValueError(f"Unknown platform '{name}'. Valid list: {available}")
def get_host_platform(self):
return self.get_platform()
#-------------------------------------------------------------------------------
class MultiPlatformCmd(Cmd):
noplatforms = Opt(False, "Disable discovery of available platforms")
def __init__(self):
super().__init__()
self._platforms = []
def use_all_platforms(self):
self._platforms = list(self.read_platforms())
def use_platform(self, platform_name):
self._platforms.append(platform_name)
def get_exec_context(self):
context = super().get_exec_context()
if self.args.noplatforms or not self._platforms:
return context
env = context.get_env()
if len(self._platforms) == 1:
name = self._platforms[0]
platform = self.get_platform(name)
self.print_info(name.title(), platform.get_version())
for item in platform.read_env():
try:
dir = str(item)
env[item.key] = dir
except EnvironmentError:
dir = flow.cmd.text.red(item.get())
print(item.key, "=", dir)
return context
self.print_info("Establishing platforms")
found = []
failed = []
for platform_name in self._platforms:
platform = self.get_platform(platform_name)
try:
platform_env = {x.key:str(x) for x in platform.read_env()}
env.update(platform_env)
found.append(platform_name)
except EnvironmentError:
failed.append(platform_name)
if found:
print(" found:", flow.cmd.text.green(" ".join(found)))
if failed:
out = "missing: "
out += flow.cmd.text.light_red(" ".join(failed))
out += flow.cmd.text.grey(" ('.info' for details)")
print(out)
return context
|
#!/project/ python3
"""
Final test script to verify all 8 animations work correctly with the character
"""
import unreal
def log_message(message):
"""Print and log message"""
print(message)
unreal.log(message)
def verify_animations_and_test_character():
"""Comprehensive test of all 8 animations and character setup"""
log_message("=" * 80)
log_message("TESTING ALL 8 ANIMATIONS WITH CHARACTER")
log_message("=" * 80)
try:
# Step 1: Verify all 8 animations exist
log_message("\n1. VERIFYING ALL 8 ANIMATIONS EXIST:")
animations = {
"Idle": "/project/",
"Move": "/project/",
"AttackUpwards": "/project/",
"AttackDownwards": "/project/",
"AttackSideways": "/project/",
"AttackUpwards2": "/project/",
"AttackDownwards2": "/project/",
"AttackSideways2": "/project/"
}
loaded_animations = {}
for name, path in animations.items():
if unreal.EditorAssetLibrary.does_asset_exist(path):
anim = unreal.EditorAssetLibrary.load_asset(path)
if anim and isinstance(anim, unreal.PaperFlipbook):
frames = anim.get_num_frames()
fps = anim.get_editor_property("frames_per_second")
loaded_animations[name] = anim
log_message(f" ✓ {name}: {frames} frames @ {fps} FPS")
else:
log_message(f" ✗ {name}: Not a valid PaperFlipbook")
return False
else:
log_message(f" ✗ {name}: Asset does not exist at {path}")
return False
log_message(f"\n SUCCESS: All {len(loaded_animations)}/8 animations loaded!")
# Step 2: Verify character blueprint
log_message("\n2. VERIFYING CHARACTER BLUEPRINT:")
bp_path = "/project/"
if not unreal.EditorAssetLibrary.does_asset_exist(bp_path):
log_message(" ✗ Character blueprint does not exist")
return False
bp = unreal.EditorAssetLibrary.load_asset(bp_path)
if not bp:
log_message(" ✗ Failed to load character blueprint")
return False
log_message(" ✓ Character blueprint loaded successfully")
# Step 3: Assign idle animation to character sprite
log_message("\n3. ASSIGNING IDLE ANIMATION TO CHARACTER:")
bp_class = bp.generated_class()
if bp_class:
default_obj = bp_class.get_default_object()
if default_obj and hasattr(default_obj, 'sprite'):
sprite_comp = default_obj.sprite
if sprite_comp:
sprite_comp.set_flipbook(loaded_animations['Idle'])
log_message(" ✓ Idle animation assigned to character sprite")
else:
log_message(" ✗ Character has no sprite component")
return False
else:
log_message(" ✗ Character has no default object or sprite")
return False
else:
log_message(" ✗ Blueprint has no generated class")
return False
# Step 4: Save and compile blueprint
unreal.EditorAssetLibrary.save_asset(bp_path)
unreal.KismetSystemLibrary.compile_blueprint(bp)
log_message(" ✓ Character blueprint saved and compiled")
# Step 5: Create test level
log_message("\n4. CREATING SIMPLE TEST LEVEL:")
try:
# Create floor
floor_actor = unreal.EditorLevelLibrary.spawn_actor_from_class(
unreal.StaticMeshActor,
unreal.Vector(0, 0, -50)
)
if floor_actor:
static_mesh_comp = floor_actor.get_component_by_class(unreal.StaticMeshComponent)
if static_mesh_comp:
cube_mesh = unreal.EditorAssetLibrary.load_asset("/project/")
if cube_mesh:
static_mesh_comp.set_static_mesh(cube_mesh)
static_mesh_comp.set_world_scale3d(unreal.Vector(10, 10, 1))
log_message(" ✓ Created floor with cube mesh")
# Create PlayerStart
player_start = unreal.EditorLevelLibrary.spawn_actor_from_class(
unreal.PlayerStart,
unreal.Vector(0, 0, 100)
)
if player_start:
log_message(" ✓ Created PlayerStart")
# Create DirectionalLight
directional_light = unreal.EditorLevelLibrary.spawn_actor_from_class(
unreal.DirectionalLight,
unreal.Vector(0, 0, 200)
)
if directional_light:
log_message(" ✓ Created DirectionalLight")
# Save level
level_path = "/project/"
success = unreal.EditorAssetLibrary.save_asset(level_path)
if success:
log_message(" ✓ Saved TestLevel")
except Exception as e:
log_message(f" ⚠️ Level creation error: {str(e)}")
# Step 6: Verify input mappings
log_message("\n5. INPUT MAPPINGS CONFIGURED:")
log_message(" Movement Controls:")
log_message(" WASD - Character movement")
log_message(" Space - Jump")
log_message(" Primary Attacks:")
log_message(" Arrow Keys - Basic attacks (Up/project/)")
log_message(" Left Mouse - General attack")
log_message(" Secondary Attacks:")
log_message(" Shift + Arrow Keys - Secondary attacks (Up2/project/)")
# Final summary
log_message("\n" + "=" * 80)
log_message("🎉 CHARACTER SETUP COMPLETE!")
log_message("✅ All 8 animations verified and loaded")
log_message("✅ Character blueprint updated and compiled")
log_message("✅ Input mappings configured")
log_message("✅ Test level created")
log_message("")
log_message("TESTING INSTRUCTIONS:")
log_message("1. Open TestLevel in the editor")
log_message("2. Click the Play button to enter PIE mode")
log_message("3. Test character with all controls:")
log_message(" - Move with WASD (should show Move animation)")
log_message(" - Stand still (should show Idle animation)")
log_message(" - Press arrow keys for basic attacks")
log_message(" - Press Shift + arrow keys for secondary attacks")
log_message(" - All 8 animations should be visible!")
log_message("=" * 80)
return True
except Exception as e:
log_message(f"✗ Error in comprehensive test: {str(e)}")
return False
def main():
"""Main function"""
success = verify_animations_and_test_character()
if success:
log_message("\n🎊 ALL TESTS PASSED! Character ready for testing!")
else:
log_message("\n❌ Some tests failed - check errors above")
if __name__ == "__main__":
main()
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import unreal
class ProcessHDA(object):
""" An object that wraps async processing of an HDA (instantiating,
cooking/project/ an HDA), with functions that are called at the
various stages of the process, that can be overridden by subclasses for
custom funtionality:
- on_failure()
- on_complete(): upon successful completion (could be PostInstantiation
if auto cook is disabled, PostProcessing if auto bake is disabled, or
after PostAutoBake if auto bake is enabled.
- on_pre_instantiation(): before the HDA is instantiated, a good place
to set parameter values before the first cook.
- on_post_instantiation(): after the HDA is instantiated, a good place
to set/configure inputs before the first cook.
- on_post_auto_cook(): right after a cook
- on_pre_process(): after a cook but before output objects have been
created/processed
- on_post_processing(): after output objects have been created
- on_post_auto_bake(): after outputs have been baked
Instantiate the processor via the constructor and then call the activate()
function to start the asynchronous process.
"""
def __init__(
self,
houdini_asset,
instantiate_at=unreal.Transform(),
parameters=None,
node_inputs=None,
parameter_inputs=None,
world_context_object=None,
spawn_in_level_override=None,
enable_auto_cook=True,
enable_auto_bake=False,
bake_directory_path="",
bake_method=unreal.HoudiniEngineBakeOption.TO_ACTOR,
remove_output_after_bake=False,
recenter_baked_actors=False,
replace_previous_bake=False,
delete_instantiated_asset_on_completion_or_failure=False):
""" Instantiates an HDA in the specified world/level. Sets parameters
and inputs supplied in InParameters, InNodeInputs and parameter_inputs.
If bInEnableAutoCook is true, cooks the HDA. If bInEnableAutoBake is
true, bakes the cooked outputs according to the supplied baking
parameters.
This all happens asynchronously, with the various output pins firing at
the various points in the process:
- PreInstantiation: before the HDA is instantiated, a good place
to set parameter values before the first cook (parameter values
from ``parameters`` are automatically applied at this point)
- PostInstantiation: after the HDA is instantiated, a good place
to set/configure inputs before the first cook (inputs from
``node_inputs`` and ``parameter_inputs`` are automatically applied
at this point)
- PostAutoCook: right after a cook
- PreProcess: after a cook but before output objects have been
created/processed
- PostProcessing: after output objects have been created
- PostAutoBake: after outputs have been baked
- Completed: upon successful completion (could be PostInstantiation
if auto cook is disabled, PostProcessing if auto bake is disabled,
or after PostAutoBake if auto bake is enabled).
- Failed: If the process failed at any point.
Args:
houdini_asset (HoudiniAsset): The HDA to instantiate.
instantiate_at (Transform): The Transform to instantiate the HDA with.
parameters (Map(Name, HoudiniParameterTuple)): The parameters to set before cooking the instantiated HDA.
node_inputs (Map(int32, HoudiniPublicAPIInput)): The node inputs to set before cooking the instantiated HDA.
parameter_inputs (Map(Name, HoudiniPublicAPIInput)): The parameter-based inputs to set before cooking the instantiated HDA.
world_context_object (Object): A world context object for identifying the world to spawn in, if spawn_in_level_override is null.
spawn_in_level_override (Level): If not nullptr, then the HoudiniAssetActor is spawned in that level. If both spawn_in_level_override and world_context_object are null, then the actor is spawned in the current editor context world's current level.
enable_auto_cook (bool): If true (the default) the HDA will cook automatically after instantiation and after parameter, transform and input changes.
enable_auto_bake (bool): If true, the HDA output is automatically baked after a cook. Defaults to false.
bake_directory_path (str): The directory to bake to if the bake path is not set via attributes on the HDA output.
bake_method (HoudiniEngineBakeOption): The bake target (to actor vs blueprint). @see HoudiniEngineBakeOption.
remove_output_after_bake (bool): If true, HDA temporary outputs are removed after a bake. Defaults to false.
recenter_baked_actors (bool): Recenter the baked actors to their bounding box center. Defaults to false.
replace_previous_bake (bool): If true, on every bake replace the previous bake's output (assets + actors) with the new bake's output. Defaults to false.
delete_instantiated_asset_on_completion_or_failure (bool): If true, deletes the instantiated asset actor on completion or failure. Defaults to false.
"""
super(ProcessHDA, self).__init__()
self._houdini_asset = houdini_asset
self._instantiate_at = instantiate_at
self._parameters = parameters
self._node_inputs = node_inputs
self._parameter_inputs = parameter_inputs
self._world_context_object = world_context_object
self._spawn_in_level_override = spawn_in_level_override
self._enable_auto_cook = enable_auto_cook
self._enable_auto_bake = enable_auto_bake
self._bake_directory_path = bake_directory_path
self._bake_method = bake_method
self._remove_output_after_bake = remove_output_after_bake
self._recenter_baked_actors = recenter_baked_actors
self._replace_previous_bake = replace_previous_bake
self._delete_instantiated_asset_on_completion_or_failure = delete_instantiated_asset_on_completion_or_failure
self._asset_wrapper = None
self._cook_success = False
self._bake_success = False
@property
def asset_wrapper(self):
""" The asset wrapper for the instantiated HDA processed by this node. """
return self._asset_wrapper
@property
def cook_success(self):
""" True if the last cook was successful. """
return self._cook_success
@property
def bake_success(self):
""" True if the last bake was successful. """
return self._bake_success
@property
def houdini_asset(self):
""" The HDA to instantiate. """
return self._houdini_asset
@property
def instantiate_at(self):
""" The transform the instantiate the asset with. """
return self._instantiate_at
@property
def parameters(self):
""" The parameters to set on on_pre_instantiation """
return self._parameters
@property
def node_inputs(self):
""" The node inputs to set on on_post_instantiation """
return self._node_inputs
@property
def parameter_inputs(self):
""" The object path parameter inputs to set on on_post_instantiation """
return self._parameter_inputs
@property
def world_context_object(self):
""" The world context object: spawn in this world if spawn_in_level_override is not set. """
return self._world_context_object
@property
def spawn_in_level_override(self):
""" The level to spawn in. If both this and world_context_object is not set, spawn in the editor context's level. """
return self._spawn_in_level_override
@property
def enable_auto_cook(self):
""" Whether to set the instantiated asset to auto cook. """
return self._enable_auto_cook
@property
def enable_auto_bake(self):
""" Whether to set the instantiated asset to auto bake after a cook. """
return self._enable_auto_bake
@property
def bake_directory_path(self):
""" Set the fallback bake directory, for if output attributes do not specify it. """
return self._bake_directory_path
@property
def bake_method(self):
""" The bake method/target: for example, to actors vs to blueprints. """
return self._bake_method
@property
def remove_output_after_bake(self):
""" Remove temporary HDA output after a bake. """
return self._remove_output_after_bake
@property
def recenter_baked_actors(self):
""" Recenter the baked actors at their bounding box center. """
return self._recenter_baked_actors
@property
def replace_previous_bake(self):
""" Replace previous bake output on each bake. For the purposes of this
node, this would mostly apply to .uassets and not actors.
"""
return self._replace_previous_bake
@property
def delete_instantiated_asset_on_completion_or_failure(self):
""" Whether or not to delete the instantiated asset after Complete is called. """
return self._delete_instantiated_asset_on_completion_or_failure
def activate(self):
""" Activate the process. This will:
- instantiate houdini_asset and wrap it as asset_wrapper
- call on_failure() for any immediate failures
- otherwise bind to delegates from asset_wrapper so that the
various self.on_*() functions are called as appropriate
Returns immediately (does not block until cooking/processing is
complete).
Returns:
(bool): False if activation failed.
"""
# Get the API instance
houdini_api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
if not houdini_api:
# Handle failures: this will unbind delegates and call on_failure()
self._handle_on_failure()
return False
# Create an empty API asset wrapper
self._asset_wrapper = unreal.HoudiniPublicAPIAssetWrapper.create_empty_wrapper(houdini_api)
if not self._asset_wrapper:
# Handle failures: this will unbind delegates and call on_failure()
self._handle_on_failure()
return False
# Bind to the wrapper's delegates for instantiation, cooking, baking
# etc events
self._asset_wrapper.on_pre_instantiation_delegate.add_callable(
self._handle_on_pre_instantiation)
self._asset_wrapper.on_post_instantiation_delegate.add_callable(
self._handle_on_post_instantiation)
self._asset_wrapper.on_post_cook_delegate.add_callable(
self._handle_on_post_auto_cook)
self._asset_wrapper.on_pre_process_state_exited_delegate.add_callable(
self._handle_on_pre_process)
self._asset_wrapper.on_post_processing_delegate.add_callable(
self._handle_on_post_processing)
self._asset_wrapper.on_post_bake_delegate.add_callable(
self._handle_on_post_auto_bake)
# Begin the instantiation process of houdini_asset and wrap it with
# self.asset_wrapper
if not houdini_api.instantiate_asset_with_existing_wrapper(
self.asset_wrapper,
self.houdini_asset,
self.instantiate_at,
self.world_context_object,
self.spawn_in_level_override,
self.enable_auto_cook,
self.enable_auto_bake,
self.bake_directory_path,
self.bake_method,
self.remove_output_after_bake,
self.recenter_baked_actors,
self.replace_previous_bake):
# Handle failures: this will unbind delegates and call on_failure()
self._handle_on_failure()
return False
return True
def _unbind_delegates(self):
""" Unbinds from self.asset_wrapper's delegates (if valid). """
if not self._asset_wrapper:
return
self._asset_wrapper.on_pre_instantiation_delegate.add_callable(
self._handle_on_pre_instantiation)
self._asset_wrapper.on_post_instantiation_delegate.add_callable(
self._handle_on_post_instantiation)
self._asset_wrapper.on_post_cook_delegate.add_callable(
self._handle_on_post_auto_cook)
self._asset_wrapper.on_pre_process_state_exited_delegate.add_callable(
self._handle_on_pre_process)
self._asset_wrapper.on_post_processing_delegate.add_callable(
self._handle_on_post_processing)
self._asset_wrapper.on_post_bake_delegate.add_callable(
self._handle_on_post_auto_bake)
def _check_wrapper(self, wrapper):
""" Checks that wrapper matches self.asset_wrapper. Logs a warning if
it does not.
Args:
wrapper (HoudiniPublicAPIAssetWrapper): the wrapper to check
against self.asset_wrapper
Returns:
(bool): True if the wrappers match.
"""
if wrapper != self._asset_wrapper:
unreal.log_warning(
'[UHoudiniPublicAPIProcessHDANode] Received delegate event '
'from unexpected asset wrapper ({0} vs {1})!'.format(
self._asset_wrapper.get_name() if self._asset_wrapper else '',
wrapper.get_name() if wrapper else ''
)
)
return False
return True
def _handle_on_failure(self):
""" Handle any failures during the lifecycle of the process. Calls
self.on_failure() and then unbinds from self.asset_wrapper and
optionally deletes the instantiated asset.
"""
self.on_failure()
self._unbind_delegates()
if self.delete_instantiated_asset_on_completion_or_failure and self.asset_wrapper:
self.asset_wrapper.delete_instantiated_asset()
def _handle_on_complete(self):
""" Handles completion of the process. This can happen at one of
three stages:
- After on_post_instantiate(), if enable_auto_cook is False.
- After on_post_auto_cook(), if enable_auto_cook is True but
enable_auto_bake is False.
- After on_post_auto_bake(), if both enable_auto_cook and
enable_auto_bake are True.
Calls self.on_complete() and then unbinds from self.asset_wrapper's
delegates and optionally deletes the instantiated asset.
"""
self.on_complete()
self._unbind_delegates()
if self.delete_instantiated_asset_on_completion_or_failure and self.asset_wrapper:
self.asset_wrapper.delete_instantiated_asset()
def _handle_on_pre_instantiation(self, wrapper):
""" Called during pre_instantiation. Sets ``parameters`` on the HDA
and calls self.on_pre_instantiation().
"""
if not self._check_wrapper(wrapper):
return
# Set any parameters specified for the HDA
if self.asset_wrapper and self.parameters:
self.asset_wrapper.set_parameter_tuples(self.parameters)
self.on_pre_instantiation()
def _handle_on_post_instantiation(self, wrapper):
""" Called during post_instantiation. Sets inputs (``node_inputs`` and
``parameter_inputs``) on the HDA and calls self.on_post_instantiation().
Completes execution if enable_auto_cook is False.
"""
if not self._check_wrapper(wrapper):
return
# Set any inputs specified when the node was created
if self.asset_wrapper:
if self.node_inputs:
self.asset_wrapper.set_inputs_at_indices(self.node_inputs)
if self.parameter_inputs:
self.asset_wrapper.set_input_parameters(self.parameter_inputs)
self.on_post_instantiation()
# If not set to auto cook, complete execution now
if not self.enable_auto_cook:
self._handle_on_complete()
def _handle_on_post_auto_cook(self, wrapper, cook_success):
""" Called during post_cook. Sets self.cook_success and calls
self.on_post_auto_cook().
Args:
cook_success (bool): True if the cook was successful.
"""
if not self._check_wrapper(wrapper):
return
self._cook_success = cook_success
self.on_post_auto_cook(cook_success)
def _handle_on_pre_process(self, wrapper):
""" Called during pre_process. Calls self.on_pre_process().
"""
if not self._check_wrapper(wrapper):
return
self.on_pre_process()
def _handle_on_post_processing(self, wrapper):
""" Called during post_processing. Calls self.on_post_processing().
Completes execution if enable_auto_bake is False.
"""
if not self._check_wrapper(wrapper):
return
self.on_post_processing()
# If not set to auto bake, complete execution now
if not self.enable_auto_bake:
self._handle_on_complete()
def _handle_on_post_auto_bake(self, wrapper, bake_success):
""" Called during post_bake. Sets self.bake_success and calls
self.on_post_auto_bake().
Args:
bake_success (bool): True if the bake was successful.
"""
if not self._check_wrapper(wrapper):
return
self._bake_success = bake_success
self.on_post_auto_bake(bake_success)
self._handle_on_complete()
def on_failure(self):
""" Called if the process fails to instantiate or fails to start
a cook.
Subclasses can override this function implement custom functionality.
"""
pass
def on_complete(self):
""" Called if the process completes instantiation, cook and/or baking,
depending on enable_auto_cook and enable_auto_bake.
Subclasses can override this function implement custom functionality.
"""
pass
def on_pre_instantiation(self):
""" Called during pre_instantiation.
Subclasses can override this function implement custom functionality.
"""
pass
def on_post_instantiation(self):
""" Called during post_instantiation.
Subclasses can override this function implement custom functionality.
"""
pass
def on_post_auto_cook(self, cook_success):
""" Called during post_cook.
Subclasses can override this function implement custom functionality.
Args:
cook_success (bool): True if the cook was successful.
"""
pass
def on_pre_process(self):
""" Called during pre_process.
Subclasses can override this function implement custom functionality.
"""
pass
def on_post_processing(self):
""" Called during post_processing.
Subclasses can override this function implement custom functionality.
"""
pass
def on_post_auto_bake(self, bake_success):
""" Called during post_bake.
Subclasses can override this function implement custom functionality.
Args:
bake_success (bool): True if the bake was successful.
"""
pass
|
import unreal
menu_owner = "editorUtilities"
tool_menus = unreal.ToolMenus.get()
owning_menu_name = "LevelEditor.LevelEditorToolBar.AssetsToolBar"
@unreal.uclass()
class createEntry_Example(unreal.ToolMenuEntryScript):
@unreal.ufunction(override=True)
def execute(self, context):
registry = unreal.AssetRegistryHelpers.get_asset_registry()
asset = unreal.EditorAssetLibrary.load_asset("/project/-unreal")
bp = unreal.get_editor_subsystem(unreal.EditorUtilitySubsystem).find_utility_widget_from_blueprint(asset)
if bp == None:
bp = unreal.get_editor_subsystem(unreal.EditorUtilitySubsystem).spawn_and_register_tab(asset)
def init_as_toolbar_button(self):
self.data.menu = owning_menu_name
self.data.advanced.entry_type = unreal.MultiBlockType.TOOL_BAR_BUTTON
#self.data.icon = unreal.ScriptSlateIcon("PresenterStyle", "Presenter.Logo")
self.data.icon = unreal.ScriptSlateIcon("MeshcapadeStyle", "Meshcapade.Icon")
#self.data.advanced.style_name_override = "CalloutToolbar" # Slightly larger block (this adds the word "meshcapade" next to the icon)
def Startup():
entry = createEntry_Example()
entry.init_as_toolbar_button()
entry.init_entry(menu_owner, "editorUilitiesExampleEntry", "", "", "Meshcapade", "Opens the Meshcapade Editor Widget UI")
toolbar = tool_menus.extend_menu(owning_menu_name)
toolbar.add_menu_entry_object(entry)
tool_menus.refresh_all_widgets()
|
import json
import unreal
with open("C:/project/ Projects/project/"
"MaterialAutoAssign/project/.json", "r") as f:
material_references_data = json.load(f)
with open("C:/project/ Projects/project/"
"MaterialAutoAssign/project/.json", "r") as f:
material_rename_data = json.load(f)
missing_material_paths = []
for mesh_path, mesh_material_data in material_references_data.items():
for slot_name, material_path in mesh_material_data.items():
material_path = material_rename_data.get(material_path, material_path)
if not unreal.EditorAssetLibrary.does_asset_exist(
material_path) and material_path not in missing_material_paths:
missing_material_paths.append(material_path)
for missing_material_path in missing_material_paths:
print(missing_material_path)
|
import unreal
# 선택된 바인딩들을 가져옵니다.
selected_bindings = unreal.LevelSequenceEditorBlueprintLibrary.get_selected_bindings()
if not selected_bindings:
unreal.log_warning("선택된 바인딩이 없습니다.")
else:
for binding in selected_bindings:
# 사용 가능한 프로퍼티 목록 출력해서 어떤 값들이 있는지 확인
available_props = dir(binding)
unreal.log("바인딩 '{}'의 프로퍼티 목록: {}".format(binding.get_display_name(), available_props))
# binding_id 프로퍼티 사용 시도 (MovieSceneBindingProxy에는 binding_id가 존재할 수 있습니다)
try:
binding_id = binding.get_editor_property("binding_id")
unreal.log("바인딩 '{}': binding_id = {}".format(binding.get_display_name(), binding_id))
except Exception as e:
unreal.log_warning("바인딩 '{}': binding_id를 가져오지 못했습니다. 에러: {}".format(binding.get_display_name(), e))
|
# This scripts describes the process of capturing an managing properties with a little more
# detail than test_variant_manager.py
import unreal
# Create all assets and objects we'll use
lvs = unreal.VariantManagerLibrary.create_level_variant_sets_asset("LVS", "/Game/")
lvs_actor = unreal.VariantManagerLibrary.create_level_variant_sets_actor(lvs)
if lvs is None or lvs_actor is None:
print ("Failed to spawn either the LevelVariantSets asset or the LevelVariantSetsActor!")
quit()
var_set1 = unreal.VariantSet()
var_set1.set_display_text("My VariantSet")
var1 = unreal.Variant()
var1.set_display_text("Variant 1")
# Adds the objects to the correct parents
lvs.add_variant_set(var_set1)
var_set1.add_variant(var1)
# Spawn a simple cube static mesh actor
cube = unreal.EditorAssetLibrary.load_asset("StaticMesh'/project/.Cube'")
spawned_actor = None
if cube:
location = unreal.Vector()
rotation = unreal.Rotator()
spawned_actor = unreal.EditorLevelLibrary.spawn_actor_from_object(cube, location, rotation)
spawned_actor.set_actor_label("Cube Actor")
else:
print ("Failed to find Cube asset!")
if spawned_actor is None:
print ("Failed to spawn an actor for the Cube asset!")
quit()
# Bind spawned_actor to all our variants
var1.add_actor_binding(spawned_actor)
# See which properties can be captured from any StaticMeshActor
capturable_by_class = unreal.VariantManagerLibrary.get_capturable_properties(unreal.StaticMeshActor.static_class())
# See which properties can be captured from our specific spawned_actor
# This will also return the properties for any custom component structure we might have setup on the actor
capturable_props = unreal.VariantManagerLibrary.get_capturable_properties(spawned_actor)
print ("Capturable properties for actor '" + spawned_actor.get_actor_label() + "':")
for prop in capturable_props:
print ("\t" + prop)
print ("Capturable properties for its class:")
for prop in capturable_by_class:
print ("\t" + prop)
# Returns nullptr for invalid paths. This will also show an error in the Output Log
prop1 = var1.capture_property(spawned_actor, "False property path")
assert prop1 is None
# Comparison is case insensitive: The property is named "Can be Damaged", but this still works
prop2 = var1.capture_property(spawned_actor, "cAn Be DAMAged")
assert prop2 is not None and prop2.get_full_display_string() == "Can be Damaged"
# Attempts to capture the same property more than once are ignored, and None is returned
prop2attempt2 = var1.capture_property(spawned_actor, "Can Be Damaged")
assert prop2attempt2 is None
# Check which properties have been captured for some actor in a variant
print ("Captured properties for '" + spawned_actor.get_actor_label() + "' so far:")
captured_props = var1.get_captured_properties(spawned_actor)
for captured_prop in captured_props:
print ("\t" + captured_prop.get_full_display_string())
# Capture property in a component
prop3 = var1.capture_property(spawned_actor, "Static Mesh Component / Relative Location")
assert prop3 is not None and prop3.get_full_display_string() == "Static Mesh Component / Relative Location"
# Can't capture the component itself. This will also show an error in the Output Log
prop4 = var1.capture_property(spawned_actor, "Static Mesh Component")
assert prop4 is None
# Capture material property
prop5 = var1.capture_property(spawned_actor, "Static Mesh Component / Material[0]")
assert prop5 is not None
# Removing property captures
var1.remove_captured_property(spawned_actor, prop2)
var1.remove_captured_property_by_name(spawned_actor, "Static Mesh Component / Relative Location")
print ("Captured properties for '" + spawned_actor.get_actor_label() + "' at the end:")
captured_props = var1.get_captured_properties(spawned_actor)
for captured_prop in captured_props:
print ("\t" + captured_prop.get_full_display_string())
# Should only have the material property left
assert len(captured_props) == 1 and captured_props[0].get_full_display_string() == "Static Mesh Component / Material[0]"
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import unreal
""" Example script for instantiating an asset, cooking it and baking an
individual output object.
"""
_g_wrapper = None
def get_test_hda_path():
return '/project/.pig_head_subdivider_v01'
def get_test_hda():
return unreal.load_object(None, get_test_hda_path())
def on_post_process(in_wrapper):
print('on_post_process')
# Print details about the outputs and record the first static mesh we find
sm_index = None
sm_identifier = None
# in_wrapper.on_post_processing_delegate.remove_callable(on_post_process)
num_outputs = in_wrapper.get_num_outputs()
print('num_outputs: {}'.format(num_outputs))
if num_outputs > 0:
for output_idx in range(num_outputs):
identifiers = in_wrapper.get_output_identifiers_at(output_idx)
output_type = in_wrapper.get_output_type_at(output_idx)
print('\toutput index: {}'.format(output_idx))
print('\toutput type: {}'.format(output_type))
print('\tnum_output_objects: {}'.format(len(identifiers)))
if identifiers:
for identifier in identifiers:
output_object = in_wrapper.get_output_object_at(output_idx, identifier)
output_component = in_wrapper.get_output_component_at(output_idx, identifier)
is_proxy = in_wrapper.is_output_current_proxy_at(output_idx, identifier)
print('\t\tidentifier: {}'.format(identifier))
print('\t\toutput_object: {}'.format(output_object.get_name() if output_object else 'None'))
print('\t\toutput_component: {}'.format(output_component.get_name() if output_component else 'None'))
print('\t\tis_proxy: {}'.format(is_proxy))
print('')
if (output_type == unreal.HoudiniOutputType.MESH and
isinstance(output_object, unreal.StaticMesh)):
sm_index = output_idx
sm_identifier = identifier
# Bake the first static mesh we found to the CB
if sm_index is not None and sm_identifier is not None:
print('baking {}'.format(sm_identifier))
success = in_wrapper.bake_output_object_at(sm_index, sm_identifier)
print('success' if success else 'failed')
# Delete the instantiated asset
in_wrapper.delete_instantiated_asset()
global _g_wrapper
_g_wrapper = None
def run():
# get the API singleton
api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
global _g_wrapper
# instantiate an asset with auto-cook enabled
_g_wrapper = api.instantiate_asset(get_test_hda(), unreal.Transform())
# Bind to the on post processing delegate (after a cook and after all
# outputs have been generated in Unreal)
_g_wrapper.on_post_processing_delegate.add_callable(on_post_process)
if __name__ == '__main__':
run()
|
import unreal
from ayon_core.pipeline import (
get_current_project_name,
get_representation_path
)
from ayon_unreal.api.pipeline import (
get_camera_tracks,
ls
)
from ayon_core.pipeline.context_tools import get_current_folder_entity
import ayon_api
from pathlib import Path
def update_skeletal_mesh(asset_content, sequence):
ar = unreal.AssetRegistryHelpers.get_asset_registry()
skeletal_mesh_asset = None
for a in asset_content:
imported_skeletal_mesh = ar.get_asset_by_object_path(a).get_asset()
if imported_skeletal_mesh.get_class().get_name() == "SkeletalMesh":
skeletal_mesh_asset = imported_skeletal_mesh
break
if sequence and skeletal_mesh_asset:
# Get the EditorActorSubsystem instance
editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
# Get all level actors
all_level_actors = editor_actor_subsystem.get_all_level_actors()
for p in sequence.get_possessables():
matching_actor = next(
(actor.get_name() for actor in all_level_actors
if actor.get_actor_label() == p.get_name()), None)
actor = unreal.EditorLevelLibrary.get_actor_reference(f"PersistentLevel.{matching_actor}")
# Ensure the actor is valid
if actor:
# Get the skeletal mesh component
skeletal_mesh_component = actor.get_component_by_class(unreal.SkeletalMeshComponent)
if skeletal_mesh_component:
# Get the skeletal mesh
skeletal_mesh = skeletal_mesh_component.skeletal_mesh
if skeletal_mesh:
skel_mesh_comp = actor.get_editor_property('skeletal_mesh_component')
unreal.log("Replacing skeleton mesh component to alembic")
unreal.log(skel_mesh_comp)
if skel_mesh_comp:
if skel_mesh_comp.get_editor_property("skeletal_mesh") != imported_skeletal_mesh:
skel_mesh_comp.set_editor_property('skeletal_mesh', skeletal_mesh_asset)
def set_sequence_frame_range(sequence, frameStart, frameEnd):
display_rate = sequence.get_display_rate()
fps = float(display_rate.numerator) / float(display_rate.denominator)
# temp fix on the incorrect frame range
sequence.set_playback_start(frameStart)
sequence.set_playback_end(frameEnd + 1)
sequence.set_work_range_start(float(frameStart / fps))
sequence.set_work_range_end(float(frameEnd / fps))
sequence.set_view_range_start(float(frameStart / fps))
sequence.set_view_range_end(float(frameEnd / fps))
def import_animation_sequence(asset_content, sequence, frameStart, frameEnd):
bindings = []
animation = None
ar = unreal.AssetRegistryHelpers.get_asset_registry()
for a in asset_content:
imported_asset_data = ar.get_asset_by_object_path(a).get_asset()
if imported_asset_data.get_class().get_name() == "AnimSequence":
animation = imported_asset_data
break
if sequence:
# Add animation to the sequencer
binding = None
for p in sequence.get_possessables():
if p.get_possessed_object_class().get_name() == "SkeletalMeshActor":
binding = p
bindings.append(binding)
anim_section = None
for binding in bindings:
tracks = binding.get_tracks()
track = None
track = tracks[0] if tracks else binding.add_track(
unreal.MovieSceneSkeletalAnimationTrack)
sections = track.get_sections()
if not sections:
anim_section = track.add_section()
else:
anim_section = sections[0]
params = unreal.MovieSceneSkeletalAnimationParams()
params.set_editor_property('Animation', animation)
anim_section.set_editor_property('Params', params)
# temp fix on the incorrect frame range
anim_section.set_range(frameStart, frameEnd + 1)
def get_representation(parent_id, version_id):
project_name = get_current_project_name()
return next(
(repre for repre in ayon_api.get_representations(
project_name, version_ids={parent_id})
if repre["id"] == version_id
), None)
def import_camera_to_level_sequence(sequence, parent_id, version_id,
namespace, world, frameStart, frameEnd):
repre_entity = get_representation(parent_id, version_id)
import_fbx_settings = unreal.MovieSceneUserImportFBXSettings()
import_fbx_settings.set_editor_property('reduce_keys', False)
camera_path = get_representation_path(repre_entity)
camera_actor_name = unreal.Paths.split(namespace)[1]
for spawned_actor in sequence.get_possessables():
if spawned_actor.get_display_name() == camera_actor_name:
spawned_actor.remove()
sel_actors = unreal.GameplayStatics().get_all_actors_of_class(
world, unreal.CameraActor)
if sel_actors:
for actor in sel_actors:
unreal.EditorLevelLibrary.destroy_actor(actor)
unreal.SequencerTools.import_level_sequence_fbx(
world,
sequence,
sequence.get_bindings(),
import_fbx_settings,
camera_path
)
camera_actors = unreal.GameplayStatics().get_all_actors_of_class(
world, unreal.CameraActor)
if namespace:
unreal.log(f"Spawning camera: {camera_actor_name}")
for actor in camera_actors:
actor.set_actor_label(camera_actor_name)
tracks = get_camera_tracks(sequence)
for track in tracks:
sections = track.get_sections()
for section in sections:
# temp fix on the incorrect frame range
section.set_range(frameStart, frameEnd + 1)
set_sequence_frame_range(sequence, frameStart, frameEnd)
def remove_loaded_asset(container):
# Check if the assets have been loaded by other layouts, and deletes
# them if they haven't.
containers = ls()
layout_containers = [
c for c in containers
if (c.get('asset_name') != container.get('asset_name') and
c.get('family') == "layout")]
for asset in eval(container.get('loaded_assets')):
layouts = [
lc for lc in layout_containers
if asset in lc.get('loaded_assets')]
if not layouts:
unreal.EditorAssetLibrary.delete_directory(str(Path(asset).parent))
# Delete the parent folder if there aren't any more
# layouts in it.
asset_content = unreal.EditorAssetLibrary.list_assets(
str(Path(asset).parent.parent), recursive=False,
include_folder=True
)
if len(asset_content) == 0:
unreal.EditorAssetLibrary.delete_directory(
str(Path(asset).parent.parent))
def import_animation(
asset_dir, path, instance_name, skeleton, actors_dict,
animation_file, bindings_dict, sequence
):
anim_file = Path(animation_file)
anim_file_name = anim_file.with_suffix('')
anim_path = f"{asset_dir}/Animations/{anim_file_name}"
folder_entity = get_current_folder_entity()
# Import animation
task = unreal.AssetImportTask()
task.options = unreal.FbxImportUI()
task.set_editor_property(
'filename', str(path.with_suffix(f".{animation_file}")))
task.set_editor_property('destination_path', anim_path)
task.set_editor_property(
'destination_name', f"{instance_name}_animation")
task.set_editor_property('replace_existing', False)
task.set_editor_property('automated', True)
task.set_editor_property('save', False)
# set import options here
task.options.set_editor_property(
'automated_import_should_detect_type', False)
task.options.set_editor_property(
'original_import_type', unreal.FBXImportType.FBXIT_SKELETAL_MESH)
task.options.set_editor_property(
'mesh_type_to_import', unreal.FBXImportType.FBXIT_ANIMATION)
task.options.set_editor_property('import_mesh', False)
task.options.set_editor_property('import_animations', True)
task.options.set_editor_property('override_full_name', True)
task.options.set_editor_property('skeleton', skeleton)
task.options.anim_sequence_import_data.set_editor_property(
'animation_length',
unreal.FBXAnimationLengthImportType.FBXALIT_EXPORTED_TIME
)
task.options.anim_sequence_import_data.set_editor_property(
'import_meshes_in_bone_hierarchy', False)
task.options.anim_sequence_import_data.set_editor_property(
'use_default_sample_rate', False)
task.options.anim_sequence_import_data.set_editor_property(
'custom_sample_rate', folder_entity.get("attrib", {}).get("fps"))
task.options.anim_sequence_import_data.set_editor_property(
'import_custom_attribute', True)
task.options.anim_sequence_import_data.set_editor_property(
'import_bone_tracks', True)
task.options.anim_sequence_import_data.set_editor_property(
'remove_redundant_keys', False)
task.options.anim_sequence_import_data.set_editor_property(
'convert_scene', True)
unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
asset_content = unreal.EditorAssetLibrary.list_assets(
anim_path, recursive=False, include_folder=False
)
animation = None
for a in asset_content:
unreal.EditorAssetLibrary.save_asset(a)
imported_asset_data = unreal.EditorAssetLibrary.find_asset_data(a)
imported_asset = unreal.AssetRegistryHelpers.get_asset(
imported_asset_data)
if imported_asset.__class__ == unreal.AnimSequence:
animation = imported_asset
break
if animation:
actor = None
if actors_dict.get(instance_name):
for a in actors_dict.get(instance_name):
if a.get_class().get_name() == 'SkeletalMeshActor':
actor = a
break
animation.set_editor_property('enable_root_motion', True)
actor.skeletal_mesh_component.set_editor_property(
'animation_mode', unreal.AnimationMode.ANIMATION_SINGLE_NODE)
actor.skeletal_mesh_component.animation_data.set_editor_property(
'anim_to_play', animation)
if sequence:
# Add animation to the sequencer
bindings = bindings_dict.get(instance_name)
ar = unreal.AssetRegistryHelpers.get_asset_registry()
for binding in bindings:
tracks = binding.get_tracks()
track = None
track = tracks[0] if tracks else binding.add_track(
unreal.MovieSceneSkeletalAnimationTrack)
sections = track.get_sections()
section = None
if not sections:
section = track.add_section()
else:
section = sections[0]
sec_params = section.get_editor_property('params')
curr_anim = sec_params.get_editor_property('animation')
if curr_anim:
# Checks if the animation path has a container.
# If it does, it means that the animation is
# already in the sequencer.
anim_path = str(Path(
curr_anim.get_path_name()).parent
).replace('\\', '/')
_filter = unreal.ARFilter(
class_names=["AyonAssetContainer"],
package_paths=[anim_path],
recursive_paths=False)
containers = ar.get_assets(_filter)
if len(containers) > 0:
return
section.set_range(
sequence.get_playback_start(),
sequence.get_playback_end())
sec_params = section.get_editor_property('params')
sec_params.set_editor_property('animation', animation)
|
#!/project/ python3
"""
Script to refresh Blueprint properties after C++ changes
"""
import unreal
def refresh_character_blueprint():
"""Force refresh the character blueprint to show new C++ properties"""
print("=" * 70)
print("REFRESHING CHARACTER BLUEPRINT PROPERTIES")
print("=" * 70)
try:
# Load the character blueprint
bp_path = "/project/"
bp = unreal.EditorAssetLibrary.load_asset(bp_path)
if not bp:
print("✗ Could not load character blueprint")
return False
print("✓ Loaded character blueprint")
# Force recompile the blueprint
print("Recompiling blueprint...")
compile_options = unreal.BlueprintCompileOptions()
compile_options.compile_type = unreal.BlueprintCompileType.FULL
compile_options.save_intermediate_products = True
result = unreal.KismetSystemLibrary.compile_blueprint(bp, compile_options)
if result == unreal.BlueprintCompileResult.SUCCEEDED:
print("✓ Blueprint compiled successfully")
else:
print(f"⚠️ Blueprint compilation result: {result}")
# Mark the blueprint as modified to force refresh
unreal.EditorAssetLibrary.save_asset(bp_path)
print("✓ Blueprint saved")
# Get the generated class and verify properties
bp_class = bp.generated_class()
if bp_class:
default_obj = bp_class.get_default_object()
if default_obj:
# Check if our new animation properties exist
animation_properties = [
'idle_animation',
'move_animation',
'attack_up_animation',
'attack_down_animation',
'attack_side_animation',
'attack_up2_animation',
'attack_down2_animation',
'attack_side2_animation'
]
print("\nChecking C++ animation properties in Blueprint:")
for prop_name in animation_properties:
if hasattr(default_obj, prop_name):
print(f"✓ Found property: {prop_name}")
else:
print(f"⚠️ Missing property: {prop_name}")
print("\n" + "=" * 70)
print("BLUEPRINT REFRESH COMPLETE!")
print("Close and reopen the Blueprint editor to see all animation properties.")
print("The new animation properties should appear in the 'Animations' category.")
print("=" * 70)
return True
except Exception as e:
print(f"✗ Error refreshing blueprint: {str(e)}")
return False
def main():
"""Main function"""
success = refresh_character_blueprint()
if success:
print("\n🎉 Blueprint refresh completed!")
print("📋 Next steps:")
print("1. Close the Blueprint editor if it's open")
print("2. Reopen the WarriorCharacter blueprint")
print("3. Look for 'Animations' category in the Details panel")
print("4. You should see all 8 animation properties")
else:
print("\n❌ Blueprint refresh failed")
if __name__ == "__main__":
main()
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
""" An example script that uses the API to instantiate two HDAs. The first HDA
will be used as an input to the second HDA. For the second HDA we set 2 inputs:
an asset input (the first instantiated HDA) and a curve input (a helix). The
inputs are set during post instantiation (before the first cook). After the
first cook and output creation (post processing) the input structure is fetched
and logged.
"""
import math
import unreal
_g_wrapper1 = None
_g_wrapper2 = None
def get_copy_curve_hda_path():
return '/project/.copy_to_curve_1_0'
def get_copy_curve_hda():
return unreal.load_object(None, get_copy_curve_hda_path())
def get_pig_head_hda_path():
return '/project/.pig_head_subdivider_v01'
def get_pig_head_hda():
return unreal.load_object(None, get_pig_head_hda_path())
def configure_inputs(in_wrapper):
print('configure_inputs')
# Unbind from the delegate
in_wrapper.on_post_instantiation_delegate.remove_callable(configure_inputs)
# Create a geo input
asset_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPIAssetInput)
# Set the input objects/assets for this input
# asset_input.set_input_objects((_g_wrapper1.get_houdini_asset_actor().houdini_asset_component, ))
asset_input.set_input_objects((_g_wrapper1, ))
# copy the input data to the HDA as node input 0
in_wrapper.set_input_at_index(0, asset_input)
# We can now discard the API input object
asset_input = None
# Create a curve input
curve_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPICurveInput)
# Create a curve wrapper/helper
curve_object = unreal.HoudiniPublicAPICurveInputObject(curve_input)
# Make it a Nurbs curve
curve_object.set_curve_type(unreal.HoudiniPublicAPICurveType.NURBS)
# Set the points of the curve, for this example we create a helix
# consisting of 100 points
curve_points = []
for i in range(10):
t = i / 10.0 * math.pi * 2.0
x = 100.0 * math.cos(t)
y = 100.0 * math.sin(t)
z = i * 10.0
curve_points.append(unreal.Transform([x, y, z], [0, 0, 0], [1, 1, 1]))
curve_object.set_curve_points(curve_points)
# Set the curve wrapper as an input object
curve_input.set_input_objects((curve_object, ))
# Copy the input data to the HDA as node input 1
in_wrapper.set_input_at_index(1, curve_input)
# We can now discard the API input object
curve_input = None
def print_api_input(in_input):
print('\t\tInput type: {0}'.format(in_input.__class__))
print('\t\tbKeepWorldTransform: {0}'.format(in_input.keep_world_transform))
print('\t\tbImportAsReference: {0}'.format(in_input.import_as_reference))
if isinstance(in_input, unreal.HoudiniPublicAPICurveInput):
print('\t\tbCookOnCurveChanged: {0}'.format(in_input.cook_on_curve_changed))
print('\t\tbAddRotAndScaleAttributesOnCurves: {0}'.format(in_input.add_rot_and_scale_attributes_on_curves))
input_objects = in_input.get_input_objects()
if not input_objects:
print('\t\tEmpty input!')
else:
print('\t\tNumber of objects in input: {0}'.format(len(input_objects)))
for idx, input_object in enumerate(input_objects):
print('\t\t\tInput object #{0}: {1}'.format(idx, input_object))
if isinstance(input_object, unreal.HoudiniPublicAPICurveInputObject):
print('\t\t\tbClosed: {0}'.format(input_object.is_closed()))
print('\t\t\tCurveMethod: {0}'.format(input_object.get_curve_method()))
print('\t\t\tCurveType: {0}'.format(input_object.get_curve_type()))
print('\t\t\tReversed: {0}'.format(input_object.is_reversed()))
print('\t\t\tCurvePoints: {0}'.format(input_object.get_curve_points()))
def print_inputs(in_wrapper):
print('print_inputs')
# Unbind from the delegate
in_wrapper.on_post_processing_delegate.remove_callable(print_inputs)
# Fetch inputs, iterate over it and log
node_inputs = in_wrapper.get_inputs_at_indices()
parm_inputs = in_wrapper.get_input_parameters()
if not node_inputs:
print('No node inputs found!')
else:
print('Number of node inputs: {0}'.format(len(node_inputs)))
for input_index, input_wrapper in node_inputs.items():
print('\tInput index: {0}'.format(input_index))
print_api_input(input_wrapper)
if not parm_inputs:
print('No parameter inputs found!')
else:
print('Number of parameter inputs: {0}'.format(len(parm_inputs)))
for parm_name, input_wrapper in parm_inputs.items():
print('\tInput parameter name: {0}'.format(parm_name))
print_api_input(input_wrapper)
def run():
# get the API singleton
api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
global _g_wrapper1, _g_wrapper2
# instantiate the input HDA with auto-cook enabled
_g_wrapper1 = api.instantiate_asset(get_pig_head_hda(), unreal.Transform())
# instantiate the copy curve HDA
_g_wrapper2 = api.instantiate_asset(get_copy_curve_hda(), unreal.Transform())
# Configure inputs on_post_instantiation, after instantiation, but before first cook
_g_wrapper2.on_post_instantiation_delegate.add_callable(configure_inputs)
# Print the input state after the cook and output creation.
_g_wrapper2.on_post_processing_delegate.add_callable(print_inputs)
if __name__ == '__main__':
run()
|
import sys
import unreal
def create_level_sequence_transform_track(asset_name, length_seconds=600, package_path='/Game/'):
sequence = unreal.AssetToolsHelpers.get_asset_tools().create_asset(asset_name, package_path, unreal.LevelSequence, unreal.LevelSequenceFactoryNew())
actor_class = unreal.EditorAssetLibrary.load_blueprint_class('/project/')
actor = unreal.EditorLevelLibrary.spawn_actor_from_class(actor_class, [-450.0, 1030.0, 230.0], [0, 0, 0])
binding = sequence.add_possessable(actor)
transform_track = binding.add_track(unreal.MovieScene3DTransformTrack)
transform_section = transform_track.add_section()
transform_section.set_start_frame_seconds(0)
transform_section.set_end_frame_seconds(length_seconds)
## now do media track
media_track = sequence.add_master_track(unreal.MovieSceneMediaTrack)
media_track.set_editor_property("display_name", "Media")
media_section = media_track.add_section()
img_source = unreal.AssetToolsHelpers.get_asset_tools().create_asset("MS_" + asset_name, '/Game', unreal.ImgMediaSource, None)
image_path = unreal.SystemLibrary.get_project_content_directory() + "/project/.png"
img_source.set_sequence_path(image_path)
media_section.media_source = img_source
media_texture = unreal.AssetToolsHelpers.get_asset_tools().create_asset("MT_" + asset_name, '/Game/', unreal.MediaTexture, unreal.MediaTextureFactoryNew())
media_section.media_texture = media_texture
media_section.set_range(0,30)
# Now create a new material instance (from base chromakey bat) and apply to newly created actor
material_instance = unreal.AssetToolsHelpers.get_asset_tools().create_asset("MI_" + asset_name, '/Game/', unreal.MaterialInstanceConstant, unreal.MaterialInstanceConstantFactoryNew())
base_material = unreal.load_asset('/project/')
material_instance.set_editor_property('parent', base_material)
media_texture = unreal.load_asset('/Game/'+"MT_" + asset_name)
unreal.MaterialEditingLibrary.set_material_instance_texture_parameter_value(material_instance, 'Texture', media_texture)
unreal.MaterialEditingLibrary.update_material_instance(material_instance)
placeholder_mat = unreal.load_asset('/project/')
unreal.EditorLevelLibrary.replace_mesh_components_materials_on_actors([actor], placeholder_mat, material_instance)
return sequence
def add_transform_keys(sequence):
transforms = []
float_list = []
transform_path = unreal.SystemLibrary.get_project_content_directory() + '/project/.txt'
with open(transform_path, 'r') as (f):
for line in f:
line.strip()
line = line.split('|')
for item in line:
new_item = item.split(',')
for i in new_item:
i.strip()
float_list.append(float(i))
n = 9
for i in xrange(0, len(float_list), n):
transforms.append(float_list[i:i + n])
print transforms
for binding in sequence.get_bindings():
for track in binding.get_tracks():
print track
for section in track.get_sections():
print '\tSection: ' + section.get_name()
for channel in section.get_channels():
print '\tChannel: ' + channel.get_name()
name = channel.get_name()
if name == 'Location.X':
add_keys_to_transform_channel(0, transforms, channel)
elif name == 'Location.Y':
add_keys_to_transform_channel(1, transforms, channel)
elif name == 'Location.Z':
add_keys_to_transform_channel(2, transforms, channel)
elif name == 'Rotation.X':
add_keys_to_transform_channel(3, transforms, channel)
elif name == 'Rotation.Y':
add_keys_to_transform_channel(4, transforms, channel)
elif name == 'Rotation.Z':
add_keys_to_transform_channel(5, transforms, channel)
elif name == 'Scale.X':
add_keys_to_transform_channel(6, transforms, channel)
elif name == 'Scale.Y':
add_keys_to_transform_channel(7, transforms, channel)
elif name == 'Scale.Z':
add_keys_to_transform_channel(8, transforms, channel)
def add_keys_to_transform_channel(transform_component, transforms, channel):
frame_number = unreal.FrameNumber()
idx = 0
for transform in transforms:
val = transform[transform_component]
channel.add_key(unreal.TimeManagementLibrary.add_frame_number_integer(frame_number, idx), val)
idx += 1
if __name__ == "__main__":
asset_name = sys.argv[1]
sequence = create_level_sequence_transform_track(asset_name)
add_transform_keys(sequence)
|
# -*- coding: utf-8 -*-
"""
"""
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
__author__ = "timmyliang"
__email__ = "[email protected]"
__date__ = "2021-08-18 17:16:54"
import os
import unreal
from functools import partial
from Qt import QtCore
from ue_util import toast
# NOTE Python 3 & 2 兼容
try:
import tkinter as tk
from tkinter import filedialog, messagebox
except:
import Tkinter as tk
import tkFileDialog as filedialog
import tkMessageBox as messagebox
# NOTE 实现
root = tk.Tk()
root.withdraw()
asset_lib = unreal.EditorAssetLibrary
render_lib = unreal.RenderingLibrary
level_lib = unreal.EditorLevelLibrary
sys_lib = unreal.SystemLibrary
static_mesh_lib = unreal.EditorStaticMeshLibrary
defer = QtCore.QTimer.singleShot
def export_asset(obj, filename, exporter, options=None, prompt=False):
task = unreal.AssetExportTask()
task.set_editor_property("object", obj)
task.set_editor_property("filename", filename)
task.set_editor_property("exporter", exporter)
task.set_editor_property("automated", True)
task.set_editor_property("prompt", prompt)
task.set_editor_property("options", options) if options else None
check = unreal.Exporter.run_asset_export_task(task)
if not check:
msg = "导出失败 %s" % filename
messagebox.showwarning(u"警告", msg)
return
def get_static_materials(mesh):
return [
mesh.get_material(i) for i in range(static_mesh_lib.get_number_materials(mesh))
]
def get_skeletal_materials(mesh):
return [
m.get_editor_property("material_interface")
for m in mesh.get_editor_property("materials")
]
BP = unreal.load_asset("/project/.BP_UVCapture")
RT = unreal.load_asset("/project/.RT_UV")
UV_MAT = unreal.load_asset("/project/.M_UVCapture")
delay_time = 1000
class UVCapturer(object):
export_dir = ""
texture_list = []
@classmethod
def on_capture_finish(cls, mesh, capture_actor):
# NOTE 生成 2D 贴图
name = os.path.basename(mesh.get_outer().get_name())
texture = render_lib.render_target_create_static_texture2d_editor_only(RT, name)
# NOTE 导出图片
exporter = unreal.TextureExporterTGA()
output_path = os.path.join(cls.export_dir, "%s.tga" % name)
export_asset(texture, output_path, exporter)
capture_actor.destroy_actor()
asset_lib.delete_asset(texture.get_path_name())
@classmethod
def capture(cls, mesh):
capture_actor = level_lib.spawn_actor_from_object(BP, unreal.Vector())
capture_comp = capture_actor.get_editor_property("capture")
if isinstance(mesh, unreal.StaticMesh):
static_comp = capture_actor.get_editor_property("static")
static_comp.set_editor_property("static_mesh", mesh)
materials = get_static_materials(mesh)
comp = capture_actor.get_editor_property("static")
elif isinstance(mesh, unreal.SkeletalMesh):
skeletal_comp = capture_actor.get_editor_property("skeletal")
skeletal_comp.set_editor_property("skeletal_mesh", mesh)
materials = get_skeletal_materials(mesh)
# NOTE 重新获取才可以设置 override_materials
comp = capture_actor.get_editor_property("skeletal")
override_materials = [UV_MAT] * len(materials)
comp.set_editor_property("override_materials", override_materials)
capture_comp.capture_scene()
capture_comp.capture_scene()
# NOTE 等待资源更新
defer(delay_time / 2, partial(cls.on_capture_finish, mesh, capture_actor))
@classmethod
def on_finished(cls,vis_dict):
asset_lib.delete_loaded_assets(cls.texture_list)
# NOTE 删除蓝图 & 恢复场景的显示
for actor, vis in vis_dict.items():
actor.set_is_temporarily_hidden_in_editor(vis)
# NOTE 打开输出路径
os.startfile(cls.export_dir)
toast("输出成功")
@classmethod
def run(cls):
types = (unreal.SkeletalMesh, unreal.StaticMesh)
meshes = [
a
for a in unreal.EditorUtilityLibrary.get_selected_assets()
if isinstance(a, types)
]
# NOTE 选择输出路径
cls.texture_list = []
cls.export_dir = filedialog.askdirectory(title=u"选择输出的路径")
if not cls.export_dir:
return
if not meshes:
toast(u"请选择 StaticMesh 或 SkeletalMesh")
return
# NOTE 记录和隐藏所有 Actor 的显示
vis_dict = {}
for actor in level_lib.get_all_level_actors():
vis = actor.is_temporarily_hidden_in_editor()
vis_dict[actor] = vis
actor.set_is_temporarily_hidden_in_editor(True)
for i, mesh in enumerate(meshes):
defer(delay_time * i, partial(cls.capture, mesh))
defer(delay_time * (i + 1), partial(cls.on_finished, vis_dict))
if __name__ == "__main__":
UVCapturer.run()
|
from typing import Optional, Iterable, Union
import unreal
OUTLINER_FOLDER = 'ClientStrategies'
ACTOR_CLASS_NAME = 'BP_StrategyActivator'
STRATEGY_ACTOR_PATH = '/project/' + ACTOR_CLASS_NAME
DATA_ASSET_DIR = '/project/'
PROPS_ASSET_PATH = DATA_ASSET_DIR + 'DA_DefaultFieldsFilling'
CLIENT_COLLECTION_ASSET_PATH = DATA_ASSET_DIR + 'DA_ClientCollection'
ActorArr = unreal.Array[unreal.Actor]
ColorCollection = unreal.Map[unreal.ClientLabels, unreal.Color]
ActivatorLabels = Optional[Iterable[str]]
ActivatorsToHandle = Union[str, Iterable[str]]
def get_client_labels() -> dict[str, unreal.ClientLabels]:
keys = 'NONE', 'HTTP', 'WS', 'UDP', 'TCP'
return { k: getattr(unreal.ClientLabels, k) for k in keys }
def load_props_asset() -> unreal.ClientCollection:
return unreal.EditorAssetLibrary.load_asset(PROPS_ASSET_PATH)
def load_strategies_asset() -> unreal.ClientCollection:
return unreal.EditorAssetLibrary.load_asset(CLIENT_COLLECTION_ASSET_PATH)
def spawn_activators(start: unreal.Vector, step: unreal.Vector, labels: ActivatorLabels = None) -> ActorArr:
client_labels = get_client_labels()
labels_to_spawn = None
if labels is None:
labels_to_spawn = tuple(client_labels.keys())
else:
labels_to_spawn = tuple(l.upper() for l in labels if l.upper() in client_labels.keys())
i = 0
position_vec = start.copy()
props = load_props_asset()
styles = load_strategies_asset()
client_colors: ColorCollection = styles.get_editor_property('ClientColors')
get_color = lambda val: client_colors.get(key=val, default=styles.get_editor_property('DefaultColor'))
actor_class = unreal.EditorAssetLibrary.load_blueprint_class(STRATEGY_ACTOR_PATH)
spawned: ActorArr = unreal.Array(type=unreal.Actor)
loading_title = 'Spawning client strategy activators: '
with unreal.ScopedSlowTask(work=len(labels_to_spawn), desc=loading_title + '...') as slow_task:
slow_task.make_dialog(can_cancel=True)
for label in labels_to_spawn:
if slow_task.should_cancel(): break
slow_task.enter_progress_frame(work=1, desc=loading_title + label)
enum_value = client_labels[label]
actor = unreal.EditorLevelLibrary().spawn_actor_from_class(actor_class, position_vec)
actor.set_actor_label(f'{ACTOR_CLASS_NAME}_{label}')
actor.set_folder_path(OUTLINER_FOLDER)
color = get_color(enum_value)
actor.set_editor_properties(dict(
StrategyType=enum_value,
Color=unreal.LinearColor(color.r, color.g, color.b),
))
position_vec += step
spawned.append(actor)
if enum_value == unreal.ClientLabels.NONE: continue
actor.set_editor_properties(dict(
Host=props.get_editor_property('Host'),
Port=props.get_editor_property('Port') + i,
))
i += 1
return spawned
def select_from(search: ActivatorsToHandle) -> ActorArr:
client_labels = get_client_labels()
if isinstance(search, str): search = (search,)
labels = tuple(client_labels[l] for l in set(s.upper() for s in search) if l in client_labels)
selected: ActorArr = unreal.Array(type=unreal.Actor)
if not labels: return selected
world = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem).get_editor_world()
actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
actor_class = unreal.EditorAssetLibrary.load_blueprint_class(STRATEGY_ACTOR_PATH)
actors = unreal.GameplayStatics.get_all_actors_of_class(world, actor_class)
for actor in actors:
strategy_type: unreal.ClientLabels = actor.get_editor_property('StrategyType')
if strategy_type not in labels: continue
actor_subsystem.set_actor_selection_state(actor, should_be_selected=True)
selected.append(actor)
return selected
def to_default_props(targets: Optional[ActivatorsToHandle] = None) -> ActorArr:
client_labels = get_client_labels()
if targets is None:
targets = tuple(client_labels.keys())
elif isinstance(targets, str):
targets = (targets,)
labels = tuple(client_labels[l] for l in set(s.upper() for s in targets) if l in client_labels)
if not labels: return unreal.Array(type=unreal.Actor)
world = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem).get_editor_world()
actor_class = unreal.EditorAssetLibrary.load_blueprint_class(STRATEGY_ACTOR_PATH)
actors = unreal.GameplayStatics.get_all_actors_of_class(world, actor_class)
props = load_props_asset()
styles = load_strategies_asset()
client_colors: ColorCollection = styles.get_editor_property('ClientColors')
get_color = lambda val: client_colors.get(key=val, default=styles.get_editor_property('DefaultColor'))
for actor in actors:
strategy_type: unreal.ClientLabels = actor.get_editor_property('StrategyType')
color = get_color(strategy_type)
actor.set_editor_property('Color', unreal.LinearColor(color.r, color.g, color.b))
if strategy_type != unreal.ClientLabels.NONE:
actor.set_editor_property('Host', props.get_editor_property('Host'))
return actors
|
# Copyright Epic Games, Inc. All Rights Reserved
"""
Deadline Job object used to submit jobs to the render farm
"""
# Built-In
import logging
# Third-party
import unreal
# Internal
from deadline_utils import merge_dictionaries, get_deadline_info_from_preset
from deadline_enums import DeadlineJobStatus
logger = logging.getLogger("DeadlineJob")
class DeadlineJob:
""" Unreal Deadline Job object """
# ------------------------------------------------------------------------------------------------------------------
# Magic Methods
def __init__(self, job_info=None, plugin_info=None, job_preset: unreal.DeadlineJobPreset=None):
""" Constructor """
self._job_id = None
self._job_info = {}
self._plugin_info = {}
self._aux_files = []
self._job_status: DeadlineJobStatus = DeadlineJobStatus.UNKNOWN
self._job_progress = 0.0
# Jobs details updated by server after submission
self._job_details = None
# Update the job, plugin and aux file info from the data asset
if job_info and plugin_info:
self.job_info = job_info
self.plugin_info = plugin_info
if job_preset:
self.job_info, self.plugin_info = get_deadline_info_from_preset(job_preset=job_preset)
def __repr__(self):
return f"{self.__class__.__name__}({self.job_name}, {self.job_id})"
# ------------------------------------------------------------------------------------------------------------------
# Public Properties
@property
def job_info(self):
"""
Returns the Deadline job info
:return: Deadline job Info as a dictionary
:rtype: dict
"""
return self._job_info
@job_info.setter
def job_info(self, value: dict):
"""
Sets the Deadline Job Info
:param value: Value to set on the job info.
"""
if not isinstance(value, dict):
raise TypeError(f"Expected `dict` found {type(value)}")
self._job_info = merge_dictionaries(self.job_info, value)
if "AuxFiles" in self._job_info:
# Set the auxiliary files for this instance
self._aux_files = self._job_info.get("AuxFiles", [])
# Remove the aux files array from the dictionary, doesn't belong there
self._job_info.pop("AuxFiles")
@property
def plugin_info(self):
"""
Returns the Deadline plugin info
:return: Deadline plugin Info as a dictionary
:rtype: dict
"""
return self._plugin_info
@plugin_info.setter
def plugin_info(self, value: dict):
"""
Sets the Deadline Plugin Info
:param value: Value to set on plugin info.
"""
if not isinstance(value, dict):
raise TypeError(f"Expected `dict` found {type(value)}")
self._plugin_info = merge_dictionaries(self.plugin_info, value)
@property
def job_id(self):
"""
Return the deadline job ID. This is the ID returned by the service after the job has been submitted
"""
return self._job_id
@property
def job_name(self):
"""
Return the deadline job name.
"""
return self.job_info.get("Name", "Unnamed Job")
@job_name.setter
def job_name(self, value):
"""
Updates the job name on the instance. This also updates the job name in the job info dictionary
:param str value: job name
"""
self.job_info.update({"Name": value})
@property
def aux_files(self):
"""
Returns the Auxiliary files for this job
:return: List of Auxiliary files
"""
return self._aux_files
@property
def job_status(self):
"""
Return the current job status
:return: Deadline status
"""
if not self.job_details:
return DeadlineJobStatus.UNKNOWN
if "Job" not in self.job_details and "Status" not in self.job_details["Job"]:
return DeadlineJobStatus.UNKNOWN
# Some Job statuses are represented as "Rendering (1)" to indicate the
# current status of the job and the number of tasks performing the
# current status. We only care about the job status so strip out the
# extra information. Task details are returned to the job details
# object which can be queried in a different implementation
return self.get_job_status_enum(self.job_details["Job"]["Status"].split()[0])
@job_status.setter
def job_status(self, value):
"""
Return the current job status
:param DeadlineJobStatus value: Job status to set on the object.
:return: Deadline status
"""
# Statuses are expected to live in the job details object. Usually this
# property is only explicitly set if the status of a job is unknown.
# for example if the service detects a queried job is non-existent on
# the farm
# NOTE: If the structure of how job status are represented in the job
# details changes, this implementation will need to be updated.
# Currently job statuses are represented in the jobs details as
# {"Job": {"Status": "Unknown"}}
# "value" is expected to be an Enum so get the name of the Enum and set
# it on the job details. When the status property is called,
# this will be re-translated back into an enum. The reason for this is,
# the native job details object returned from the service has no
# concept of the job status enum. This is an internal
# representation which allows for more robust comparison operator logic
if self.job_details and isinstance(self.job_details, dict):
self.job_details.update({"Job": {"Status": value.name}})
@property
def job_progress(self):
"""
Returns the current job progress
:return: Deadline job progress as a float value
"""
if not self.job_details:
return 0.0
if "Job" in self.job_details and "Progress" in self.job_details["Job"]:
progress_str = self._job_details["Job"]["Progress"]
progress_str = progress_str.split()[0]
return float(progress_str) / 100 # 0-1 progress
@property
def job_details(self):
"""
Returns the job details from the deadline service.
:return: Deadline Job details
"""
return self._job_details
@job_details.setter
def job_details(self, value):
"""
Sets the job details from the deadline service. This is typically set
by the service, but can be used as a general container for job
information.
"""
self._job_details = value
# ------------------------------------------------------------------------------------------------------------------
# Public Methods
def get_submission_data(self):
"""
Returns the submission data used by the Deadline service to submit a job
:return: Dictionary with job, plugin, auxiliary info
:rtype: dict
"""
return {
"JobInfo": self.job_info,
"PluginInfo": self.plugin_info,
"AuxFiles": self.aux_files
}
# ------------------------------------------------------------------------------------------------------------------
# Protected Methods
@staticmethod
def get_job_status_enum(job_status):
"""
This method returns an enum representing the job status from the server
:param job_status: Deadline job status
:return: Returns the job_status as an enum
:rtype DeadlineJobStatus
"""
# Convert this job status returned by the server into the job status
# enum representation
# Check if the job status name has an enum representation, if not check
# the value of the job_status.
# Reference: https://docs.thinkboxsoftware.com/project/.1/1_User%20Manual/project/-jobs.html#job-property-values
try:
status = DeadlineJobStatus(job_status)
except ValueError:
try:
status = getattr(DeadlineJobStatus, job_status)
except Exception as exp:
raise RuntimeError(f"An error occurred getting the Enum status type of {job_status}. Error: \n\t{exp}")
return status
|
"""
tools_build_lookdev_level.py
Generate a minimal look-dev map that places poster/emblem decals and icon cards for quick visual checks.
Run inside Unreal Editor Python.
"""
import os
from datetime import date
import unreal # noqa: F401
ROOT = unreal.SystemLibrary.get_project_directory()
LOG = os.path.normpath(os.path.join(ROOT, "../project/.md"))
LEVEL_PATH = "/project/"
LEVEL_DIR = "/project/"
MASTER_MAT = "/project/"
GRID_COLS = 8
SPACING = 450
ASSET_FOLDERS = [
"/project/",
"/project/",
"/project/",
]
def _iter_textures() -> list[str]:
all_tex_paths = []
for folder in ASSET_FOLDERS:
assets = unreal.EditorAssetLibrary.list_assets(folder, recursive=True, include_folder=False)
all_tex_paths.extend([p for p in assets if p.endswith('.Texture2D')])
return all_tex_paths
def append_log(msg: str):
try:
with open(LOG, "a", encoding="utf-8") as f:
f.write(f"\n[{date.today().isoformat()}] {msg}\n")
except Exception:
pass
def ensure_level():
if unreal.EditorAssetLibrary.does_asset_exist(LEVEL_PATH):
return unreal.load_object(None, LEVEL_PATH)
if not unreal.EditorAssetLibrary.does_directory_exist(LEVEL_DIR):
unreal.EditorAssetLibrary.make_directory(LEVEL_DIR)
world_factory = unreal.WorldFactory()
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
level = asset_tools.create_asset("L_TG_LookDev", LEVEL_DIR, unreal.World, world_factory)
return level
def _make_mid_for_texture(tex: unreal.Texture):
master = unreal.load_object(None, MASTER_MAT)
if not master:
return None
try:
mid = unreal.MaterialInstanceDynamic.create(master)
mid.set_texture_parameter_value("BaseTex", tex)
return mid
except Exception:
return None
def _ensure_lighting():
if len(unreal.EditorLevelLibrary.get_all_level_actors()) >= 5:
return
unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.DirectionalLight, unreal.Vector(0, 0, 3000))
unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.SkyLight, unreal.Vector(0, 0, 2000))
unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.SkyAtmosphere, unreal.Vector(0, 0, 0))
unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.ExponentialHeightFog, unreal.Vector(0, 0, 0))
def _spawn_decal_at(tex: unreal.Texture, x: int, y: int) -> bool:
loc = unreal.Vector(x, y, 150)
actor = unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.DecalActor, loc)
try:
comp = actor.get_component_by_class(unreal.DecalComponent)
comp.set_editor_property("decal_size", unreal.Vector(256, 256, 256))
mid = _make_mid_for_texture(tex)
if mid:
comp.set_decal_material(mid)
return True
except Exception:
return False
def place_assets():
world = unreal.EditorLevelLibrary.get_editor_world()
if not world:
return 0
_ensure_lighting()
count = 0
row = 0
col = 0
for path in _iter_textures():
tex = unreal.load_object(None, path)
if not tex:
continue
x = col * SPACING
y = row * SPACING
if _spawn_decal_at(tex, x, y):
count += 1
col += 1
if col >= GRID_COLS:
col = 0
row += 1
return count
def main():
ensure_level()
unreal.EditorLevelLibrary.load_level(LEVEL_PATH)
num = place_assets()
append_log(f"LookDev level prepared: {LEVEL_PATH}, placed items: {num}")
unreal.SystemLibrary.print_string(None, f"LookDev: placed {num}", text_color=unreal.LinearColor.GREEN)
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
"""
Initialization module for mca-package
"""
# mca python imports
# software specific imports
import unreal
# mca python imports
from mca.ue.assettypes import py_skeletalmesh
from mca.ue.assettypes import py_staticmesh
class AssetMapping:
"""
Class used for mapping an Unreal asset type to a MAT asset type.
"""
class_dict = {unreal.SkeletalMesh: py_skeletalmesh.PySkelMesh,
unreal.StaticMesh: py_staticmesh.PyStaticMesh
}
@classmethod
def attr(cls, attr_instance):
inst_name = attr_instance.__class__
new_instance = cls.class_dict.get(inst_name, attr_instance)
if new_instance == attr_instance:
return attr_instance
return new_instance(u_asset=attr_instance)
def getAttr(self, attr_instance):
inst_name = attr_instance.__class__
new_instance = self.class_dict.get(inst_name, attr_instance)
if new_instance == inst_name:
return inst_name
return new_instance(u_asset=attr_instance)
|
"""
AutoMatty Material Instancer - Updated Version
Smart material instance creation with environment + height map + texture variation support
"""
import unreal
from automatty_config import AutoMattyConfig
from automatty_utils import AutoMattyUtils
def create_material_instance():
"""
Main function - creates smart material instance with auto-detection including texture variation
Works with: import textures, content browser selection, or folder selection
"""
# Get selected material
selected_assets = unreal.EditorUtilityLibrary.get_selected_assets()
materials = [asset for asset in selected_assets if isinstance(asset, unreal.Material)]
if len(materials) != 1:
unreal.log_error("❌ Select exactly one Material asset")
return None
base_material = materials[0]
unreal.log(f"🔧 Base material: {base_material.get_name()}")
# Try different texture sources in order of preference
textures = _get_textures_from_selection(selected_assets)
if not textures:
# No textures in selection, try importing
textures = _import_textures()
if not textures:
# Still no textures, try recent folder
textures = _get_textures_from_folder()
if not textures:
unreal.log_error("❌ No textures found. Try: selecting textures, importing, or setting texture path")
return None
unreal.log(f"🎯 Found {len(textures)} textures")
# Create the instance
return _create_instance(base_material, textures)
def _get_textures_from_selection(selected_assets):
"""Get textures from current content browser selection"""
textures = [asset for asset in selected_assets if isinstance(asset, unreal.Texture2D)]
if textures:
unreal.log(f"📋 Using {len(textures)} textures from selection")
return textures
def _import_textures():
"""Import textures using dialog"""
unreal.log("📁 Opening import dialog...")
texture_path = AutoMattyConfig.get_custom_texture_path()
atools = unreal.AssetToolsHelpers.get_asset_tools()
imported = atools.import_assets_with_dialog(texture_path)
if not imported:
return []
textures = [asset for asset in imported if isinstance(asset, unreal.Texture2D)]
if textures:
unreal.log(f"📦 Imported {len(textures)} textures")
return textures
def _get_textures_from_folder():
"""Get textures from configured material folder"""
material_path = AutoMattyConfig.get_custom_material_path()
asset_paths = unreal.EditorAssetLibrary.list_assets(material_path, recursive=False)
textures = []
for asset_path in asset_paths:
asset = unreal.EditorAssetLibrary.load_asset(asset_path)
if isinstance(asset, unreal.Texture2D):
textures.append(asset)
if textures:
unreal.log(f"📂 Found {len(textures)} textures in {material_path}")
return textures
def _create_instance(base_material, textures):
"""Create the actual material instance"""
# Get paths and naming
material_path = AutoMattyConfig.get_custom_material_path()
instance_name, target_folder = AutoMattyUtils.generate_smart_instance_name(
base_material, textures, material_path
)
# Analyze material capabilities
texture_params = unreal.MaterialEditingLibrary.get_texture_parameter_names(base_material)
has_height = "Height" in texture_params
has_variation = "VariationHeightMap" in texture_params # NEW - check for texture variation
is_environment = _is_environment_material(texture_params)
# Check for UDIM sets first
#udim_sets = detect_udim_sets(textures)
#if udim_sets:
# unreal.log(f"🗺️ Found {len(udim_sets)} UDIM sets")
# # Use first texture from each UDIM set for matching
# textures = [group[0] for group in udim_sets.values()]
#
#if is_environment:
# unreal.log("🌍 Environment material detected")
#if has_height:
# unreal.log("🏔️ Height displacement supported")
#if has_variation:
# unreal.log("🎲 Texture variation supported")
# Match textures to parameters
matched_textures = _match_textures(textures, has_height, is_environment, has_variation)
if not matched_textures:
unreal.log_warning("⚠️ No matching textures found")
return None
# Create the instance
atools = unreal.AssetToolsHelpers.get_asset_tools()
mic_factory = unreal.MaterialInstanceConstantFactoryNew()
instance = atools.create_asset(
instance_name, target_folder,
unreal.MaterialInstanceConstant, mic_factory
)
unreal.MaterialEditingLibrary.set_material_instance_parent(instance, base_material)
unreal.log(f"🎉 Created instance: {instance.get_name()}")
# Apply textures
applied_count = _apply_textures(instance, matched_textures)
# Save
unreal.EditorAssetLibrary.save_asset(instance.get_path_name())
unreal.log(f"🏆 Applied {applied_count} textures successfully")
return instance
def _is_environment_material(texture_params):
"""Check if material has environment A/B parameters"""
env_indicators = ['ColorA', 'ColorB', 'NormalA', 'NormalB', 'RoughnessA', 'RoughnessB']
return any(param in texture_params for param in env_indicators)
def _match_textures(textures, include_height=False, is_environment=False, include_variation=False):
"""Smart texture matching with environment, height, and texture variation support"""
import re
patterns = AutoMattyConfig.TEXTURE_PATTERNS.copy()
matched = {}
if is_environment:
# Environment material matching
matched = _match_environment_textures(textures, patterns, include_variation)
else:
# Standard material matching
for texture in textures:
name = texture.get_name().lower()
for param_type, pattern in patterns.items():
# Skip Height matching if not supported
if param_type == "Height" and not include_height:
continue
if param_type not in matched and pattern.search(name):
matched[param_type] = texture
emoji = "🏔️" if param_type == "Height" else "✅"
unreal.log(f"{emoji} Matched '{texture.get_name()}' → {param_type}")
break
# Handle texture variation height map for standard materials
if include_variation and "Height" not in matched and "Height" in patterns:
# Look for any height-like texture that could be used for variation
for texture in textures:
name = texture.get_name().lower()
if patterns["Height"].search(name) and texture not in matched.values():
matched["VariationHeightMap"] = texture
unreal.log(f"🎲 Matched '{texture.get_name()}' → VariationHeightMap")
break
return matched
def _match_environment_textures(textures, patterns, include_variation=False):
"""Match textures for environment materials (A/B sets + blend mask + variation)"""
matched = {}
# Environment patterns
env_patterns = {
"ColorA": patterns["Color"],
"ColorB": patterns["Color"],
"NormalA": patterns["Normal"],
"NormalB": patterns["Normal"],
"RoughnessA": patterns["Roughness"],
"RoughnessB": patterns["Roughness"],
"MetallicA": patterns["Metallic"],
"MetallicB": patterns["Metallic"],
"BlendMask": patterns["BlendMask"],
}
# First pass: explicit A/B markers
for texture in textures:
name = texture.get_name().lower()
for param, pattern in env_patterns.items():
if param in matched:
continue
if not pattern.search(name):
continue
# Check for explicit markers
if param.endswith('A'):
if any(marker in name for marker in ['_a_', '_a.', '_01_', '_1_', 'first', 'primary']):
matched[param] = texture
unreal.log(f"🌍 Matched '{texture.get_name()}' → {param} (explicit A)")
elif param.endswith('B'):
if any(marker in name for marker in ['_b_', '_b.', '_02_', '_2_', 'second', 'secondary']):
matched[param] = texture
unreal.log(f"🌍 Matched '{texture.get_name()}' → {param} (explicit B)")
elif param == "BlendMask":
matched[param] = texture
unreal.log(f"🌍 Matched '{texture.get_name()}' → {param}")
# Second pass: assign remaining textures to A first, then B
for texture in textures:
if texture in matched.values():
continue
name = texture.get_name().lower()
for base_type in ["Color", "Normal", "Roughness", "Metallic"]:
if base_type in patterns and patterns[base_type].search(name):
param_a = f"{base_type}A"
param_b = f"{base_type}B"
if param_a not in matched:
matched[param_a] = texture
unreal.log(f"🌍 Matched '{texture.get_name()}' → {param_a} (fallback)")
break
elif param_b not in matched:
matched[param_b] = texture
unreal.log(f"🌍 Matched '{texture.get_name()}' → {param_b} (fallback)")
break
# Handle texture variation for environment materials
if include_variation:
# Look for height textures that haven't been matched yet
for texture in textures:
if texture in matched.values():
continue
name = texture.get_name().lower()
if patterns["Height"].search(name):
matched["VariationHeightMap"] = texture
unreal.log(f"🎲 Environment matched '{texture.get_name()}' → VariationHeightMap")
break
return matched
def _apply_textures(instance, matched_textures):
"""Apply matched textures to material instance"""
applied_count = 0
for param_name, texture in matched_textures.items():
try:
unreal.MaterialEditingLibrary.set_material_instance_texture_parameter_value(
instance, param_name, texture
)
# Emoji based on parameter type
if param_name == "Height":
emoji = "🏔️"
elif param_name == "VariationHeightMap":
emoji = "🎲"
elif param_name.endswith(('A', 'B')) or param_name == "BlendMask":
emoji = "🌍"
else:
emoji = "✅"
unreal.log(f"{emoji} Set '{param_name}' → {texture.get_name()}")
applied_count += 1
except Exception as e:
unreal.log_warning(f"⚠️ Failed to set {param_name}: {str(e)}")
return applied_count
# Execute when called directly
if __name__ == "__main__":
create_material_instance()
|
import unreal
import os
import json
# SETTINGS
JSON_FOLDER = "H:/project/" # Full path to material JSON files
SAVE_MATERIALS_TO = "/project/" # Where to save generated materials
ROOT_DIR = "/Game" # Root directory to search for textures
# Helpers
def ensure_directory_exists(path):
if not unreal.EditorAssetLibrary.does_directory_exist(path):
unreal.EditorAssetLibrary.make_directory(path)
def find_texture_by_filename(root_dir, filename):
asset_registry = unreal.AssetRegistryHelpers.get_asset_registry()
asset_registry.scan_paths_synchronous([root_dir], True)
assets = asset_registry.get_assets_by_path(root_dir, recursive=True)
base_name = os.path.basename(filename).split(".")[0].lower()
for asset in assets:
if asset.asset_class == "Texture2D" and str(asset.asset_name).lower() == base_name:
return asset.object_path
# Fallback fuzzy match: try partial matching
for asset in assets:
if asset.asset_class == "Texture2D" and base_name in str(asset.asset_name).lower():
return asset.object_path
return None
def material_exists_in_folder(material_name, folder_path):
asset_registry = unreal.AssetRegistryHelpers.get_asset_registry()
assets = asset_registry.get_assets_by_path(folder_path, recursive=False)
for asset in assets:
if asset.asset_class == "Material" and str(asset.asset_name) == material_name:
return True
return False
def create_material(material_name, textures):
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
material_path = SAVE_MATERIALS_TO + "/" + material_name
ensure_directory_exists(SAVE_MATERIALS_TO)
if unreal.EditorAssetLibrary.does_asset_exist(material_path):
print(f"Material {material_name} already exists, skipping creation.")
return unreal.load_asset(material_path)
resolved_textures = {}
for param_name, texture_filename in textures.items():
texture_path = find_texture_by_filename(ROOT_DIR, texture_filename)
if texture_path:
resolved_textures[param_name] = texture_path
else:
print(f" - Texture not found for: {texture_filename}")
if len(resolved_textures) == 0:
print(f"⚠️ No textures found for {material_name}. Still creating empty material.")
material_factory = unreal.MaterialFactoryNew()
material = asset_tools.create_asset(material_name, SAVE_MATERIALS_TO, unreal.Material, material_factory)
print(f"🎨 Created new material: {material_name}")
x = -384
y = -200
y_spacing = 250
for param_name, texture_path in resolved_textures.items():
texture = unreal.load_asset(texture_path)
if not texture:
continue
tex_sample = unreal.MaterialEditingLibrary.create_material_expression(material, unreal.MaterialExpressionTextureSample, x, y)
tex_sample.texture = texture
param_name_lower = param_name.lower()
if "normal" in param_name_lower:
tex_sample.sampler_type = unreal.MaterialSamplerType.SAMPLERTYPE_NORMAL
unreal.MaterialEditingLibrary.connect_material_property(tex_sample, "RGB", unreal.MaterialProperty.MP_NORMAL)
elif "emissive" in param_name_lower:
unreal.MaterialEditingLibrary.connect_material_property(tex_sample, "RGB", unreal.MaterialProperty.MP_EMISSIVE_COLOR)
elif "ao" in param_name_lower or "rough" in param_name_lower or "metal" in param_name_lower:
unreal.MaterialEditingLibrary.connect_material_property(tex_sample, "RGB", unreal.MaterialProperty.MP_AMBIENT_OCCLUSION)
elif "basecolor" in param_name_lower or "diffuse" in param_name_lower or "albedo" in param_name_lower:
unreal.MaterialEditingLibrary.connect_material_property(tex_sample, "RGB", unreal.MaterialProperty.MP_BASE_COLOR)
print(f" - Added and connected TextureSample for {param_name} ({os.path.basename(str(texture_path))})")
y += y_spacing
unreal.MaterialEditingLibrary.layout_material_expressions(material)
unreal.MaterialEditingLibrary.recompile_material(material)
unreal.EditorAssetLibrary.save_asset(material_path)
unreal.SystemLibrary.collect_garbage()
print(f"✅ Saved and cleaned up memory for material: {material_name}")
return material
# Main
def process_json_materials(json_folder):
json_files = []
for root, dirs, files in os.walk(json_folder):
for file in files:
if file.endswith(".json"):
json_files.append(os.path.join(root, file))
with unreal.ScopedSlowTask(len(json_files), "Generating Materials from JSON...") as task:
task.make_dialog(True)
for i, full_path in enumerate(json_files):
if task.should_cancel():
print("Material generation canceled.")
break
file = os.path.basename(full_path)
mat_name = os.path.splitext(file)[0]
task.enter_progress_frame(1.0, f"Processing {mat_name}...")
if material_exists_in_folder(mat_name, SAVE_MATERIALS_TO):
print(f"Material {mat_name} already exists in Materials folder, skipping.")
continue
with open(full_path, 'r') as f:
try:
data = json.load(f)
except Exception as e:
print(f"❌ Failed to parse JSON {file}: {e}")
continue
if "Textures" in data and isinstance(data["Textures"], dict):
textures = data["Textures"]
create_material(mat_name, textures)
else:
print(f"No valid 'Textures' section in {file}")
# Run
process_json_materials(JSON_FOLDER)
|
import unreal
from Utilities.Utils import Singleton
import math
try:
import numpy as np
b_use_numpy = True
except:
b_use_numpy = False
class ImageCompare(metaclass=Singleton):
def __init__(self, json_path:str):
self.json_path = json_path
self.data:unreal.ChameleonData = unreal.PythonBPLib.get_chameleon_data(self.json_path)
self.left_texture_size = (128, 128)
self.right_texture_size = (128, 128)
self.dpi_scale = 1
self.ui_img_left = "ImageLeft"
self.ui_img_right = "ImageRight"
self.ui_img_right_bg = "ImageRightBG"
self.ui_comparison_widget = "ComparisonWidget"
self.ui_dpi_scaler = "Scaler"
self.ui_status_bar = "StatusBar"
self.ui_ignore_alpha = "AlphaCheckBox"
self.ui_scaler_combobox = "ScaleComboBox"
self.combobox_items = self.data.get_combo_box_items(self.ui_scaler_combobox)
self.update_status_bar()
def set_image_from_viewport(self, bLeft):
data, width_height = unreal.PythonBPLib.get_viewport_pixels_as_data()
w, h = width_height.x, width_height.y
channel_num = int(len(data) / w / h)
if b_use_numpy:
im = np.fromiter(data, dtype=np.uint8).reshape(w, h, channel_num)
self.data.set_image_data_from_memory(self.ui_img_left if bLeft else self.ui_img_right, im.ctypes.data, len(data)
, w, h, channel_num=channel_num, bgr=False
, tiling=unreal.SlateBrushTileType.HORIZONTAL if bLeft else unreal.SlateBrushTileType.NO_TILE)
else:
texture = unreal.PythonBPLib.get_viewport_pixels_as_texture()
self.data.set_image_data_from_texture2d(self.ui_img_left if bLeft else self.ui_img_right, texture
, tiling=unreal.SlateBrushTileType.HORIZONTAL if bLeft else unreal.SlateBrushTileType.NO_TILE)
if bLeft:
self.left_texture_size = (w, h)
else:
self.right_texture_size = (w, h)
self.update_dpi_by_texture_size()
self.fit_window_size()
def fit_window_size1(self):
size = unreal.ChameleonData.get_chameleon_desired_size(self.json_path)
def set_images_from_viewport(self):
unreal.AutomationLibrary.set_editor_viewport_view_mode(unreal.ViewModeIndex.VMI_LIT)
self.set_image_from_viewport(bLeft=True)
unreal.AutomationLibrary.set_editor_viewport_view_mode(unreal.ViewModeIndex.VMI_WIREFRAME)
self.set_image_from_viewport(bLeft=False)
unreal.AutomationLibrary.set_editor_viewport_view_mode(unreal.ViewModeIndex.VMI_LIT)
self.fit_window_size()
self.update_status_bar()
def update_dpi_by_texture_size(self):
max_size = max(self.left_texture_size[1], self.right_texture_size[1])
if max_size >= 64:
self.dpi_scale = 1 / math.ceil(max_size / 512)
else:
self.dpi_scale = 4 if max_size <= 16 else 2
print(f"Set dpi -> {self.dpi_scale }")
self.data.set_dpi_scale(self.ui_dpi_scaler, self.dpi_scale)
for index, value_str in enumerate(self.combobox_items):
if float(value_str) == self.dpi_scale:
self.data.set_combo_box_selected_item(self.ui_scaler_combobox, index)
break
def on_ui_change_scale(self, value_str):
self.dpi_scale = float(value_str)
self.data.set_dpi_scale(self.ui_dpi_scaler, self.dpi_scale)
self.fit_window_size()
def update_status_bar(self):
self.data.set_text(self.ui_status_bar, f"Left: {self.left_texture_size}, Right: {self.right_texture_size} ")
if self.left_texture_size != self.right_texture_size:
self.data.set_color_and_opacity(self.ui_status_bar, unreal.LinearColor(2, 0, 0, 1))
else:
self.data.set_color_and_opacity(self.ui_status_bar, unreal.LinearColor.WHITE)
def fit_window_size(self):
max_x = max(self.left_texture_size[0], self.right_texture_size[0])
max_y = max(self.left_texture_size[1], self.right_texture_size[1])
MIN_WIDTH = 400
MAX_HEIGHT = 900
self.data.set_chameleon_window_size(self.json_path
, unreal.Vector2D(max(MIN_WIDTH, max_x * self.dpi_scale + 18)
, min(MAX_HEIGHT, max_y * self.dpi_scale + 125))
)
def on_drop(self, bLeft, **kwargs):
for asset_path in kwargs["assets"]:
asset = unreal.load_asset(asset_path)
if isinstance(asset, unreal.Texture2D):
width = asset.blueprint_get_size_x()
height = asset.blueprint_get_size_y()
ignore_alpha = self.data.get_is_checked(self.ui_ignore_alpha)
if self.data.set_image_data_from_texture2d(self.ui_img_left if bLeft else self.ui_img_right, asset, ignore_alpha=ignore_alpha):
if bLeft:
self.left_texture_size = (width, height)
else:
self.right_texture_size = (width, height)
self.update_dpi_by_texture_size()
self.fit_window_size()
self.update_status_bar()
break
|
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
import unreal
from typing import Optional, Union
from openjd.model import parse_model
from openjd.model.v2023_09 import (
Environment,
EnvironmentScript,
)
from deadline.unreal_submitter import settings
from deadline.unreal_submitter.unreal_open_job.unreal_open_job_entity import UnrealOpenJobEntity
from deadline.unreal_submitter.unreal_open_job.unreal_open_job_parameters_consistency import (
ParametersConsistencyChecker,
)
from deadline.unreal_logger import get_logger
logger = get_logger()
# Base Environment implementation
class UnrealOpenJobEnvironment(UnrealOpenJobEntity):
"""
Unreal Open Job Environment entity
"""
def __init__(
self,
file_path: Optional[str] = None,
name: Optional[str] = None,
variables: Optional[dict[str, str]] = None,
):
"""
:param file_path: The file path of the environment descriptor
:type file_path: str
:param name: The name of the environment
:type name: str
:param variables: Environment variables as dictionary
:type variables: dict[str, str]
"""
super().__init__(Environment, file_path, name)
self._variables = variables or {}
self._create_missing_variables_from_template()
@property
def variables(self) -> dict[str, str]:
return self._variables
@variables.setter
def variables(self, value: Union[dict[str, str], unreal.Map]):
self._variables = dict(value)
@classmethod
def from_data_asset(cls, data_asset: unreal.DeadlineCloudEnvironment):
"""
Create the instance of UnrealOpenJobEnvironment from unreal.DeadlineCloudEnvironment
:param data_asset: unreal.DeadlineCloudEnvironment instance
:return: UnrealOpenJobEnvironment instance
:rtype: UnrealOpenJobEnvironment
"""
return cls(
file_path=data_asset.path_to_template.file_path,
name=data_asset.name,
variables=dict(data_asset.variables.variables),
)
def _create_missing_variables_from_template(self):
"""
Update variables with YAML template data. Mostly needed for custom job submission process.
If no template file found, skip updating and log warning.
This is not an error and should not break the building process.
"""
try:
template_variables = self.get_template_object().get("variables", {})
for key, value in template_variables.items():
if key not in self._variables:
self._variables[key] = value
except FileNotFoundError:
logger.warning("No template file found to read parameters from.")
def _check_parameters_consistency(self):
"""
Check Environment variables consistency
:return: Result of parameters consistency check
:rtype: ParametersConsistencyCheckResult
"""
result = ParametersConsistencyChecker.check_environment_variables_consistency(
environment_template_path=self.file_path, environment_variables=self._variables
)
result.reason = f'OpenJob Environment "{self.name}": ' + result.reason
return result
def _build_template(self) -> Environment:
"""
Build Environment OpenJD model with updated name and variables dictionary
"""
environment_template_object = self.get_template_object()
template_dict = {
"name": self.name,
}
script = environment_template_object.get("script")
if script:
template_dict["script"] = parse_model(model=EnvironmentScript, obj=script)
if self._variables:
template_dict["variables"] = self._variables
return parse_model(model=self.template_class, obj=template_dict)
# Launch Unreal Editor Environment
class LaunchEditorUnrealOpenJobEnvironment(UnrealOpenJobEnvironment):
"""Predefined Environment for launching the Unreal Editor"""
default_template_path = settings.LAUNCH_ENVIRONMENT_TEMPLATE_DEFAULT_PATH
# UGS Environments
class UgsUnrealOpenJobEnvironment(UnrealOpenJobEnvironment):
"""Parent class for predefined UGS Environment"""
pass
class UgsLaunchEditorUnrealOpenJobEnvironment(UgsUnrealOpenJobEnvironment):
"""Predefined Environment for launching the Unreal Editor in UGS case"""
default_template_path = settings.UGS_LAUNCH_ENVIRONMENT_TEMPLATE_DEFAULT_PATH
class UgsSyncCmfUnrealOpenJobEnvironment(UgsUnrealOpenJobEnvironment):
"""Predefined Environment for syncing the Unreal project via UGS on CMF farm"""
default_template_path = settings.UGS_SYNC_CMF_ENVIRONMENT_TEMPLATE_DEFAULT_PATH
class UgsSyncSmfUnrealOpenJobEnvironment(UgsUnrealOpenJobEnvironment):
"""Predefined Environment for syncing the Unreal project via UGS on SMF farm"""
default_template_path = settings.UGS_SYNC_SMF_ENVIRONMENT_TEMPLATE_DEFAULT_PATH
# Perforce (non UGS) Environments
class P4UnrealOpenJobEnvironment(UnrealOpenJobEnvironment):
pass
class P4LaunchEditorUnrealOpenJobEnvironment(P4UnrealOpenJobEnvironment):
default_template_path = settings.P4_LAUNCH_ENVIRONMENT_TEMPLATE_DEFAULT_PATH
class P4SyncCmfUnrealOpenJobEnvironment(P4UnrealOpenJobEnvironment):
default_template_path = settings.P4_SYNC_CMF_ENVIRONMENT_TEMPLATE_DEFAULT_PATH
class P4SyncSmfUnrealOpenJobEnvironment(P4UnrealOpenJobEnvironment):
default_template_path = settings.P4_SYNC_SMF_ENVIRONMENT_TEMPLATE_DEFAULT_PATH
|
#!/project/ python3
"""
Blueprint Verification Script
Check if WarriorCharacter blueprint exists and create it if needed
"""
import unreal
def check_and_create_warrior_blueprint():
"""Check if WarriorCharacter blueprint exists, create if not"""
blueprint_path = "/project/"
print(f"Checking for blueprint at: {blueprint_path}")
# Try to load the existing blueprint
existing_blueprint = unreal.EditorAssetLibrary.load_asset(blueprint_path)
if existing_blueprint:
print(f"✓ Blueprint already exists: {blueprint_path}")
print(f"✓ Blueprint class: {type(existing_blueprint)}")
return True
else:
print(f"✗ Blueprint not found at: {blueprint_path}")
print("Creating new WarriorCharacter blueprint...")
# Create the blueprint
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
# Create blueprint based on PaperCharacter
parent_class = unreal.PaperCharacter
blueprint = asset_tools.create_blueprint(
parent_class,
"/project/",
"WarriorCharacter"
)
if blueprint:
print(f"✓ Successfully created blueprint: {blueprint.get_path_name()}")
# Configure the blueprint
configure_warrior_blueprint(blueprint)
# Save the blueprint
unreal.EditorAssetLibrary.save_asset(blueprint.get_path_name())
print("✓ Blueprint saved successfully")
return True
else:
print("✗ Failed to create blueprint")
return False
def configure_warrior_blueprint(blueprint):
"""Configure the warrior blueprint with proper settings"""
try:
print("Configuring blueprint properties...")
# Get the default object
default_object = blueprint.get_default_object()
if not default_object:
print("ERROR: Could not get blueprint default object")
return False
# Configure movement component
movement_component = default_object.get_character_movement()
if movement_component:
movement_component.set_editor_property('max_walk_speed', 300.0)
movement_component.set_editor_property('jump_z_velocity', 400.0)
movement_component.set_editor_property('gravity_scale', 1.0)
movement_component.set_editor_property('air_control', 0.2)
movement_component.set_editor_property('ground_friction', 8.0)
# Constrain to 2D plane
movement_component.set_editor_property('plane_constraint_enabled', True)
movement_component.set_editor_property('plane_constraint_normal', unreal.Vector(0, 1, 0))
print("✓ Movement component configured")
print("✓ Blueprint configuration completed")
return True
except Exception as e:
print(f"ERROR during blueprint configuration: {e}")
return False
def list_all_blueprints():
"""List all existing blueprints in the project"""
print("\nListing all blueprints in project:")
# Get all blueprint assets
asset_registry = unreal.AssetRegistryHelpers.get_asset_registry()
# Search for Blueprint assets
filter = unreal.ARFilter(
class_names=["Blueprint"],
package_paths=["/Game"],
recursive_paths=True
)
assets = asset_registry.get_assets(filter)
if assets:
print(f"Found {len(assets)} blueprint(s):")
for asset in assets:
print(f" - {asset.package_name}")
print(f" Class: {asset.asset_class}")
print(f" Path: {asset.object_path}")
else:
print("No blueprints found in /Game directory")
if __name__ == "__main__":
print("=== Blueprint Verification ===")
# List existing blueprints
list_all_blueprints()
# Check and create warrior blueprint
success = check_and_create_warrior_blueprint()
if success:
print("\n✓ Verification completed successfully!")
else:
print("\n✗ Verification failed!")
|
# -*- coding: utf-8 -*-
"""
检测导入的 FBX 和现有的动画资源的帧数
右键导入可以导入匹配对的动画资源
"""
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
__author__ = 'timmyliang'
__email__ = '[email protected]'
__date__ = '2020-05-30 21:27:26'
import os
import sys
DIR = os.path.dirname(__file__)
sys.path.insert(0, DIR) if DIR else None
from dayu_widgets.push_button import MPushButton
from progress_dialog import IProgressDialog
from splitter import ISplitter
from path_selector import IPathSelector
from Qt import QtCore, QtWidgets, QtGui
from functools import partial
from collections import Iterable
from itertools import chain
import webbrowser
import unreal
import FbxCommon
import fbx
class ListSyncer(object):
"""
用来同步两个 ListWidget 滚动和选择
"""
protected = False
def protected_decorator(func):
def wrapper(self, *args, **kwargs):
# NOTE 避免重复调用
if self.protected:
return
self.protected = True
func(self, *args, **kwargs)
self.protected = False
return wrapper
def __init__(self, *args, **kwargs):
# NOTE args 传入 ListWidget 列表，可以是层层嵌套的数据，下面的操作会自动过滤出 ListWidget 列表
# NOTE flattern list https://stackoverflow.com/project/-list-of-list-through-list-comprehension
widget_list = list(chain.from_iterable(item if isinstance(item, Iterable) and
not isinstance(item, basestring) else [item] for item in args))
self.widget_list = [widget for widget in widget_list if isinstance(
widget, QtWidgets.QListWidget)]
# NOTE 默认同步滚动
if kwargs.get("scroll", True):
self.scroll_list = [widget.verticalScrollBar()
for widget in self.widget_list]
for scroll in self.scroll_list:
# NOTE 默认 scroll_sync 参数不启用 | 滚动根据滚动值进行同步 | 反之则根据滚动百分比同步
callback = partial(self.move_scrollbar, scroll) if kwargs.get(
"scroll_sync", False) else lambda value: [scroll.setValue(value) for scroll in self.scroll_list]
scroll.valueChanged.connect(callback)
# NOTE 同步选择 默认不同步
if kwargs.get("selection", False):
for widget in self.widget_list:
callback = partial(self.item_selection, widget)
widget.itemSelectionChanged.connect(callback)
@protected_decorator
def move_scrollbar(self, scroll, value):
scroll.setValue(value)
ratio = float(value)/scroll.maximum()
for _scroll in self.scroll_list:
# NOTE 跳过自己
if scroll is _scroll:
continue
val = int(ratio*_scroll.maximum())
_scroll.setValue(val)
@protected_decorator
def item_selection(self, widget):
items = widget.selectedItems()
row_list = [widget.row(item) for item in items]
for _widget in self.widget_list:
# NOTE 跳过自己
if widget is _widget:
continue
_widget.clearSelection()
for row in row_list:
item = _widget.item(row)
# NOTE 如果 item 存在选择 item
if item:
item.setSelected(True)
class FBXListWidget(QtWidgets.QListWidget):
def __init__(self, parent=None, file_filter=None):
super(FBXListWidget, self).__init__()
self.FBX_UI = parent
self.asset_list = parent.asset_list
self.file_filter = file_filter
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection)
self.customContextMenuRequested.connect(self.right_menu)
self.setAcceptDrops(True)
def dragEnterEvent(self, event):
event.accept() if event.mimeData().hasUrls() else event.ignore()
def dropEvent(self, event):
# Note 获取拖拽文件的地址
if event.mimeData().hasUrls:
event.setDropAction(QtCore.Qt.CopyAction)
event.accept()
for url in IProgressDialog.loop(event.mimeData().urls()):
path = (url.toLocalFile())
_, ext = os.path.splitext(path)
# Note 过滤已有的路径
if ext.lower() in self.file_filter or "*" in self.file_filter:
self.addItem(path)
else:
event.ignore()
def dragMoveEvent(self, event):
if event.mimeData().hasUrls:
event.setDropAction(QtCore.Qt.CopyAction)
event.accept()
else:
event.ignore()
def right_menu(self):
self.menu = QtWidgets.QMenu(self)
open_file_action = QtWidgets.QAction(u'打开文件路径', self)
open_file_action.triggered.connect(self.open_file_location)
remove_action = QtWidgets.QAction(u'删除选择', self)
remove_action.triggered.connect(self.remove_items)
import_action = QtWidgets.QAction(u'导入选择', self)
import_action.triggered.connect(self.import_items)
item = self.currentItem()
path = item.toolTip()
path = path.split('\n')[0]
if not os.path.exists(path):
open_file_action.setVisible(False)
self.menu.addAction(open_file_action)
self.menu.addSeparator()
self.menu.addAction(remove_action)
self.menu.addSeparator()
self.menu.addAction(import_action)
self.menu.popup(QtGui.QCursor.pos())
def open_file_location(self):
item = self.currentItem()
path = item.toolTip()
path = path.split('\n')[0]
print(path)
os.startfile(os.path.dirname(path))
def remove_items(self):
style = QtWidgets.QApplication.style()
icon = style.standardIcon(QtWidgets.QStyle.SP_MessageBoxQuestion)
# NOTE 如果没有选择 直接删除当前项
for item in self.selectedItems():
row = self.row(item)
count = self.asset_list.count()
if row < count:
item.setText("")
item.setToolTip("")
item.setIcon(icon)
else:
item = self.takeItem(row)
def buildImportTask(self, filename='', destination_path='', skeleton=None):
options = unreal.FbxImportUI()
options.set_editor_property("skeleton", skeleton)
# NOTE 只导入 动画 数据
options.set_editor_property("import_animations", True)
options.set_editor_property("import_as_skeletal", False)
options.set_editor_property("import_materials", False)
options.set_editor_property("import_textures", False)
options.set_editor_property("import_rigid_mesh", False)
options.set_editor_property("create_physics_asset", False)
options.set_editor_property(
"mesh_type_to_import", unreal.FBXImportType.FBXIT_ANIMATION)
# NOTE https://forums.unrealengine.com/development-discussion/python-scripting/1576474-importing-skeletal-meshes-4-21
options.set_editor_property(
"automated_import_should_detect_type", False)
task = unreal.AssetImportTask()
task.set_editor_property("factory", unreal.FbxFactory())
# NOTE 设置 automated 为 True 不会弹窗
task.set_editor_property("automated", True)
task.set_editor_property("destination_name", '')
task.set_editor_property("destination_path", destination_path)
task.set_editor_property("filename", filename)
task.set_editor_property("replace_existing", True)
task.set_editor_property("save", False)
task.options = options
return task
def import_items(self):
# Note unreal 导入 FBX
tasks = []
for fbx_item in self.selectedItems():
fbx_path = fbx_item.toolTip()
if not fbx_path:
continue
fbx_path = fbx_path.split("\n")[0]
row = self.row(fbx_item)
asset_item = self.asset_list.item(row)
asset_path = os.path.dirname(asset_item.text())
skeleton = asset_item.asset.get_editor_property('skeleton')
task = self.buildImportTask(fbx_path, asset_path, skeleton)
tasks.append(task)
# NOTE 配置颜色
fbx_item.setBackground(QtGui.QBrush(QtGui.QColor(0, 255, 0)))
asset_item.setBackground(QtGui.QBrush(QtGui.QColor(0, 255, 0)))
# NOTE 批量导入 FBX
unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks(tasks)
def read_fbx_frame(self, fbx_file):
# NOTE read FBX frame count
manager, scene = FbxCommon.InitializeSdkObjects()
# NOTE 只导入 Global_Settings 读取帧数
s = manager.GetIOSettings()
s.SetBoolProp("Import|AdvOptGrp|FileFormat|Fbx|Material", False)
s.SetBoolProp("Import|AdvOptGrp|FileFormat|Fbx|Texture", False)
s.SetBoolProp("Import|AdvOptGrp|FileFormat|Fbx|Audio", False)
s.SetBoolProp("Import|AdvOptGrp|FileFormat|Fbx|Audio", False)
s.SetBoolProp("Import|AdvOptGrp|FileFormat|Fbx|Shape", False)
s.SetBoolProp("Import|AdvOptGrp|FileFormat|Fbx|Link", False)
s.SetBoolProp("Import|AdvOptGrp|FileFormat|Fbx|Gobo", False)
s.SetBoolProp("Import|AdvOptGrp|FileFormat|Fbx|Animation", False)
s.SetBoolProp("Import|AdvOptGrp|FileFormat|Fbx|Character", False)
s.SetBoolProp("Import|AdvOptGrp|FileFormat|Fbx|Global_Settings", True)
manager.SetIOSettings(s)
result = FbxCommon.LoadScene(manager, scene, fbx_file)
if not result:
raise RuntimeError("%s load Fail" % fbx_file)
# NOTE 获取 FBX 设定设置的帧数
setting = scene.GetGlobalSettings()
time_span = setting.GetTimelineDefaultTimeSpan()
time_mode = setting.GetTimeMode()
frame_rate = fbx.FbxTime.GetFrameRate(time_mode)
duration = time_span.GetDuration()
second = duration.GetMilliSeconds()
frame_count = round(second/1000*frame_rate) + 1
return frame_count
def handleItem(self, item, callback):
path = item.text() if isinstance(item, QtWidgets.QListWidgetItem) else item
style = QtWidgets.QApplication.style()
warn_icon = style.standardIcon(QtWidgets.QStyle.SP_MessageBoxWarning)
question_icon = style.standardIcon(
QtWidgets.QStyle.SP_MessageBoxQuestion)
file_name = ""
if os.path.exists(path):
file_name = os.path.basename(path)
item = QtWidgets.QListWidgetItem(warn_icon, file_name)
if self.findItems(file_name, QtCore.Qt.MatchContains):
return
item.frame_count = self.read_fbx_frame(path)
tooltip = u"%s\n关键帧数: %s" % (path, item.frame_count)
item.setToolTip(tooltip)
elif path == "":
item = QtWidgets.QListWidgetItem(question_icon, "")
else:
return
callback(item)
self.FBX_UI.compare_assets() if path else None
def addItem(self, item):
self.handleItem(item, lambda item: super(
FBXListWidget, self).addItem(item))
def addItems(self, items):
for item in IProgressDialog.loop(items):
self.addItem(item)
def insertItem(self, row, item):
self.handleItem(item, lambda item: super(
FBXListWidget, self).insertItem(row, item))
def insertItems(self, row, items):
for item in IProgressDialog.loop(items):
self.insertItem(row, item)
class AssetListWidget(QtWidgets.QListWidget):
def __init__(self, parent=None):
super(AssetListWidget, self).__init__(parent=parent)
self.FBX_UI = parent
self.setIconSize(QtCore.QSize(15, 15))
self.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.right_menu)
def right_menu(self):
self.menu = QtWidgets.QMenu(self)
# NOTE 右键选择资源
select_asset = QtWidgets.QAction(u'选择资源', self)
select_asset.triggered.connect(self.sync_asset)
select_assets = QtWidgets.QAction(u'选择已选中的资源', self)
select_assets.triggered.connect(self.sync_assets)
self.menu.addAction(select_asset)
self.menu.addAction(select_assets)
self.menu.popup(QtGui.QCursor.pos())
def sync_asset(self):
item = self.currentItem()
path = item.text()
unreal.EditorAssetLibrary.sync_browser_to_objects([path])
def sync_assets(self):
path_list = [item.text() for item in self.selectedItems()]
unreal.EditorAssetLibrary.sync_browser_to_objects(path_list)
class FBXImporter_UI(QtWidgets.QWidget):
def __init__(self, *args, **kwargs):
super(FBXImporter_UI, self).__init__(*args, **kwargs)
self.settings = QtCore.QSettings(
self.__class__.__name__, QtCore.QSettings.IniFormat)
self.setWindowTitle(u"FBX 动画导入比对面板")
self.Unreal_Layout = QtWidgets.QVBoxLayout()
self.Unreal_Layout.setContentsMargins(0, 0, 0, 0)
self.selector = IPathSelector(
select_callback=self.select_folder, button_text=u"获取选择资源的目录路径")
self.asset_list = AssetListWidget(self)
self.Unreal_Layout.addWidget(self.selector)
self.Unreal_Layout.addWidget(self.asset_list)
self.Unreal_Widget = QtWidgets.QWidget()
self.Unreal_Widget.setLayout(self.Unreal_Layout)
self.fbx_list = FBXListWidget(self, file_filter=[".fbx"])
fbx_layout = QtWidgets.QVBoxLayout()
fbx_layout.setContentsMargins(0, 0, 0, 0)
butotn_layout = QtWidgets.QHBoxLayout()
self.root_btn = MPushButton(u"获取文件目录路径")
self.root_btn.clicked.connect(self.handle_directory)
self.file_btn = MPushButton(u"获取文件")
self.file_btn.clicked.connect(self.get_file)
butotn_layout.addWidget(self.root_btn)
butotn_layout.addWidget(self.file_btn)
fbx_layout.addLayout(butotn_layout)
fbx_layout.addWidget(self.fbx_list)
fbx_widget = QtWidgets.QWidget()
fbx_widget.setLayout(fbx_layout)
# NOTE 同步滚动
self.syncer = ListSyncer(
self.asset_list, self.fbx_list, selection=True)
self.compare_splitter = ISplitter()
self.compare_splitter.addWidget(self.Unreal_Widget)
self.compare_splitter.addWidget(fbx_widget)
self.import_button = MPushButton(u"刷新")
self.import_button.clicked.connect(self.refresh)
layout = QtWidgets.QVBoxLayout()
layout.setContentsMargins(9, 0, 9, 9)
self.setLayout(layout)
self.Menu_Bar = QtWidgets.QMenuBar(self)
self.Menu_Bar.setSizePolicy(QtWidgets.QSizePolicy(
QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed))
self.Help_Menu = self.Menu_Bar.addMenu(u"帮助")
self.Help_Action = QtWidgets.QAction(u"帮助文档", self)
self.Help_Menu.addAction(self.Help_Action)
self.Help_Action.triggered.connect(lambda: webbrowser.open_new_tab(
'http://wiki.l0v0.com/project/#/project/'))
layout.addWidget(self.Menu_Bar)
layout.addWidget(self.compare_splitter)
layout.addWidget(self.import_button)
# Note QSettings 记录加载路径
directory = self.settings.value("assets_path")
if directory:
self.selector.line.setText(directory)
self.update_list(directory)
def refresh(self):
# NOTE 获取目录下的资源
assets = unreal.EditorAssetLibrary.list_assets(
self.selector.line.text())
# NOTE unreal asset 添加 帧数 tooltip
for i, asset in enumerate(assets):
anim = unreal.load_asset(asset)
if not isinstance(anim, unreal.AnimSequence):
continue
frame_count = unreal.AnimationLibrary.get_num_frames(anim)
item = self.asset_list.item(i)
item.setToolTip(u"关键帧数: %s" % frame_count)
item.frame_count = frame_count
self.compare_assets()
def handle_directory(self, directory=None):
directory = directory if directory else QtWidgets.QFileDialog.getExistingDirectory(
self)
if not directory:
return
for file_name in IProgressDialog.loop(os.listdir(directory)):
if not file_name.lower().endswith(".fbx"):
continue
self.fbx_list.addItem(os.path.join(directory, file_name))
def get_file(self):
path_list, _ = QtWidgets.QFileDialog.getOpenFileNames(
self, caption=u"获取 FBX 文件", filter="FBX (*.fbx);;所有文件 (*)")
for path in IProgressDialog.loop(path_list):
self.fbx_list.addItem(path)
def select_folder(self, line):
selected_assets = unreal.EditorUtilityLibrary.get_selected_assets()
if len(selected_assets) == 0:
return
asset = selected_assets[0]
directory = unreal.Paths.get_path(asset.get_path_name())
if directory:
line.setText(directory)
self.update_list(directory)
self.settings.setValue("assets_path", directory)
def update_list(self, directory):
self.asset_list.clear()
self.fbx_list.clear()
# NOTE 获取目录下的资源
assets = unreal.EditorAssetLibrary.list_assets(directory)
# NOTE unreal asset 添加 帧数 tooltip
for asset in assets:
item = QtWidgets.QListWidgetItem()
anim = unreal.load_asset(asset)
if type(anim) is not unreal.AnimSequence:
continue
frame_count = unreal.AnimationLibrary.get_num_frames(anim)
item.setText(asset)
item.frame_count = frame_count
item.setToolTip(u"关键帧数: %s" % frame_count)
item.asset = anim
self.asset_list.addItem(item)
self.fbx_list.insertItem(0, "")
# NOTE 添加空 item
self.compare_assets()
def compare_assets(self):
style = QtWidgets.QApplication.style()
error_icon = style.standardIcon(QtWidgets.QStyle.SP_MessageBoxCritical)
apply_icon = style.standardIcon(QtWidgets.QStyle.SP_DialogApplyButton)
# NOTE 获取未匹配的 FBX
count = self.asset_list.count()
asset_list = [self.asset_list.item(i).text() for i in range(count)]
for i in range(count, self.fbx_list.count()):
item = self.fbx_list.item(i)
if not item:
continue
path = item.text()
if not path:
self.fbx_list.takeItem(i)
continue
fbx_name, _ = os.path.splitext(item.text())
for j, asset in enumerate(asset_list):
asset_name = asset.split(".")[-1]
asset_name = asset_name.strip().lower()
fbx_name = fbx_name.strip().lower()
# print("%s <=> %s %s" % (fbx_name, asset_name,asset_name == fbx_name))
if asset_name == fbx_name:
# NOTE 设置 item
compare_item = self.fbx_list.item(j)
compare_item.setText(item.text())
compare_item.setToolTip(item.toolTip())
compare_item.setIcon(error_icon)
compare_item.frame_count = item.frame_count
self.fbx_list.takeItem(i)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 0))
compare_item.setBackground(brush)
break
# NOTE compare assets frame data
for i in range(count):
anim_item = self.asset_list.item(i)
fbx_item = self.fbx_list.item(i)
if fbx_item.text() and hasattr(fbx_item, "frame_count"):
if anim_item.frame_count == fbx_item.frame_count:
fbx_item.setIcon(apply_icon)
else:
fbx_item.setIcon(error_icon)
def main():
global FBXImporter_win
FBXImporter_win = FBXImporter_UI()
FBXImporter_win.show()
if __name__ == "__main__":
main()
|
# coding: utf-8
import unreal
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-vrm")
parser.add_argument("-rig")
parser.add_argument("-meta")
args = parser.parse_args()
print(args.vrm)
#print(dummy[3])
humanoidBoneList = [
"hips",
"leftUpperLeg",
"rightUpperLeg",
"leftLowerLeg",
"rightLowerLeg",
"leftFoot",
"rightFoot",
"spine",
"chest",
"upperChest", # 9 optional
"neck",
"head",
"leftShoulder",
"rightShoulder",
"leftUpperArm",
"rightUpperArm",
"leftLowerArm",
"rightLowerArm",
"leftHand",
"rightHand",
"leftToes",
"rightToes",
"leftEye",
"rightEye",
"jaw",
"leftThumbProximal", # 24
"leftThumbIntermediate",
"leftThumbDistal",
"leftIndexProximal",
"leftIndexIntermediate",
"leftIndexDistal",
"leftMiddleProximal",
"leftMiddleIntermediate",
"leftMiddleDistal",
"leftRingProximal",
"leftRingIntermediate",
"leftRingDistal",
"leftLittleProximal",
"leftLittleIntermediate",
"leftLittleDistal",
"rightThumbProximal",
"rightThumbIntermediate",
"rightThumbDistal",
"rightIndexProximal",
"rightIndexIntermediate",
"rightIndexDistal",
"rightMiddleProximal",
"rightMiddleIntermediate",
"rightMiddleDistal",
"rightRingProximal",
"rightRingIntermediate",
"rightRingDistal",
"rightLittleProximal",
"rightLittleIntermediate",
"rightLittleDistal", #54
]
humanoidBoneParentList = [
"", #"hips",
"hips",#"leftUpperLeg",
"hips",#"rightUpperLeg",
"leftUpperLeg",#"leftLowerLeg",
"rightUpperLeg",#"rightLowerLeg",
"leftLowerLeg",#"leftFoot",
"rightLowerLeg",#"rightFoot",
"hips",#"spine",
"spine",#"chest",
"chest",#"upperChest" 9 optional
"chest",#"neck",
"neck",#"head",
"chest",#"leftShoulder", # <-- upper..
"chest",#"rightShoulder",
"leftShoulder",#"leftUpperArm",
"rightShoulder",#"rightUpperArm",
"leftUpperArm",#"leftLowerArm",
"rightUpperArm",#"rightLowerArm",
"leftLowerArm",#"leftHand",
"rightLowerArm",#"rightHand",
"leftFoot",#"leftToes",
"rightFoot",#"rightToes",
"head",#"leftEye",
"head",#"rightEye",
"head",#"jaw",
"leftHand",#"leftThumbProximal",
"leftThumbProximal",#"leftThumbIntermediate",
"leftThumbIntermediate",#"leftThumbDistal",
"leftHand",#"leftIndexProximal",
"leftIndexProximal",#"leftIndexIntermediate",
"leftIndexIntermediate",#"leftIndexDistal",
"leftHand",#"leftMiddleProximal",
"leftMiddleProximal",#"leftMiddleIntermediate",
"leftMiddleIntermediate",#"leftMiddleDistal",
"leftHand",#"leftRingProximal",
"leftRingProximal",#"leftRingIntermediate",
"leftRingIntermediate",#"leftRingDistal",
"leftHand",#"leftLittleProximal",
"leftLittleProximal",#"leftLittleIntermediate",
"leftLittleIntermediate",#"leftLittleDistal",
"rightHand",#"rightThumbProximal",
"rightThumbProximal",#"rightThumbIntermediate",
"rightThumbIntermediate",#"rightThumbDistal",
"rightHand",#"rightIndexProximal",
"rightIndexProximal",#"rightIndexIntermediate",
"rightIndexIntermediate",#"rightIndexDistal",
"rightHand",#"rightMiddleProximal",
"rightMiddleProximal",#"rightMiddleIntermediate",
"rightMiddleIntermediate",#"rightMiddleDistal",
"rightHand",#"rightRingProximal",
"rightRingProximal",#"rightRingIntermediate",
"rightRingIntermediate",#"rightRingDistal",
"rightHand",#"rightLittleProximal",
"rightLittleProximal",#"rightLittleIntermediate",
"rightLittleIntermediate",#"rightLittleDistal",
]
for i in range(len(humanoidBoneList)):
humanoidBoneList[i] = humanoidBoneList[i].lower()
for i in range(len(humanoidBoneParentList)):
humanoidBoneParentList[i] = humanoidBoneParentList[i].lower()
######
reg = unreal.AssetRegistryHelpers.get_asset_registry();
##
rigs = unreal.ControlRigBlueprint.get_currently_open_rig_blueprints()
print(rigs)
for r in rigs:
s:str = r.get_path_name()
ss:str = args.rig
if (s.find(ss) < 0):
print("no rig")
else:
rig = r
#rig = rigs[10]
h_mod = rig.get_hierarchy_modifier()
#elements = h_mod.get_selection()
#sk = rig.get_preview_mesh()
#k = sk.skeleton
#print(k)
#print(sk.bone_tree)
#
#kk = unreal.RigElementKey(unreal.RigElementType.BONE, "hipssss");
#kk.name = ""
#kk.type = 1;
#print(h_mod.get_bone(kk))
#print(h_mod.get_elements())
### 全ての骨
modelBoneListAll = []
modelBoneNameList = []
#for e in reversed(h_mod.get_elements()):
# if (e.type != unreal.RigElementType.BONE):
# h_mod.remove_element(e)
for e in h_mod.get_elements():
if (e.type == unreal.RigElementType.BONE):
modelBoneListAll.append(e)
modelBoneNameList.append("{}".format(e.name).lower())
# else:
# h_mod.remove_element(e)
print(modelBoneListAll[0])
#exit
#print(k.get_editor_property("bone_tree")[0].get_editor_property("translation_retargeting_mode"))
#print(k.get_editor_property("bone_tree")[0].get_editor_property("parent_index"))
#unreal.select
#vrmlist = unreal.VrmAssetListObject
#vrmmeta = vrmlist.vrm_meta_object
#print(vrmmeta.humanoid_bone_table)
#selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
#selected_static_mesh_actors = unreal.EditorFilterLibrary.by_class(selected_actors,unreal.StaticMeshActor.static_class())
#static_meshes = np.array([])
## meta 取得
reg = unreal.AssetRegistryHelpers.get_asset_registry();
a = reg.get_all_assets();
if (args.meta):
for aa in a:
if (aa.get_editor_property("object_path") == args.meta):
v:unreal.VrmMetaObject = aa
vv = aa.get_asset()
if (vv == None):
for aa in a:
if (aa.get_editor_property("object_path") == args.vrm):
v:unreal.VrmAssetListObject = aa
vv = v.get_asset().vrm_meta_object
print(vv)
meta = vv
#v:unreal.VrmAssetListObject = None
#if (True):
# a = reg.get_assets_by_path(args.vrm)
# a = reg.get_all_assets();
# for aa in a:
# if (aa.get_editor_property("object_path") == args.vrm):
# v:unreal.VrmAssetListObject = aa
#v = unreal.VrmAssetListObject.cast(v)
#print(v)
#unreal.VrmAssetListObject.vrm_meta_object
#meta = v.vrm_meta_object()
#meta = unreal.EditorFilterLibrary.by_class(asset,unreal.VrmMetaObject.static_class())
print (meta)
#print(meta[0].humanoid_bone_table)
### モデル骨のうち、ヒューマノイドと同じもの
### 上の変換テーブル
humanoidBoneToModel = {"" : ""}
humanoidBoneToModel.clear()
### modelBoneでループ
#for bone_h in meta.humanoid_bone_table:
for bone_h_base in humanoidBoneList:
bone_h = None
for e in meta.humanoid_bone_table:
if ("{}".format(e).lower() == bone_h_base):
bone_h = e;
break;
print("{}".format(bone_h))
if (bone_h==None):
continue
bone_m = meta.humanoid_bone_table[bone_h]
try:
i = modelBoneNameList.index(bone_m.lower())
except:
i = -1
if (i < 0):
continue
if ("{}".format(bone_h).lower() == "upperchest"):
continue;
humanoidBoneToModel["{}".format(bone_h).lower()] = "{}".format(bone_m).lower()
if ("{}".format(bone_h).lower() == "chest"):
#upperchestがあれば、これの次に追加
bh = 'upperchest'
print("upperchest: check begin")
for e in meta.humanoid_bone_table:
if ("{}".format(e).lower() != 'upperchest'):
continue
bm = "{}".format(meta.humanoid_bone_table[e]).lower()
if (bm == ''):
continue
humanoidBoneToModel[bh] = bm
humanoidBoneParentList[10] = "upperchest"
humanoidBoneParentList[12] = "upperchest"
humanoidBoneParentList[13] = "upperchest"
print("upperchest: find and insert parent")
break
print("upperchest: check end")
parent=None
control_to_mat={None:None}
count = 0
### 骨名からControlへのテーブル
name_to_control = {"dummy_for_table" : None}
print("loop begin")
###### root
key = unreal.RigElementKey(unreal.RigElementType.SPACE, 'root_s')
space = h_mod.get_space(key)
if (space.get_editor_property('index') < 0):
space = h_mod.add_space('root_s', space_type=unreal.RigSpaceType.SPACE)
else:
space = key
key = unreal.RigElementKey(unreal.RigElementType.CONTROL, 'root_c')
control = h_mod.get_control(key)
if (control.get_editor_property('index') < 0):
control = h_mod.add_control('root_c',
space_name=space.name,
gizmo_color=[1.0, 0.0, 0.0, 1.0],
)
else:
control = key
h_mod.reparent_element(control, space)
parent = control
cc = h_mod.get_control(control)
cc.set_editor_property('gizmo_visible', False)
h_mod.set_control(cc)
for ee in humanoidBoneToModel:
element = humanoidBoneToModel[ee]
humanoidBone = ee
modelBoneNameSmall = element
# 対象の骨
#modelBoneNameSmall = "{}".format(element.name).lower()
#humanoidBone = modelBoneToHumanoid[modelBoneNameSmall];
boneNo = humanoidBoneList.index(humanoidBone)
print("{}_{}_{}__parent={}".format(modelBoneNameSmall, humanoidBone, boneNo,humanoidBoneParentList[boneNo]))
# 親
if count != 0:
parent = name_to_control[humanoidBoneParentList[boneNo]]
# 階層作成
bIsNew = False
name_s = "{}_s".format(humanoidBone)
key = unreal.RigElementKey(unreal.RigElementType.SPACE, name_s)
space = h_mod.get_space(key)
if (space.get_editor_property('index') < 0):
space = h_mod.add_space(name_s, space_type=unreal.RigSpaceType.SPACE)
bIsNew = True
else:
space = key
name_c = "{}_c".format(humanoidBone)
key = unreal.RigElementKey(unreal.RigElementType.CONTROL, name_c)
control = h_mod.get_control(key)
if (control.get_editor_property('index') < 0):
control = h_mod.add_control(name_c,
space_name=space.name,
gizmo_color=[1.0, 0.0, 0.0, 1.0],
)
#h_mod.get_control(control).gizmo_transform = gizmo_trans
if (24<=boneNo & boneNo<=53):
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.1, 0.1, 0.1])
else:
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1, 1, 1])
if (17<=boneNo & boneNo<=18):
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1, 1, 1])
cc = h_mod.get_control(control)
cc.set_editor_property('gizmo_transform', gizmo_trans)
cc.set_editor_property('control_type', unreal.RigControlType.ROTATOR)
h_mod.set_control(cc)
#h_mod.set_control_value_transform(control,gizmo_trans)
bIsNew = True
else:
control = key
if (bIsNew == True):
h_mod.reparent_element(control, space)
# テーブル登録
name_to_control[humanoidBone] = control
print(humanoidBone)
# ロケータ 座標更新
# 不要な上層階層を考慮
gTransform = h_mod.get_global_transform(modelBoneListAll[modelBoneNameList.index(modelBoneNameSmall)])
if count == 0:
bone_initial_transform = gTransform
else:
#bone_initial_transform = h_mod.get_initial_transform(element)
bone_initial_transform = gTransform.multiply(control_to_mat[parent].inverse())
h_mod.set_initial_transform(space, bone_initial_transform)
control_to_mat[control] = gTransform
# 階層修正
h_mod.reparent_element(space, parent)
count += 1
if (count >= 500):
break
|
import unreal
# =====================================
# 파라미터 (여기만 수정하세요)
# =====================================
folder_path = "/project/" # 던전 폴더 경로
scale_multiplier = 3.0 # 스케일 배수
# =====================================
# 작업 시작
# =====================================
asset_registry = unreal.AssetRegistryHelpers.get_asset_registry()
assets = asset_registry.get_assets_by_path(folder_path, recursive=True)
print("===== 던전 스케일러 시작 =====")
print("총 검색된 에셋 수:", len(assets))
for asset in assets:
asset_path = asset.package_name
static_mesh = unreal.EditorAssetLibrary.load_asset(asset_path)
if isinstance(static_mesh, unreal.StaticMesh):
changed = False
num_source_models = static_mesh.get_editor_property("num_source_models")
source_models = static_mesh.get_editor_property("source_models")
for lod_index in range(num_source_models):
source_model = source_models[lod_index]
build_settings = source_model.build_settings
current_scale = build_settings.build_scale3d
new_scale = unreal.Vector(
current_scale.x * scale_multiplier,
current_scale.y * scale_multiplier,
current_scale.z * scale_multiplier
)
if new_scale != current_scale:
build_settings.build_scale3d = new_scale
source_model.build_settings = build_settings
changed = True
print(f"스케일 변경됨: {static_mesh.get_name()} → {new_scale}")
if changed:
static_mesh.post_edit_change()
unreal.EditorAssetLibrary.save_asset(asset_path)
print("===== 던전 스케일러 완료 =====")
|
import unreal
OUTPUT_FILENAME = r"/project/.usda"
INPUT_ASSET_CONTENT_PATH = r"/project/"
asset = unreal.load_asset(INPUT_ASSET_CONTENT_PATH)
options = unreal.StaticMeshExporterUSDOptions()
options.stage_options.meters_per_unit = 0.02
options.mesh_asset_options.use_payload = True
options.mesh_asset_options.payload_format = "usda"
options.mesh_asset_options.bake_materials = True
task = unreal.AssetExportTask()
task.set_editor_property('object', asset)
task.set_editor_property('filename', OUTPUT_FILENAME)
task.set_editor_property('automated', True)
task.set_editor_property('options', options)
task.set_editor_property('exporter', unreal.StaticMeshExporterUsd())
unreal.Exporter.run_asset_export_task(task)
|
# -*- coding: utf-8 -*-
"""
"""
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
__author__ = 'timmyliang'
__email__ = '[email protected]'
__date__ = '2021-08-18 14:00:19'
import time
import unreal
from unreal import SystemLibrary as sys_lib
from unreal import EditorLevelLibrary as level_lib
cur = time.time()
@unreal.uclass()
class TestObject(unreal.Object):
world = level_lib.get_editor_world()
# NOTE 蓝图库分类设置为 Python Blueprint
@unreal.ufunction(static=True)
def timer_call():
print("timer_call")
@unreal.ufunction(ret=unreal.World)
def get_world(cls):
return cls.world
obj = TestObject()
print(obj.get_world())
# def callback(*args):
# print(args)
# elapsed = time.time() - cur
# print("callback %s" % elapsed)
# delegate = unreal.TimerDynamicDelegate()
# delegate.bind_callable(callback)
# handle = sys_lib.set_timer_delegate(delegate,3,False)
handle = sys_lib.set_timer(obj,"timer_call",3,False)
|
# -*- coding: utf-8 -*-
"""
Documentation:
"""
"""
Description:
"""
# Import Libraries
# ============================================================
import unreal
import os
import json
def createAssetTool():
"""
To create asset tools helper
Returns:
"""
return unreal.AssetToolsHelpers.get_asset_tools()
def buildImportTask(filepath, destination_path, options=None, name=None):
"""
To build a task for imported asset
Args:
filepath (str): the imported asset windows filepath.
destination_path (str): the unreal path that start with "Game/.../..."
options (object): object of options to import
Returns (object): created task object
"""
if not os.path.isfile(filepath):
raise WindowsError('File not found: "{}"'.format(filepath))
task = unreal.AssetImportTask()
task.filename = filepath
task.destination_path = destination_path
if name:
task.destination_name = name
task.automated = True # Avoid dialogs
task.save = True
task.replace_existing = True
task.options = options
return task
def execteImportTasks(tasks):
"""
To execute the import tasks
Args:
tasks (list): list of tasks
Returns(list): list of lists of imported objects
"""
importedAssets = []
assetTools = createAssetTool()
assetTools.import_asset_tasks(tasks)
for task in tasks:
# task_imported_assets = task.get_editor_property("imported_object_paths")
task_imported_assets = task.imported_object_paths
importedAssets.append(task_imported_assets)
return importedAssets
def buildStaticMeshOptions(**kwargs):
"""
To creates options for static mesh import
Returns(object): object with static mesh options
"""
# unreal.FbxSceneImportOptions()
options = unreal.FbxImportUI()
# unreal.FbxImportUI
options.import_mesh = kwargs.get('import_mesh', True)
options.import_textures = kwargs.get('import_textures', True)
options.import_materials = kwargs.get('import_materials', False)
options.import_as_skeletal = kwargs.get('import_as_skeletal', False)
# unreal.FbxMeshImportData
options.static_mesh_import_data.import_translation = unreal.Vector(0.0, 0.0, 0.0)
options.static_mesh_import_data.import_rotation = unreal.Rotator(90.0, 0.0, 0.0)
options.static_mesh_import_data.import_uniform_scale = kwargs.get('scale', 1.0)
# unreal.FbxStaticMeshImportData
options.static_mesh_import_data.combine_meshes = kwargs.get('combine_meshes', True)
options.static_mesh_import_data.generate_lightmap_u_vs = kwargs.get('generate_lightmap_u_vs', True)
options.static_mesh_import_data.auto_generate_collision = kwargs.get('auto_generate_collision', True)
return options
def buildSKeletalMeshOptions(**kwargs):
"""
To creates options for skeletal mesh import
Returns(object): object with skeletal mesh options
"""
# unreal.FbxSceneImportOptions()
options = unreal.FbxImportUI()
# unreal.FbxImportUI
options.import_mesh = kwargs.get('import_mesh', True)
options.import_textures = kwargs.get('import_textures', True)
options.import_materials = kwargs.get('import_materials', False)
options.import_as_skeletal = kwargs.get('import_as_skeletal', False)
# unreal.FbxMeshImportData
options.static_mesh_import_data.import_translation = unreal.Vector(0.0, 0.0, 0.0)
options.static_mesh_import_data.import_rotation = unreal.Rotator(0.0, 0.0, 0.0)
options.static_mesh_import_data.import_uniform_scale = kwargs.get('scale', 1.0)
# unreal.FbxStaticMeshImportData
options.skeletal_mesh_import_data.import_morph_targets = True
options.skeletal_mesh_import_data.update_skeleton_reference_pose = False
return options
def buildAnimationOptions(skeleton_path):
"""
To creates options for animation mesh import
@param skeleton_path: (str) Skeleton unreal asset path of the skeleton that will be used to bind the animation
Returns(object): object with skeletal mesh options
"""
options = unreal.FbxImportUI()
# unreal.FbxImportUI
options.import_animations = True
options.skeleton = unreal.load_asset(skeleton_path)
# unreal.FbxMeshImportData
options.static_mesh_import_data.import_translation = unreal.Vector(0.0, 0.0, 0.0)
options.static_mesh_import_data.import_rotation = unreal.Rotator(0.0, 0.0, 0.0)
options.static_mesh_import_data.import_uniform_scale = 1.0
# unreal.FbxAnimSequenceImportData
options.anim_sequence_import_data.animation_length = unreal.FBXAnimationLengthImportType.FBXALIT_EXPORTED_TIME
options.anim_sequence_import_data.remove_redundant_keys = False
return options
def importStaticMesh(filepath, destination_path, prefix="ST", **kwargs):
"""
To import a static mesh to unreal
Args:
filepath (str): the imported asset windows filepath.
destination_path (str): the unreal path that start with "Game/.../..."
Returns(list): list of lists of imported objects
:param prefix:
"""
task = buildImportTask(filepath, destination_path, buildStaticMeshOptions(**kwargs), prefix)
result = execteImportTasks([task])
return result
def importSkeletalMesh(filepath, destination_path):
"""
To import a skeletal mesh to unreal
Args:
filepath (str): the imported asset windows filepath.
destination_path (str): the unreal path that start with "Game/.../..."
Returns(list): list of lists of imported objects
"""
task = buildImportTask(filepath, destination_path, buildStaticMeshOptions())
result = execteImportTasks([task])
return result
def importAnimation(filepath, destination_path, skeleton_path):
"""
To import animation from fbx filepath and combine it with skeleton
Args:
filepath (str): fbx windows file path
destination_path (str): unreal destination path for imported fbx meshes
skeleton_path (str): unreal path of skeleton
Returns (list): list of lists of imported objects
"""
task = buildImportTask(filepath, destination_path, buildAnimationOptions(skeleton_path))
result = execteImportTasks([task])
return result
def importTexture(filepath, destination_path, virtual_texture=False):
task = buildImportTask(filepath, destination_path)
result = execteImportTasks([task])
if virtual_texture and result:
for tex_path in result[0]:
get_asset(tex_path).set_editor_property('virtual_texture_streaming', True)
return result
def createMaterial(game_material_path):
"""
To creates material in certain path
:param game_material_path:
:return: unreal.Object
"""
assetTools = createAssetTool()
material_dir, material_name = game_material_path.rsplit('/', 1)
createDir(material_dir)
material = assetTools.create_asset(material_name, material_dir, unreal.Material, unreal.MaterialFactoryNew())
return material
#########################################################
# Utility class to do most of the common functionalities with the ContentBrowser
def saveAsset(asset_path, only_if_is_dirty=True):
return unreal.EditorAssetLibrary.save_asset(asset_path, only_if_is_dirty)
def saveDir(dir_path, only_if_is_dirty=True, recursive=True):
return unreal.EditorAssetLibrary.save_asset(dir_path, only_if_is_dirty, recursive)
def createDir(dir_path):
"""
To creates directory in unreal
Args:
dir_path (str): the unreal directory to created
Returns (bool): True if the operation succeeds
"""
return unreal.EditorAssetLibrary.make_directory(dir_path)
def duplicateDir(from_dir, to_dir):
return unreal.EditorAssetLibrary.duplicate_directory(from_dir, to_dir)
def renameDir(from_dir, to_dir):
return unreal.EditorAssetLibrary.rename_directory(from_dir, to_dir)
def deleteDir(dir_path):
return unreal.EditorAssetLibrary.delete_directory(dir_path)
def dirExists(dir_path):
return unreal.EditorAssetLibrary.does_directory_exist(dir_path)
def duplicateAsset(from_dir, to_dir):
return unreal.EditorAssetLibrary.duplicate_asset(from_dir, to_dir)
def renameAsset(from_dir, to_dir):
return unreal.EditorAssetLibrary.rename_asset(from_dir, to_dir)
def deleteAsset(asset_path):
return unreal.EditorAssetLibrary.delete_asset(asset_path)
def assetExists(asset_path):
return unreal.EditorAssetLibrary.does_asset_exist(asset_path)
def listAsset(dir_path, asset_type=None):
"""
To list all asset in certain directory
Args:
dir_path (str): the unreal dir path
asset_type (str): the asset type class : MaterialInstanceConstant
Returns(list(objects)): list of objects of required assets
"""
assets = []
for asset in unreal.EditorAssetLibrary.list_assets(dir_path):
assetObj = unreal.EditorAssetLibrary.load_asset(asset)
if asset_type is None:
assets.append(assetObj)
else:
asset_data = unreal.EditorAssetLibrary.find_asset_data(asset)
if asset_data.asset_class == asset_type:
assets.append(assetObj)
return assets
def setMaterialInstanceTexture(mi_asset, param_name, tex_path):
"""
Args:
mi_asset (object): the instance material object
param_name (str): the attribute name in instance material : base color, roughness
tex_path (str): the unreal path of texture asset
Returns (bool): True if the process is done successfully
"""
if isinstance(tex_path, str):
tex_asset = unreal.EditorAssetLibrary.find_asset_data(tex_path).get_asset()
else:
tex_asset = tex_path
# if not unreal.EditorAssetLibrary.does_asset_exist(tex_asset):
# unreal.log_warning(f"Can't find texture: {tex_asset}")
# return False
unreal.log_error(f"mi_asset: {mi_asset}")
unreal.log_error(f"param_name: {param_name}")
unreal.log_error(f"tex_path: {tex_path}")
return unreal.MaterialEditingLibrary.set_material_instance_texture_parameter_value(mi_asset, param_name, tex_asset)
def makeMaterialInstance(master_path, instance_path):
"""
To make an instance from master material
Args:
master_path (str): the unreal master material path
instance_path (str): the unreal instance material path
Returns(object): the object of instance material
"""
# Get asset object of master material
master_mtl_asset = unreal.EditorAssetLibrary.find_asset_data(master_path).get_asset()
mi_dir, mi_name = instance_path.rsplit("/", 1)
assetTools = createAssetTool()
# Check if material instance already exists
if unreal.EditorAssetLibrary.does_asset_exist(instance_path):
mi_asset = unreal.EditorAssetLibrary.find_asset_data(instance_path).get_asset()
unreal.log("Asset already exists")
else:
instance_factory = unreal.MaterialInstanceConstantFactoryNew()
mi_asset = assetTools.create_asset(mi_name, mi_dir, unreal.MaterialInstanceConstant, instance_factory)
unreal.MaterialEditingLibrary.set_material_instance_parent(mi_asset, master_mtl_asset)
unreal.EditorAssetLibrary.save_loaded_asset(mi_asset)
# unreal.MaterialEditingLibrary.set_material_instance_scalar_parameter_value(mi_asset, "Desaturation", 0.3) # set scalar parameter
return mi_asset
def makeInstanceWithTextures(master_path, instance_path, texturesData):
"""
To make an instance material with ites texture
Args:
master_path (str): the unreal master material path
instance_path (str): the unreal instance material path
texturesData (list(tupels)): list of tuples contains (attr, texture_path), ("Albedo", '/project/')
Returns(object): the object of instance material
"""
instance_mtl_asset = makeMaterialInstance(master_path, instance_path)
for attr, texture in texturesData:
setMaterialInstanceTexture(instance_mtl_asset, attr, texture)
return instance_mtl_asset
def assignMaterial(st_mesh_asset, material_object, mtl_id=0, slot_name=None):
if isinstance(st_mesh_asset, str):
st_mesh_asset = unreal.EditorAssetLibrary.find_asset_data(st_mesh_asset).get_asset()
if slot_name:
mtl_id = st_mesh_asset.get_material_index(slot_name)
st_mesh_asset.set_material(mtl_id, material_object)
def get_material_slot_names(static_mesh):
sm_component = unreal.StaticMeshComponent()
sm_component.set_static_mesh(static_mesh)
return unreal.StaticMeshComponent.get_material_slot_names(sm_component)
AttrsCon = {
"baseColor": "Albedo",
"metalness": "Metalness",
"normalCamera": "Normal",
"specularRoughness": "Roughness",
"specular": None,
"transmission": None,
"specularColor": None,
"transmissionColor": None,
"subsurface": None,
"subsurfaceColor": None,
"subsurfaceRadius": None,
"sheenColor": None,
"emission": None,
"emissionColor": None,
"opacity": None,
}
#########################################################
# Utility
def get_asset(game_path):
"""
To get the unreal asset object
:param game_path: The unreal path to required asset
:return: unreal.Object
"""
# unreal.AssetData
return unreal.EditorAssetLibrary.find_asset_data(game_path).get_asset()
def spawn_asset(game_path, translate=(0.0, 0.0, 0.0), rotate=(0.0, 0.0, 0.0)):
"""
To place the objet in viewport
:param game_path: The unreal path to required asset
:param translate: list of translation
:param rotate: list of rotation
:return: (unreal.Actor) created actor
"""
asset_object = get_asset(game_path)
# unreal.Actor
actor = unreal.EditorLevelLibrary.spawn_actor_from_object(
asset_object,
unreal.Vector(translate[0], translate[1], translate[2]),
unreal.Rotator(rotate[0], rotate[1], rotate[2]))
return actor
# Main
# =====================================================================================================================
def main():
MasterMaterial_VT = '/project/'
MasterMaterial = '/project/'
# MasterMaterial_VT = '/project/'
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
asset_tools.import_assets_with_dialog('/project/')
fbx_path = "old_car.fbx"
json_path = fbx_path.replace("fbx", "json")
with open(json_path, "r") as f:
jsonData = json.load(f)
if not jsonData:
unreal.log_error("Can not read json file: '{}'".format(json_path))
'''
destination_path = "/project/"
assets_pathes = importStaticMesh(fbx_path, destination_path+"ST_MESH")
for asset_path in assets_pathes[0]:
asset = unreal.EditorAssetLibrary.find_asset_data(asset_path).get_asset()
actor = unreal.EditorLevelLibrary.spawn_actor_from_object(asset, unreal.Vector(0.0, 0.0, 0.0), unreal.Rotator(0.0, 0.0, 0.0))
#actions = get_material_slot_names(asset)
mtl = unreal.EditorAssetLibrary.find_asset_data("/project/").get_asset()
assignMaterial(asset, mtl, 0)
'''
for name in jsonData:
destination_path = f"/project/{name}/"
ST_path = destination_path + "ST_MESH"
MTL_path = destination_path + "Materials"
TX_path = destination_path + "Texture"
assets_pathes = importStaticMesh(fbx_path, ST_path, "ST")
# loop on assets
counter = 0
sgsData = jsonData[name]
for sg in sgsData:
geos = sgsData[sg]["geos"]
for geo in geos:
asset_path = ST_path + "/ST_" + geo
if assetExists(asset_path):
# get asset object
asset = unreal.EditorAssetLibrary.find_asset_data(asset_path).get_asset()
mtl_id = geos[geo]["id"]
udim = geos[geo]["udim"]
mtls = geos[geo]["materials"]
if not mtls:
continue
mtl = list(mtls.keys())[0]
# mtl_asset = unreal.EditorAssetLibrary.find_asset_data("/project/").get_asset()
textures_data = mtls[mtl]["textures"]
# textures_data = [r"P:/project/.1001.tif",
# r"P:/project/.1001.tif",
# r"P:/project/.1001.tif"]
tx_data = []
for tx_node in textures_data:
filepath = textures_data[tx_node]["filepath"] # windows path
plugs = textures_data[tx_node]["plugs"]
colorSpace = textures_data[tx_node]["colorspace"]
if not filepath:
continue
import_tex_path = TX_path + "/" + os.path.basename(filepath).split(".", 1)[0]
if assetExists(import_tex_path):
textures = [unreal.EditorAssetLibrary.find_asset_data(import_tex_path).get_asset()]
else:
textures = importTexture(filepath, TX_path)[0]
if not textures:
continue
for plug in plugs:
attr = AttrsCon[plug]
if attr:
tx_data.append((attr, textures[0]))
if len(udim) > 1:
Material2Used = MasterMaterial_VT
else:
if udim[0] == 1001 and len(udim) == 1:
Material2Used = MasterMaterial
else:
Material2Used = MasterMaterial_VT
inst_mtl_path = MTL_path + "/" + mtl
if assetExists(inst_mtl_path):
mtl_asset = unreal.EditorAssetLibrary.find_asset_data(inst_mtl_path).get_asset()
else:
mtl_asset = makeInstanceWithTextures(Material2Used, inst_mtl_path, tx_data)
if mtl_asset:
assignMaterial(asset, mtl_asset, mtl_id)
actor = unreal.EditorLevelLibrary.spawn_actor_from_object(asset, unreal.Vector(0.0, 0.0, 0.0),
unreal.Rotator(0.0, 0.0, 0.0))
# path = '/project/.IMP_pSphere2'
# asset = unreal.EditorAssetLibrary.find_asset_data(path).get_asset()
# mtl = unreal.EditorAssetLibrary.find_asset_data("/project/").get_asset()
#
# assignMaterial(path, mtl)
#
# import asset
# filename = r"/project/.reda\Documents\Unreal Projects\Pythons\unreal\_maya\mayaFiles\fbx\spheres.fbx"
# textureDir = r"/project/-RnD\03_Production\Assets\AboShanab\Textures\Substance\v0001"
#
# destination_path = "/project/"
#
# assets_pathes = importStaticMesh(filename, destination_path)
#
# tx_path = os.path.join(textureDir, "shnbSkinSG_BaseColor.1001.tif")
# textures = importTexture(tx_path, destination_path)
# unreal.log_error("textures: {}".format(textures))
# unreal.log_error("objetcs: {}".format(type(assets_pathes[0][0])))
# MasterMaterial = r'/project/'
# instance = r'/project/'
#
# tex_data = [('Albedo', '/project/'), ('Normal', '/project/.shnbSkinSG_Normal')]
#
# inst_mtl = makeInstanceWithTextures(MasterMaterial, instance, tex_data)
#
# assignMaterial('/project/', inst_mtl, mtl_id=0)
if __name__ == '__main__':
print(__name__)
|
# -*- coding: utf-8 -*-
import unreal
from Utilities.Utils import Singleton
class MinimalExample(metaclass=Singleton):
def __init__(self, jsonPath:str):
self.jsonPath = jsonPath
self.data = unreal.PythonBPLib.get_chameleon_data(self.jsonPath)
self.ui_output = "InfoOutput"
self.clickCount = 0
def on_button_click(self):
self.clickCount += 1
self.data.set_text(self.ui_output, "Clicked {} time(s)".format(self.clickCount))
|
# coding: utf-8
import unreal
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-vrm")
parser.add_argument("-rig")
parser.add_argument("-meta")
args = parser.parse_args()
print(args.vrm)
#print(dummy[3])
humanoidBoneList = [
"hips",
"leftUpperLeg",
"rightUpperLeg",
"leftLowerLeg",
"rightLowerLeg",
"leftFoot",
"rightFoot",
"spine",
"chest",
"upperChest", # 9 optional
"neck",
"head",
"leftShoulder",
"rightShoulder",
"leftUpperArm",
"rightUpperArm",
"leftLowerArm",
"rightLowerArm",
"leftHand",
"rightHand",
"leftToes",
"rightToes",
"leftEye",
"rightEye",
"jaw",
"leftThumbProximal", # 24
"leftThumbIntermediate",
"leftThumbDistal",
"leftIndexProximal",
"leftIndexIntermediate",
"leftIndexDistal",
"leftMiddleProximal",
"leftMiddleIntermediate",
"leftMiddleDistal",
"leftRingProximal",
"leftRingIntermediate",
"leftRingDistal",
"leftLittleProximal",
"leftLittleIntermediate",
"leftLittleDistal",
"rightThumbProximal",
"rightThumbIntermediate",
"rightThumbDistal",
"rightIndexProximal",
"rightIndexIntermediate",
"rightIndexDistal",
"rightMiddleProximal",
"rightMiddleIntermediate",
"rightMiddleDistal",
"rightRingProximal",
"rightRingIntermediate",
"rightRingDistal",
"rightLittleProximal",
"rightLittleIntermediate",
"rightLittleDistal", #54
]
humanoidBoneParentList = [
"", #"hips",
"hips",#"leftUpperLeg",
"hips",#"rightUpperLeg",
"leftUpperLeg",#"leftLowerLeg",
"rightUpperLeg",#"rightLowerLeg",
"leftLowerLeg",#"leftFoot",
"rightLowerLeg",#"rightFoot",
"hips",#"spine",
"spine",#"chest",
"chest",#"upperChest" 9 optional
"chest",#"neck",
"neck",#"head",
"chest",#"leftShoulder", # <-- upper..
"chest",#"rightShoulder",
"leftShoulder",#"leftUpperArm",
"rightShoulder",#"rightUpperArm",
"leftUpperArm",#"leftLowerArm",
"rightUpperArm",#"rightLowerArm",
"leftLowerArm",#"leftHand",
"rightLowerArm",#"rightHand",
"leftFoot",#"leftToes",
"rightFoot",#"rightToes",
"head",#"leftEye",
"head",#"rightEye",
"head",#"jaw",
"leftHand",#"leftThumbProximal",
"leftThumbProximal",#"leftThumbIntermediate",
"leftThumbIntermediate",#"leftThumbDistal",
"leftHand",#"leftIndexProximal",
"leftIndexProximal",#"leftIndexIntermediate",
"leftIndexIntermediate",#"leftIndexDistal",
"leftHand",#"leftMiddleProximal",
"leftMiddleProximal",#"leftMiddleIntermediate",
"leftMiddleIntermediate",#"leftMiddleDistal",
"leftHand",#"leftRingProximal",
"leftRingProximal",#"leftRingIntermediate",
"leftRingIntermediate",#"leftRingDistal",
"leftHand",#"leftLittleProximal",
"leftLittleProximal",#"leftLittleIntermediate",
"leftLittleIntermediate",#"leftLittleDistal",
"rightHand",#"rightThumbProximal",
"rightThumbProximal",#"rightThumbIntermediate",
"rightThumbIntermediate",#"rightThumbDistal",
"rightHand",#"rightIndexProximal",
"rightIndexProximal",#"rightIndexIntermediate",
"rightIndexIntermediate",#"rightIndexDistal",
"rightHand",#"rightMiddleProximal",
"rightMiddleProximal",#"rightMiddleIntermediate",
"rightMiddleIntermediate",#"rightMiddleDistal",
"rightHand",#"rightRingProximal",
"rightRingProximal",#"rightRingIntermediate",
"rightRingIntermediate",#"rightRingDistal",
"rightHand",#"rightLittleProximal",
"rightLittleProximal",#"rightLittleIntermediate",
"rightLittleIntermediate",#"rightLittleDistal",
]
for i in range(len(humanoidBoneList)):
humanoidBoneList[i] = humanoidBoneList[i].lower()
for i in range(len(humanoidBoneParentList)):
humanoidBoneParentList[i] = humanoidBoneParentList[i].lower()
######
reg = unreal.AssetRegistryHelpers.get_asset_registry();
##
rigs = unreal.ControlRigBlueprint.get_currently_open_rig_blueprints()
print(rigs)
for r in rigs:
s:str = r.get_path_name()
ss:str = args.rig
if (s.find(ss) < 0):
print("no rig")
else:
rig = r
#rig = rigs[10]
h_mod = rig.get_hierarchy_modifier()
#elements = h_mod.get_selection()
#sk = rig.get_preview_mesh()
#k = sk.skeleton
#print(k)
#print(sk.bone_tree)
#
#kk = unreal.RigElementKey(unreal.RigElementType.BONE, "hipssss");
#kk.name = ""
#kk.type = 1;
#print(h_mod.get_bone(kk))
#print(h_mod.get_elements())
### 全ての骨
modelBoneListAll = []
modelBoneNameList = []
#for e in reversed(h_mod.get_elements()):
# if (e.type != unreal.RigElementType.BONE):
# h_mod.remove_element(e)
for e in h_mod.get_elements():
if (e.type == unreal.RigElementType.BONE):
modelBoneListAll.append(e)
modelBoneNameList.append("{}".format(e.name).lower())
# else:
# h_mod.remove_element(e)
print(modelBoneListAll[0])
#exit
#print(k.get_editor_property("bone_tree")[0].get_editor_property("translation_retargeting_mode"))
#print(k.get_editor_property("bone_tree")[0].get_editor_property("parent_index"))
#unreal.select
#vrmlist = unreal.VrmAssetListObject
#vrmmeta = vrmlist.vrm_meta_object
#print(vrmmeta.humanoid_bone_table)
#selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
#selected_static_mesh_actors = unreal.EditorFilterLibrary.by_class(selected_actors,unreal.StaticMeshActor.static_class())
#static_meshes = np.array([])
## meta 取得
reg = unreal.AssetRegistryHelpers.get_asset_registry();
a = reg.get_all_assets();
if (args.meta):
for aa in a:
if (aa.get_editor_property("object_path") == args.meta):
v:unreal.VrmMetaObject = aa
vv = aa.get_asset()
if (vv == None):
for aa in a:
if (aa.get_editor_property("object_path") == args.vrm):
v:unreal.VrmAssetListObject = aa
vv = v.get_asset().vrm_meta_object
print(vv)
meta = vv
#v:unreal.VrmAssetListObject = None
#if (True):
# a = reg.get_assets_by_path(args.vrm)
# a = reg.get_all_assets();
# for aa in a:
# if (aa.get_editor_property("object_path") == args.vrm):
# v:unreal.VrmAssetListObject = aa
#v = unreal.VrmAssetListObject.cast(v)
#print(v)
#unreal.VrmAssetListObject.vrm_meta_object
#meta = v.vrm_meta_object()
#meta = unreal.EditorFilterLibrary.by_class(asset,unreal.VrmMetaObject.static_class())
print (meta)
#print(meta[0].humanoid_bone_table)
### モデル骨のうち、ヒューマノイドと同じもの
### 上の変換テーブル
humanoidBoneToModel = {"" : ""}
humanoidBoneToModel.clear()
### modelBoneでループ
#for bone_h in meta.humanoid_bone_table:
for bone_h_base in humanoidBoneList:
bone_h = None
for e in meta.humanoid_bone_table:
if ("{}".format(e).lower() == bone_h_base):
bone_h = e;
break;
print("{}".format(bone_h))
if (bone_h==None):
continue
bone_m = meta.humanoid_bone_table[bone_h]
try:
i = modelBoneNameList.index(bone_m.lower())
except:
i = -1
if (i < 0):
continue
if ("{}".format(bone_h).lower() == "upperchest"):
continue;
humanoidBoneToModel["{}".format(bone_h).lower()] = "{}".format(bone_m).lower()
if ("{}".format(bone_h).lower() == "chest"):
#upperchestがあれば、これの次に追加
bh = 'upperchest'
print("upperchest: check begin")
for e in meta.humanoid_bone_table:
if ("{}".format(e).lower() != 'upperchest'):
continue
bm = "{}".format(meta.humanoid_bone_table[e]).lower()
if (bm == ''):
continue
humanoidBoneToModel[bh] = bm
humanoidBoneParentList[10] = "upperchest"
humanoidBoneParentList[12] = "upperchest"
humanoidBoneParentList[13] = "upperchest"
print("upperchest: find and insert parent")
break
print("upperchest: check end")
parent=None
control_to_mat={None:None}
count = 0
### 骨名からControlへのテーブル
name_to_control = {"dummy_for_table" : None}
print("loop begin")
###### root
key = unreal.RigElementKey(unreal.RigElementType.SPACE, 'root_s')
space = h_mod.get_space(key)
if (space.get_editor_property('index') < 0):
space = h_mod.add_space('root_s', space_type=unreal.RigSpaceType.SPACE)
else:
space = key
key = unreal.RigElementKey(unreal.RigElementType.CONTROL, 'root_c')
control = h_mod.get_control(key)
if (control.get_editor_property('index') < 0):
control = h_mod.add_control('root_c',
space_name=space.name,
gizmo_color=[1.0, 0.0, 0.0, 1.0],
)
else:
control = key
h_mod.reparent_element(control, space)
parent = control
cc = h_mod.get_control(control)
cc.set_editor_property('gizmo_visible', False)
h_mod.set_control(cc)
for ee in humanoidBoneToModel:
element = humanoidBoneToModel[ee]
humanoidBone = ee
modelBoneNameSmall = element
# 対象の骨
#modelBoneNameSmall = "{}".format(element.name).lower()
#humanoidBone = modelBoneToHumanoid[modelBoneNameSmall];
boneNo = humanoidBoneList.index(humanoidBone)
print("{}_{}_{}__parent={}".format(modelBoneNameSmall, humanoidBone, boneNo,humanoidBoneParentList[boneNo]))
# 親
if count != 0:
parent = name_to_control[humanoidBoneParentList[boneNo]]
# 階層作成
bIsNew = False
name_s = "{}_s".format(humanoidBone)
key = unreal.RigElementKey(unreal.RigElementType.SPACE, name_s)
space = h_mod.get_space(key)
if (space.get_editor_property('index') < 0):
space = h_mod.add_space(name_s, space_type=unreal.RigSpaceType.SPACE)
bIsNew = True
else:
space = key
name_c = "{}_c".format(humanoidBone)
key = unreal.RigElementKey(unreal.RigElementType.CONTROL, name_c)
control = h_mod.get_control(key)
if (control.get_editor_property('index') < 0):
control = h_mod.add_control(name_c,
space_name=space.name,
gizmo_color=[1.0, 0.0, 0.0, 1.0],
)
#h_mod.get_control(control).gizmo_transform = gizmo_trans
if (24<=boneNo & boneNo<=53):
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.1, 0.1, 0.1])
else:
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1, 1, 1])
if (17<=boneNo & boneNo<=18):
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1, 1, 1])
cc = h_mod.get_control(control)
cc.set_editor_property('gizmo_transform', gizmo_trans)
cc.set_editor_property('control_type', unreal.RigControlType.ROTATOR)
h_mod.set_control(cc)
#h_mod.set_control_value_transform(control,gizmo_trans)
bIsNew = True
else:
control = key
if (bIsNew == True):
h_mod.reparent_element(control, space)
# テーブル登録
name_to_control[humanoidBone] = control
print(humanoidBone)
# ロケータ 座標更新
# 不要な上層階層を考慮
gTransform = h_mod.get_global_transform(modelBoneListAll[modelBoneNameList.index(modelBoneNameSmall)])
if count == 0:
bone_initial_transform = gTransform
else:
#bone_initial_transform = h_mod.get_initial_transform(element)
bone_initial_transform = gTransform.multiply(control_to_mat[parent].inverse())
h_mod.set_initial_transform(space, bone_initial_transform)
control_to_mat[control] = gTransform
# 階層修正
h_mod.reparent_element(space, parent)
count += 1
if (count >= 500):
break
|
# 该脚本用于输出当前选中所有actor到csv文件中，用于后续的数据处理
# 面向需求是：
# 当前按照AO组合成的飞机，需要将隔热棉的部分挑出来，希望这部分材质相同
# 因此先在scene中挑出所有隔热棉部分，导出所选部分的actor label
# 在 jupyter/AO_sync_mat_Index.ipynb 之前使用
import unreal
import csv
csv_file_path = "C:/project/.csv"
selectedActors = unreal.get_editor_subsystem(unreal.EditorActorSubsystem).get_selected_level_actors()
with open(csv_file_path, mode='w', newline='') as file:
writer = csv.writer(file)
writer.writerow(['Filename'])
for item in selectedActors:
item_name = item.get_actor_label()
writer.writerow([item_name])
unreal.log("CSV file has been created successfully.")
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import unreal
class ProcessHDA(object):
""" An object that wraps async processing of an HDA (instantiating,
cooking/project/ an HDA), with functions that are called at the
various stages of the process, that can be overridden by subclasses for
custom funtionality:
- on_failure()
- on_complete(): upon successful completion (could be PostInstantiation
if auto cook is disabled, PostProcessing if auto bake is disabled, or
after PostAutoBake if auto bake is enabled.
- on_pre_instantiation(): before the HDA is instantiated, a good place
to set parameter values before the first cook.
- on_post_instantiation(): after the HDA is instantiated, a good place
to set/configure inputs before the first cook.
- on_post_auto_cook(): right after a cook
- on_pre_process(): after a cook but before output objects have been
created/processed
- on_post_processing(): after output objects have been created
- on_post_auto_bake(): after outputs have been baked
Instantiate the processor via the constructor and then call the activate()
function to start the asynchronous process.
"""
def __init__(
self,
houdini_asset,
instantiate_at=unreal.Transform(),
parameters=None,
node_inputs=None,
parameter_inputs=None,
world_context_object=None,
spawn_in_level_override=None,
enable_auto_cook=True,
enable_auto_bake=False,
bake_directory_path="",
bake_method=unreal.HoudiniEngineBakeOption.TO_ACTOR,
remove_output_after_bake=False,
recenter_baked_actors=False,
replace_previous_bake=False,
delete_instantiated_asset_on_completion_or_failure=False):
""" Instantiates an HDA in the specified world/level. Sets parameters
and inputs supplied in InParameters, InNodeInputs and parameter_inputs.
If bInEnableAutoCook is true, cooks the HDA. If bInEnableAutoBake is
true, bakes the cooked outputs according to the supplied baking
parameters.
This all happens asynchronously, with the various output pins firing at
the various points in the process:
- PreInstantiation: before the HDA is instantiated, a good place
to set parameter values before the first cook (parameter values
from ``parameters`` are automatically applied at this point)
- PostInstantiation: after the HDA is instantiated, a good place
to set/configure inputs before the first cook (inputs from
``node_inputs`` and ``parameter_inputs`` are automatically applied
at this point)
- PostAutoCook: right after a cook
- PreProcess: after a cook but before output objects have been
created/processed
- PostProcessing: after output objects have been created
- PostAutoBake: after outputs have been baked
- Completed: upon successful completion (could be PostInstantiation
if auto cook is disabled, PostProcessing if auto bake is disabled,
or after PostAutoBake if auto bake is enabled).
- Failed: If the process failed at any point.
Args:
houdini_asset (HoudiniAsset): The HDA to instantiate.
instantiate_at (Transform): The Transform to instantiate the HDA with.
parameters (Map(Name, HoudiniParameterTuple)): The parameters to set before cooking the instantiated HDA.
node_inputs (Map(int32, HoudiniPublicAPIInput)): The node inputs to set before cooking the instantiated HDA.
parameter_inputs (Map(Name, HoudiniPublicAPIInput)): The parameter-based inputs to set before cooking the instantiated HDA.
world_context_object (Object): A world context object for identifying the world to spawn in, if spawn_in_level_override is null.
spawn_in_level_override (Level): If not nullptr, then the HoudiniAssetActor is spawned in that level. If both spawn_in_level_override and world_context_object are null, then the actor is spawned in the current editor context world's current level.
enable_auto_cook (bool): If true (the default) the HDA will cook automatically after instantiation and after parameter, transform and input changes.
enable_auto_bake (bool): If true, the HDA output is automatically baked after a cook. Defaults to false.
bake_directory_path (str): The directory to bake to if the bake path is not set via attributes on the HDA output.
bake_method (HoudiniEngineBakeOption): The bake target (to actor vs blueprint). @see HoudiniEngineBakeOption.
remove_output_after_bake (bool): If true, HDA temporary outputs are removed after a bake. Defaults to false.
recenter_baked_actors (bool): Recenter the baked actors to their bounding box center. Defaults to false.
replace_previous_bake (bool): If true, on every bake replace the previous bake's output (assets + actors) with the new bake's output. Defaults to false.
delete_instantiated_asset_on_completion_or_failure (bool): If true, deletes the instantiated asset actor on completion or failure. Defaults to false.
"""
super(ProcessHDA, self).__init__()
self._houdini_asset = houdini_asset
self._instantiate_at = instantiate_at
self._parameters = parameters
self._node_inputs = node_inputs
self._parameter_inputs = parameter_inputs
self._world_context_object = world_context_object
self._spawn_in_level_override = spawn_in_level_override
self._enable_auto_cook = enable_auto_cook
self._enable_auto_bake = enable_auto_bake
self._bake_directory_path = bake_directory_path
self._bake_method = bake_method
self._remove_output_after_bake = remove_output_after_bake
self._recenter_baked_actors = recenter_baked_actors
self._replace_previous_bake = replace_previous_bake
self._delete_instantiated_asset_on_completion_or_failure = delete_instantiated_asset_on_completion_or_failure
self._asset_wrapper = None
self._cook_success = False
self._bake_success = False
@property
def asset_wrapper(self):
""" The asset wrapper for the instantiated HDA processed by this node. """
return self._asset_wrapper
@property
def cook_success(self):
""" True if the last cook was successful. """
return self._cook_success
@property
def bake_success(self):
""" True if the last bake was successful. """
return self._bake_success
@property
def houdini_asset(self):
""" The HDA to instantiate. """
return self._houdini_asset
@property
def instantiate_at(self):
""" The transform the instantiate the asset with. """
return self._instantiate_at
@property
def parameters(self):
""" The parameters to set on on_pre_instantiation """
return self._parameters
@property
def node_inputs(self):
""" The node inputs to set on on_post_instantiation """
return self._node_inputs
@property
def parameter_inputs(self):
""" The object path parameter inputs to set on on_post_instantiation """
return self._parameter_inputs
@property
def world_context_object(self):
""" The world context object: spawn in this world if spawn_in_level_override is not set. """
return self._world_context_object
@property
def spawn_in_level_override(self):
""" The level to spawn in. If both this and world_context_object is not set, spawn in the editor context's level. """
return self._spawn_in_level_override
@property
def enable_auto_cook(self):
""" Whether to set the instantiated asset to auto cook. """
return self._enable_auto_cook
@property
def enable_auto_bake(self):
""" Whether to set the instantiated asset to auto bake after a cook. """
return self._enable_auto_bake
@property
def bake_directory_path(self):
""" Set the fallback bake directory, for if output attributes do not specify it. """
return self._bake_directory_path
@property
def bake_method(self):
""" The bake method/target: for example, to actors vs to blueprints. """
return self._bake_method
@property
def remove_output_after_bake(self):
""" Remove temporary HDA output after a bake. """
return self._remove_output_after_bake
@property
def recenter_baked_actors(self):
""" Recenter the baked actors at their bounding box center. """
return self._recenter_baked_actors
@property
def replace_previous_bake(self):
""" Replace previous bake output on each bake. For the purposes of this
node, this would mostly apply to .uassets and not actors.
"""
return self._replace_previous_bake
@property
def delete_instantiated_asset_on_completion_or_failure(self):
""" Whether or not to delete the instantiated asset after Complete is called. """
return self._delete_instantiated_asset_on_completion_or_failure
def activate(self):
""" Activate the process. This will:
- instantiate houdini_asset and wrap it as asset_wrapper
- call on_failure() for any immediate failures
- otherwise bind to delegates from asset_wrapper so that the
various self.on_*() functions are called as appropriate
Returns immediately (does not block until cooking/processing is
complete).
Returns:
(bool): False if activation failed.
"""
# Get the API instance
houdini_api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
if not houdini_api:
# Handle failures: this will unbind delegates and call on_failure()
self._handle_on_failure()
return False
# Create an empty API asset wrapper
self._asset_wrapper = unreal.HoudiniPublicAPIAssetWrapper.create_empty_wrapper(houdini_api)
if not self._asset_wrapper:
# Handle failures: this will unbind delegates and call on_failure()
self._handle_on_failure()
return False
# Bind to the wrapper's delegates for instantiation, cooking, baking
# etc events
self._asset_wrapper.on_pre_instantiation_delegate.add_callable(
self._handle_on_pre_instantiation)
self._asset_wrapper.on_post_instantiation_delegate.add_callable(
self._handle_on_post_instantiation)
self._asset_wrapper.on_post_cook_delegate.add_callable(
self._handle_on_post_auto_cook)
self._asset_wrapper.on_pre_process_state_exited_delegate.add_callable(
self._handle_on_pre_process)
self._asset_wrapper.on_post_processing_delegate.add_callable(
self._handle_on_post_processing)
self._asset_wrapper.on_post_bake_delegate.add_callable(
self._handle_on_post_auto_bake)
# Begin the instantiation process of houdini_asset and wrap it with
# self.asset_wrapper
if not houdini_api.instantiate_asset_with_existing_wrapper(
self.asset_wrapper,
self.houdini_asset,
self.instantiate_at,
self.world_context_object,
self.spawn_in_level_override,
self.enable_auto_cook,
self.enable_auto_bake,
self.bake_directory_path,
self.bake_method,
self.remove_output_after_bake,
self.recenter_baked_actors,
self.replace_previous_bake):
# Handle failures: this will unbind delegates and call on_failure()
self._handle_on_failure()
return False
return True
def _unbind_delegates(self):
""" Unbinds from self.asset_wrapper's delegates (if valid). """
if not self._asset_wrapper:
return
self._asset_wrapper.on_pre_instantiation_delegate.add_callable(
self._handle_on_pre_instantiation)
self._asset_wrapper.on_post_instantiation_delegate.add_callable(
self._handle_on_post_instantiation)
self._asset_wrapper.on_post_cook_delegate.add_callable(
self._handle_on_post_auto_cook)
self._asset_wrapper.on_pre_process_state_exited_delegate.add_callable(
self._handle_on_pre_process)
self._asset_wrapper.on_post_processing_delegate.add_callable(
self._handle_on_post_processing)
self._asset_wrapper.on_post_bake_delegate.add_callable(
self._handle_on_post_auto_bake)
def _check_wrapper(self, wrapper):
""" Checks that wrapper matches self.asset_wrapper. Logs a warning if
it does not.
Args:
wrapper (HoudiniPublicAPIAssetWrapper): the wrapper to check
against self.asset_wrapper
Returns:
(bool): True if the wrappers match.
"""
if wrapper != self._asset_wrapper:
unreal.log_warning(
'[UHoudiniPublicAPIProcessHDANode] Received delegate event '
'from unexpected asset wrapper ({0} vs {1})!'.format(
self._asset_wrapper.get_name() if self._asset_wrapper else '',
wrapper.get_name() if wrapper else ''
)
)
return False
return True
def _handle_on_failure(self):
""" Handle any failures during the lifecycle of the process. Calls
self.on_failure() and then unbinds from self.asset_wrapper and
optionally deletes the instantiated asset.
"""
self.on_failure()
self._unbind_delegates()
if self.delete_instantiated_asset_on_completion_or_failure and self.asset_wrapper:
self.asset_wrapper.delete_instantiated_asset()
def _handle_on_complete(self):
""" Handles completion of the process. This can happen at one of
three stages:
- After on_post_instantiate(), if enable_auto_cook is False.
- After on_post_auto_cook(), if enable_auto_cook is True but
enable_auto_bake is False.
- After on_post_auto_bake(), if both enable_auto_cook and
enable_auto_bake are True.
Calls self.on_complete() and then unbinds from self.asset_wrapper's
delegates and optionally deletes the instantiated asset.
"""
self.on_complete()
self._unbind_delegates()
if self.delete_instantiated_asset_on_completion_or_failure and self.asset_wrapper:
self.asset_wrapper.delete_instantiated_asset()
def _handle_on_pre_instantiation(self, wrapper):
""" Called during pre_instantiation. Sets ``parameters`` on the HDA
and calls self.on_pre_instantiation().
"""
if not self._check_wrapper(wrapper):
return
# Set any parameters specified for the HDA
if self.asset_wrapper and self.parameters:
self.asset_wrapper.set_parameter_tuples(self.parameters)
self.on_pre_instantiation()
def _handle_on_post_instantiation(self, wrapper):
""" Called during post_instantiation. Sets inputs (``node_inputs`` and
``parameter_inputs``) on the HDA and calls self.on_post_instantiation().
Completes execution if enable_auto_cook is False.
"""
if not self._check_wrapper(wrapper):
return
# Set any inputs specified when the node was created
if self.asset_wrapper:
if self.node_inputs:
self.asset_wrapper.set_inputs_at_indices(self.node_inputs)
if self.parameter_inputs:
self.asset_wrapper.set_input_parameters(self.parameter_inputs)
self.on_post_instantiation()
# If not set to auto cook, complete execution now
if not self.enable_auto_cook:
self._handle_on_complete()
def _handle_on_post_auto_cook(self, wrapper, cook_success):
""" Called during post_cook. Sets self.cook_success and calls
self.on_post_auto_cook().
Args:
cook_success (bool): True if the cook was successful.
"""
if not self._check_wrapper(wrapper):
return
self._cook_success = cook_success
self.on_post_auto_cook(cook_success)
def _handle_on_pre_process(self, wrapper):
""" Called during pre_process. Calls self.on_pre_process().
"""
if not self._check_wrapper(wrapper):
return
self.on_pre_process()
def _handle_on_post_processing(self, wrapper):
""" Called during post_processing. Calls self.on_post_processing().
Completes execution if enable_auto_bake is False.
"""
if not self._check_wrapper(wrapper):
return
self.on_post_processing()
# If not set to auto bake, complete execution now
if not self.enable_auto_bake:
self._handle_on_complete()
def _handle_on_post_auto_bake(self, wrapper, bake_success):
""" Called during post_bake. Sets self.bake_success and calls
self.on_post_auto_bake().
Args:
bake_success (bool): True if the bake was successful.
"""
if not self._check_wrapper(wrapper):
return
self._bake_success = bake_success
self.on_post_auto_bake(bake_success)
self._handle_on_complete()
def on_failure(self):
""" Called if the process fails to instantiate or fails to start
a cook.
Subclasses can override this function implement custom functionality.
"""
pass
def on_complete(self):
""" Called if the process completes instantiation, cook and/or baking,
depending on enable_auto_cook and enable_auto_bake.
Subclasses can override this function implement custom functionality.
"""
pass
def on_pre_instantiation(self):
""" Called during pre_instantiation.
Subclasses can override this function implement custom functionality.
"""
pass
def on_post_instantiation(self):
""" Called during post_instantiation.
Subclasses can override this function implement custom functionality.
"""
pass
def on_post_auto_cook(self, cook_success):
""" Called during post_cook.
Subclasses can override this function implement custom functionality.
Args:
cook_success (bool): True if the cook was successful.
"""
pass
def on_pre_process(self):
""" Called during pre_process.
Subclasses can override this function implement custom functionality.
"""
pass
def on_post_processing(self):
""" Called during post_processing.
Subclasses can override this function implement custom functionality.
"""
pass
def on_post_auto_bake(self, bake_success):
""" Called during post_bake.
Subclasses can override this function implement custom functionality.
Args:
bake_success (bool): True if the bake was successful.
"""
pass
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import unreal
""" Example script for instantiating an asset, cooking it and baking an
individual output object.
"""
_g_wrapper = None
def get_test_hda_path():
return '/project/.pig_head_subdivider_v01'
def get_test_hda():
return unreal.load_object(None, get_test_hda_path())
def on_post_process(in_wrapper):
print('on_post_process')
# Print details about the outputs and record the first static mesh we find
sm_index = None
sm_identifier = None
# in_wrapper.on_post_processing_delegate.remove_callable(on_post_process)
num_outputs = in_wrapper.get_num_outputs()
print('num_outputs: {}'.format(num_outputs))
if num_outputs > 0:
for output_idx in range(num_outputs):
identifiers = in_wrapper.get_output_identifiers_at(output_idx)
output_type = in_wrapper.get_output_type_at(output_idx)
print('\toutput index: {}'.format(output_idx))
print('\toutput type: {}'.format(output_type))
print('\tnum_output_objects: {}'.format(len(identifiers)))
if identifiers:
for identifier in identifiers:
output_object = in_wrapper.get_output_object_at(output_idx, identifier)
output_component = in_wrapper.get_output_component_at(output_idx, identifier)
is_proxy = in_wrapper.is_output_current_proxy_at(output_idx, identifier)
print('\t\tidentifier: {}'.format(identifier))
print('\t\toutput_object: {}'.format(output_object.get_name() if output_object else 'None'))
print('\t\toutput_component: {}'.format(output_component.get_name() if output_component else 'None'))
print('\t\tis_proxy: {}'.format(is_proxy))
print('')
if (output_type == unreal.HoudiniOutputType.MESH and
isinstance(output_object, unreal.StaticMesh)):
sm_index = output_idx
sm_identifier = identifier
# Bake the first static mesh we found to the CB
if sm_index is not None and sm_identifier is not None:
print('baking {}'.format(sm_identifier))
success = in_wrapper.bake_output_object_at(sm_index, sm_identifier)
print('success' if success else 'failed')
# Delete the instantiated asset
in_wrapper.delete_instantiated_asset()
global _g_wrapper
_g_wrapper = None
def run():
# get the API singleton
api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
global _g_wrapper
# instantiate an asset with auto-cook enabled
_g_wrapper = api.instantiate_asset(get_test_hda(), unreal.Transform())
# Bind to the on post processing delegate (after a cook and after all
# outputs have been generated in Unreal)
_g_wrapper.on_post_processing_delegate.add_callable(on_post_process)
if __name__ == '__main__':
run()
|
#!/project/ python3
"""
Test script to verify character can load all required animations
"""
import unreal
def log_message(message):
"""Print and log message"""
print(message)
unreal.log(message)
def test_animation_loading():
"""Test that all character animations can be loaded"""
log_message("=== TESTING CHARACTER ANIMATION LOADING ===")
# Animation paths that the character expects
animation_paths = {
"Idle": "/project/",
"Move": "/project/",
"AttackUpwards": "/project/",
"AttackDownwards": "/project/",
"AttackSideways": "/project/"
}
all_loaded = True
for name, path in animation_paths.items():
try:
if unreal.EditorAssetLibrary.does_asset_exist(path):
anim = unreal.EditorAssetLibrary.load_asset(path)
if anim and isinstance(anim, unreal.PaperFlipbook):
frames = anim.get_num_frames()
fps = anim.get_editor_property("frames_per_second")
log_message(f"✓ {name}: {frames} frames @ {fps} FPS")
else:
log_message(f"✗ {name}: Failed to load as PaperFlipbook")
all_loaded = False
else:
log_message(f"✗ {name}: Asset does not exist at {path}")
all_loaded = False
except Exception as e:
log_message(f"✗ {name}: Error loading - {str(e)}")
all_loaded = False
return all_loaded
def test_character_blueprint():
"""Test that character blueprint exists and is accessible"""
log_message("\n=== TESTING CHARACTER BLUEPRINT ===")
try:
bp_path = "/project/"
if unreal.EditorAssetLibrary.does_asset_exist(bp_path):
bp = unreal.EditorAssetLibrary.load_asset(bp_path)
if bp:
log_message("✓ Character blueprint loaded successfully")
# Get the blueprint's class
bp_class = bp.generated_class()
if bp_class:
log_message("✓ Blueprint has generated class")
# Get default object
default_obj = bp_class.get_default_object()
if default_obj:
log_message("✓ Blueprint has default object")
# Check if it has a sprite component
if hasattr(default_obj, 'sprite'):
sprite_comp = default_obj.sprite
if sprite_comp:
log_message("✓ Character has sprite component")
return True
else:
log_message("✗ Character sprite component is None")
else:
log_message("✗ Character has no sprite attribute")
else:
log_message("✗ Blueprint has no default object")
else:
log_message("✗ Blueprint has no generated class")
else:
log_message("✗ Blueprint failed to load")
else:
log_message("✗ Character blueprint does not exist")
return False
except Exception as e:
log_message(f"✗ Error testing character blueprint: {str(e)}")
return False
def assign_idle_animation_to_character():
"""Assign idle animation to character blueprint as default"""
log_message("\n=== ASSIGNING IDLE ANIMATION TO CHARACTER ===")
try:
# Load idle animation
idle_anim = unreal.EditorAssetLibrary.load_asset("/project/")
if not idle_anim:
log_message("✗ Could not load Idle animation")
return False
log_message("✓ Loaded Idle animation")
# Load character blueprint
bp_path = "/project/"
bp = unreal.EditorAssetLibrary.load_asset(bp_path)
if not bp:
log_message("✗ Could not load character blueprint")
return False
log_message("✓ Loaded character blueprint")
# Get the default object and set sprite flipbook
bp_class = bp.generated_class()
if bp_class:
default_obj = bp_class.get_default_object()
if default_obj and hasattr(default_obj, 'sprite'):
sprite_comp = default_obj.sprite
if sprite_comp:
sprite_comp.set_flipbook(idle_anim)
log_message("✓ Set idle animation on character sprite")
# Save the blueprint
unreal.EditorAssetLibrary.save_asset(bp_path)
log_message("✓ Saved character blueprint")
return True
else:
log_message("✗ Character has no sprite component")
else:
log_message("✗ Character has no default object or sprite")
else:
log_message("✗ Blueprint has no generated class")
return False
except Exception as e:
log_message(f"✗ Error assigning animation: {str(e)}")
return False
def test_game_mode_setup():
"""Test that game mode is properly configured"""
log_message("\n=== TESTING GAME MODE SETUP ===")
try:
# Check WarriorGameMode blueprint
gm_path = "/project/"
if unreal.EditorAssetLibrary.does_asset_exist(gm_path):
gm = unreal.EditorAssetLibrary.load_asset(gm_path)
if gm:
log_message("✓ WarriorGameMode blueprint exists")
return True
else:
log_message("✗ WarriorGameMode blueprint failed to load")
else:
log_message("✗ WarriorGameMode blueprint does not exist")
return False
except Exception as e:
log_message(f"✗ Error testing game mode: {str(e)}")
return False
def main():
"""Main test function"""
log_message("=" * 70)
log_message("CHARACTER ANIMATION ASSIGNMENT TEST")
log_message("=" * 70)
# Test 1: Verify all required animations can be loaded
animations_ok = test_animation_loading()
# Test 2: Verify character blueprint is accessible
blueprint_ok = test_character_blueprint()
# Test 3: Assign idle animation to character
assignment_ok = assign_idle_animation_to_character()
# Test 4: Check game mode setup
gamemode_ok = test_game_mode_setup()
# Summary
log_message("=" * 70)
log_message("TEST RESULTS:")
log_message(f"✓ Required animations loadable: {'YES' if animations_ok else 'NO'}")
log_message(f"✓ Character blueprint accessible: {'YES' if blueprint_ok else 'NO'}")
log_message(f"✓ Idle animation assigned: {'YES' if assignment_ok else 'NO'}")
log_message(f"✓ Game mode configured: {'YES' if gamemode_ok else 'NO'}")
if animations_ok and blueprint_ok and assignment_ok and gamemode_ok:
log_message("\n🎉 ALL TESTS PASSED!")
log_message("✅ Character should have working animations!")
log_message("\nTo test:")
log_message("1. Open TestLevel in the editor")
log_message("2. Click the Play button to enter PIE mode")
log_message("3. Use WASD to move and see movement animations")
log_message("4. Use arrow keys or mouse to attack and see attack animations")
log_message("5. Character should show idle animation when not moving")
else:
log_message("\n❌ Some tests failed - check errors above")
log_message("=" * 70)
if __name__ == "__main__":
main()
|
# Copyright Epic Games, Inc. All Rights Reserved
# Built-In
import os
import re
import json
import traceback
from collections import OrderedDict
# External
import unreal
from deadline_service import get_global_deadline_service_instance
from deadline_job import DeadlineJob
from deadline_utils import get_deadline_info_from_preset
@unreal.uclass()
class MoviePipelineDeadlineRemoteExecutor(unreal.MoviePipelineExecutorBase):
"""
This class defines the editor implementation for Deadline (what happens when you
press 'Render (Remote)', which is in charge of taking a movie queue from the UI
and processing it into something Deadline can handle.
"""
# The queue we are working on, null if no queue has been provided.
pipeline_queue = unreal.uproperty(unreal.MoviePipelineQueue)
job_ids = unreal.uproperty(unreal.Array(str))
# A MoviePipelineExecutor implementation must override this.
@unreal.ufunction(override=True)
def execute(self, pipeline_queue):
"""
This is called when the user presses Render (Remote) in the UI. We will
split the queue up into multiple jobs. Each job will be submitted to
deadline separately, with each shot within the job split into one Deadline
task per shot.
"""
unreal.log(f"Asked to execute Queue: {pipeline_queue}")
unreal.log(f"Queue has {len(pipeline_queue.get_jobs())} jobs")
# Don't try to process empty/null Queues, no need to send them to
# Deadline.
if not pipeline_queue or (not pipeline_queue.get_jobs()):
self.on_executor_finished_impl()
return
# The user must save their work and check it in so that Deadline
# can sync it.
dirty_packages = []
dirty_packages.extend(
unreal.EditorLoadingAndSavingUtils.get_dirty_content_packages()
)
dirty_packages.extend(
unreal.EditorLoadingAndSavingUtils.get_dirty_map_packages()
)
# Sometimes the dialog will return `False`
# even when there are no packages to save. so we are
# being explict about the packages we need to save
if dirty_packages:
if not unreal.EditorLoadingAndSavingUtils.save_dirty_packages_with_dialog(
True, True
):
message = (
"One or more jobs in the queue have an unsaved map/content. "
"{packages} "
"Please save and check-in all work before submission.".format(
packages="\n".join(dirty_packages)
)
)
unreal.log_error(message)
unreal.EditorDialog.show_message(
"Unsaved Maps/Content", message, unreal.AppMsgType.OK
)
self.on_executor_finished_impl()
return
# Make sure all the maps in the queue exist on disk somewhere,
# unsaved maps can't be loaded on the remote machine, and it's common
# to have the wrong map name if you submit without loading the map.
has_valid_map = (
unreal.MoviePipelineEditorLibrary.is_map_valid_for_remote_render(
pipeline_queue.get_jobs()
)
)
if not has_valid_map:
message = (
"One or more jobs in the queue have an unsaved map as "
"their target map. "
"These unsaved maps cannot be loaded by an external process, "
"and the render has been aborted."
)
unreal.log_error(message)
unreal.EditorDialog.show_message(
"Unsaved Maps", message, unreal.AppMsgType.OK
)
self.on_executor_finished_impl()
return
self.pipeline_queue = pipeline_queue
deadline_settings = unreal.get_default_object(
unreal.MoviePipelineDeadlineSettings
)
# Arguments to pass to the executable. This can be modified by settings
# in the event a setting needs to be applied early.
# In the format of -foo -bar
# commandLineArgs = ""
command_args = []
# Append all of our inherited command line arguments from the editor.
in_process_executor_settings = unreal.get_default_object(
unreal.MoviePipelineInProcessExecutorSettings
)
inherited_cmds = in_process_executor_settings.inherited_command_line_arguments
# Sanitize the commandline by removing any execcmds that may
# have passed through the commandline.
# We remove the execcmds because, in some cases, users may execute a
# script that is local to their editor build for some automated
# workflow but this is not ideal on the farm. We will expect all
# custom startup commands for rendering to go through the `Start
# Command` in the MRQ settings.
inherited_cmds = re.sub(
".*(?P<cmds>-execcmds=[\s\S]+[\'\"])",
"",
inherited_cmds
)
command_args.extend(inherited_cmds.split(" "))
command_args.extend(
in_process_executor_settings.additional_command_line_arguments.split(
" "
)
)
command_args.extend(
["-nohmd", "-windowed", f"-ResX=1280", f"-ResY=720"]
)
# Get the project level preset
project_preset = deadline_settings.default_job_preset
# Get the job and plugin info string.
# Note:
# Sometimes a project level default may not be set,
# so if this returns an empty dictionary, that is okay
# as we primarily care about the job level preset.
# Catch any exceptions here and continue
try:
project_job_info, project_plugin_info = get_deadline_info_from_preset(job_preset=project_preset)
except Exception:
pass
deadline_service = get_global_deadline_service_instance()
for job in self.pipeline_queue.get_jobs():
unreal.log(f"Submitting Job `{job.job_name}` to Deadline...")
try:
# Create a Deadline job object with the default project level
# job info and plugin info
deadline_job = DeadlineJob(project_job_info, project_plugin_info)
deadline_job_id = self.submit_job(
job, deadline_job, command_args, deadline_service
)
except Exception as err:
unreal.log_error(
f"Failed to submit job `{job.job_name}` to Deadline, aborting render. \n\tError: {str(err)}"
)
unreal.log_error(traceback.format_exc())
self.on_executor_errored_impl(None, True, str(err))
unreal.EditorDialog.show_message(
"Submission Result",
f"Failed to submit job `{job.job_name}` to Deadline with error: {str(err)}. "
f"See log for more details.",
unreal.AppMsgType.OK,
)
self.on_executor_finished_impl()
return
if not deadline_job_id:
message = (
f"A problem occurred submitting `{job.job_name}`. "
f"Either the job doesn't have any data to submit, "
f"or an error occurred getting the Deadline JobID. "
f"This job status would not be reflected in the UI. "
f"Check the logs for more details."
)
unreal.log_warning(message)
unreal.EditorDialog.show_message(
"Submission Result", message, unreal.AppMsgType.OK
)
return
else:
unreal.log(f"Deadline JobId: {deadline_job_id}")
self.job_ids.append(deadline_job_id)
# Store the Deadline JobId in our job (the one that exists in
# the queue, not the duplicate) so we can match up Movie
# Pipeline jobs with status updates from Deadline.
job.user_data = deadline_job_id
# Now that we've sent a job to Deadline, we're going to request a status
# update on them so that they transition from "Ready" to "Queued" or
# their actual status in Deadline. self.request_job_status_update(
# deadline_service)
message = (
f"Successfully submitted {len(self.job_ids)} jobs to Deadline. JobIds: {', '.join(self.job_ids)}. "
f"\nPlease use Deadline Monitor to track render job statuses"
)
unreal.log(message)
unreal.EditorDialog.show_message(
"Submission Result", message, unreal.AppMsgType.OK
)
# Set the executor to finished
self.on_executor_finished_impl()
@unreal.ufunction(override=True)
def is_rendering(self):
# Because we forward unfinished jobs onto another service when the
# button is pressed, they can always submit what is in the queue and
# there's no need to block the queue.
# A MoviePipelineExecutor implementation must override this. If you
# override a ufunction from a base class you don't specify the return
# type or parameter types.
return False
def submit_job(self, job, deadline_job, command_args, deadline_service):
"""
Submit a new Job to Deadline
:param job: Queued job to submit
:param deadline_job: Deadline job object
:param list[str] command_args: Commandline arguments to configure for the Deadline Job
:param deadline_service: An instance of the deadline service object
:returns: Deadline Job ID
:rtype: str
"""
# Get the Job Info and plugin Info
# If we have a preset set on the job, get the deadline submission details
try:
job_info, plugin_info = get_deadline_info_from_preset(job_preset_struct=job.get_deadline_job_preset_struct_with_overrides())
# Fail the submission if any errors occur
except Exception as err:
raise RuntimeError(
f"An error occurred getting the deadline job and plugin "
f"details. \n\tError: {err} "
)
# check for required fields in pluginInfo
if "Executable" not in plugin_info:
raise RuntimeError("An error occurred formatting the Plugin Info string. \n\tMissing \"Executable\" key")
elif not plugin_info["Executable"]:
raise RuntimeError(f"An error occurred formatting the Plugin Info string. \n\tExecutable value cannot be empty")
if "ProjectFile" not in plugin_info:
raise RuntimeError("An error occurred formatting the Plugin Info string. \n\tMissing \"ProjectFile\" key")
elif not plugin_info["ProjectFile"]:
raise RuntimeError(f"An error occurred formatting the Plugin Info string. \n\tProjectFile value cannot be empty")
# Update the job info with overrides from the UI
if job.batch_name:
job_info["BatchName"] = job.batch_name
if hasattr(job, "comment") and not job_info.get("Comment"):
job_info["Comment"] = job.comment
if not job_info.get("Name") or job_info["Name"] == "Untitled":
job_info["Name"] = job.job_name
if job.author:
job_info["UserName"] = job.author
if unreal.Paths.is_project_file_path_set():
# Trim down to just "Game.uproject" instead of absolute path.
game_name_or_project_file = (
unreal.Paths.convert_relative_path_to_full(
unreal.Paths.get_project_file_path()
)
)
else:
raise RuntimeError(
"Failed to get a project name. Please set a project!"
)
# Create a new queue with only this job in it and save it to disk,
# then load it, so we can send it with the REST API
new_queue = unreal.MoviePipelineQueue()
new_job = new_queue.duplicate_job(job)
duplicated_queue, manifest_path = unreal.MoviePipelineEditorLibrary.save_queue_to_manifest_file(
new_queue
)
# Convert the queue to text (load the serialized json from disk) so we
# can send it via deadline, and deadline will write the queue to the
# local machines on job startup.
serialized_pipeline = unreal.MoviePipelineEditorLibrary.convert_manifest_file_to_string(
manifest_path
)
# Loop through our settings in the job and let them modify the command
# line arguments/params.
new_job.get_configuration().initialize_transient_settings()
# Look for our Game Override setting to pull the game mode to start
# with. We start with this game mode even on a blank map to override
# the project default from kicking in.
game_override_class = None
out_url_params = []
out_command_line_args = []
out_device_profile_cvars = []
out_exec_cmds = []
for setting in new_job.get_configuration().get_all_settings():
out_url_params, out_command_line_args, out_device_profile_cvars, out_exec_cmds = setting.build_new_process_command_line_args(
out_url_params,
out_command_line_args,
out_device_profile_cvars,
out_exec_cmds,
)
# Set the game override
if setting.get_class() == unreal.MoviePipelineGameOverrideSetting.static_class():
game_override_class = setting.game_mode_override
# This triggers the editor to start looking for render jobs when it
# finishes loading.
out_exec_cmds.append("py mrq_rpc.py")
# Convert the arrays of command line args, device profile cvars,
# and exec cmds into actual commands for our command line.
command_args.extend(out_command_line_args)
if out_device_profile_cvars:
# -dpcvars="arg0,arg1,..."
command_args.append(
'-dpcvars="{dpcvars}"'.format(
dpcvars=",".join(out_device_profile_cvars)
)
)
if out_exec_cmds:
# -execcmds="cmd0,cmd1,..."
command_args.append(
'-execcmds="{cmds}"'.format(cmds=",".join(out_exec_cmds))
)
# Add support for telling the remote process to wait for the
# asset registry to complete synchronously
command_args.append("-waitonassetregistry")
# Build a shot-mask from this sequence, to split into the appropriate
# number of tasks. Remove any already-disabled shots before we
# generate a list, otherwise we make unneeded tasks which get sent to
# machines
shots_to_render = []
for shot_index, shot in enumerate(new_job.shot_info):
if not shot.enabled:
unreal.log(
f"Skipped submitting shot {shot_index} in {job.job_name} "
f"to server due to being already disabled!"
)
else:
shots_to_render.append(shot.outer_name)
# If there are no shots enabled,
# "these are not the droids we are looking for", move along ;)
# We will catch this later and deal with it
if not shots_to_render:
unreal.log_warning("No shots enabled in shot mask, not submitting.")
return
# Divide the job to render by the chunk size
# i.e {"O": "my_new_shot"} or {"0", "shot_1,shot_2,shot_4"}
chunk_size = int(job_info.get("ChunkSize", 1))
shots = {}
frame_list = []
for index in range(0, len(shots_to_render), chunk_size):
shots[str(index)] = ",".join(shots_to_render[index : index + chunk_size])
frame_list.append(str(index))
job_info["Frames"] = ",".join(frame_list)
# Get the current index of the ExtraInfoKeyValue pair, we will
# increment the index, so we do not stomp other settings
extra_info_key_indexs = set()
for key in job_info.keys():
if key.startswith("ExtraInfoKeyValue"):
_, index = key.split("ExtraInfoKeyValue")
extra_info_key_indexs.add(int(index))
# Get the highest number in the index list and increment the number
# by one
current_index = max(extra_info_key_indexs) + 1 if extra_info_key_indexs else 0
# Put the serialized Queue into the Job data but hidden from
# Deadline UI
job_info[f"ExtraInfoKeyValue{current_index}"] = f"serialized_pipeline={serialized_pipeline}"
# Increment the index
current_index += 1
# Put the shot info in the job extra info keys
job_info[f"ExtraInfoKeyValue{current_index}"] = f"shot_info={json.dumps(shots)}"
current_index += 1
# Set the job output directory override on the deadline job
if hasattr(new_job, "output_directory_override"):
if new_job.output_directory_override.path:
job_info[f"ExtraInfoKeyValue{current_index}"] = f"output_directory_override={new_job.output_directory_override.path}"
current_index += 1
# Set the job filename format override on the deadline job
if hasattr(new_job, "filename_format_override"):
if new_job.filename_format_override:
job_info[f"ExtraInfoKeyValue{current_index}"] = f"filename_format_override={new_job.filename_format_override}"
current_index += 1
# Build the command line arguments the remote machine will use.
# The Deadline plugin will provide the executable since it is local to
# the machine. It will also write out queue manifest to the correct
# location relative to the Saved folder
# Get the current commandline args from the plugin info
plugin_info_cmd_args = [plugin_info.get("CommandLineArguments", "")]
if not plugin_info.get("ProjectFile"):
project_file = plugin_info.get("ProjectFile", game_name_or_project_file)
plugin_info["ProjectFile"] = project_file
# This is the map included in the plugin to boot up to.
project_cmd_args = [
f"MoviePipelineEntryMap?game={game_override_class.get_path_name()}"
]
# Combine all the compiled arguments
full_cmd_args = project_cmd_args + command_args + plugin_info_cmd_args
# Remove any duplicates in the commandline args and convert to a string
full_cmd_args = " ".join(list(OrderedDict.fromkeys(full_cmd_args))).strip()
unreal.log(f"Deadline job command line args: {full_cmd_args}")
# Update the plugin info with the commandline arguments
plugin_info.update(
{
"CommandLineArguments": full_cmd_args,
"CommandLineMode": "false",
}
)
deadline_job.job_info = job_info
deadline_job.plugin_info = plugin_info
# Submit the deadline job
return deadline_service.submit_job(deadline_job)
# TODO: For performance reasons, we will skip updating the UI and request
# that users use a different mechanism for checking on job statuses.
# This will be updated once we have a performant solution.
|
# -*- coding: utf-8 -*-
import os
import unreal
from Utilities.Utils import Singleton
import random
class ChameleonGallery(metaclass=Singleton):
def __init__(self, jsonPath):
self.jsonPath = jsonPath
self.data = unreal.PythonBPLib.get_chameleon_data(self.jsonPath)
self.ui_crumbname = "SBreadcrumbTrailA"
self.ui_image = "SImageA"
self.ui_image_local = "SImage_ImageFromRelativePath"
self.ui_imageB = "SImage_ImageFromPath"
self.ui_progressBar = "ProgressBarA"
self.ui_drop_target_text_box = "DropResultBox"
self.ui_python_not_ready = "IsPythonReadyImg"
self.ui_python_is_ready = "IsPythonReadyImgB"
self.ui_is_python_ready_text = "IsPythonReadyText"
self.imageFlagA = 0
self.imageFlagB = 0
# set data in init
self.set_random_image_data()
self.data.set_combo_box_items('CombBoxA', ['1', '3', '5'])
print("ChameleonGallery.Init")
def mark_python_ready(self):
print("mark_python_ready call")
self.data.set_visibility(self.ui_python_not_ready, "Collapsed")
self.data.set_visibility(self.ui_python_is_ready, "Visible")
self.data.set_text(self.ui_is_python_ready_text, "Python Path Ready.")
def push_breadcrumb(self):
count = self.data.get_breadcrumbs_count_string(self.ui_crumbname)
strs = "is breadcrumb tail from alice in wonder world"
label = strs.split()[count % len(strs.split())]
self.data.push_breadcrumb_string(self.ui_crumbname, label, label)
def set_random_image_data(self):
width = 64
height = 64
colors = [unreal.LinearColor(1, 1, 1, 1) if random.randint(0, 1) else unreal.LinearColor(0, 0, 0, 1) for _ in range(width * height)]
self.data.set_image_pixels(self.ui_image, colors, width, height)
def set_random_progress_bar_value(self):
self.data.set_progress_bar_percent(self.ui_progressBar,random.random())
def change_local_image(self):
self.data.set_image_from(self.ui_image_local, ["Images/ChameleonLogo_c.png", "Images/ChameleonLogo_b.png"][self.imageFlagA])
self.imageFlagA = (self.imageFlagA + 1) % 2
def change_image(self):
self.data.set_image_from_path(self.ui_imageB, ["PythonChameleonIcon_128x.png", "Icon128.png"][self.imageFlagB])
self.imageFlagB = (self.imageFlagB + 1) % 2
def change_comboBox_items(self):
offset = random.randint(1, 10)
items = [str(v+offset) for v in range(random.randint(1, 10))]
self.data.set_combo_box_items("CombBoxA", items)
def launch_other_galleries(self):
if not os.path.exists(os.path.join(os.path.dirname(__file__), 'auto_gen/border_brushes_Gallery.json')):
unreal.PythonBPLib.notification("auto-generated Gallerys not exists", info_level=1)
return
gallery_paths = ['ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json']
bLaunch = unreal.PythonBPLib.confirm_dialog(f'Open Other {len(gallery_paths)} Galleries? You can close them with the "Close all Gallery" Button' , "Open Other Galleries", with_cancel_button=False)
if bLaunch:
with unreal.ScopedSlowTask(len(gallery_paths), "Spawn Actors") as slow_task:
slow_task.make_dialog(True)
for i, p in enumerate(gallery_paths):
slow_task.enter_progress_frame(1, f"Launch Gallery: {p}")
unreal.ChameleonData.launch_chalemeon_tool(p)
def request_close_other_galleries(self):
if not os.path.exists(os.path.join(os.path.dirname(__file__), 'auto_gen/border_brushes_Gallery.json')):
unreal.PythonBPLib.notification("auto-generated Gallerys not exists", info_level=1)
return
gallery_paths = ['ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json',
'ChameleonGallery/project/.json']
for i, p in enumerate(gallery_paths):
unreal.ChameleonData.request_close(p)
# unreal.ChameleonData.request_close('/project/.json')
exists_tools_var = [globals()[x] for x in globals() if "Utilities.Utils.Singleton" in str(type(type(globals()[x])))]
def on_drop(self, assets, assets_folders, actors):
str_for_show = ""
for items, name in zip([assets, assets_folders, actors], ["Assets:", "Assets Folders:", "Actors:"]):
if items:
str_for_show += f"{name}\n"
for item in items:
str_for_show += f"\t{item}\n"
self.data.set_text(self.ui_drop_target_text_box, str_for_show)
print(f"str_for_show: {str_for_show}")
def on_drop_func(self, *args, **kwargs):
print(f"args: {args}")
print(f"kwargs: {kwargs}")
str_for_show = ""
for name, items in kwargs.items():
if items:
str_for_show += f"{name}:\n"
for item in items:
str_for_show += f"\t{item}\n"
self.data.set_text(self.ui_drop_target_text_box, str_for_show)
|
import json
from pathlib import Path
import unreal
from unreal import EditorLevelLibrary
import ayon_api
from ayon_core.pipeline import (
discover_loader_plugins,
loaders_from_representation,
load_container,
get_representation_path,
AYON_CONTAINER_ID,
)
from ayon_core.hosts.unreal.api import plugin
from ayon_core.hosts.unreal.api import pipeline as upipeline
class ExistingLayoutLoader(plugin.Loader):
"""
Load Layout for an existing scene, and match the existing assets.
"""
product_types = {"layout"}
representations = ["json"]
label = "Load Layout on Existing Scene"
icon = "code-fork"
color = "orange"
ASSET_ROOT = "/project/"
delete_unmatched_assets = True
@classmethod
def apply_settings(cls, project_settings):
super(ExistingLayoutLoader, cls).apply_settings(
project_settings
)
cls.delete_unmatched_assets = (
project_settings["unreal"]["delete_unmatched_assets"]
)
@staticmethod
def _create_container(
asset_name,
asset_dir,
folder_path,
representation,
version_id,
product_type
):
container_name = f"{asset_name}_CON"
if not unreal.EditorAssetLibrary.does_asset_exist(
f"{asset_dir}/{container_name}"
):
container = upipeline.create_container(container_name, asset_dir)
else:
ar = unreal.AssetRegistryHelpers.get_asset_registry()
obj = ar.get_asset_by_object_path(
f"{asset_dir}/{container_name}.{container_name}")
container = obj.get_asset()
data = {
"schema": "ayon:container-2.0",
"id": AYON_CONTAINER_ID,
"folder_path": folder_path,
"namespace": asset_dir,
"container_name": container_name,
"asset_name": asset_name,
# "loader": str(self.__class__.__name__),
"representation": representation,
"parent": version_id,
"product_type": product_type,
# TODO these shold be probably removed
"asset": folder_path,
"family": product_type,
}
upipeline.imprint(
"{}/{}".format(asset_dir, container_name), data)
return container.get_path_name()
@staticmethod
def _get_current_level():
ue_version = unreal.SystemLibrary.get_engine_version().split('.')
ue_major = ue_version[0]
if ue_major == '4':
return EditorLevelLibrary.get_editor_world()
elif ue_major == '5':
return unreal.LevelEditorSubsystem().get_current_level()
raise NotImplementedError(
f"Unreal version {ue_major} not supported")
def _transform_from_basis(self, transform, basis):
"""Transform a transform from a basis to a new basis."""
# Get the basis matrix
basis_matrix = unreal.Matrix(
basis[0],
basis[1],
basis[2],
basis[3]
)
transform_matrix = unreal.Matrix(
transform[0],
transform[1],
transform[2],
transform[3]
)
new_transform = (
basis_matrix.get_inverse() * transform_matrix * basis_matrix)
return new_transform.transform()
def _spawn_actor(self, obj, lasset):
actor = EditorLevelLibrary.spawn_actor_from_object(
obj, unreal.Vector(0.0, 0.0, 0.0)
)
actor.set_actor_label(lasset.get('instance_name'))
transform = lasset.get('transform_matrix')
basis = lasset.get('basis')
computed_transform = self._transform_from_basis(transform, basis)
actor.set_actor_transform(computed_transform, False, True)
@staticmethod
def _get_fbx_loader(loaders, family):
name = ""
if family == 'rig':
name = "SkeletalMeshFBXLoader"
elif family == 'model' or family == 'staticMesh':
name = "StaticMeshFBXLoader"
elif family == 'camera':
name = "CameraLoader"
if name == "":
return None
for loader in loaders:
if loader.__name__ == name:
return loader
return None
@staticmethod
def _get_abc_loader(loaders, family):
name = ""
if family == 'rig':
name = "SkeletalMeshAlembicLoader"
elif family == 'model':
name = "StaticMeshAlembicLoader"
if name == "":
return None
for loader in loaders:
if loader.__name__ == name:
return loader
return None
def _load_asset(self, repr_data, representation, instance_name, family):
repr_format = repr_data.get('name')
all_loaders = discover_loader_plugins()
loaders = loaders_from_representation(
all_loaders, representation)
loader = None
if repr_format == 'fbx':
loader = self._get_fbx_loader(loaders, family)
elif repr_format == 'abc':
loader = self._get_abc_loader(loaders, family)
if not loader:
self.log.error(f"No valid loader found for {representation}")
return []
# This option is necessary to avoid importing the assets with a
# different conversion compared to the other assets. For ABC files,
# it is in fact impossible to access the conversion settings. So,
# we must assume that the Maya conversion settings have been applied.
options = {
"default_conversion": True
}
assets = load_container(
loader,
representation,
namespace=instance_name,
options=options
)
return assets
def _get_valid_repre_entities(self, project_name, version_ids):
valid_formats = ['fbx', 'abc']
repre_entities = list(ayon_api.get_representations(
project_name,
representation_names=valid_formats,
version_ids=version_ids
))
repre_entities_by_version_id = {}
for repre_entity in repre_entities:
version_id = repre_entity["versionId"]
repre_entities_by_version_id[version_id] = repre_entity
return repre_entities_by_version_id
def _process(self, lib_path, project_name):
ar = unreal.AssetRegistryHelpers.get_asset_registry()
actors = EditorLevelLibrary.get_all_level_actors()
with open(lib_path, "r") as fp:
data = json.load(fp)
elements = []
repre_ids = set()
# Get all the representations in the JSON from the database.
for element in data:
repre_id = element.get('representation')
if repre_id:
repre_ids.add(repre_id)
elements.append(element)
repre_entities = ayon_api.get_representations(
project_name, representation_ids=repre_ids
)
repre_entities_by_id = {
repre_entity["id"]: repre_entity
for repre_entity in repre_entities
}
layout_data = []
version_ids = set()
for element in elements:
repre_id = element.get("representation")
repre_entity = repre_entities_by_id.get(repre_id)
if not repre_entity:
raise AssertionError("Representation not found")
if not (
repre_entity.get("attrib")
or repre_entity["attrib"].get("path")
):
raise AssertionError("Representation does not have path")
if not repre_entity.get('context'):
raise AssertionError("Representation does not have context")
layout_data.append((repre_entity, element))
version_ids.add(repre_entity["versionId"])
repre_parents_by_id = ayon_api.get_representation_parents(
project_name, repre_entities_by_id.keys()
)
# Prequery valid repre documents for all elements at once
valid_repre_entities_by_version_id = self._get_valid_repre_entities(
project_name, version_ids)
containers = []
actors_matched = []
for (repre_entity, lasset) in layout_data:
# For every actor in the scene, check if it has a representation in
# those we got from the JSON. If so, create a container for it.
# Otherwise, remove it from the scene.
found = False
repre_id = repre_entity["id"]
repre_parents = repre_parents_by_id[repre_id]
folder_path = repre_parents.folder["path"]
folder_name = repre_parents.folder["name"]
product_name = repre_parents.product["name"]
product_type = repre_parents.product["productType"]
for actor in actors:
if not actor.get_class().get_name() == 'StaticMeshActor':
continue
if actor in actors_matched:
continue
# Get the original path of the file from which the asset has
# been imported.
smc = actor.get_editor_property('static_mesh_component')
mesh = smc.get_editor_property('static_mesh')
import_data = mesh.get_editor_property('asset_import_data')
filename = import_data.get_first_filename()
path = Path(filename)
if (not path.name or
path.name not in repre_entity["attrib"]["path"]):
continue
actor.set_actor_label(lasset.get('instance_name'))
mesh_path = Path(mesh.get_path_name()).parent.as_posix()
# Create the container for the asset.
container = self._create_container(
f"{folder_name}_{product_name}",
mesh_path,
folder_path,
repre_entity["id"],
repre_entity["versionId"],
product_type
)
containers.append(container)
# Set the transform for the actor.
transform = lasset.get('transform_matrix')
basis = lasset.get('basis')
computed_transform = self._transform_from_basis(
transform, basis)
actor.set_actor_transform(computed_transform, False, True)
actors_matched.append(actor)
found = True
break
# If an actor has not been found for this representation,
# we check if it has been loaded already by checking all the
# loaded containers. If so, we add it to the scene. Otherwise,
# we load it.
if found:
continue
all_containers = upipeline.ls()
loaded = False
for container in all_containers:
repre_id = container.get('representation')
if not repre_id == repre_entity["id"]:
continue
asset_dir = container.get('namespace')
arfilter = unreal.ARFilter(
class_names=["StaticMesh"],
package_paths=[asset_dir],
recursive_paths=False)
assets = ar.get_assets(arfilter)
for asset in assets:
obj = asset.get_asset()
self._spawn_actor(obj, lasset)
loaded = True
break
# If the asset has not been loaded yet, we load it.
if loaded:
continue
version_id = lasset.get('version')
assets = self._load_asset(
valid_repre_entities_by_version_id.get(version_id),
lasset.get('representation'),
lasset.get('instance_name'),
lasset.get('family')
)
for asset in assets:
obj = ar.get_asset_by_object_path(asset).get_asset()
if not obj.get_class().get_name() == 'StaticMesh':
continue
self._spawn_actor(obj, lasset)
break
# Check if an actor was not matched to a representation.
# If so, remove it from the scene.
for actor in actors:
if not actor.get_class().get_name() == 'StaticMeshActor':
continue
if actor not in actors_matched:
self.log.warning(f"Actor {actor.get_name()} not matched.")
if self.delete_unmatched_assets:
EditorLevelLibrary.destroy_actor(actor)
return containers
def load(self, context, name, namespace, options):
print("Loading Layout and Match Assets")
folder_name = context["folder"]["name"]
folder_path = context["folder"]["path"]
product_type = context["product"]["productType"]
asset_name = f"{folder_name}_{name}" if folder_name else name
container_name = f"{folder_name}_{name}_CON"
curr_level = self._get_current_level()
if not curr_level:
raise AssertionError("Current level not saved")
project_name = context["project"]["name"]
path = self.filepath_from_context(context)
containers = self._process(path, project_name)
curr_level_path = Path(
curr_level.get_outer().get_path_name()).parent.as_posix()
if not unreal.EditorAssetLibrary.does_asset_exist(
f"{curr_level_path}/{container_name}"
):
upipeline.create_container(
container=container_name, path=curr_level_path)
data = {
"schema": "ayon:container-2.0",
"id": AYON_CONTAINER_ID,
"folder_path": folder_path,
"namespace": curr_level_path,
"container_name": container_name,
"asset_name": asset_name,
"loader": str(self.__class__.__name__),
"representation": context["representation"]["id"],
"parent": context["representation"]["versionId"],
"product_type": product_type,
"loaded_assets": containers,
# TODO these shold be probably removed
"asset": folder_path,
"family": product_type,
}
upipeline.imprint(f"{curr_level_path}/{container_name}", data)
def update(self, container, context):
asset_dir = container.get('namespace')
project_name = context["project"]["name"]
repre_entity = context["representation"]
source_path = get_representation_path(repre_entity)
containers = self._process(source_path, project_name)
data = {
"representation": repre_entity["id"],
"loaded_assets": containers,
"parent": repre_entity["versionId"],
}
upipeline.imprint(
"{}/{}".format(asset_dir, container.get('container_name')), data)
|
import unreal
""" Should be used with internal UE Python API
Auto generate collision for static meshes"""
asset_reg = unreal.AssetRegistryHelpers.get_asset_registry()
asset_root_dir = '/project/'
assets = asset_reg.get_assets_by_path(asset_root_dir, recursive=True)
def set_convex_collision(static_mesh):
unreal.EditorStaticMeshLibrary.set_convex_decomposition_collisions(static_mesh, 4, 16, 100000)
unreal.EditorAssetLibrary.save_loaded_asset(static_mesh)
for asset in assets:
if asset.asset_class == "StaticMesh":
static_mesh = unreal.EditorAssetLibrary.find_asset_data(asset.object_path).get_asset()
set_convex_collision(static_mesh)
|
"""Python execution commands for Unreal Engine.
This module contains commands for executing Python code in Unreal Engine.
"""
import sys
import os
from mcp.server.fastmcp import Context
# Import send_command from the parent module
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from unreal_mcp_bridge import send_command
def register_all(mcp):
"""Register all Python execution commands with the MCP server."""
@mcp.tool()
def execute_python(ctx: Context, code: str = None, file: str = None) -> str:
"""Execute Python code or a Python script file in Unreal Engine.
This function allows you to execute arbitrary Python code directly in the Unreal Engine
environment. You can either provide Python code as a string or specify a path to a Python
script file to execute.
The Python code will have access to the full Unreal Engine Python API, including the 'unreal'
module, allowing you to interact with and manipulate the Unreal Engine editor and its assets.
Args:
code: Python code to execute as a string. Can be multiple lines.
file: Path to a Python script file to execute.
Note:
- You must provide either code or file, but not both.
- The output of the Python code will be visible in the Unreal Engine log.
- The Python code runs in the Unreal Engine process, so it has full access to the engine.
- Be careful with destructive operations as they can affect your project.
Examples:
# Execute simple Python code
execute_python(code="print('Hello from Unreal Engine!')")
# Get information about the current level
execute_python(code='''
import unreal
level = unreal.EditorLevelLibrary.get_editor_world()
print(f"Current level: {level.get_name()}")
actors = unreal.EditorLevelLibrary.get_all_level_actors()
print(f"Number of actors: {len(actors)}")
''')
# Execute a Python script file
execute_python(file="D:/project/.py")
"""
try:
if not code and not file:
return "Error: You must provide either 'code' or 'file' parameter"
if code and file:
return "Error: You can only provide either 'code' or 'file', not both"
params = {}
if code:
params["code"] = code
if file:
params["file"] = file
response = send_command("execute_python", params)
# Handle the response
if response["status"] == "success":
return f"Python execution successfu/project/{response['result']['output']}"
elif response["status"] == "error":
# New format with detailed error information
result = response.get("result", {})
output = result.get("output", "")
error = result.get("error", "")
# Format the response with both output and error information
response_text = "Python execution failed with error/project/"
if output:
response_text += f"--- Output ---\n{output}\n\n"
if error:
response_text += f"--- Error ---\n{error}"
return response_text
else:
return f"Error: {response['message']}"
except Exception as e:
return f"Error executing Python: {str(e)}"
|
import os
import json
import unreal
from Utilities.Utils import Singleton
class Shelf(metaclass=Singleton):
'''
This is a demo tool for showing how to create Chamelon Tools in Python
'''
MAXIMUM_ICON_COUNT = 12
Visible = "Visible"
Collapsed = "Collapsed"
def __init__(self, jsonPath:str):
self.jsonPath = jsonPath
self.data = unreal.PythonBPLib.get_chameleon_data(self.jsonPath)
self.shelf_data = self.load_data()
self.is_text_readonly = True
self.ui_drop_at_last_aka = "DropAtLast"
self.ui_drop_is_full_aka = "DropIsFull"
self.update_ui(bForce=True)
def update_ui(self, bForce=False):
visibles = [False] * Shelf.MAXIMUM_ICON_COUNT
for i, shortcut in enumerate(self.shelf_data.shortcuts):
if i >= Shelf.MAXIMUM_ICON_COUNT:
continue
self.data.set_visibility(self.get_ui_button_group_name(i), Shelf.Visible)
self.data.set_tool_tip_text(self.get_ui_button_group_name(i), self.shelf_data.shortcuts[i].get_tool_tips())
self.data.set_text(self.get_ui_text_name(i), self.shelf_data.shortcuts[i].text)
# ITEM_TYPE_PY_CMD = 1 ITEM_TYPE_CHAMELEON = 2 ITEM_TYPE_ACTOR = 3 ITEM_TYPE_ASSETS = 4 ITEM_TYPE_ASSETS_FOLDER = 5
icon_name = ["PythonTextGreyIcon_40x.png", "PythonChameleonGreyIcon_40x.png", "LitSphere_40x.png", "Primitive_40x.png", "folderIcon.png"][shortcut.drop_type-1]
if os.path.exists(os.path.join(os.path.dirname(__file__), f"Images/{icon_name}")):
self.data.set_image_from(self.get_ui_img_name(i), f"Images/{icon_name}")
else:
unreal.log_warning("file: {} not exists in this tool's folder: {}".format(f"Images/{icon_name}", os.path.join(os.path.dirname(__file__))))
visibles[i] = True
for i, v in enumerate(visibles):
if not v:
self.data.set_visibility(self.get_ui_button_group_name(i), Shelf.Collapsed)
self.lock_text(self.is_text_readonly, bForce)
bFull = len(self.shelf_data) == Shelf.MAXIMUM_ICON_COUNT
self.data.set_visibility(self.ui_drop_at_last_aka, "Collapsed" if bFull else "Visible")
self.data.set_visibility(self.ui_drop_is_full_aka, "Visible" if bFull else "Collapsed" )
def lock_text(self, bLock, bForce=False):
if self.is_text_readonly != bLock or bForce:
for i in range(Shelf.MAXIMUM_ICON_COUNT):
self.data.set_text_read_only(self.get_ui_text_name(i), bLock)
self.data.set_color_and_opacity(self.get_ui_text_name(i), [1,1,1,1] if bLock else [1,0,0,1])
self.data.set_visibility(self.get_ui_text_name(i), "HitTestInvisible" if bLock else "Visible" )
self.is_text_readonly = bLock
def get_ui_button_group_name(self, index):
return f"ButtonGroup_{index}"
def get_ui_text_name(self, index):
return f"Txt_{index}"
def get_ui_img_name(self, index):
return f"Img_{index}"
def on_close(self):
self.save_data()
def get_data_path(self):
return os.path.join(os.path.dirname(__file__), "saved_shelf.json")
def load_data(self):
saved_file_path = self.get_data_path()
if os.path.exists(saved_file_path):
return ShelfData.load(saved_file_path)
else:
return ShelfData()
def save_data(self):
# fetch text from UI
for i, shortcut in enumerate(self.shelf_data.shortcuts):
shortcut.text = self.data.get_text(self.get_ui_text_name(i))
saved_file_path = self.get_data_path()
if self.shelf_data != None:
ShelfData.save(self.shelf_data, saved_file_path)
else:
unreal.log_warning("data null")
def clear_shelf(self):
self.shelf_data.clear()
self.update_ui()
def set_item_to_shelf(self, index, shelf_item):
if index >= len(self.shelf_data):
self.shelf_data.add(shelf_item)
else:
self.shelf_data.set(index, shelf_item)
self.update_ui()
# add shortcuts
def add_py_code_shortcut(self, index, py_code):
shelf_item = ShelfItem(icon="", drop_type=ShelfItem.ITEM_TYPE_PY_CMD)
shelf_item.py_cmd = py_code
shelf_item.text=py_code[:3]
self.set_item_to_shelf(index, shelf_item)
def add_chameleon_shortcut(self, index, chameleon_json):
short_name = os.path.basename(chameleon_json)
if short_name.lower().startswith("chameleon") and len(short_name) > 9:
short_name = short_name[9:]
shelf_item = ShelfItem(icon="", drop_type=ShelfItem.ITEM_TYPE_CHAMELEON)
shelf_item.chameleon_json = chameleon_json
shelf_item.text = short_name[:3]
self.set_item_to_shelf(index, shelf_item)
def add_actors_shortcut(self, index, actor_names):
shelf_item = ShelfItem(icon="", drop_type=ShelfItem.ITEM_TYPE_ACTOR)
shelf_item.actors = actor_names
shelf_item.text = shelf_item.actors[0][:3] if shelf_item.actors else ""
shelf_item.text += str(len(shelf_item.actors))
self.set_item_to_shelf(index, shelf_item)
def add_assets_shortcut(self, index, assets):
shelf_item = ShelfItem(icon="", drop_type=ShelfItem.ITEM_TYPE_ASSETS)
shelf_item.assets = assets
if assets:
first_asset = unreal.load_asset(assets[0])
if first_asset:
shelf_item.text = f"{first_asset.get_name()[:3]}{str(len(shelf_item.assets)) if len(shelf_item.assets)>1 else ''}"
else:
shelf_item.text = "None"
else:
shelf_item.text = ""
self.set_item_to_shelf(index, shelf_item)
def add_folders_shortcut(self, index, folders):
shelf_item = ShelfItem(icon="", drop_type=ShelfItem.ITEM_TYPE_ASSETS_FOLDER)
shelf_item.folders = folders
if folders:
shelf_item.text = f"{(os.path.basename(folders[0]))[:3]}{str(len(folders)) if len(folders)>1 else ''}"
else:
shelf_item.text = ""
self.set_item_to_shelf(index, shelf_item)
def get_dropped_by_type(self, *args, **kwargs):
py_cmd = kwargs.get("text", "")
file_names = kwargs.get("files", None)
if file_names:
json_files = [n for n in file_names if n.lower().endswith(".json")]
chameleon_json = json_files[0] if json_files else ""
else:
chameleon_json = ""
actors = kwargs.get("actors", [])
assets = kwargs.get("assets", [])
folders = kwargs.get("assets_folders", [])
return py_cmd, chameleon_json, actors, assets, folders
def on_drop(self, id, *args, **kwargs):
print(f"OnDrop: id:{id} {kwargs}")
py_cmd, chameleon_json, actors, assets, folders = self.get_dropped_by_type(*args, **kwargs)
if chameleon_json:
self.add_chameleon_shortcut(id, chameleon_json)
elif py_cmd:
self.add_py_code_shortcut(id, py_cmd)
elif actors:
self.add_actors_shortcut(id, actors)
elif assets:
self.add_assets_shortcut(id, assets)
elif folders:
self.add_folders_shortcut(id, folders)
else:
print("Drop python snippet, chameleon json, actors or assets.")
def on_drop_last(self, *args, **kwargs):
print(f"on drop last: {args}, {kwargs}")
if len(self.shelf_data) <= Shelf.MAXIMUM_ICON_COUNT:
self.on_drop(len(self.shelf_data) + 1, *args, **kwargs)
def select_actors(self, actor_names):
actors = [unreal.PythonBPLib.find_actor_by_name(name) for name in actor_names]
unreal.PythonBPLib.select_none()
for i, actor in enumerate(actors):
if actor:
unreal.PythonBPLib.select_actor(actor, selected=True, notify=True, force_refresh= i == len(actors)-1)
def select_assets(self, assets):
exists_assets = [asset for asset in assets if unreal.EditorAssetLibrary.does_asset_exist(asset)]
unreal.PythonBPLib.set_selected_assets_by_paths(exists_assets)
def select_assets_folders(self, assets_folders):
print(f"select_assets_folders: {assets_folders}")
unreal.PythonBPLib.set_selected_folder(assets_folders)
def on_button_click(self, id):
shortcut = self.shelf_data.shortcuts[id]
if not shortcut:
unreal.log_warning("shortcut == None")
return
if shortcut.drop_type == ShelfItem.ITEM_TYPE_PY_CMD:
eval(shortcut.py_cmd)
elif shortcut.drop_type == ShelfItem.ITEM_TYPE_CHAMELEON:
unreal.ChameleonData.launch_chameleon_tool(shortcut.chameleon_json)
elif shortcut.drop_type == ShelfItem.ITEM_TYPE_ACTOR:
self.select_actors(shortcut.actors) # do anything what you want
elif shortcut.drop_type == ShelfItem.ITEM_TYPE_ASSETS:
self.select_assets(shortcut.assets)
elif shortcut.drop_type == ShelfItem.ITEM_TYPE_ASSETS_FOLDER:
self.select_assets_folders(shortcut.folders)
class ShelfItem:
ITEM_TYPE_NONE = 0
ITEM_TYPE_PY_CMD = 1
ITEM_TYPE_CHAMELEON = 2
ITEM_TYPE_ACTOR = 3
ITEM_TYPE_ASSETS = 4
ITEM_TYPE_ASSETS_FOLDER = 5
def __init__(self, drop_type, icon=""):
self.drop_type = drop_type
self.icon = icon
self.py_cmd = ""
self.chameleon_json = ""
self.actors = []
self.assets = []
self.folders = []
self.text = ""
def get_tool_tips(self):
if self.drop_type == ShelfItem.ITEM_TYPE_PY_CMD:
return f"PyCmd: {self.py_cmd}"
elif self.drop_type == ShelfItem.ITEM_TYPE_CHAMELEON:
return f"Chameleon Tools: {os.path.basename(self.chameleon_json)}"
elif self.drop_type == ShelfItem.ITEM_TYPE_ACTOR:
return f"{len(self.actors)} actors: {self.actors}"
elif self.drop_type == ShelfItem.ITEM_TYPE_ASSETS:
return f"{len(self.assets)} actors: {self.assets}"
elif self.drop_type == ShelfItem.ITEM_TYPE_ASSETS_FOLDER:
return f"{len(self.folders)} folders: {self.folders}"
class ShelfData:
def __init__(self):
self.shortcuts = []
def __len__(self):
return len(self.shortcuts)
def add(self, item):
assert isinstance(item, ShelfItem)
self.shortcuts.append(item)
def set(self, index, item):
assert isinstance(item, ShelfItem)
self.shortcuts[index] = item
def clear(self):
self.shortcuts.clear()
@staticmethod
def save(shelf_data, file_path):
with open(file_path, 'w') as f:
f.write(json.dumps(shelf_data, default=lambda o: o.__dict__, sort_keys=True, indent=4))
print(f"Shelf data saved: {file_path}")
@staticmethod
def load(file_path):
if not os.path.exists(file_path):
return None
with open(file_path, 'r') as f:
content = json.load(f)
instance = ShelfData()
instance.shortcuts = []
for item in content["shortcuts"]:
shelf_item = ShelfItem(item["drop_type"], item["icon"])
shelf_item.py_cmd = item["py_cmd"]
shelf_item.chameleon_json = item["chameleon_json"]
shelf_item.text = item["text"]
shelf_item.actors = item["actors"]
shelf_item.assets = item["assets"]
shelf_item.folders = item["folders"]
instance.shortcuts.append(shelf_item)
return instance
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
""" An example script that uses the API and
HoudiniEngineV2.asyncprocessor.ProcessHDA. ProcessHDA is configured with the
asset to instantiate, as well as 2 inputs: a geometry input (a cube) and a
curve input (a helix).
ProcessHDA is then activiated upon which the asset will be instantiated,
inputs set, and cooked. The ProcessHDA class's on_post_processing() function is
overridden to fetch the input structure and logged. The other state/phase
functions (on_pre_instantiate(), on_post_instantiate() etc) are overridden to
simply log the function name, in order to observe progress in the log.
"""
import math
import unreal
from HoudiniEngineV2.asyncprocessor import ProcessHDA
_g_processor = None
class ProcessHDAExample(ProcessHDA):
@staticmethod
def _print_api_input(in_input):
print('\t\tInput type: {0}'.format(in_input.__class__))
print('\t\tbKeepWorldTransform: {0}'.format(in_input.keep_world_transform))
print('\t\tbImportAsReference: {0}'.format(in_input.import_as_reference))
if isinstance(in_input, unreal.HoudiniPublicAPIGeoInput):
print('\t\tbPackBeforeMerge: {0}'.format(in_input.pack_before_merge))
print('\t\tbExportLODs: {0}'.format(in_input.export_lo_ds))
print('\t\tbExportSockets: {0}'.format(in_input.export_sockets))
print('\t\tbExportColliders: {0}'.format(in_input.export_colliders))
elif isinstance(in_input, unreal.HoudiniPublicAPICurveInput):
print('\t\tbCookOnCurveChanged: {0}'.format(in_input.cook_on_curve_changed))
print('\t\tbAddRotAndScaleAttributesOnCurves: {0}'.format(in_input.add_rot_and_scale_attributes_on_curves))
input_objects = in_input.get_input_objects()
if not input_objects:
print('\t\tEmpty input!')
else:
print('\t\tNumber of objects in input: {0}'.format(len(input_objects)))
for idx, input_object in enumerate(input_objects):
print('\t\t\tInput object #{0}: {1}'.format(idx, input_object))
if hasattr(in_input, 'supports_transform_offset') and in_input.supports_transform_offset():
print('\t\t\tObject Transform Offset: {0}'.format(in_input.get_input_object_transform_offset(idx)))
if isinstance(input_object, unreal.HoudiniPublicAPICurveInputObject):
print('\t\t\tbClosed: {0}'.format(input_object.is_closed()))
print('\t\t\tCurveMethod: {0}'.format(input_object.get_curve_method()))
print('\t\t\tCurveType: {0}'.format(input_object.get_curve_type()))
print('\t\t\tReversed: {0}'.format(input_object.is_reversed()))
print('\t\t\tCurvePoints: {0}'.format(input_object.get_curve_points()))
def on_failure(self):
print('on_failure')
global _g_processor
_g_processor = None
def on_complete(self):
print('on_complete')
global _g_processor
_g_processor = None
def on_pre_instantiation(self):
print('on_pre_instantiation')
def on_post_instantiation(self):
print('on_post_instantiation')
def on_post_auto_cook(self, cook_success):
print('on_post_auto_cook, success = {0}'.format(cook_success))
def on_pre_process(self):
print('on_pre_process')
def on_post_processing(self):
print('on_post_processing')
# Fetch inputs, iterate over it and log
node_inputs = self.asset_wrapper.get_inputs_at_indices()
parm_inputs = self.asset_wrapper.get_input_parameters()
if not node_inputs:
print('No node inputs found!')
else:
print('Number of node inputs: {0}'.format(len(node_inputs)))
for input_index, input_wrapper in node_inputs.items():
print('\tInput index: {0}'.format(input_index))
self._print_api_input(input_wrapper)
if not parm_inputs:
print('No parameter inputs found!')
else:
print('Number of parameter inputs: {0}'.format(len(parm_inputs)))
for parm_name, input_wrapper in parm_inputs.items():
print('\tInput parameter name: {0}'.format(parm_name))
self._print_api_input(input_wrapper)
def on_post_auto_bake(self, bake_success):
print('on_post_auto_bake, succes = {0}'.format(bake_success))
def get_test_hda_path():
return '/project/.copy_to_curve_1_0'
def get_test_hda():
return unreal.load_object(None, get_test_hda_path())
def get_geo_asset_path():
return '/project/.Cube'
def get_geo_asset():
return unreal.load_object(None, get_geo_asset_path())
def build_inputs():
print('configure_inputs')
# get the API singleton
houdini_api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
node_inputs = {}
# Create a geo input
geo_input = houdini_api.create_empty_input(unreal.HoudiniPublicAPIGeoInput)
# Set the input objects/assets for this input
geo_object = get_geo_asset()
geo_input.set_input_objects((geo_object, ))
# store the input data to the HDA as node input 0
node_inputs[0] = geo_input
# Create a curve input
curve_input = houdini_api.create_empty_input(unreal.HoudiniPublicAPICurveInput)
# Create a curve wrapper/helper
curve_object = unreal.HoudiniPublicAPICurveInputObject(curve_input)
# Make it a Nurbs curve
curve_object.set_curve_type(unreal.HoudiniPublicAPICurveType.NURBS)
# Set the points of the curve, for this example we create a helix
# consisting of 100 points
curve_points = []
for i in range(100):
t = i / 20.0 * math.pi * 2.0
x = 100.0 * math.cos(t)
y = 100.0 * math.sin(t)
z = i
curve_points.append(unreal.Transform([x, y, z], [0, 0, 0], [1, 1, 1]))
curve_object.set_curve_points(curve_points)
# Set the curve wrapper as an input object
curve_input.set_input_objects((curve_object, ))
# Store the input data to the HDA as node input 1
node_inputs[1] = curve_input
return node_inputs
def run():
# Create the processor with preconfigured inputs
global _g_processor
_g_processor = ProcessHDAExample(
get_test_hda(), node_inputs=build_inputs())
# Activate the processor, this will starts instantiation, and then cook
if not _g_processor.activate():
unreal.log_warning('Activation failed.')
else:
unreal.log('Activated!')
if __name__ == '__main__':
run()
|
import unreal
import os
path = "/project/ - Technicolor\HDRI_WITH_hdriS"
tasks = []
def buildImportTask(destination_path,filename,destination_name):
task = unreal.AssetImportTask()
task.set_editor_property('automated',True)
task.set_editor_property('destination_name', destination_name)
task.set_editor_property('destination_path', destination_path)
task.set_editor_property('filename',filename)
task.set_editor_property('replace_existing', False)
task.set_editor_property('save', False)
return task
def execute(tasks):
unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks(tasks)
# buildImportTask
for i in os.listdir(path):
f = os.path.join(path, i)
if(os.path.isfile(f)):
continue
for k in os.listdir(f):
if(k.endswith(".hdr")):
print(k)
fullpath = os.path.join(f, k)
task = buildImportTask('/project/',fullpath,i)
tasks.append(task)
execute(tasks)
|
import unreal
dirAnimBP = '/project/'
dirNew = dirAnimBP.replace('CH_M_NA_10','Master')
dirAnimBP = str(dirAnimBP)
print(dirAnimBP.replace('CH_M_NA_10','Master'))
bpAnimBP = unreal.EditorAssetLibrary.load_asset(dirAnimBP)
bpCloned = unreal.EditorAssetLibrary.duplicate_asset(dirAnimBP,dirNew)
#bpCloned1 = unreal.EditorAssetLibrary.load_asset(dirNew)
A = bpCloned.get_editor_property("target_skeleton")
#bpCloneAnimBP = unreal.EditorAssetLibrary.load_asset(bpAnimBP)
#for i in bs_assets_list:
# num_sample = i.get_editor_property("sample_data")
# num_count = len(num_sample)
# if num_count == 0:
# print (num_count)
|
import unreal
#Import classes
actor_subsystem = unreal.EditorActorSubsystem()
gameplay_statics = unreal.GameplayStatics()
#Get selected actors
selected_actors = actor_subsystem.get_selected_level_actors()
#Initialize min and max vectors with extreme values, and origin with 0 values
min_vector = unreal.Vector(float('inf'), float('inf'), float('inf'))
max_vector = unreal.Vector(float('-inf'), float('-inf'), float('-inf'))
total_x = 0.0
total_y = 0.0
total_z = 0.0
#Iterate over the actor to find the outermost points
for actor in selected_actors:
#Look for the DatasmithActor class
actor_location = actor.get_actor_location()
total_x = total_x + actor_location.x
total_y = total_y + actor_location.y
total_z = total_z + actor_location.z
#Update the min and max vectors
min_vector.x = min(min_vector.x, actor_location.x)
min_vector.y = min(min_vector.y, actor_location.y)
min_vector.z = min(min_vector.z, actor_location.z)
max_vector.x = max(max_vector.x, actor_location.x)
max_vector.y = max(max_vector.y, actor_location.y)
max_vector.z = max(max_vector.z, actor_location.z)
vertices = [
unreal.Vector(min_vector.x, min_vector.y, min_vector.z),
unreal.Vector(max_vector.x, min_vector.y, min_vector.z),
unreal.Vector(min_vector.x, max_vector.y, min_vector.z),
unreal.Vector(min_vector.x, min_vector.y, max_vector.z),
unreal.Vector(max_vector.x, max_vector.y, min_vector.z),
unreal.Vector(min_vector.z, max_vector.y, max_vector.z),
unreal.Vector(max_vector.x, min_vector.y, max_vector.z),
unreal.Vector(max_vector.x, max_vector.y, max_vector.z)
]
# The dimensions of the box are the differences between the max and min vectors
dimensions_x = max_vector.x - min_vector.x
dimensions_y = max_vector.y - min_vector.y
dimensions_z = max_vector.z - min_vector.z
# Print the dimensions
print("Dimensions in X: ", dimensions_x)
print("Dimensions in Y: ", dimensions_y)
print("Dimensions in Z: ", dimensions_z)
# Calculate the midpoint (origin) of the bounding box
origin_x = (min_vector.x + max_vector.x) / 2.0
origin_y = (min_vector.y + max_vector.y) / 2.0
origin_z = (min_vector.z + max_vector.z) / 2.0
origin = unreal.Vector(origin_x, origin_y, origin_z)
x = total_x / len(selected_actors)
y = total_y / len(selected_actors)
z = total_z / len(selected_actors)
# Print the origin
print("(X={},Y={},Z={})".format(x, y, z))
|
# If you've somehow found this in your ai journey, don't judge my bad code! I worked 18h straight to get this ready for an update lol...
# Clean will happen later!
#!-!-!-!-!-!-!-!-!-!-!-!-!-!-#
#####
######## IMPORTS
#####
import unreal
import os
import sys
import shutil
print('ai_backups.py has started')
# copy_tree might be used instead of shutil.copytree at some point.
from distutils.dir_util import copy_tree
#!-!-!-!-!-!-!-!-!-!-!-!-!-!-#
#####
######## VARIABLES
#####
######## PATHS
#####
paths_unreal_content_dir = unreal.Paths.convert_relative_path_to_full(unreal.Paths.engine_content_dir())
paths_unreal_plugins_dir = unreal.Paths.convert_relative_path_to_full(unreal.Paths.engine_plugins_dir())
paths_vis_main_contents_dir = paths_unreal_content_dir + "Python"
paths_vis_ai_dir = paths_vis_main_contents_dir + "/ai"
paths_vis_ai_savedata_dir = paths_vis_ai_dir + '/saved'
paths_vis_ai_template_live_dir = unreal.Paths.project_content_dir() + "Vis/project/"
paths_vis_ai_template_test_file = "/VisAI_HealthAndDamage_Temp_C.uasset"
paths_vis_ai_template_test_file_full = paths_vis_ai_template_live_dir + "/Base" + paths_vis_ai_template_test_file
paths_vis_ai_template_backup_dir = paths_unreal_plugins_dir + "vis/Template/"
paths_vis_ai_subsystem_savedata_file = paths_vis_ai_savedata_dir + "/subsystemdata.ai"
paths_vis_ai_original_subsystem_savedata_file = unreal.Paths.project_content_dir() + "Vis/project/.ai"
paths_vis_ai_new_version_indicator_file = paths_vis_ai_savedata_dir + "/new_version_indicator.ai"
######## FILE NAMES
#####
#!-!-!-!-!-!-!-!-!-!-!-!-!-!-#
#####
######## FUNCTIONS
#####
######## COPYTREE THAT WORKS BETTER
#####
def vis_copytree(src, dst, symlinks=False, ignore=None):
for item in os.listdir(src):
s = os.path.join(src, item)
d = os.path.join(dst, item)
if os.path.isdir(s):
shutil.copytree(s, d, symlinks, ignore)
else:
shutil.copy(s, d)
######## ADD NEW SUBSYSTEM TO DATA
#####
def add_new_subsystem_to_data(subsystemName, subsystemNamingConvention):
# If file doesn't exist
if not os.path.isfile(paths_vis_ai_subsystem_savedata_file):
# Create new file, write subsystem data to file
anstd_local_subsystem_data_file = open(paths_vis_ai_subsystem_savedata_file, "w+")
anstd_local_subsystem_data_file.write(subsystemName + "," + subsystemNamingConvention + "\n")
anstd_local_subsystem_data_file.close()
else:
# Append to current subsystem data
anstd_local_subsystem_data_file = open(paths_vis_ai_subsystem_savedata_file, "a+")
anstd_local_subsystem_data_file.write(subsystemName + "," + subsystemNamingConvention + "\n")
anstd_local_subsystem_data_file.close()
######## READ SUBSYSTEM DATA FILE
#####
def read_subsystem_data_file():
rsdf_local_contents = ""
# Read and return contents
if os.path.isfile(paths_vis_ai_subsystem_savedata_file):
rsdf_local_subsystem_data_file = open(paths_vis_ai_subsystem_savedata_file, "r")
rsdf_local_contents = rsdf_local_subsystem_data_file.read()
rsdf_local_subsystem_data_file.close()
return rsdf_local_contents
else:
return rsdf_local_contents
######## READ ALL SUBSYSTEM NAMES
#####
def read_all_subsystem_names():
# Data
rasn_names_list = ['']
rasn_subsystemdata = read_subsystem_data_file()
rasn_subsystemsdata_parsed = rasn_subsystemdata.split("\n")
# Loop through and get all names, add to a list
for i in rasn_subsystemsdata_parsed:
rasn_x = i.split(',')
rasn_name = rasn_x[0]
rasn_names_list.append(rasn_name)
# Clean up data
del rasn_names_list[0]
del rasn_names_list[-1]
# Return Data
return rasn_names_list
######## READ ALL NAMING CONVENTIONS
#####
def read_all_subsystem_naming_conventions():
# Data
rasn_names_list = ['']
rasn_subsystemdata = read_subsystem_data_file()
rasn_subsystemsdata_parsed = rasn_subsystemdata.split("\n")
# Loop through and get all names, add to a list
for i in rasn_subsystemsdata_parsed:
rasn_x = i.split(',')
rasn_name = rasn_x[-1]
rasn_names_list.append(rasn_name)
# Clean up data
del rasn_names_list[0]
del rasn_names_list[-1]
# Return Data
return rasn_names_list
######## READ SUBSYSTEM NAMING CONVENTION
#####
def read_subsystem_naming_convention(subsystemName = ""):
rsnc_subsystem_name_index = read_all_subsystem_names().index(subsystemName)
rsnc_subsystem_name = read_all_subsystem_naming_conventions()[rsnc_subsystem_name_index]
return rsnc_subsystem_name
######## BACKUP VISAI TEMPLATE FILES
#####
def backup_visai_template():
if os.path.isdir(paths_vis_ai_template_live_dir):
#If current backup template exists, remove it (for updates). This should be changed to a version check instead.
if os.path.isdir(paths_vis_ai_template_backup_dir):
shutil.rmtree(paths_vis_ai_template_backup_dir)
# Copy live files to backup
shutil.copytree(paths_vis_ai_template_live_dir, paths_vis_ai_template_backup_dir)
if os.path.isdir(paths_vis_ai_template_backup_dir):
return True
else:
return False
######## BACKUP VISAI TEMPLATE FILES
#####
def restore_visai_template():
#need to make this a try
#shutil.rmtree(paths_vis_ai_template_live_dir)
shutil.copytree(paths_vis_ai_template_backup_dir, paths_vis_ai_template_live_dir)
if os.path.isdir(paths_vis_ai_template_live_dir):
return True
else:
return False
#!-!-!-!-!-!-!-!-!-!-!-!-!-!-#
#####
######## THE APP
#####
######## BACKUP VISAI TEMPLATE FILES
#####
#backup_visai_template()
# this is borken
# need to make it check if template *asset* doesn't exist in the folder, and verify there's a current template ready. ,
# before that, need to have a way to properly deal with references.
# if not os.path.isfile(paths_vis_ai_template_test_file_full):
# if unreal.Paths.directory_exists(paths_vis_ai_template_backup_dir):
# restore_visai_template()
print('ai_backups.py has initialized')
# - EOF - #
# print(read_subsystem_naming_convention("Subsystem Name"))
# to use this in unreal, do;
# to read a naming convention;
# unreal.log(read_subsystem_naming_convention("Subsystem Name"))
# to add a subsystem;
# add_new_subsystem_to_data("ThisTest", "TST")
|
# Copyright Epic Games, Inc. All Rights Reserved.
import re
import unreal
import flow.cmd
import unrealcmd
import uelogprinter
import unreal.cmdline
#-------------------------------------------------------------------------------
class _CookPrettyPrinter(uelogprinter.Printer):
def __init__(self):
super().__init__()
self._cook_re = re.compile(r"ages (\d+).+otal (\d+)")
def _print(self, line):
m = self._cook_re.search(line)
if m:
percent = (int(m.group(1)) * 100) // max(int(m.group(2)), 1)
line += f" [{percent}%]"
super()._print(line)
#-------------------------------------------------------------------------------
class _Cook(unrealcmd.MultiPlatformCmd):
cookargs = unrealcmd.Arg([str], "Additional arguments passed to the cook commandlet")
cultures = unrealcmd.Opt("en", "Cultures to cook (comma separated, defaults to 'en')")
onthefly = unrealcmd.Opt(False, "Launch as an on-the-fly server")
iterate = unrealcmd.Opt(False, "Cook iteratively on top of the previous cook")
noxge = unrealcmd.Opt(False, "Disable XGE-based shader compilation")
unpretty = unrealcmd.Opt(False, "Turns off colourful pretty-printing")
attach = unrealcmd.Opt(False, "Attach a debugger to the cook")
debug = unrealcmd.Opt(False, "Use debug executables")
@unrealcmd.Cmd.summarise
def _cook(self, cook_form, exec_context=None):
ue_context = self.get_unreal_context()
# Check there is a valid project
project = ue_context.get_project()
if not project:
self.print_error("An active project is required to cook")
return False
# Prepare arguments
cultures = self.args.cultures.replace(",", "+")
commandlet_args = (
"-targetplatform=" + cook_form,
"-cookcultures=" + cultures if cultures else None,
"-unattended",
"-unversioned",
"-stdout",
"-cookonthefly" if self.args.onthefly else None,
"-iterate" if self.args.iterate else None,
"-noxgeshadercompile" if self.args.noxge else None,
*unreal.cmdline.read_ueified(*self.args.cookargs),
)
commandlet_args = tuple(x for x in commandlet_args if x)
# To support attaching a debugger we will reuse '.run commandlet'. This
# approach is not used normally as it interferes with pretty-printing and
# creates an awful lot of child processes.
if self.args.attach:
args = ("_run", "commandlet", "cook", "--noplatforms", "--attach")
if self.args.debug:
args = (*args, "debug")
args = (*args, "--", *commandlet_args)
# Disable our handling of Ctrl-C
import signal
def nop_handler(*args): pass
signal.signal(signal.SIGINT, nop_handler)
import subprocess
return subprocess.run(args).returncode
# Find the editor binary
target = ue_context.get_target_by_type(unreal.TargetType.EDITOR)
variant = unreal.Variant.DEBUG if self.args.debug else unreal.Variant.DEVELOPMENT
build = target.get_build(variant=variant)
if not build:
self.print_error(f"No {variant.name.lower()} editor build found")
return False
cmd = str(build.get_binary_path())
if not cmd.endswith("-Cmd.exe"):
cmd = cmd.replace(".exe", "-Cmd.exe")
# Launch
args = (
project.get_path(),
"-run=cook",
*commandlet_args,
)
exec_context = exec_context or self.get_exec_context()
cmd = exec_context.create_runnable(cmd, *args)
if self.args.unpretty or not self.is_interactive():
cmd.run()
else:
printer = _CookPrettyPrinter()
printer.run(cmd)
return cmd.get_return_code()
#-------------------------------------------------------------------------------
class Cook(_Cook):
""" Prepares a cooked meal of dataset for the given target platform """
target = unrealcmd.Arg(str, "Full target platform name (i.e. WindowsNoEditor)")
def main(self):
return self._cook(self.args.target)
#-------------------------------------------------------------------------------
class _Runtime(_Cook):
platform = unrealcmd.Arg("", "The platform to cook data for")
def main(self, target):
platform = self.args.platform
if not platform:
platform = unreal.Platform.get_host()
platform = self.get_platform(platform)
exec_context = super().get_exec_context()
exec_env = exec_context.get_env()
# Establish target platform's environment
name = platform.get_name()
self.print_info(name, "-", platform.get_version())
for item in platform.read_env():
try:
dir = str(item)
exec_env[item.key] = dir
except EnvironmentError:
dir = flow.cmd.text.red(item.get())
print(item.key, "=", dir)
cook_form = platform.get_cook_form(target.name.lower())
return self._cook(cook_form, exec_context)
#-------------------------------------------------------------------------------
class Game(_Runtime):
""" Cooks game data for a particular platform """
def main(self):
return super().main(unreal.TargetType.GAME)
#-------------------------------------------------------------------------------
class Client(_Runtime):
""" Cooks client data for a particular platform """
def main(self):
return super().main(unreal.TargetType.CLIENT)
#-------------------------------------------------------------------------------
class Server(_Runtime):
""" Cooks server data for a particular platform """
complete_platform = ("win64", "linux")
def main(self):
return super().main(unreal.TargetType.SERVER)
|
import unreal
MAPS_PATH = '/project/'
CLIENT_SWITCH_FORM_MAP = 'ClientSwitchForm'
CLIENTS_PLAYGROUND_MAP = 'ClientsPlayground'
def open(name: str):
unreal.EditorLoadingAndSavingUtils.load_map(MAPS_PATH + name)
def open_form():
open(name=CLIENT_SWITCH_FORM_MAP)
def open_playground():
open(name=CLIENTS_PLAYGROUND_MAP)
def switch():
load_destinations = {
CLIENT_SWITCH_FORM_MAP: CLIENTS_PLAYGROUND_MAP,
CLIENTS_PLAYGROUND_MAP: CLIENT_SWITCH_FORM_MAP,
}
world = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem).get_editor_world()
name = world.get_name()
open(load_destinations.get(name, CLIENT_SWITCH_FORM_MAP))
|
# SPDX-FileCopyrightText: 2018-2025 Xavier Loux (BleuRaven)
#
# SPDX-License-Identifier: GPL-3.0-or-later
# ----------------------------------------------
# Blender For UnrealEngine
# https://github.com/project/-For-UnrealEngine-Addons
# ----------------------------------------------
import os.path
from typing import List, Dict, Any, Optional, Tuple
from pathlib import Path
import unreal
from . import bpl
from . import import_module_utils
from . import import_module_unreal_utils
from . import import_module_post_treatment
from . import import_module_tasks_class
from . import import_module_tasks_helper
from . import bfu_import_animations
from . import bfu_import_lods
from . import bfu_import_materials
from . import bfu_import_vertex_color
from . import bfu_import_light_map
from . import bfu_import_nanite
from . import config
from .asset_types import ExportAssetType, AssetFileTypeEnum
def ready_for_asset_import():
if not import_module_unreal_utils.alembic_importer_active():
message = 'WARNING: Alembic Importer Plugin should be activated.' + "\n"
message += 'Edit > Plugin > Importer > Alembic Importer.'
import_module_unreal_utils.show_warning_message("Alembic Importer not activated.", message)
return False
if not import_module_unreal_utils.editor_scripting_utilities_active():
message = 'WARNING: Editor Scripting Utilities Plugin should be activated.' + "\n"
message += 'Edit > Plugin > Scripting > Editor Scripting Utilities.'
import_module_unreal_utils.show_warning_message("Editor Scripting Utilities not activated.", message)
return False
return True
def import_task(asset_data: Dict[str, Any]) -> (str, Optional[List[unreal.AssetData]]):
asset_type = ExportAssetType.get_asset_type_from_string(asset_data["asset_type"])
if asset_type in [ExportAssetType.STATIC_MESH, ExportAssetType.SKELETAL_MESH]:
if "import_as_lod_mesh" in asset_data:
if asset_data["import_as_lod_mesh"] == True: # Lod should not be imported here so return if lod is not 0.
return "FAIL", None
def found_additional_data() -> Dict[str, Any]:
files: List[Dict[str, Any]] = asset_data["files"]
for file in files:
if file["content_type"] == "ADDITIONAL_DATA":
return import_module_utils.json_load_file(Path(file["file_path"]))
return {}
asset_additional_data = found_additional_data()
if asset_type.is_skeletal():
origin_skeleton = None
origin_skeletal_mesh = None
if "target_skeleton_search_ref" in asset_data:
find_sk_asset = import_module_unreal_utils.load_asset(asset_data["target_skeleton_search_ref"])
if isinstance(find_sk_asset, unreal.Skeleton):
origin_skeleton = find_sk_asset
elif isinstance(find_sk_asset, unreal.SkeletalMesh):
origin_skeleton = find_sk_asset.skeleton
origin_skeletal_mesh = find_sk_asset
if "target_skeletal_mesh_search_ref" in asset_data:
find_skm_asset = import_module_unreal_utils.load_asset(asset_data["target_skeletal_mesh_search_ref"])
if isinstance(find_skm_asset, unreal.SkeletalMesh):
origin_skeleton = find_skm_asset.skeleton
origin_skeletal_mesh = find_skm_asset
elif isinstance(find_skm_asset, unreal.Skeleton):
origin_skeletal_mesh = find_skm_asset
if asset_type in [ExportAssetType.ANIM_ACTION, ExportAssetType.ANIM_POSE, ExportAssetType.ANIM_NLA]:
skeleton_search_str = f'"target_skeleton_search_ref": {asset_data["target_skeleton_search_ref"]}'
skeletal_mesh_search_str = f'"target_skeletal_mesh_search_ref": {asset_data["target_skeletal_mesh_search_ref"]}'
if origin_skeleton:
print(f'{skeleton_search_str} and "{skeletal_mesh_search_str} "was found for animation immport:" {str(origin_skeleton)}')
else:
message = "WARNING: Could not find skeleton for animation import." + "\n"
message += f" -{skeleton_search_str}" + "\n"
message += f" -{skeletal_mesh_search_str}" + "\n"
import_module_unreal_utils.show_warning_message("Skeleton not found.", message)
itask = import_module_tasks_class.ImportTask()
def get_file_from_types(file_types: List[str]) -> Tuple[str, AssetFileTypeEnum]:
for file in asset_data["files"]:
if "type" in file and "file_path" in file:
if file["type"] in file_types:
return file["file_path"], AssetFileTypeEnum.get_file_type_from_string(file["type"])
return "", AssetFileTypeEnum.UNKNOWN
# Search for the file to import
if asset_type == ExportAssetType.ANIM_ALEMBIC:
file_name, file_type = get_file_from_types([AssetFileTypeEnum.ALEMBIC.value])
if not file_name:
return "FAIL", None
itask.set_filename(file_name)
print("Target Alembic file:", file_name)
else:
file_name, file_type = get_file_from_types([AssetFileTypeEnum.GLTF.value, AssetFileTypeEnum.FBX.value])
if not file_name:
return "FAIL", None
itask.set_filename(file_name)
print("Target file:", file_name)
itask.get_task().destination_path = "/" + os.path.normpath(asset_data["asset_import_path"])
itask.get_task().automated = config.automated_import_tasks
itask.get_task().save = False
itask.get_task().replace_existing = True
task_option = import_module_tasks_helper.init_options_data(asset_type, file_type)
print("Task options:", task_option)
itask.set_task_option(task_option)
# Alembic
if asset_type == ExportAssetType.ANIM_ALEMBIC:
import_module_utils.print_debug_step("Process Alembic")
alembic_import_data = itask.get_abc_import_settings()
alembic_import_data.static_mesh_settings.set_editor_property("merge_meshes", True)
alembic_import_data.set_editor_property("import_type", unreal.AlembicImportType.SKELETAL)
alembic_import_data.conversion_settings.set_editor_property("flip_u", False)
alembic_import_data.conversion_settings.set_editor_property("flip_v", True)
scale = asset_data["scene_unit_scale"] * asset_data["asset_global_scale"]
ue_scale = unreal.Vector(scale * 100, scale * -100, scale * 100) # Unit scale * object scale * 100
rotation = unreal.Vector(90, 0, 0)
alembic_import_data.conversion_settings.set_editor_property("scale", ue_scale)
alembic_import_data.conversion_settings.set_editor_property("rotation", rotation)
# #################################[Change]
# unreal.FbxImportUI
# https://docs.unrealengine.com/4.26/en-US/project/.html
import_module_utils.print_debug_step("Process transform and curve")
# Import transform and curve
if isinstance(itask.task_option, unreal.InterchangeGenericAssetsPipeline):
animation_pipeline = itask.get_igap_animation()
if "do_not_import_curve_with_zero" in asset_data:
animation_pipeline.set_editor_property('do_not_import_curve_with_zero', asset_data["do_not_import_curve_with_zero"])
else:
anim_sequence_import_data = itask.get_animation_import_data()
anim_sequence_import_data.import_translation = unreal.Vector(0, 0, 0)
if "do_not_import_curve_with_zero" in asset_data:
anim_sequence_import_data.set_editor_property('do_not_import_curve_with_zero', asset_data["do_not_import_curve_with_zero"])
if asset_type == ExportAssetType.ANIM_ALEMBIC:
itask.get_abc_import_settings().set_editor_property('import_type', unreal.AlembicImportType.SKELETAL)
else:
if asset_type.is_skeletal_animation():
if isinstance(itask.task_option, unreal.InterchangeGenericAssetsPipeline):
if origin_skeleton:
itask.get_igap_skeletal_mesh().set_editor_property('skeleton', origin_skeleton)
itask.get_igap_skeletal_mesh().set_editor_property('import_only_animations', True)
else:
if origin_skeleton:
itask.get_fbx_import_ui().set_editor_property('skeleton', origin_skeleton)
if asset_type == ExportAssetType.SKELETAL_MESH:
if isinstance(itask.task_option, unreal.InterchangeGenericAssetsPipeline):
if origin_skeleton:
itask.get_igap_skeletal_mesh().set_editor_property('skeleton', origin_skeleton)
# From Unreal Engine 5.1 to 5.4, the interchange pipeline still creates a new skeleton asset. #Look like a bug.
# May do a replace reference after import?
print("Skeleton set, ", origin_skeleton.get_path_name())
unreal_version = import_module_unreal_utils.get_unreal_version()
if unreal_version >= (5, 1, 0) and unreal_version <= (5, 4, 0):
print("Skeleton is set, but a new skeleton asset will be created. This is a bug with the Interchange Generic Assets Pipeline in Unreal Engine 5.1 to 5.4.")
else:
# Unreal Engine may randomly select a skeleton asset because it thinks it could be used for the skeletal mesh.
# This is a big issue and the Python API does not allow to avoid that...
# Even when I set the skeleton to None, Unreal Engine may still select a skeleton without letting the import create a new one.
itask.get_igap_skeletal_mesh().set_editor_property('skeleton', None)
print("Skeleton is not set, a new skeleton asset will be created...")
elif isinstance(itask.task_option, unreal.FbxImportUI):
if origin_skeleton:
itask.get_fbx_import_ui().set_editor_property('skeleton', origin_skeleton)
print("Skeleton set, ", origin_skeleton.get_path_name())
else:
itask.get_fbx_import_ui().set_editor_property('skeleton', None)
print("Skeleton is not set, a new skeleton asset will be created...")
import_module_utils.print_debug_step("Set Asset Type")
# Set Asset Type
if isinstance(itask.task_option, unreal.InterchangeGenericAssetsPipeline):
if asset_type == ExportAssetType.STATIC_MESH:
itask.get_igap_common_mesh().set_editor_property('force_all_mesh_as_type', unreal.InterchangeForceMeshType.IFMT_STATIC_MESH)
if asset_type == ExportAssetType.SKELETAL_MESH:
itask.get_igap_common_mesh().set_editor_property('force_all_mesh_as_type', unreal.InterchangeForceMeshType.IFMT_SKELETAL_MESH)
if asset_type.is_skeletal_animation():
itask.get_igap_common_mesh().set_editor_property('force_all_mesh_as_type', unreal.InterchangeForceMeshType.IFMT_NONE)
else:
itask.get_igap_common_mesh().set_editor_property('force_all_mesh_as_type', unreal.InterchangeForceMeshType.IFMT_NONE)
else:
if asset_type == ExportAssetType.STATIC_MESH:
itask.get_fbx_import_ui().set_editor_property('original_import_type', unreal.FBXImportType.FBXIT_STATIC_MESH)
elif asset_type.is_skeletal_animation():
itask.get_fbx_import_ui().set_editor_property('original_import_type', unreal.FBXImportType.FBXIT_ANIMATION)
else:
itask.get_fbx_import_ui().set_editor_property('original_import_type', unreal.FBXImportType.FBXIT_SKELETAL_MESH)
import_module_utils.print_debug_step("Set Material Use")
# Set Material Use
if isinstance(itask.task_option, unreal.InterchangeGenericAssetsPipeline):
if asset_type.is_skeletal_animation():
itask.get_igap_material().set_editor_property('import_materials', False)
else:
itask.get_igap_material().set_editor_property('import_materials', True)
else:
if asset_type.is_skeletal_animation():
itask.get_fbx_import_ui().set_editor_property('import_materials', False)
else:
itask.get_fbx_import_ui().set_editor_property('import_materials', True)
import_module_utils.print_debug_step("Set Texture Type")
# Set Texture Use
if isinstance(itask.task_option, unreal.InterchangeGenericAssetsPipeline):
itask.get_igap_texture().set_editor_property('import_textures', False)
else:
itask.get_fbx_import_ui().set_editor_property('import_textures', False)
if isinstance(itask.task_option, unreal.InterchangeGenericAssetsPipeline):
if asset_type.is_skeletal_animation():
itask.get_igap_animation().set_editor_property('import_animations', True)
bfu_import_animations.bfu_import_animations_utils.set_animation_sample_rate(itask, asset_additional_data, asset_type, file_type)
itask.get_igap_mesh().set_editor_property('import_skeletal_meshes', False)
itask.get_igap_mesh().set_editor_property('import_static_meshes', False)
itask.get_igap_mesh().set_editor_property('create_physics_asset',False)
else:
itask.get_igap_animation().set_editor_property('import_animations', False)
itask.get_igap_mesh().set_editor_property('import_skeletal_meshes', True)
itask.get_igap_mesh().set_editor_property('import_static_meshes', True)
if "create_physics_asset" in asset_data:
itask.get_igap_mesh().set_editor_property('create_physics_asset', asset_data["create_physics_asset"])
else:
if asset_type.is_skeletal_animation():
itask.get_fbx_import_ui().set_editor_property('import_as_skeletal',True)
itask.get_fbx_import_ui().set_editor_property('import_animations', True)
itask.get_fbx_import_ui().set_editor_property('import_mesh', False)
itask.get_fbx_import_ui().set_editor_property('create_physics_asset',False)
else:
itask.get_fbx_import_ui().set_editor_property('import_animations', False)
itask.get_fbx_import_ui().set_editor_property('import_mesh', True)
if "create_physics_asset" in asset_data:
itask.get_fbx_import_ui().set_editor_property('create_physics_asset', asset_data["create_physics_asset"])
import_module_utils.print_debug_step("Process per-modules changes")
# Vertex color
bfu_import_vertex_color.bfu_import_vertex_color_utils.apply_import_settings(itask, asset_data, asset_additional_data)
# Lods
bfu_import_lods.bfu_import_lods_utils.apply_import_settings(itask, asset_data, asset_additional_data)
# Materials
bfu_import_materials.bfu_import_materials_utils.apply_import_settings(itask, asset_data, asset_additional_data)
# Light Maps
bfu_import_light_map.bfu_import_light_map_utils.apply_import_settings(itask, asset_data, asset_additional_data)
# Nanite
bfu_import_nanite.bfu_import_nanite_utils.apply_import_settings(itask, asset_data, asset_additional_data)
if isinstance(itask.task_option, unreal.InterchangeGenericAssetsPipeline):
itask.get_igap_mesh().set_editor_property('combine_static_meshes', True)
itask.get_igap_mesh().set_editor_property('combine_skeletal_meshes', True)
# @TODO auto_generate_collision Removed with InterchangeGenericAssetsPipeline?
# I yes need also remove auto_generate_collision from the addon propertys.
itask.get_igap_mesh().set_editor_property('import_morph_targets', True)
itask.get_igap_common_mesh().set_editor_property('recompute_normals', False)
itask.get_igap_common_mesh().set_editor_property('recompute_tangents', False)
else:
if asset_type == ExportAssetType.STATIC_MESH:
# unreal.FbxStaticMeshImportData
itask.get_static_mesh_import_data().set_editor_property('combine_meshes', True)
if "auto_generate_collision" in asset_data:
itask.get_static_mesh_import_data().set_editor_property('auto_generate_collision', asset_data["auto_generate_collision"])
if asset_type.is_skeletal():
# unreal.FbxSkeletalMeshImportData
itask.get_skeletal_mesh_import_data().set_editor_property('import_morph_targets', True)
itask.get_skeletal_mesh_import_data().set_editor_property('convert_scene', True)
itask.get_skeletal_mesh_import_data().set_editor_property('normal_import_method', unreal.FBXNormalImportMethod.FBXNIM_IMPORT_NORMALS_AND_TANGENTS)
# ###############[ pre import ]################
import_module_utils.print_debug_step("Process pre import")
# Check is the file alredy exit
if asset_additional_data:
task_asset_full_path = itask.get_preview_import_refs()
find_target_asset = import_module_unreal_utils.load_asset(task_asset_full_path)
if find_target_asset:
# Vertex color
bfu_import_vertex_color.bfu_import_vertex_color_utils.apply_one_asset_settings(itask, find_target_asset, asset_additional_data)
# ###############[ import asset ]################
import_module_utils.print_debug_step("Process import asset")
if asset_type.is_skeletal_animation():
# For animation the script will import a skeletal mesh and remove after.
# If the skeletal mesh already exists, try to remove it.
asset_name = import_module_unreal_utils.clean_filename_for_unreal(asset_data["asset_name"])
asset_import_path = asset_data['asset_import_path']
asset_path = f"SkeletalMesh'/{asset_import_path}/{asset_name}.{asset_name}'"
if unreal.EditorAssetLibrary.does_asset_exist(asset_path):
old_asset = unreal.EditorAssetLibrary.find_asset_data(asset_path)
if old_asset.asset_class == "SkeletalMesh":
unreal.EditorAssetLibrary.delete_asset(asset_path)
import_module_utils.print_debug_step("Process import...")
itask.import_asset_task()
import_module_utils.print_debug_step("Import asset done!")
if len(itask.get_imported_assets()) == 0:
fail_reason = 'Error zero imported object for: ' + asset_data["asset_name"]
return fail_reason, None
# ###############[ Post treatment ]################
import_module_utils.print_debug_step("Process Post treatment")
if asset_type.is_skeletal_animation():
bfu_import_animations.bfu_import_animations_utils.apply_post_import_assets_changes(itask, asset_data, file_type)
animation = itask.get_imported_anim_sequence()
if animation:
# Preview mesh
if origin_skeletal_mesh:
import_module_post_treatment.set_sequence_preview_skeletal_mesh(animation, origin_skeletal_mesh)
else:
fail_reason = 'Error: animation not found after import!'
return fail_reason, None
if asset_type == ExportAssetType.STATIC_MESH:
if "collision_trace_flag" in asset_data:
collision_data = itask.get_imported_static_mesh().get_editor_property('body_setup')
if collision_data:
if asset_data["collision_trace_flag"] == "CTF_UseDefault":
collision_data.set_editor_property('collision_trace_flag', unreal.CollisionTraceFlag.CTF_USE_DEFAULT)
elif asset_data["collision_trace_flag"] == "CTF_UseSimpleAndComplex":
collision_data.set_editor_property('collision_trace_flag', unreal.CollisionTraceFlag.CTF_USE_SIMPLE_AND_COMPLEX)
elif asset_data["collision_trace_flag"] == "CTF_UseSimpleAsComplex":
collision_data.set_editor_property('collision_trace_flag', unreal.CollisionTraceFlag.CTF_USE_SIMPLE_AS_COMPLEX)
elif asset_data["collision_trace_flag"] == "CTF_UseComplexAsSimple":
collision_data.set_editor_property('collision_trace_flag', unreal.CollisionTraceFlag.CTF_USE_COMPLEX_AS_SIMPLE)
if asset_type == ExportAssetType.SKELETAL_MESH:
if origin_skeleton is None:
# Unreal create a new skeleton when no skeleton was selected, so addon rename it.
if import_module_unreal_utils.get_unreal_version() >= (5, 5, 0):
skeleton = itask.get_imported_skeleton()
else:
# Before Unreal Engine 5.5, the skeleton is not included in the imported assets but still created.
# So try to find using skeletal mesh name.
skeletal_mesh = itask.get_imported_skeletal_mesh()
if skeletal_mesh:
skeletal_mesh_name = skeletal_mesh.get_name()
skeletal_mesh_path = skeletal_mesh.get_path_name()
skeleton_path = skeletal_mesh_path.replace(skeletal_mesh_name, skeletal_mesh_name + "_Skeleton")
skeleton = unreal.EditorAssetLibrary.find_asset_data(skeleton_path).get_asset()
else:
skeleton = None
if skeleton:
if "target_skeleton_import_ref" in asset_data:
print("Start rename skeleton...")
unreal.EditorAssetLibrary.rename_asset(skeleton.get_path_name(), asset_data["target_skeleton_import_ref"])
else:
print("Error: export skeleton not found after import!")
print("Imported object paths:")
for path in itask.task.imported_object_paths:
print(" -", path)
if isinstance(itask.task_option, unreal.InterchangeGenericAssetsPipeline):
if asset_type == ExportAssetType.STATIC_MESH:
itask.get_igap_common_mesh().set_editor_property('recompute_normals', False)
itask.get_igap_common_mesh().set_editor_property('recompute_tangents', False)
if asset_type == ExportAssetType.SKELETAL_MESH:
itask.get_igap_common_mesh().set_editor_property('recompute_normals', False)
itask.get_igap_common_mesh().set_editor_property('recompute_tangents', False)
if "enable_skeletal_mesh_per_poly_collision" in asset_data:
itask.get_imported_skeletal_mesh().set_editor_property('enable_per_poly_collision', asset_data["enable_skeletal_mesh_per_poly_collision"])
else:
if asset_type == ExportAssetType.STATIC_MESH:
static_mesh = itask.get_imported_static_mesh()
if static_mesh:
asset_import_data = static_mesh.get_editor_property('asset_import_data')
asset_import_data.set_editor_property('normal_import_method', unreal.FBXNormalImportMethod.FBXNIM_IMPORT_NORMALS_AND_TANGENTS)
else:
print("Error: Static Mesh not found after import!")
elif asset_type == ExportAssetType.SKELETAL_MESH:
skeletal_mesh = itask.get_imported_skeletal_mesh()
if skeletal_mesh:
asset_import_data = skeletal_mesh.get_editor_property('asset_import_data')
asset_import_data.set_editor_property('normal_import_method', unreal.FBXNormalImportMethod.FBXNIM_IMPORT_NORMALS_AND_TANGENTS)
if "enable_skeletal_mesh_per_poly_collision" in asset_data:
skeletal_mesh.set_editor_property('enable_per_poly_collision', asset_data["enable_skeletal_mesh_per_poly_collision"])
else:
print("Error: Skeletal Mesh not found after import!")
# Socket
if asset_type == ExportAssetType.SKELETAL_MESH:
# Import the SkeletalMesh socket(s)
sockets_to_add = asset_additional_data["Sockets"]
for socket in sockets_to_add:
old_socket = itask.get_imported_skeletal_mesh().find_socket(socket["SocketName"])
if old_socket:
# Edit socket
pass
# old_socket.relative_location = socket["Location"]
# old_socket.relative_rotation = socket["Rotation"]
# old_socket.relative_scale = socket["Scale"]
else:
# Create socket
pass
# new_socket = unreal.SkeletalMeshSocket(asset)
# new_socket.socket_name = socket["SocketName"]
# new_socket.bone_name = socket["BoneName"]
# new_socket.relative_location = socket["Location"]
# new_socket.relative_rotation = socket["Rotation"]
# new_socket.relative_scale = socket["Scale"]
# NEED UNREAL ENGINE IMPLEMENTATION IN PYTHON API.
# skeleton.add_socket(new_socket)
import_module_utils.print_debug_step("Process per-modules apply asset settings")
# Vertex color
bfu_import_vertex_color.bfu_import_vertex_color_utils.apply_asset_settings(itask, asset_additional_data)
# Lods
bfu_import_lods.bfu_import_lods_utils.apply_asset_settings(itask, asset_additional_data)
# Materials
bfu_import_materials.bfu_import_materials_utils.apply_asset_settings(itask, asset_additional_data)
# Light maps
bfu_import_light_map.bfu_import_light_map_utils.apply_asset_settings(itask, asset_additional_data)
# Nanite
bfu_import_nanite.bfu_import_nanite_utils.apply_asset_settings(itask, asset_additional_data)
if asset_type == ExportAssetType.ANIM_ALEMBIC:
pass
# @TODO Need to found how create an physical asset, generate bodies, and assign it.
"""
skeletal_mesh_path = itask.GetImportedSkeletalMeshAsset().get_path_name()
path = skeletal_mesh_path.rsplit('/', 1)[0]
name = skeletal_mesh_path.rsplit('/', 1)[1] + "_Physics"
physical_asset_factory = unreal.PhysicsAssetFactory()
physical_asset = unreal.AssetToolsHelpers.get_asset_tools().create_asset(
asset_name=name,
package_path=path,
asset_class=unreal.PhysicsAsset,
factory=physical_asset_factory
)
"""
# #################################[EndChange]
return "SUCCESS", itask.get_imported_assets()
def import_all_assets(assets_data: Dict[str, Any], show_finished_popup: bool = True):
import_counter = 0
imported_list = []
import_fail_list = []
def get_asset_by_type(types: List[str]) -> List[Dict[str, Any]]:
target_assets: List[Dict[str, Any]] = []
for asset in assets_data["assets"]:
if asset["asset_type"] in types:
target_assets.append(asset)
return target_assets
def prepare_import_task(asset_data: Dict[str, Any]):
nonlocal import_counter
bpl.advprint.print_separator()
counter = str(import_counter + 1) + "/" + str(len(assets_data["assets"]))
asset_name = asset_data["asset_name"]
import_task_message = f"Import asset {counter}: '{asset_name}'"
print("###", import_task_message)
result, assets = import_task(asset_data)
if result == "SUCCESS":
imported_list.append([assets, asset_data["asset_type"]])
else:
import_fail_list.append(result)
import_counter += 1
bpl.advprint.print_separator()
# Process import
bpl.advprint.print_simple_title("Import started !")
counter = bpl.utils.CounterTimer()
# Import assets with a specific order
for asset_data in get_asset_by_type(["AlembicAnimation", "GroomSimulation", "Spline", "Camera"]):
prepare_import_task(asset_data)
for asset_data in get_asset_by_type(["StaticMesh", "CollectionStaticMesh"]):
prepare_import_task(asset_data)
for asset_data in get_asset_by_type(["SkeletalMesh"]):
prepare_import_task(asset_data)
for asset_data in get_asset_by_type(["SkeletalAnimation", "Action", "Pose", "NonLinearAnimation"]):
prepare_import_task(asset_data)
bpl.advprint.print_simple_title("Full import completed !")
# import result
StaticMesh_ImportedList = []
SkeletalMesh_ImportedList = []
Alembic_ImportedList = []
Animation_ImportedList = []
for inport_data in imported_list:
assets = inport_data[0]
source_asset_type = ExportAssetType.get_asset_type_from_string(inport_data[1])
if source_asset_type == ExportAssetType.STATIC_MESH:
StaticMesh_ImportedList.append(assets)
elif source_asset_type == ExportAssetType.SKELETAL_MESH:
SkeletalMesh_ImportedList.append(assets)
elif source_asset_type == ExportAssetType.ANIM_ALEMBIC:
Alembic_ImportedList.append(assets)
else:
Animation_ImportedList.append(assets)
import_log = []
import_log.append('Imported StaticMesh: '+str(len(StaticMesh_ImportedList)))
import_log.append('Imported SkeletalMesh: '+str(len(SkeletalMesh_ImportedList)))
import_log.append('Imported Alembic: '+str(len(Alembic_ImportedList)))
import_log.append('Imported Animation: '+str(len(Animation_ImportedList)))
import_log.append('Import failled: '+str(len(import_fail_list)))
for import_row in import_log:
print(import_row)
for error in import_fail_list:
print(error)
asset_paths = []
for assets in (StaticMesh_ImportedList + SkeletalMesh_ImportedList + Alembic_ImportedList + Animation_ImportedList):
for asset in assets:
asset_paths.append(asset.get_path_name())
if config.save_assets_after_import:
# Save asset(s) after import
for path in asset_paths:
unreal.EditorAssetLibrary.save_asset(path)
if config.select_assets_after_import:
# Select asset(s) in content browser
unreal.EditorAssetLibrary.sync_browser_to_objects(asset_paths)
title = "Import finished!"
if show_finished_popup:
if len(import_fail_list) > 0:
message = 'Some asset(s) could not be imported.' + "\n"
else:
message = 'All assets imported with success!' + "\n"
message += "Import finished in " + counter.get_str_time() + "\n"
message += "\n"
for import_row in import_log:
message += import_row + "\n"
if len(import_fail_list) > 0:
message += "\n"
for error in import_fail_list:
message += error + "\n"
import_module_unreal_utils.show_simple_message(title, message)
else:
bpl.advprint.print_simple_title(title)
bpl.advprint.print_separator()
return True
|
#!/project/ python3
"""
Simple Blueprint Creation Script
Creates WarriorCharacter blueprint with detailed logging
"""
import unreal
import sys
def main():
print("=== Starting Simple Blueprint Creation ===")
try:
# Test if we can access basic Unreal functions
print("Testing Unreal Python integration...")
editor_lib = unreal.EditorAssetLibrary
print(f"✓ EditorAssetLibrary available: {editor_lib}")
# Check if the C++ class exists
print("\nLooking for C++ WarriorCharacter class...")
try:
warrior_class = unreal.load_class(None, '/project/.WarriorCharacter')
if warrior_class:
print(f"✓ Found C++ class: {warrior_class}")
print(f"✓ Class name: {warrior_class.get_name()}")
print(f"✓ Class path: {warrior_class.get_path_name()}")
else:
print("✗ WarriorCharacter C++ class not found")
return False
except Exception as e:
print(f"✗ Error loading class: {e}")
return False
# Check if Blueprints directory exists
print("\nChecking Blueprints directory...")
blueprint_dir = "/project/"
if unreal.EditorAssetLibrary.does_directory_exist(blueprint_dir):
print(f"✓ Directory exists: {blueprint_dir}")
else:
print(f"Creating directory: {blueprint_dir}")
unreal.EditorAssetLibrary.make_directory(blueprint_dir)
# Check if blueprint already exists
blueprint_path = "/project/"
existing_bp = unreal.EditorAssetLibrary.load_asset(blueprint_path)
if existing_bp:
print(f"✓ Blueprint already exists: {blueprint_path}")
return True
# Create the blueprint
print(f"\nCreating blueprint at: {blueprint_path}")
# Get AssetTools
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
if not asset_tools:
print("✗ Could not get AssetTools")
return False
print(f"✓ AssetTools available: {asset_tools}")
# Create blueprint using different method
print("Creating blueprint using blueprint factory...")
# Get the blueprint factory
blueprint_factory = unreal.BlueprintFactory()
blueprint_factory.set_editor_property('parent_class', warrior_class)
print(f"✓ Blueprint factory created: {blueprint_factory}")
print(f"✓ Parent class set to: {blueprint_factory.get_editor_property('parent_class')}")
# Create the asset
blueprint = asset_tools.create_asset(
"WarriorCharacter",
"/project/",
unreal.Blueprint,
blueprint_factory
)
if blueprint:
print(f"✓ Blueprint created successfully!")
print(f"✓ Blueprint type: {type(blueprint)}")
print(f"✓ Blueprint path: {blueprint.get_path_name()}")
# Save the blueprint
print("Saving blueprint...")
success = unreal.EditorAssetLibrary.save_asset(blueprint.get_path_name())
print(f"Save result: {success}")
return True
else:
print("✗ create_blueprint returned None")
return False
except Exception as e:
print(f"✗ Exception in main: {e}")
import traceback
traceback.print_exc()
return False
if __name__ == "__main__":
print("Python script started")
result = main()
if result:
print("\n✓ SUCCESS: Blueprint creation completed!")
else:
print("\n✗ FAILED: Blueprint creation failed!")
print("Python script finished")
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
""" An example script that uses the API to instantiate an HDA and then
set 2 geometry inputs: one node input and one object path parameter
input. The inputs are set during post instantiation (before the first
cook). After the first cook and output creation (post processing) the
input structure is fetched and logged.
"""
import unreal
_g_wrapper = None
def get_test_hda_path():
return '/project/.subnet_test_2_0'
def get_test_hda():
return unreal.load_object(None, get_test_hda_path())
def get_geo_asset_path():
return '/project/.Cube'
def get_geo_asset():
return unreal.load_object(None, get_geo_asset_path())
def get_cylinder_asset_path():
return '/project/.Cylinder'
def get_cylinder_asset():
return unreal.load_object(None, get_cylinder_asset_path())
def configure_inputs(in_wrapper):
print('configure_inputs')
# Unbind from the delegate
in_wrapper.on_post_instantiation_delegate.remove_callable(configure_inputs)
# Deprecated input functions
# in_wrapper.set_input_type(0, unreal.HoudiniInputType.GEOMETRY)
# in_wrapper.set_input_objects(0, (get_geo_asset(), ))
# in_wrapper.set_input_type(1, unreal.HoudiniInputType.GEOMETRY)
# in_wrapper.set_input_objects(1, (get_geo_asset(), ))
# in_wrapper.set_input_import_as_reference(1, True)
# Create a geometry input
geo_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPIGeoInput)
# Set the input objects/assets for this input
geo_asset = get_geo_asset()
geo_input.set_input_objects((geo_asset, ))
# Set the transform of the input geo
geo_input.set_input_object_transform_offset(
0,
unreal.Transform(
(200, 0, 100),
(45, 0, 45),
(2, 2, 2),
)
)
# copy the input data to the HDA as node input 0
in_wrapper.set_input_at_index(0, geo_input)
# We can now discard the API input object
geo_input = None
# Create a another geometry input
geo_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPIGeoInput)
# Set the input objects/assets for this input (cylinder in this case)
geo_asset = get_cylinder_asset()
geo_input.set_input_objects((geo_asset, ))
# Set the transform of the input geo
geo_input.set_input_object_transform_offset(
0,
unreal.Transform(
(-200, 0, 0),
(0, 0, 0),
(2, 2, 2),
)
)
# copy the input data to the HDA as input parameter 'objpath1'
in_wrapper.set_input_parameter('objpath1', geo_input)
# We can now discard the API input object
geo_input = None
# Set the subnet_test HDA to output its first input
in_wrapper.set_int_parameter_value('enable_geo', 1)
def print_api_input(in_input):
print('\t\tInput type: {0}'.format(in_input.__class__))
print('\t\tbKeepWorldTransform: {0}'.format(in_input.keep_world_transform))
print('\t\tbImportAsReference: {0}'.format(in_input.import_as_reference))
if isinstance(in_input, unreal.HoudiniPublicAPIGeoInput):
print('\t\tbPackBeforeMerge: {0}'.format(in_input.pack_before_merge))
print('\t\tbExportLODs: {0}'.format(in_input.export_lo_ds))
print('\t\tbExportSockets: {0}'.format(in_input.export_sockets))
print('\t\tbExportColliders: {0}'.format(in_input.export_colliders))
input_objects = in_input.get_input_objects()
if not input_objects:
print('\t\tEmpty input!')
else:
print('\t\tNumber of objects in input: {0}'.format(len(input_objects)))
for idx, input_object in enumerate(input_objects):
print('\t\t\tInput object #{0}: {1}'.format(idx, input_object))
if hasattr(in_input, 'get_input_object_transform_offset'):
print('\t\t\tObject Transform Offset: {0}'.format(in_input.get_input_object_transform_offset(idx)))
def print_inputs(in_wrapper):
print('print_inputs')
# Unbind from the delegate
in_wrapper.on_post_processing_delegate.remove_callable(print_inputs)
# Fetch inputs, iterate over it and log
node_inputs = in_wrapper.get_inputs_at_indices()
parm_inputs = in_wrapper.get_input_parameters()
if not node_inputs:
print('No node inputs found!')
else:
print('Number of node inputs: {0}'.format(len(node_inputs)))
for input_index, input_wrapper in node_inputs.items():
print('\tInput index: {0}'.format(input_index))
print_api_input(input_wrapper)
if not parm_inputs:
print('No parameter inputs found!')
else:
print('Number of parameter inputs: {0}'.format(len(parm_inputs)))
for parm_name, input_wrapper in parm_inputs.items():
print('\tInput parameter name: {0}'.format(parm_name))
print_api_input(input_wrapper)
def run():
# get the API singleton
api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
global _g_wrapper
# instantiate an asset with auto-cook enabled
_g_wrapper = api.instantiate_asset(get_test_hda(), unreal.Transform())
# Configure inputs on_post_instantiation, after instantiation, but before first cook
_g_wrapper.on_post_instantiation_delegate.add_callable(configure_inputs)
# Bind on_post_processing, after cook + output creation
_g_wrapper.on_post_processing_delegate.add_callable(print_inputs)
if __name__ == '__main__':
run()
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import unreal
""" Example script for instantiating an asset, cooking it and baking all of
its outputs.
"""
_g_wrapper = None
def get_test_hda_path():
return '/project/.pig_head_subdivider_v01'
def get_test_hda():
return unreal.load_object(None, get_test_hda_path())
def on_post_instantiation(in_wrapper):
print('on_post_instantiation')
# in_wrapper.on_post_instantiation_state_exited_delegate_delegate.remove_callable(on_post_instantiation)
# Set parameter values for the next cook
# in_wrapper.set_bool_parameter_value('add_instances', True)
# in_wrapper.set_int_parameter_value('num_instances', 8)
in_wrapper.set_parameter_tuples({
'add_instances': unreal.HoudiniParameterTuple(bool_values=(True, )),
'num_instances': unreal.HoudiniParameterTuple(int32_values=(8, )),
})
# Print all parameter values
param_tuples = in_wrapper.get_parameter_tuples()
print('parameter tuples: {}'.format(len(param_tuples) if param_tuples else 0))
if param_tuples:
for param_tuple_name, param_tuple in param_tuples.items():
print('parameter tuple name: {}'.format(param_tuple_name))
print('\tbool_values: {}'.format(param_tuple.bool_values))
print('\tfloat_values: {}'.format(param_tuple.float_values))
print('\tint32_values: {}'.format(param_tuple.int32_values))
print('\tstring_values: {}'.format(param_tuple.string_values))
# Force a cook/recook
in_wrapper.recook()
def on_post_bake(in_wrapper, success):
in_wrapper.on_post_bake_delegate.remove_callable(on_post_bake)
print('bake complete ... {}'.format('success' if success else 'failed'))
# Delete the hda after the bake
in_wrapper.delete_instantiated_asset()
global _g_wrapper
_g_wrapper = None
def on_post_process(in_wrapper):
print('on_post_process')
# in_wrapper.on_post_processing_delegate.remove_callable(on_post_process)
# Print out all outputs generated by the HDA
num_outputs = in_wrapper.get_num_outputs()
print('num_outputs: {}'.format(num_outputs))
if num_outputs > 0:
for output_idx in range(num_outputs):
identifiers = in_wrapper.get_output_identifiers_at(output_idx)
print('\toutput index: {}'.format(output_idx))
print('\toutput type: {}'.format(in_wrapper.get_output_type_at(output_idx)))
print('\tnum_output_objects: {}'.format(len(identifiers)))
if identifiers:
for identifier in identifiers:
output_object = in_wrapper.get_output_object_at(output_idx, identifier)
output_component = in_wrapper.get_output_component_at(output_idx, identifier)
is_proxy = in_wrapper.is_output_current_proxy_at(output_idx, identifier)
print('\t\tidentifier: {}'.format(identifier))
print('\t\toutput_object: {}'.format(output_object.get_name() if output_object else 'None'))
print('\t\toutput_component: {}'.format(output_component.get_name() if output_component else 'None'))
print('\t\tis_proxy: {}'.format(is_proxy))
print('')
# bind to the post bake delegate
in_wrapper.on_post_bake_delegate.add_callable(on_post_bake)
# Bake all outputs to actors
print('baking all outputs to actors')
in_wrapper.bake_all_outputs_with_settings(
unreal.HoudiniEngineBakeOption.TO_ACTOR,
replace_previous_bake=False,
remove_temp_outputs_on_success=False)
def run():
# get the API singleton
api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
global _g_wrapper
# instantiate an asset, disabling auto-cook of the asset (so we have to
# call wrapper.reCook() to cook it)
_g_wrapper = api.instantiate_asset(get_test_hda(), unreal.Transform(), enable_auto_cook=False)
# Bind to the on post instantiation delegate (before the first cook)
_g_wrapper.on_post_instantiation_delegate.add_callable(on_post_instantiation)
# Bind to the on post processing delegate (after a cook and after all
# outputs have been generated in Unreal)
_g_wrapper.on_post_processing_delegate.add_callable(on_post_process)
if __name__ == '__main__':
run()
|
import unreal
from pamux_unreal_tools.generated.material_expression_wrappers import *
from pamux_unreal_tools.base.material_expression.material_expression_container_builder_base import MaterialExpressionContainerBuilderBase
class LayerBuild:
@staticmethod
def call_and_connect_LandscapeBaseMaterial(builder: MaterialExpressionContainerBuilderBase):
appendVector = AppendVector(builder.inputs.uvParams, builder.inputs.uvParams.a)
appendVector.add_rt()
call = builder.dependencies.MF_LandscapeBaseMaterial.call()
builder.inputs.albedo.connectTo(call.inputs.albedo)
builder.inputs.colorOverlay.connectTo(call.inputs.colorOverlay)
builder.inputs.colorOverlayIntensity.connectTo(call.inputs.colorOverlayIntensity)
builder.inputs.contrast.connectTo(call.inputs.contrast)
builder.inputs.contrastVariation.connectTo(call.inputs.contrastVariation)
builder.inputs.roughness.connectTo(call.inputs.roughness)
builder.inputs.roughnessIntensity.connectTo(call.inputs.roughnessIntensity)
builder.inputs.normalIntensity.connectTo(call.inputs.normalIntensity)
builder.inputs.normal.connectTo(call.inputs.normal)
builder.inputs.displacement.connectTo(call.inputs.displacement)
appendVector.connectTo(call.inputs.uVParams)
builder.inputs.rotation.connectTo(call.inputs.rotation)
builder.inputs.doTextureBomb.connectTo(call.inputs.doTextureBomb)
builder.inputs.doRotationVariation.connectTo(call.inputs.doRotationVariation)
builder.inputs.bombCellScale.connectTo(call.inputs.bombCellScale)
builder.inputs.bombPatternScale.connectTo(call.inputs.bombPatternScale)
builder.inputs.bombRandomOffset.connectTo(call.inputs.bombRandomOffset)
builder.inputs.bombRotationVariation.connectTo(call.inputs.bombRotationVariation)
call.outputs.height.connectTo(builder.outputs.height)
return call
|
import unreal
import random
import utils.utils as utils
from math import pi
class PointLight:
def __init__(self):
self.object = unreal.PointLight(name='pointLight')
self.actor = unreal.EditorLevelLibrary.spawn_actor_from_object(self.object, [0., 0., 0.])
def add_to_level(self, level_sequence):
self.binding = utils.add_transformable(level_sequence, self.actor)
def add_key_transform(self, loc, rot, t):
utils.key_transform(self.binding, loc, rot, t)
def add_key_random(self, t, distance=None, offset=[0., 0., 0.]):
theta = random.uniform(-pi/3 + pi/2, pi/3 + pi/2)
phi = random.uniform(pi/8, pi/2)
if not distance:
distance = random.uniform(250, 320)
loc = utils.spherical_coordinates(distance, phi, theta)
for k in range(3):
loc[k] += offset[k]
utils.add_key_transform(self.binding, loc, [0., 0., 0.], t)
return({"location": loc, "rotation": [0., 0, 0]})
def change_interpmode(self, mode):
utils.change_interpmode(self.binding, mode)
|
#!/project/ python3
"""
Create WarriorCharacter Blueprint
Creates a new blueprint based on the C++ WarriorCharacter class
"""
import unreal
def create_warrior_character_blueprint():
"""Create WarriorCharacter blueprint from C++ class"""
print("=== Creating WarriorCharacter Blueprint ===")
# Check if C++ class exists
warrior_class = unreal.load_class(None, '/project/.WarriorCharacter')
if not warrior_class:
print("ERROR: WarriorCharacter C++ class not found")
return False
print(f"✓ Found C++ class: {warrior_class}")
# Create blueprint directory if it doesn't exist
blueprint_dir = "/project/"
if not unreal.EditorAssetLibrary.does_directory_exist(blueprint_dir):
print(f"Creating directory: {blueprint_dir}")
unreal.EditorAssetLibrary.make_directory(blueprint_dir)
# Create the blueprint
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
blueprint = asset_tools.create_blueprint(
warrior_class,
blueprint_dir,
"WarriorCharacter"
)
if blueprint:
print(f"✓ Successfully created blueprint: {blueprint.get_path_name()}")
# Configure the blueprint
configure_blueprint(blueprint)
# Save the blueprint
unreal.EditorAssetLibrary.save_asset(blueprint.get_path_name())
print("✓ Blueprint saved successfully")
return True
else:
print("ERROR: Failed to create blueprint")
return False
def configure_blueprint(blueprint):
"""Configure the blueprint properties"""
try:
print("Configuring blueprint...")
# Get the default object
default_object = blueprint.get_default_object()
if not default_object:
print("WARNING: Could not get default object")
return
# Configure movement component if available
if hasattr(default_object, 'get_character_movement'):
movement_component = default_object.get_character_movement()
if movement_component:
movement_component.set_editor_property('max_walk_speed', 300.0)
movement_component.set_editor_property('jump_z_velocity', 400.0)
movement_component.set_editor_property('gravity_scale', 1.0)
print("✓ Movement component configured")
print("✓ Blueprint configuration completed")
except Exception as e:
print(f"WARNING: Exception during configuration: {e}")
def verify_blueprint_creation():
"""Verify the blueprint was created successfully"""
blueprint_path = "/project/"
blueprint = unreal.EditorAssetLibrary.load_asset(blueprint_path)
if blueprint:
print(f"✓ Verification successful: {blueprint_path} exists")
print(f"✓ Blueprint type: {type(blueprint)}")
return True
else:
print(f"✗ Verification failed: {blueprint_path} not found")
return False
if __name__ == "__main__":
success = create_warrior_character_blueprint()
if success:
print("\n=== Verifying Creation ===")
verify_blueprint_creation()
print("\n✓ WarriorCharacter Blueprint creation completed!")
else:
print("\n✗ WarriorCharacter Blueprint creation failed!")
|
"""
This script describes how to import a USD Stage into actors and assets, also optionally specifying specific prim
paths to import.
The `prims_to_import` property can be left at its default value of ["/"] (a list with just the "/" prim path in it)
to import the entire stage.
The provided paths in `prims_to_import` are used as a USD population mask when opening the stage, and as such are
subject to the rules described here: https://graphics.pixar.com/project/.html
As an example, consider the following USD stage:
#usda 1.0
def Xform "ParentA"
{
def Xform "ChildA"
{
}
def Xform "ChildB"
{
}
}
def Xform "ParentB"
{
def Xform "ChildC"
{
}
def Xform "ChildD"
{
}
}
In general, the main thing to keep in mind is that if "/ParentA" is within `prims_to_import`, ParentA and *all* of its
children will be imported. As a consequence, having both "/ParentA" and "/project/" on the list is reduntant, as
"/ParentA" will already lead to "/project/" being imported, as previously mentioned.
"""
import unreal
ROOT_LAYER_FILENAME = r"/project/.usda"
DESTINATION_CONTENT_PATH = r"/project/"
options = unreal.UsdStageImportOptions()
options.import_actors = True
options.import_geometry = True
options.import_skeletal_animations = True
options.import_level_sequences = True
options.import_materials = True
options.prim_path_folder_structure = False
options.prims_to_import = [
"/ParentA", # This will import ParentA, ChildA and ChildB
"/project/" # This will import ParentB and ChildC only (and *not* import ChildD)
]
task = unreal.AssetImportTask()
task.set_editor_property('filename', ROOT_LAYER_FILENAME)
task.set_editor_property('destination_path', DESTINATION_CONTENT_PATH)
task.set_editor_property('automated', True)
task.set_editor_property('options', options)
task.set_editor_property('replace_existing', True)
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
asset_tools.import_asset_tasks([task])
asset_paths = task.get_editor_property("imported_object_paths")
success = asset_paths and len(asset_paths) > 0
|
#!/project/ python
# format_test.py - Tests different command formats for MCP Server
import socket
import json
import sys
import time
# Configuration
HOST = '127.0.0.1'
PORT = 13377
TIMEOUT = 5 # seconds
# Simple Python code to execute
PYTHON_CODE = """
import unreal
return "Hello from Python!"
"""
def send_command(command_dict):
"""Send a command to the MCP Server and return the response."""
try:
# Create a socket connection
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.settimeout(TIMEOUT)
s.connect((HOST, PORT))
# Convert command to JSON and send
command_json = json.dumps(command_dict)
print(f"Sending command format: {command_json}")
s.sendall(command_json.encode('utf-8'))
# Receive response
response = b""
while True:
chunk = s.recv(4096)
if not chunk:
break
response += chunk
# Parse and return response
if response:
try:
return json.loads(response.decode('utf-8'))
except json.JSONDecodeError:
return {"status": "error", "message": "Invalid JSON response", "raw": response.decode('utf-8')}
else:
return {"status": "error", "message": "Empty response"}
except socket.timeout:
return {"status": "error", "message": "Connection timed out"}
except ConnectionRefusedError:
return {"status": "error", "message": "Connection refused. Is the MCP Server running?"}
except Exception as e:
return {"status": "error", "message": f"Error: {str(e)}"}
def test_format(format_name, command_dict):
"""Test a specific command format and print the result."""
print(f"\n=== Testing Format: {format_name} ===")
response = send_command(command_dict)
print(f"Response: {json.dumps(response, indent=2)}")
if response.get("status") == "success":
print(f"✅ SUCCESS: Format '{format_name}' works!")
return True
else:
print(f"❌ FAILED: Format '{format_name}' does not work.")
return False
def main():
print("=== MCP Server Command Format Test ===")
print(f"Connecting to {HOST}:{PORT}")
# Test different command formats
formats = [
("Format 1: Basic", {
"command": "execute_python",
"code": PYTHON_CODE
}),
("Format 2: Type field", {
"type": "execute_python",
"code": PYTHON_CODE
}),
("Format 3: Command in data", {
"command": "execute_python",
"data": {
"code": PYTHON_CODE
}
}),
("Format 4: Type in data", {
"type": "execute_python",
"data": {
"code": PYTHON_CODE
}
}),
("Format 5: Command and params", {
"command": "execute_python",
"params": {
"code": PYTHON_CODE
}
}),
("Format 6: Type and params", {
"type": "execute_python",
"params": {
"code": PYTHON_CODE
}
}),
("Format 7: Command and type", {
"command": "execute_python",
"type": "python",
"code": PYTHON_CODE
}),
("Format 8: Command, type, and data", {
"command": "execute_python",
"type": "python",
"data": {
"code": PYTHON_CODE
}
})
]
success_count = 0
for format_name, command_dict in formats:
if test_format(format_name, command_dict):
success_count += 1
time.sleep(1) # Brief pause between tests
print(f"\n=== Test Summary ===")
print(f"Tested {len(formats)} command formats")
print(f"Successful formats: {success_count}")
print(f"Failed formats: {len(formats) - success_count}")
if __name__ == "__main__":
main()
|
# coding: utf-8
import unreal
# import AssetFunction_6 as af
# reload(af)
# af.showAssetsInContentBrowser()
# ! 选择指定资产
def showAssetsInContentBrowser():
paths = [
'/project/',
'/project/'
]
unreal.EditorAssetLibrary.sync_browser_to_objects(paths)
# ! 调用 C++ 命令设置选择文件夹
def getSelectedAssets():
return unreal.CppLib.get_selected_assets(paths)
# ! 调用 C++ 命令设置选择文件夹
def setSelectedAssets():
paths = [
'/project/',
'/project/'
]
return unreal.CppLib.set_selected_assets(paths)
# ! 调用 C++ 命令获取选择文件夹
def getSelectedFolders():
return unreal.CppLib.get_selected_folders()
# ! 调用 C++ 命令设置文件夹
def setSelectedFolders():
paths = [
'/project/',
'/project/'
]
return unreal.CppLib.set_selected_folders(paths)
|
# This script describes a generic use case for the variant manager
import unreal
# Create all assets and objects we'll use
lvs = unreal.VariantManagerLibrary.create_level_variant_sets_asset("LVS", "/Game/")
lvs_actor = unreal.VariantManagerLibrary.create_level_variant_sets_actor(lvs)
if lvs is None or lvs_actor is None:
print ("Failed to spawn either the LevelVariantSets asset or the LevelVariantSetsActor!")
quit()
var_set1 = unreal.VariantSet()
var_set1.set_display_text("My VariantSet")
var_set2 = unreal.VariantSet()
var_set2.set_display_text("VariantSet we'll delete")
var1 = unreal.Variant()
var1.set_display_text("Variant 1")
var2 = unreal.Variant()
var2.set_display_text("Variant 2")
var3 = unreal.Variant()
var3.set_display_text("Variant 3")
var4 = unreal.Variant()
var4.set_display_text("Variant 4")
var5 = unreal.Variant()
var5.set_display_text("Variant 5")
# Adds the objects to the correct parents
lvs.add_variant_set(var_set1)
var_set1.add_variant(var1)
var_set1.add_variant(var2)
var_set1.add_variant(var3)
var_set1.add_variant(var4)
var_set1.add_variant(var5)
# Spawn a simple cube static mesh actor
cube = unreal.EditorAssetLibrary.load_asset("StaticMesh'/project/.Cube'")
spawned_actor = None
if cube:
location = unreal.Vector()
rotation = unreal.Rotator()
spawned_actor = unreal.EditorLevelLibrary.spawn_actor_from_object(cube, location, rotation)
spawned_actor.set_actor_label("Cube Actor")
else:
print ("Failed to find Cube asset!")
if spawned_actor is None:
print ("Failed to spawn an actor for the Cube asset!")
quit()
# Bind spawned_actor to all our variants
var1.add_actor_binding(spawned_actor)
var2.add_actor_binding(spawned_actor)
var3.add_actor_binding(spawned_actor)
var4.add_actor_binding(spawned_actor)
var5.add_actor_binding(spawned_actor)
capturable_props = unreal.VariantManagerLibrary.get_capturable_properties(spawned_actor)
print ("Capturable properties for actor '" + spawned_actor.get_actor_label() + "':")
for prop in capturable_props:
print ("\t" + prop)
# Capture all available properties on Variant 1
for prop in capturable_props:
var1.capture_property(spawned_actor, prop)
# Capture just materials on Variant 2
just_mat_props = (p for p in capturable_props if "Material[" in p)
for prop in just_mat_props:
var2.capture_property(spawned_actor, prop)
# Capture just relative location on Variant 4
just_rel_loc = (p for p in capturable_props if "Relative Location" in p)
rel_loc_props = []
for prop in just_rel_loc:
captured_prop = var4.capture_property(spawned_actor, prop)
rel_loc_props.append(captured_prop)
# Store a property value on Variant 4
rel_loc_prop = rel_loc_props[0]
print (rel_loc_prop.get_full_display_string())
spawned_actor.set_actor_relative_location(unreal.Vector(100, 200, 300), False, False)
rel_loc_prop.record()
# Move the target actor to some other position
spawned_actor.set_actor_relative_location(unreal.Vector(500, 500, 500), False, False)
# Can switch on the variant, applying the recorded value of all its properties to all
# of its bound actors
var4.switch_on() # Cube will be at 100, 200, 300 after this
# Apply the recorded value from just a single property
rel_loc_prop.apply()
# Get the relative rotation property
rel_rot = [p for p in capturable_props if "Relative Rotation" in p][0]
# Remove objects
lvs.remove_variant_set(var_set2)
lvs.remove_variant_set(var_set2)
var_set1.remove_variant(var3)
var5.remove_actor_binding(spawned_actor)
var1.remove_captured_property_by_name(spawned_actor, rel_rot)
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
""" An example script that uses the API to instantiate an HDA and then
set 2 inputs: a geometry input (a cube) and a curve input (a helix). The
inputs are set during post instantiation (before the first cook). After the
first cook and output creation (post processing) the input structure is fetched
and logged.
"""
import math
import unreal
_g_wrapper = None
def get_test_hda_path():
return '/project/.copy_to_curve_1_0'
def get_test_hda():
return unreal.load_object(None, get_test_hda_path())
def get_geo_asset_path():
return '/project/.Cube'
def get_geo_asset():
return unreal.load_object(None, get_geo_asset_path())
def configure_inputs(in_wrapper):
print('configure_inputs')
# Unbind from the delegate
in_wrapper.on_post_instantiation_delegate.remove_callable(configure_inputs)
# Create a geo input
geo_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPIGeoInput)
# Set the input objects/assets for this input
geo_object = get_geo_asset()
if not geo_input.set_input_objects((geo_object, )):
# If any errors occurred, get the last error message
print('Error on geo_input: {0}'.format(geo_input.get_last_error_message()))
# copy the input data to the HDA as node input 0
in_wrapper.set_input_at_index(0, geo_input)
# We can now discard the API input object
geo_input = None
# Create a curve input
curve_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPICurveInput)
# Create a curve wrapper/helper
curve_object = unreal.HoudiniPublicAPICurveInputObject(curve_input)
# Make it a Nurbs curve
curve_object.set_curve_type(unreal.HoudiniPublicAPICurveType.NURBS)
# Set the points of the curve, for this example we create a helix
# consisting of 100 points
curve_points = []
for i in range(100):
t = i / 20.0 * math.pi * 2.0
x = 100.0 * math.cos(t)
y = 100.0 * math.sin(t)
z = i
curve_points.append(unreal.Transform([x, y, z], [0, 0, 0], [1, 1, 1]))
curve_object.set_curve_points(curve_points)
# Error handling/message example: try to set geo_object on curve input
if not curve_input.set_input_objects((geo_object, )):
print('Error (example) while setting \'{0}\' on curve input: {1}'.format(
geo_object.get_name(), curve_input.get_last_error_message()
))
# Set the curve wrapper as an input object
curve_input.set_input_objects((curve_object, ))
# Copy the input data to the HDA as node input 1
in_wrapper.set_input_at_index(1, curve_input)
# We can now discard the API input object
curve_input = None
# Check for errors on the wrapper
last_error = in_wrapper.get_last_error_message()
if last_error:
print('Error on wrapper during input configuration: {0}'.format(last_error))
def print_api_input(in_input):
print('\t\tInput type: {0}'.format(in_input.__class__))
print('\t\tbKeepWorldTransform: {0}'.format(in_input.keep_world_transform))
print('\t\tbImportAsReference: {0}'.format(in_input.import_as_reference))
if isinstance(in_input, unreal.HoudiniPublicAPIGeoInput):
print('\t\tbPackBeforeMerge: {0}'.format(in_input.pack_before_merge))
print('\t\tbExportLODs: {0}'.format(in_input.export_lo_ds))
print('\t\tbExportSockets: {0}'.format(in_input.export_sockets))
print('\t\tbExportColliders: {0}'.format(in_input.export_colliders))
elif isinstance(in_input, unreal.HoudiniPublicAPICurveInput):
print('\t\tbCookOnCurveChanged: {0}'.format(in_input.cook_on_curve_changed))
print('\t\tbAddRotAndScaleAttributesOnCurves: {0}'.format(in_input.add_rot_and_scale_attributes_on_curves))
input_objects = in_input.get_input_objects()
if not input_objects:
print('\t\tEmpty input!')
else:
print('\t\tNumber of objects in input: {0}'.format(len(input_objects)))
for idx, input_object in enumerate(input_objects):
print('\t\t\tInput object #{0}: {1}'.format(idx, input_object))
if isinstance(input_object, unreal.HoudiniPublicAPICurveInputObject):
print('\t\t\tbClosed: {0}'.format(input_object.is_closed()))
print('\t\t\tCurveMethod: {0}'.format(input_object.get_curve_method()))
print('\t\t\tCurveType: {0}'.format(input_object.get_curve_type()))
print('\t\t\tReversed: {0}'.format(input_object.is_reversed()))
print('\t\t\tCurvePoints: {0}'.format(input_object.get_curve_points()))
def print_inputs(in_wrapper):
print('print_inputs')
# Unbind from the delegate
in_wrapper.on_post_processing_delegate.remove_callable(print_inputs)
# Fetch inputs, iterate over it and log
node_inputs = in_wrapper.get_inputs_at_indices()
parm_inputs = in_wrapper.get_input_parameters()
if not node_inputs:
print('No node inputs found!')
else:
print('Number of node inputs: {0}'.format(len(node_inputs)))
for input_index, input_wrapper in node_inputs.items():
print('\tInput index: {0}'.format(input_index))
print_api_input(input_wrapper)
if not parm_inputs:
print('No parameter inputs found!')
else:
print('Number of parameter inputs: {0}'.format(len(parm_inputs)))
for parm_name, input_wrapper in parm_inputs.items():
print('\tInput parameter name: {0}'.format(parm_name))
print_api_input(input_wrapper)
def run():
# get the API singleton
api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
global _g_wrapper
# instantiate an asset with auto-cook enabled
_g_wrapper = api.instantiate_asset(get_test_hda(), unreal.Transform())
# Configure inputs on_post_instantiation, after instantiation, but before first cook
_g_wrapper.on_post_instantiation_delegate.add_callable(configure_inputs)
# Print the input state after the cook and output creation.
_g_wrapper.on_post_processing_delegate.add_callable(print_inputs)
if __name__ == '__main__':
run()
|
import unreal
import json
import os
def normalize_path(path):
"""
Normaliza una ruta para asegurar que comience con /Game/
"""
if not path.startswith('/Game/'):
path = path.strip('/')
path = f'/Game/{path}'
return path
def force_delete_asset(asset_path):
"""
Fuerza la eliminación de un asset y sus referencias
"""
try:
if unreal.EditorAssetLibrary.does_asset_exist(asset_path):
# Intentar eliminar referencias
unreal.EditorAssetLibrary.delete_loaded_asset(asset_path)
print(f'Asset eliminado: {asset_path}')
return True
except Exception as e:
print(f'Error al eliminar asset {asset_path}: {str(e)}')
return False
def create_blueprint(parent_class, name, folder_path, force_recreate=True):
"""
Crea un nuevo Blueprint con la clase padre y nombre especificados
"""
try:
# Normalizar la ruta
full_path = normalize_path(folder_path)
package_path = f"{full_path}/{name}"
# Si existe y force_recreate es True, intentar eliminar
if force_recreate:
force_delete_asset(package_path)
# Crear el factory para Blueprints
factory = unreal.BlueprintFactory()
factory.set_editor_property('ParentClass', parent_class)
# Obtener el asset tools
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
# Asegurarse de que el directorio existe
package_name = unreal.Paths.get_base_filename(package_path)
package_folder = unreal.Paths.get_path(package_path)
if not unreal.EditorAssetLibrary.does_directory_exist(package_folder):
unreal.EditorAssetLibrary.make_directory(package_folder)
# Crear el Blueprint
new_blueprint = asset_tools.create_asset(
package_name,
package_folder,
unreal.Blueprint,
factory
)
if new_blueprint is not None:
# Forzar la compilación del Blueprint
unreal.EditorLoadingAndSavingUtils.save_dirty_packages(
save_map_packages=True,
save_content_packages=True
)
print(f'Blueprint creado y guardado: {package_path}')
return new_blueprint
else:
print(f'Error al crear Blueprint: {package_path}')
return None
except Exception as e:
print(f'Error al crear Blueprint {name}: {str(e)}')
return None
def clean_directory(directory_path):
"""
Limpia un directorio eliminando todos los assets
"""
try:
if unreal.EditorAssetLibrary.does_directory_exist(directory_path):
assets = unreal.EditorAssetLibrary.list_assets(directory_path)
for asset in assets:
force_delete_asset(asset)
print(f'Directorio limpiado: {directory_path}')
except Exception as e:
print(f'Error al limpiar directorio {directory_path}: {str(e)}')
def setup_digital_twin():
"""
Configura todos los Blueprints necesarios para el gemelo digital
"""
try:
# Limpiar directorios existentes
base_folders = [
'Blueprints/Core',
'Blueprints/Security',
'Blueprints/Inventory',
'Blueprints/Customer',
'Blueprints/Layout',
'Blueprints/Help'
]
print('Limpiando directorios existentes...')
for folder in base_folders:
path = normalize_path(folder)
clean_directory(path)
if not unreal.EditorAssetLibrary.does_directory_exist(path):
unreal.EditorAssetLibrary.make_directory(path)
print(f'Directorio creado: {path}')
# Forzar una recolección de basura
unreal.EditorLevelLibrary.editor_command('GC.CollectGarbage')
print('Creando nuevos Blueprints...')
# Crear GameMode principal
game_mode = create_blueprint(
unreal.GameModeBase.static_class(),
'BP_DigitalTwinGameMode',
'/project/',
force_recreate=True
)
# Definir sistemas principales
systems = {
'Blueprints/Security': {
'BP_SecurityCamera': unreal.Actor.static_class(),
'BP_SecuritySystem': unreal.Actor.static_class()
},
'Blueprints/Inventory': {
'BP_InventoryManager': unreal.Actor.static_class(),
'BP_Product': unreal.Actor.static_class()
},
'Blueprints/Customer': {
'BP_CustomerSimulation': unreal.Actor.static_class(),
'BP_VirtualCustomer': unreal.Character.static_class()
},
'Blueprints/Layout': {
'BP_LayoutEditor': unreal.Actor.static_class(),
'BP_LayoutValidator': unreal.Actor.static_class()
},
'Blueprints/Help': {
'WBP_HelpSystem': unreal.WidgetBlueprint.static_class(),
'BP_TutorialManager': unreal.Actor.static_class()
}
}
created_blueprints = {}
# Crear Blueprints para cada sistema
for folder_path, blueprints in systems.items():
normalized_path = normalize_path(folder_path)
folder_name = folder_path.split('/')[-1]
created_blueprints[folder_name] = {}
for bp_name, parent_class in blueprints.items():
bp = create_blueprint(parent_class, bp_name, normalized_path, force_recreate=True)
if bp is not None:
created_blueprints[folder_name][bp_name] = bp
# Forzar guardado de todos los paquetes
unreal.EditorLoadingAndSavingUtils.save_dirty_packages(
save_map_packages=True,
save_content_packages=True
)
print('Configuración del gemelo digital completada')
except Exception as e:
print(f'Error durante la configuración: {str(e)}')
def generate_websocket_blueprint():
# Configuración básica del Blueprint
blueprint_name = '/project/'
blueprint_factory = unreal.BlueprintFactory()
blueprint_factory.set_editor_property('ParentClass', unreal.Actor)
# Crear el Blueprint
package_path = '/project/'
blueprint = unreal.AssetToolsHelpers.get_asset_tools().create_asset(
'BP_WebSocketManager',
package_path,
unreal.Blueprint,
blueprint_factory
)
# Añadir variables
blueprint_class = blueprint.get_blueprint_class()
# Variables para WebSocket
unreal.BlueprintVariable(
'WebSocketURL',
unreal.EdGraphPinType(
'string',
'ESPMode::Type::ThreadSafe',
None,
unreal.EPinContainerType.NONE,
False,
unreal.FEdGraphTerminalType()
)
)
# Funciones principales
functions = [
{
'name': 'ConnectToServer',
'inputs': [],
'outputs': [('Success', 'bool')]
},
{
'name': 'ProcessSensorData',
'inputs': [('SensorData', 'string')],
'outputs': []
},
{
'name': 'UpdateDigitalTwin',
'inputs': [
('Temperature', 'float'),
('Humidity', 'float'),
('Pressure', 'float'),
('Motion', 'bool'),
('Stock', 'int')
],
'outputs': []
}
]
# Crear funciones
for func in functions:
function = unreal.BlueprintFunctionLibrary.create_function(
blueprint_class,
func['name']
)
# Añadir inputs y outputs
for input_name, input_type in func['inputs']:
unreal.BlueprintFunctionLibrary.add_parameter(
function,
unreal.Parameter(input_name, input_type)
)
for output_name, output_type in func['outputs']:
unreal.BlueprintFunctionLibrary.add_return_value(
function,
unreal.Parameter(output_name, output_type)
)
# Compilar Blueprint
unreal.EditorLoadingAndSavingUtils.save_package(
blueprint.get_outer(),
'/project/'
)
if __name__ == '__main__':
setup_digital_twin()
generate_websocket_blueprint()
|
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 13 11:46:18 2024
@author: WillQuantique
"""
import unreal
import time
def reset_scene(sequence_path):
"""
Deletes the specified sequence from the asset library and removes the MetaHuman actor and camera actor from the scene.
Args:
sequence_path (str): The path to the sequence asset in the asset library.
Returns:
None
"""
# Delete the sequence from the asset library
sequence_asset = unreal.EditorAssetLibrary.load_asset(sequence_path)
if sequence_asset:
unreal.EditorAssetLibrary.delete_asset(sequence_path)
print(f"Sequence '{sequence_path}' deleted from the asset library.")
else:
print(f"Sequence '{sequence_path}' not found in the asset library.")
all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
for actor in all_actors:
unreal.log(actor.get_name())
if "F" in actor.get_name() or "Rig" in actor.get_name() or actor.get_class().get_name() == "CineCameraActor" or "H" in actor.get_name() :
unreal.EditorLevelLibrary.destroy_actor(actor)
print(f"Deleted actor: {actor.get_name()}")
def SetupCineCameraActor(location=unreal.Vector(0, 0, 0), rotation=unreal.Rotator(0, 0, 0)):
# adapted from https://github.com/project/.py
"""
Parameters
----------
location : Unreal vector for camera location
The default is unreal.Vector(0, 0, 0).
rotation : Unreal rotator for camera rotation
The default is unreal.Rotator(0, 0, 0).
focus : float, for focus distance
The default is 132.0.
Returns
-------
camera_actor : Unreal actor
The camera set with given rotation, position
"""
# Spawn a Camera Actor in the World
world = unreal.EditorLevelLibrary.get_editor_world()
camera_actor = unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.CineCameraActor, location, rotation)
# create an instance of camera settings and set it to manual focus method
settings = unreal.CameraFocusSettings()
settings.focus_method = unreal.CameraFocusMethod.MANUAL
# create the camera and pass the settings to it
ccc = camera_actor.get_cine_camera_component()
ccc.set_editor_property("focus_settings", settings)
return camera_actor
def ChangeCamSettings(camera:object, focal_length:float,focus_distance:float, aperture:float, loc: object = None, rot:object = None, tracktor = None ):
"""
Parameters
----------
camera : object
Camera object
focal_length : float
focal lenght in mm (function as in real camera)
focus_distance : float
Focus distance in cm
aperture : float
Aperture un trems of f-stops 2.8 for f/2.8
loc : object, optional
unreal.locator(x,y,z). In game coordinates The. default is None.
rot : object, optional
unreal.rotator(x,y,z). In degrees relative to game coordinate. The default is None.
Returns
-------
None.
"""
ccc = camera.get_cine_camera_component()
ccc.current_focal_length = focal_length
settings = unreal.CameraFocusSettings()
settings.focus_method = unreal.CameraFocusMethod.MANUAL
settings.manual_focus_distance = focus_distance
if tracktor is not None :
lookat = unreal.CameraLookatTrackingSettings()
lookat.actor_to_track = tracktor
lookat.enable_look_at_tracking = True
ccc.lookat_tracking_settings = lookat
filmback = unreal.CameraFilmbackSettings()
filmback.sensor_width = 16
filmback.sensor_height = 16
ccc.set_editor_property("filmback", filmback)
ccc.set_editor_property("focus_settings", settings)
ccc.current_aperture = aperture
if loc : camera.set_actor_location(loc,False,False)
if rot : camera.set_actor_rotation(rot,False,False)
def CreateSequence(sequence_name, camera, length_frames = 1, package_path = '/project/'):
'''
Args:
sequence_name(str): The name of the sequence to be created
length_frames(int): The number of frames in the camera cut section.
package_path(str): The location for the new sequence
Returns:
unreal.LevelSequence: The created level sequence
'''
all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
# Loop through all actors to find the first camera
print("launching")
# Create the sequence asset in the desired location
sequence = unreal.AssetToolsHelpers.get_asset_tools().create_asset(
sequence_name,
package_path,
unreal.LevelSequence,
unreal.LevelSequenceFactoryNew())
print("sequence created from selection")
# Only one frame needed to render stills
sequence.set_playback_end(length_frames)
"""
camera = SetupCineCameraActor(unreal.Vector(0,90,149), unreal.Rotator(0,0,-90))
ChangeCamSettings(camera, 50.0,80.0, 2.8 )
"""
movie_scene = sequence.get_movie_scene()
for actor in all_actors:
unreal.log(actor.get_class().get_name())
if actor.get_class().get_name() == "CineCameraActor":
camera = actor
break
binding = sequence.add_possessable(camera)
for actor in all_actors:
actor_binding= sequence.add_possessable(actor)
try:
camera_cut_track = sequence.add_master_track(unreal.MovieSceneCameraCutTrack)
# Add a camera cut track for this camera
# Make sure the camera cut is stretched to the -1 mark
camera_cut_section = camera_cut_track.add_section()
camera_cut_section.set_start_frame(-1)
camera_cut_section.set_end_frame(length_frames)
# bind the camera
camera_binding_id = unreal.MovieSceneObjectBindingID()
camera_binding_id.set_editor_property("Guid", binding.get_id())
camera_cut_section.set_editor_property("CameraBindingID", camera_binding_id)
# Add a current focal length track to the cine camera component
camera_component = camera.get_cine_camera_component()
camera_component_binding = sequence.add_possessable(camera_component)
camera_component_binding.set_parent(binding)
focal_length_track = camera_component_binding.add_track(unreal.MovieSceneFloatTrack)
focal_length_track.set_property_name_and_path('CurrentFocalLength', 'CurrentFocalLength')
focal_length_section = focal_length_track.add_section()
focal_length_section.set_start_frame_bounded(0)
focal_length_section.set_end_frame_bounded(length_frames)
except TypeError:
unreal.log_error(f"Trex TypeError {str(sequence)}")
# Log the output sequence with tag Trex for easy lookup
print("camerajob done")
unreal.log("Trex" + str(sequence))
return sequence
def add_metahuman_components_to_sequence(sequence, metahuman_actor):
# Retrieve all components attached to the metahuman actor
unreal.log("before world")
editor_subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
sequence_to_activate = unreal.load_asset("/project/")
s= unreal.LevelSequenceEditorBlueprintLibrary.open_level_sequence(sequence_to_activate)
# Use the new recommended method to get the editor world
world = editor_subsystem.get_editor_world()
unreal.log("world")
skeletal_mesh_components = metahuman_actor.get_components_by_class(unreal.SkeletalMeshComponent)
unreal.log("mesh")
#sequence = unreal.LevelSequenceEditorBlueprintLibrary.get_current_level_sequence()
unreal.log("sequence")
for skeletal_mesh_component in skeletal_mesh_components:
# Assuming naming convention to identify relevant skeletal meshes for control rigs
if "face" in skeletal_mesh_component.get_name().lower():
rig = unreal.load_asset('/project/')
skel = sequence.add_possessable(skeletal_mesh_component)
rig_class = rig.get_control_rig_class()
rig_track = unreal.ControlRigSequencerLibrary.find_or_create_control_rig_track(world,sequence, rig_class, skel)
elif "body" in skeletal_mesh_component.get_name().lower():
rig = unreal.load_asset("/project/")
skel = sequence.add_possessable(skeletal_mesh_component)
rig_class = rig.get_control_rig_class()
rig_track = unreal.ControlRigSequencerLibrary.find_or_create_control_rig_track(world,sequence, rig_class, skel)
def LoadBlueprint(blueprint_path:str, loc:unreal.Vector = unreal.Vector(0,0, 0),rot:unreal.Rotator = unreal.Rotator(0, 0, 0)):
"""
Parameters
----------
blueprint_path : str
Unreal path to the blue print eg. Game/project/
loc : unreal.Vector, optional
Desired Position in absolute coordinates The default is unreal.Vector(0,0, 0).
rot : unreal.Rotator, optional
Desired Rotation The default is unreal.Rotator(0, 0, 0).
Returns
-------
actor : TYPE
Actor as defined by the blue print
"""
asset = unreal.EditorAssetLibrary.load_asset(blueprint_path)
if asset is None:
print(f"Failed to load asset at {blueprint_path}")
return None
actor = unreal.EditorLevelLibrary.spawn_actor_from_object(asset, loc, rot)
return actor
def PoseFromAsset(pose_asset_path, ctrl_rig_name:str= "Face_ControlBoard_CtrlRig", sequence = None):
# do it AFTER load sequence
"""
Parameters
----------
pose_asset_path : str
path to the pose asset
ctrl_rig_name : str
name of the control rig
Returns
-------
None.
"""
# load the pose asset
pose_asset = unreal.EditorAssetLibrary.load_asset(pose_asset_path)
# isolate controls
controls = pose_asset.get_control_names()
#select the active level sequence
unreal.log(sequence)
if sequence == None:
sequence = unreal.LevelSequenceEditorBlueprintLibrary.get_current_level_sequence()
# Get face rig to paste pose on it
faceRigs = []
rigProxies = unreal.ControlRigSequencerLibrary.get_control_rigs(sequence)
unreal.log(rigProxies)
for rigProxy in rigProxies:
rig = rigProxy.control_rig
if rig.get_name() == ctrl_rig_name:
print("Face found")
faceRigs.append(rig)
#select controls with same names as in the pose asset
for control in controls:
rig.select_control(control)
pose_asset.paste_pose(rig)
def MovieQueueRender(u_level_file, u_level_seq_file, u_preset_file, job_name:str, sequence = None):
"""
Parameters
----------
u_level_file : Unreal path
Path to level
u_level_seq_file : Unreal path
Path to sequence
u_preset_file : Unreal path
Path to movie render presets
Returns
-------
None.
"""
subsystem = unreal.get_editor_subsystem(unreal.MoviePipelineQueueSubsystem)
executor = unreal.MoviePipelinePIEExecutor()
queue = subsystem.get_queue()
queue.delete_all_jobs()
# config render job with movie pipeline config
job = queue.allocate_new_job(unreal.MoviePipelineExecutorJob)
job.job_name = job_name
job.map = unreal.SoftObjectPath(u_level_file)
job.sequence = unreal.SoftObjectPath(u_level_seq_file)
preset = unreal.EditorAssetLibrary.find_asset_data(u_preset_file).get_asset()
job.set_configuration(preset)
if sequence is not None:
print(unreal.MoviePipelineLibrary.update_job_shot_list_from_sequence(sequence, job))
subsystem.render_queue_with_executor_instance(executor)
print("###################################################\n")
print("rendered")
print("###################################################\n")
def get_file_paths(folder_path, limit = 0):
file_paths = []
# Convertir le chemin du dossier en un objet Path d'Unreal Engine
assets = unreal.EditorAssetLibrary.list_assets(folder_path)
# Parcourir les assets et ajouter leurs chemins complets à la liste
asset_paths = unreal.EditorAssetLibrary.list_assets(folder_path)
cnt = 0
# Parcourir les chemins d'assets et ajouter les chemins valides à la liste
for asset_path in asset_paths:
cnt +=1
if unreal.EditorAssetLibrary.does_asset_exist(asset_path):
file_paths.append(asset_path)
if cnt == limit:
break
return file_paths
def control_by_control(pose_asset_path, sequence, frame=1):
pose_asset = unreal.EditorAssetLibrary.load_asset(pose_asset_path)
#pose_rig = pose_asset.create_control_rig()
# Attempt to find the Metahuman actor in the scene
sequence = unreal.LevelSequenceEditorBlueprintLibrary.get_current_level_sequence()
# Get face rigs
rigProxies = unreal.ControlRigSequencerLibrary.get_control_rigs(sequence)
print(rigProxies)
rigP = rigProxies[1]
rig = rigP.control_rig
pose = pose_asset.pose.copy_of_controls[0]
rigProxies = unreal.ControlRigSequencerLibrary.get_control_rigs(sequence)
unreal.log(rigProxies)
faceRigs = []
for rigProxy in rigProxies:
rig = rigProxy.control_rig
if rig.get_name() == "Face_ControlBoard_CtrlRig":
print("Face found")
faceRigs.append(rig)
print(faceRigs)
print(pose.name)
print("offset ",pose.offset_transform)
print("local ",pose.local_transform)
print("global ", pose.global_transform)
print("parent ",pose.parent_transform)
for pose_control in pose_asset.pose.copy_of_controls:
control_name = pose_control.name
# Ensure the transform is clean and ready to be applied
control_value = pose_control.global_transform
# control_value = pose.parent_transform
#control_value = pose.local_transform
#control_value = pose.offset_transform
rig.select_control(control_name)
x = control_value.rotation.x
y = control_value.rotation.y
z = control_value.rotation.z
rot = unreal.Rotator(x,y,z)
# Convert the control value to a Transform object
control_transform = unreal.Transform(
location=control_value.translation,
rotation=rot,
scale=control_value.scale3d
)
frame_number = unreal.FrameNumber(frame)
# Directly set the transform
#print(rig.current_control_selection())
#space = unreal.RigElementKey(type = unreal.RigElementType.CONTROL, name = control_name)
#unreal.ControlRigSequencerLibrary.delete_control_rig_space(sequence, rig, control_name, frame_number)
#unreal.ControlRigSequencerLibrary.set_control_rig_space(sequence, rig, control_name, space, frame_number)
#unreal.ControlRigSequencerLibrary.set_local_control_rig_transform(sequence, rig, control_name, frame_number, control_value)
if not "teeth" in str(control_name):
unreal.ControlRigSequencerLibrary.set_control_rig_world_transform(sequence, rig, control_name, frame_number, control_value)
def add_key_to_channels(sequencer_asset_path, frame_nb):
# Load the sequence asset
sequence = unreal.load_asset(sequencer_asset_path, unreal.LevelSequence)
# Iterate over object bindings and tracks/sections
all_tracks = sequence.get_tracks()
for object_binding in sequence.get_bindings():
all_tracks.extend(object_binding.get_tracks())
# Now we iterate through each section and look for Bool channels within each track.
print("Found " + str(len(all_tracks)) + " tracks, searching for bool channels...")
num_bool_keys_modified = 0
for track in all_tracks:
# Tracks are composed of sections
for section in track.get_sections():
# Sections are composed of channels which contain the actual data!
for channel in section.get_channels():
print("Found bool channel in section " + section.get_name() + " for track " + track.get_name() + " flipping values...")
# Channels are often composed of some (optional) default values and keys.
print(channel.get_name())
#channel.add_key(frame_nb, None)
print ("Modified " + str(num_bool_keys_modified) + " keys!")
def understand_sequence(sequence, sec_nb):
all_tracks = sequence.get_tracks()
for object_binding in sequence.get_bindings():
all_tracks.extend(object_binding.get_tracks())
print("Found " + str(len(all_tracks)) + " tracks, searching for bool channels...")
num_bool_keys_modified = 0
for track in all_tracks:
# Tracks are composed of sections
for n in range(sec_nb):
sec = track.add_section()
sec.set_start_frame(n)
sec.set_end_frame(n+1)
for section in track.get_sections():
# Sections are composed of channels which contain the actual data!
print(section)
"""
for channel in section.get_channels():
print("Found bool channel in section " + section.get_name() + " for track " + track.get_name())
print(channel)
# Channels are often composed of some (optional) default values and keys.
for key in channel.get_keys():
print(key.name)
key.set_value(not key.get_value())
num_bool_keys_modified = num_bool_keys_modified + 1
"""
print(track)
def section_sequence(sequence, sec_nb):
all_tracks = sequence.get_tracks()
for object_binding in sequence.get_bindings():
all_tracks.extend(object_binding.get_tracks())
print("Found " + str(len(all_tracks)) + " tracks, searching for bool channels...")
num_bool_keys_modified = 0
for track in all_tracks:
# Tracks are composed of sections
for n in range(sec_nb):
sec = track.add_section()
sec.set_start_frame(n)
sec.set_end_frame(n+1)
print(track)
def add_key_example(sequence, frame):
print("This example inserts a new key at half the current key's time with the opposite value as the current key. Assumes you have bool keys in an object binding!")
# Create a test sequence for us to use.
# Iterate over the Object Bindings in the sequence as they're more likely to have a track we can test with.
for binding in sequence.get_bindings():
for track in binding.get_tracks():
print(track)
for section in track.get_sections():
print("\tSection: " + section.get_name())
for channel in section.get_channels_by_type(unreal.MovieSceneScriptingFloatChannel):
print("\tChannel: " + channel.get_name())
print("\tClass: " + str(channel.get_class()))
#new_key = channel.add_key(unreal.FrameNumber(frame), channel.get_default())
return
def print_delta(pose_asset_path, sequence):
pose_asset = unreal.EditorAssetLibrary.load_asset(pose_asset_path)
sequence = unreal.LevelSequenceEditorBlueprintLibrary.get_current_level_sequence()
rigProxies = unreal.ControlRigSequencerLibrary.get_control_rigs(sequence)
for rigProxy in rigProxies:
rig = rigProxy.control_rig
print(rig.get_name())
rigP = rigProxies[0]
rig = rigP.control_rig
#pose = [ p for p in pose_asset.pose.copy_of_controls if p.name == "ring_01_l_ctrl"][0]
hierarchy = rig.get_hierarchy()
#print(hierarchy.get_global_transform(pose.name,True))
keys = sorted([ k.name for k in hierarchy.get_all_keys()])
pose_names = sorted([p.name for p in pose_asset.pose.copy_of_controls])
common_controls = sorted([k for k in keys if k in pose_names])
print(common_controls)
stuff = [hierarchy.get_global_transform(key,True).translation.z for key in hierarchy.get_all_keys() if key.name in common_controls]
odic = {key.name: hierarchy.get_global_transform(key, True).translation.z for key in hierarchy.get_all_keys() if key.name in common_controls}
pdic = {pose.name: pose.global_transform.translation.z for pose in pose_asset.pose.copy_of_controls if pose.name in common_controls}
diff_dic = {k: odic[k]-pdic[k] for k in common_controls}
input_list = list(diff_dic.values())
print(max(set(input_list), key=input_list.count))
"""
print([s.translation.z for s in stuff])
poses = [p for p in pose_asset.pose.copy_of_controls if p.name == key.name]
print([pose.global_transform.translation.z for pose in pose_asset.pose.copy_of_controls ])
"""
import importlib.util
import sys
def import_py_as_module(path, module_name):
spec = importlib.util.spec_from_file_location(module_name, path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
sys.modules[module_name] = module
return module
if __name__ == "__main__":
start = time.time()
reset_scene("/project/")
pose_asset_folder = "/project/"
#pose_asset_folder = "/project/"
all_pose_asset_path = get_file_paths(pose_asset_folder)
y_dist = 25 #Y 22 minimum
camera = SetupCineCameraActor(unreal.Vector(0,y_dist,149), unreal.Rotator(0,0,-90))
ChangeCamSettings(camera, y_dist/1.8, y_dist-10, 2.8 )
MH = LoadBlueprint("/project/")
all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
"""
for actor in all_actors:
unreal.log(actor.get_name())
if "F" in actor.get_name() :
tracktor = actor
ChangeCamSettings(camera, y_dist/1.8, y_dist-10, 2.8 , tracktor = tracktor)
"""
length = len(all_pose_asset_path)
sequence = CreateSequence("sequence",camera, length)
add_metahuman_components_to_sequence(sequence, MH)
all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
for actor in all_actors:
unreal.log(actor.get_name())
if "F" in actor.get_name() :
tracktor = actor
"""
u_level_file = "/project/"
u_level_seq_file = "/project/"
u_preset_file = "/project/"
"""
u_level_file = "/project/"
u_level_seq_file = "/project/"
u_preset_file = "/project/"
for i in range(len(all_pose_asset_path)):
pose_asset_path = all_pose_asset_path[i]
#PoseFromAsset( pose_asset_path, "Face_ControlBoard_CtrlRig", sequence)
#add_key_example(sequence, i)
control_by_control(pose_asset_path, sequence, frame=i)
job_name = "FA_0073"
end = time.time()
print(end-start)
MovieQueueRender(u_level_file, u_level_seq_file, u_preset_file, job_name)
end = time.time()
print(end-start)
|
import os
import json
import unreal
from Utilities.Utils import Singleton
class Shelf(metaclass=Singleton):
'''
This is a demo tool for showing how to create Chamelon Tools in Python
'''
MAXIMUM_ICON_COUNT = 12
Visible = "Visible"
Collapsed = "Collapsed"
def __init__(self, jsonPath:str):
self.jsonPath = jsonPath
self.data = unreal.PythonBPLib.get_chameleon_data(self.jsonPath)
self.shelf_data = self.load_data()
self.is_text_readonly = True
self.ui_drop_at_last_aka = "DropAtLast"
self.ui_drop_is_full_aka = "DropIsFull"
self.update_ui(bForce=True)
def update_ui(self, bForce=False):
visibles = [False] * Shelf.MAXIMUM_ICON_COUNT
for i, shortcut in enumerate(self.shelf_data.shortcuts):
if i >= Shelf.MAXIMUM_ICON_COUNT:
continue
self.data.set_visibility(self.get_ui_button_group_name(i), Shelf.Visible)
self.data.set_tool_tip_text(self.get_ui_button_group_name(i), self.shelf_data.shortcuts[i].get_tool_tips())
self.data.set_text(self.get_ui_text_name(i), self.shelf_data.shortcuts[i].text)
# ITEM_TYPE_PY_CMD = 1 ITEM_TYPE_CHAMELEON = 2 ITEM_TYPE_ACTOR = 3 ITEM_TYPE_ASSETS = 4 ITEM_TYPE_ASSETS_FOLDER = 5
icon_name = ["PythonTextGreyIcon_40x.png", "PythonChameleonGreyIcon_40x.png", "LitSphere_40x.png", "Primitive_40x.png", "folderIcon.png"][shortcut.drop_type-1]
if os.path.exists(os.path.join(os.path.dirname(__file__), f"Images/{icon_name}")):
self.data.set_image_from(self.get_ui_img_name(i), f"Images/{icon_name}")
else:
unreal.log_warning("file: {} not exists in this tool's folder: {}".format(f"Images/{icon_name}", os.path.join(os.path.dirname(__file__))))
visibles[i] = True
for i, v in enumerate(visibles):
if not v:
self.data.set_visibility(self.get_ui_button_group_name(i), Shelf.Collapsed)
self.lock_text(self.is_text_readonly, bForce)
bFull = len(self.shelf_data) == Shelf.MAXIMUM_ICON_COUNT
self.data.set_visibility(self.ui_drop_at_last_aka, "Collapsed" if bFull else "Visible")
self.data.set_visibility(self.ui_drop_is_full_aka, "Visible" if bFull else "Collapsed" )
def lock_text(self, bLock, bForce=False):
if self.is_text_readonly != bLock or bForce:
for i in range(Shelf.MAXIMUM_ICON_COUNT):
self.data.set_text_read_only(self.get_ui_text_name(i), bLock)
self.data.set_color_and_opacity(self.get_ui_text_name(i), [1,1,1,1] if bLock else [1,0,0,1])
self.data.set_visibility(self.get_ui_text_name(i), "HitTestInvisible" if bLock else "Visible" )
self.is_text_readonly = bLock
def get_ui_button_group_name(self, index):
return f"ButtonGroup_{index}"
def get_ui_text_name(self, index):
return f"Txt_{index}"
def get_ui_img_name(self, index):
return f"Img_{index}"
def on_close(self):
self.save_data()
def get_data_path(self):
return os.path.join(os.path.dirname(__file__), "saved_shelf.json")
def load_data(self):
saved_file_path = self.get_data_path()
if os.path.exists(saved_file_path):
return ShelfData.load(saved_file_path)
else:
return ShelfData()
def save_data(self):
# fetch text from UI
for i, shortcut in enumerate(self.shelf_data.shortcuts):
shortcut.text = self.data.get_text(self.get_ui_text_name(i))
saved_file_path = self.get_data_path()
if self.shelf_data != None:
ShelfData.save(self.shelf_data, saved_file_path)
else:
unreal.log_warning("data null")
def clear_shelf(self):
self.shelf_data.clear()
self.update_ui()
def set_item_to_shelf(self, index, shelf_item):
if index >= len(self.shelf_data):
self.shelf_data.add(shelf_item)
else:
self.shelf_data.set(index, shelf_item)
self.update_ui()
# add shortcuts
def add_py_code_shortcut(self, index, py_code):
shelf_item = ShelfItem(icon="", drop_type=ShelfItem.ITEM_TYPE_PY_CMD)
shelf_item.py_cmd = py_code
shelf_item.text=py_code[:3]
self.set_item_to_shelf(index, shelf_item)
def add_chameleon_shortcut(self, index, chameleon_json):
short_name = os.path.basename(chameleon_json)
if short_name.lower().startswith("chameleon") and len(short_name) > 9:
short_name = short_name[9:]
shelf_item = ShelfItem(icon="", drop_type=ShelfItem.ITEM_TYPE_CHAMELEON)
shelf_item.chameleon_json = chameleon_json
shelf_item.text = short_name[:3]
self.set_item_to_shelf(index, shelf_item)
def add_actors_shortcut(self, index, actor_names):
shelf_item = ShelfItem(icon="", drop_type=ShelfItem.ITEM_TYPE_ACTOR)
shelf_item.actors = actor_names
shelf_item.text = shelf_item.actors[0][:3] if shelf_item.actors else ""
shelf_item.text += str(len(shelf_item.actors))
self.set_item_to_shelf(index, shelf_item)
def add_assets_shortcut(self, index, assets):
shelf_item = ShelfItem(icon="", drop_type=ShelfItem.ITEM_TYPE_ASSETS)
shelf_item.assets = assets
if assets:
first_asset = unreal.load_asset(assets[0])
if first_asset:
shelf_item.text = f"{first_asset.get_name()[:3]}{str(len(shelf_item.assets)) if len(shelf_item.assets)>1 else ''}"
else:
shelf_item.text = "None"
else:
shelf_item.text = ""
self.set_item_to_shelf(index, shelf_item)
def add_folders_shortcut(self, index, folders):
shelf_item = ShelfItem(icon="", drop_type=ShelfItem.ITEM_TYPE_ASSETS_FOLDER)
shelf_item.folders = folders
if folders:
shelf_item.text = f"{(os.path.basename(folders[0]))[:3]}{str(len(folders)) if len(folders)>1 else ''}"
else:
shelf_item.text = ""
self.set_item_to_shelf(index, shelf_item)
def get_dropped_by_type(self, *args, **kwargs):
py_cmd = kwargs.get("text", "")
file_names = kwargs.get("files", None)
if file_names:
json_files = [n for n in file_names if n.lower().endswith(".json")]
chameleon_json = json_files[0] if json_files else ""
else:
chameleon_json = ""
actors = kwargs.get("actors", [])
assets = kwargs.get("assets", [])
folders = kwargs.get("assets_folders", [])
return py_cmd, chameleon_json, actors, assets, folders
def on_drop(self, id, *args, **kwargs):
print(f"OnDrop: id:{id} {kwargs}")
py_cmd, chameleon_json, actors, assets, folders = self.get_dropped_by_type(*args, **kwargs)
if chameleon_json:
self.add_chameleon_shortcut(id, chameleon_json)
elif py_cmd:
self.add_py_code_shortcut(id, py_cmd)
elif actors:
self.add_actors_shortcut(id, actors)
elif assets:
self.add_assets_shortcut(id, assets)
elif folders:
self.add_folders_shortcut(id, folders)
else:
print("Drop python snippet, chameleon json, actors or assets.")
def on_drop_last(self, *args, **kwargs):
print(f"on drop last: {args}, {kwargs}")
if len(self.shelf_data) <= Shelf.MAXIMUM_ICON_COUNT:
self.on_drop(len(self.shelf_data) + 1, *args, **kwargs)
def select_actors(self, actor_names):
actors = [unreal.PythonBPLib.find_actor_by_name(name) for name in actor_names]
unreal.PythonBPLib.select_none()
for i, actor in enumerate(actors):
if actor:
unreal.PythonBPLib.select_actor(actor, selected=True, notify=True, force_refresh= i == len(actors)-1)
def select_assets(self, assets):
exists_assets = [asset for asset in assets if unreal.EditorAssetLibrary.does_asset_exist(asset)]
unreal.PythonBPLib.set_selected_assets_by_paths(exists_assets)
def select_assets_folders(self, assets_folders):
print(f"select_assets_folders: {assets_folders}")
unreal.PythonBPLib.set_selected_folder(assets_folders)
def on_button_click(self, id):
shortcut = self.shelf_data.shortcuts[id]
if not shortcut:
unreal.log_warning("shortcut == None")
return
if shortcut.drop_type == ShelfItem.ITEM_TYPE_PY_CMD:
eval(shortcut.py_cmd)
elif shortcut.drop_type == ShelfItem.ITEM_TYPE_CHAMELEON:
unreal.ChameleonData.launch_chameleon_tool(shortcut.chameleon_json)
elif shortcut.drop_type == ShelfItem.ITEM_TYPE_ACTOR:
self.select_actors(shortcut.actors) # do anything what you want
elif shortcut.drop_type == ShelfItem.ITEM_TYPE_ASSETS:
self.select_assets(shortcut.assets)
elif shortcut.drop_type == ShelfItem.ITEM_TYPE_ASSETS_FOLDER:
self.select_assets_folders(shortcut.folders)
class ShelfItem:
ITEM_TYPE_NONE = 0
ITEM_TYPE_PY_CMD = 1
ITEM_TYPE_CHAMELEON = 2
ITEM_TYPE_ACTOR = 3
ITEM_TYPE_ASSETS = 4
ITEM_TYPE_ASSETS_FOLDER = 5
def __init__(self, drop_type, icon=""):
self.drop_type = drop_type
self.icon = icon
self.py_cmd = ""
self.chameleon_json = ""
self.actors = []
self.assets = []
self.folders = []
self.text = ""
def get_tool_tips(self):
if self.drop_type == ShelfItem.ITEM_TYPE_PY_CMD:
return f"PyCmd: {self.py_cmd}"
elif self.drop_type == ShelfItem.ITEM_TYPE_CHAMELEON:
return f"Chameleon Tools: {os.path.basename(self.chameleon_json)}"
elif self.drop_type == ShelfItem.ITEM_TYPE_ACTOR:
return f"{len(self.actors)} actors: {self.actors}"
elif self.drop_type == ShelfItem.ITEM_TYPE_ASSETS:
return f"{len(self.assets)} actors: {self.assets}"
elif self.drop_type == ShelfItem.ITEM_TYPE_ASSETS_FOLDER:
return f"{len(self.folders)} folders: {self.folders}"
class ShelfData:
def __init__(self):
self.shortcuts = []
def __len__(self):
return len(self.shortcuts)
def add(self, item):
assert isinstance(item, ShelfItem)
self.shortcuts.append(item)
def set(self, index, item):
assert isinstance(item, ShelfItem)
self.shortcuts[index] = item
def clear(self):
self.shortcuts.clear()
@staticmethod
def save(shelf_data, file_path):
with open(file_path, 'w') as f:
f.write(json.dumps(shelf_data, default=lambda o: o.__dict__, sort_keys=True, indent=4))
print(f"Shelf data saved: {file_path}")
@staticmethod
def load(file_path):
if not os.path.exists(file_path):
return None
with open(file_path, 'r') as f:
content = json.load(f)
instance = ShelfData()
instance.shortcuts = []
for item in content["shortcuts"]:
shelf_item = ShelfItem(item["drop_type"], item["icon"])
shelf_item.py_cmd = item["py_cmd"]
shelf_item.chameleon_json = item["chameleon_json"]
shelf_item.text = item["text"]
shelf_item.actors = item["actors"]
shelf_item.assets = item["assets"]
shelf_item.folders = item["folders"]
instance.shortcuts.append(shelf_item)
return instance
|
# Copyright (c) 2023 Max Planck Society
# License: https://bedlam.is.tuebingen.mpg.de/license.html
#
# Import clothing textures and generate MaterialInstances
#
import os
from pathlib import Path
import sys
import time
import unreal
DATA_ROOT = r"/project/"
DATA_ROOT_UNREAL = "/project/"
MASTER_MATERIAL_PATH = "/project/"
def import_textures(texture_paths):
master_material = unreal.EditorAssetLibrary.load_asset(f"Material'{MASTER_MATERIAL_PATH}'")
if not master_material:
unreal.log_error(f"Cannot load master material: {MASTER_MATERIAL_PATH}")
return False
for texture_path in texture_paths:
unreal.log(f"Processing {texture_path}")
# Check if texture is already imported
# clothing_abc\rp_aaron_posed_002\clothing_textures\texture_01\texture_01_diffuse_1001.png
subject_name = texture_path.parent.parent.parent.name
texture_name = texture_path.parent.name
import_tasks = []
# Diffuse texture
texture_asset_name = f"T_{subject_name}_{texture_name}_diffuse"
texture_asset_dir = f"{DATA_ROOT_UNREAL}/{subject_name}"
texture_asset_path = f"{texture_asset_dir}/{texture_asset_name}"
if unreal.EditorAssetLibrary.does_asset_exist(texture_asset_path):
unreal.log(" Skipping. Already imported: " + texture_asset_path)
else:
unreal.log(" Importing: " + texture_asset_path)
task = unreal.AssetImportTask()
task.set_editor_property("filename", str(texture_path))
task.set_editor_property("destination_name", texture_asset_name)
task.set_editor_property("destination_path", texture_asset_dir)
task.set_editor_property('save', True)
import_tasks.append(task)
# Normal texture
normal_texture_path = texture_path.parent / texture_path.name.replace("diffuse", "normal")
normal_texture_asset_name = f"T_{subject_name}_{texture_name}_normal"
normal_texture_asset_path = f"{texture_asset_dir}/{normal_texture_asset_name}"
if unreal.EditorAssetLibrary.does_asset_exist(normal_texture_asset_path):
unreal.log(" Skipping. Already imported: " + normal_texture_asset_path)
else:
unreal.log(" Importing: " + normal_texture_asset_path)
task = unreal.AssetImportTask()
task.set_editor_property("filename", str(normal_texture_path))
task.set_editor_property("destination_name", normal_texture_asset_name)
task.set_editor_property("destination_path", texture_asset_dir)
task.set_editor_property('save', True)
import_tasks.append(task)
# Import diffuse and normal textures
unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks(import_tasks)
# Load diffuse and normal textures
texture_asset = unreal.EditorAssetLibrary.load_asset(f"Texture2D'{texture_asset_path}'")
if not texture_asset:
unreal.log_error(f"Cannot load texture: {texture_asset_path}")
return False
normal_texture_asset = unreal.EditorAssetLibrary.load_asset(f"Texture2D'{normal_texture_asset_path}'")
if not texture_asset:
unreal.log_error(f"Cannot load texture: {normal_texture_asset_path}")
return False
# Create MaterialInstance
material_instance_name = f"MI_{subject_name}_{texture_name}"
material_instance_dir = texture_asset_dir
material_instance_path = f"{material_instance_dir}/{material_instance_name}"
if unreal.EditorAssetLibrary.does_asset_exist(material_instance_path):
unreal.log(" Skipping. MaterialInstance exists: " + material_instance_path)
else:
unreal.log(f" Creating MaterialInstance: {material_instance_path}")
material_instance = unreal.AssetToolsHelpers.get_asset_tools().create_asset(asset_name=material_instance_name, package_path=material_instance_dir, asset_class=unreal.MaterialInstanceConstant, factory=unreal.MaterialInstanceConstantFactoryNew())
unreal.MaterialEditingLibrary.set_material_instance_parent(material_instance, master_material)
unreal.MaterialEditingLibrary.set_material_instance_texture_parameter_value(material_instance, 'BaseColor', texture_asset)
unreal.MaterialEditingLibrary.set_material_instance_texture_parameter_value(material_instance, 'Normal', normal_texture_asset)
return True
######################################################################
# Main
######################################################################
if __name__ == "__main__":
unreal.log("============================================================")
unreal.log("Running: %s" % __file__)
# Build import list
import_texture_paths = sorted(Path(DATA_ROOT).rglob("*diffuse*.png"))
import_textures(import_texture_paths)
|
'''
# SM Actor, Decal Actor 대응
import unreal
# SM Actor, BP 내 SM Actor, Decal Actor
selected_assets = unreal.EditorLevelLibrary.get_selected_level_actors()
source_path = '/project/'
editor_asset_library = unreal.EditorAssetLibrary()
# MI Copy
def copy_material_instance(material_instance, source_path):
material_instance_name = material_instance.get_name()
new_path = source_path + material_instance_name
if editor_asset_library.duplicate_asset(material_instance.get_path_name(), new_path):
unreal.log(f"Copied {material_instance_name} to {source_path}")
else:
unreal.log_error(f"Failed to copy {material_instance_name} to {source_path}")
# MI Replace
def replace_material_instance(actor, material_instance, source_path):
material_instance_name = material_instance.get_name()
new_material_instance_path = source_path + material_instance_name + '.' + material_instance_name
new_material_instance = unreal.EditorAssetLibrary.load_asset(new_material_instance_path)
if not new_material_instance:
unreal.log_error(f"Failed to load material instance: {new_material_instance_path}")
return
if isinstance(actor, unreal.StaticMeshActor):
get_smComp = actor.static_mesh_component
for index, mat in enumerate(get_smComp.get_materials()):
if mat == material_instance:
get_smComp.set_material(index, new_material_instance)
unreal.log(f"Replaced material instance {material_instance_name} in StaticMeshActor {actor.get_name()}")
elif isinstance(actor, unreal.DecalActor)
elif isinstance(actor.get_class(), unreal.BlueprintGeneratedClass):
actor_components = actor.get_components_by_class(unreal.ActorComponent)
for comp in actor_components:
if isinstance(comp, unreal.StaticMeshComponent):
for index, mat in enumerate(comp.get_materials()):
if mat == material_instance:
comp.set_material(index, new_material_instance)
unreal.log(f"Replaced material instance {material_instance_name} in Blueprint {actor.get_name()}")
for actor in selected_assets:
actor_class = actor.get_class()
# StaticMeshActor 대응
if isinstance(actor, unreal.StaticMeshActor):
get_smComp = actor.static_mesh_component
for get_mi in get_smComp.get_materials():
if get_mi is not None:
copy_material_instance(get_mi, source_path)
replace_material_instance(actor, get_mi, source_path)
# Blueprint 대응
elif isinstance(actor_class, unreal.BlueprintGeneratedClass):
actor_components = actor.get_components_by_class(unreal.ActorComponent)
for comp in actor_components:
if isinstance(comp, unreal.StaticMeshComponent):
for get_mi in comp.get_materials():
if get_mi is not None:
copy_material_instance(get_mi, source_path)
replace_material_instance(actor, get_mi, source_path)
'''
# SM Actor, Decal Actor, BP 내 SM Comp 대응
import unreal
selected_assets = unreal.EditorLevelLibrary.get_selected_level_actors()
source_path = '/project/'
editor_asset_library = unreal.EditorAssetLibrary()
# MI Copy
def copy_material_instance(material_instance, source_path):
material_instance_name = material_instance.get_name()
new_path = source_path + material_instance_name
if editor_asset_library.duplicate_asset(material_instance.get_path_name(), new_path):
unreal.log(f"Copied {material_instance_name} to {source_path}")
else:
unreal.log_error(f"Failed to copy {material_instance_name} to {source_path}")
# MI Replace
def replace_material_instance(actor, material_instance, source_path):
material_instance_name = material_instance.get_name()
new_material_instance_path = source_path + material_instance_name + '.' + material_instance_name
new_material_instance = unreal.EditorAssetLibrary.load_asset(new_material_instance_path)
if not new_material_instance:
unreal.log_error(f"Failed to load material instance: {new_material_instance_path}")
return
if isinstance(actor, unreal.StaticMeshActor):
get_smComp = actor.static_mesh_component
for index, mat in enumerate(get_smComp.get_materials()):
if mat == material_instance:
get_smComp.set_material(index, new_material_instance)
unreal.log(f"Replaced material instance {material_instance_name} in StaticMeshActor {actor.get_name()}")
elif isinstance(actor.get_class(), unreal.BlueprintGeneratedClass):
actor_components = actor.get_components_by_class(unreal.ActorComponent)
for comp in actor_components:
if isinstance(comp, unreal.StaticMeshComponent):
for index, mat in enumerate(comp.get_materials()):
if mat == material_instance:
comp.set_material(index, new_material_instance)
unreal.log(f"Replaced material instance {material_instance_name} in Blueprint {actor.get_name()}")
elif isinstance(actor, unreal.DecalActor) :
decal_comp = actor.decal
mat = decal_comp.get_decal_material()
if mat == material_instance:
decal_comp.set_decal_material(new_material_instance)
unreal.log(f"Replaced material instance {material_instance_name} in DecalActor {actor.get_name()}")
for actor in selected_assets:
actor_class = actor.get_class()
# SM Actor 대응
if isinstance(actor, unreal.StaticMeshActor):
get_smComp = actor.static_mesh_component
for get_mi in get_smComp.get_materials():
if get_mi is not None:
copy_material_instance(get_mi, source_path)
replace_material_instance(actor, get_mi, source_path)
# BP내 SMComp 대응
elif isinstance(actor_class, unreal.BlueprintGeneratedClass):
actor_components = actor.get_components_by_class(unreal.ActorComponent)
for comp in actor_components:
if isinstance(comp, unreal.StaticMeshComponent):
for get_mi in comp.get_materials():
if get_mi is not None:
copy_material_instance(get_mi, source_path)
replace_material_instance(actor, get_mi, source_path)
# DecalActor 대응
elif isinstance(actor, unreal.DecalActor):
decal_comp = actor.decal
mat = decal_comp.get_decal_material()
if mat is not None:
copy_material_instance(mat, source_path)
replace_material_instance(actor, mat, source_path)
|
"""
AutoMatty Menu Registration - PROPER IMPLEMENTATION
This file should be placed at: AutoMatty/project/.py
Runs ONCE on editor startup, avoiding class registration conflicts
"""
import unreal
@unreal.uclass()
class AutoMattyMaterialEditor(unreal.ToolMenuEntryScript):
"""Menu script for AutoMatty Material Editor"""
@unreal.ufunction(override=True)
def execute(self, context):
"""Execute when menu item is clicked"""
try:
# Simple import - no path discovery needed!
import automatty_material_instance_editor
import importlib
importlib.reload(automatty_material_instance_editor)
automatty_material_instance_editor.show_editor_for_selection()
unreal.log("🎯 AutoMatty Material Editor opened!")
except Exception as e:
unreal.log_error(f"❌ Failed to open AutoMatty editor: {e}")
@unreal.uclass()
class AutoMattyMainWidget(unreal.ToolMenuEntryScript):
"""Menu script for main AutoMatty widget"""
@unreal.ufunction(override=True)
def execute(self, context):
"""Execute when menu item is clicked"""
try:
# Open the main AutoMatty widget
subsystem = unreal.get_editor_subsystem(unreal.EditorUtilitySubsystem)
blueprint = unreal.EditorAssetLibrary.load_asset("/project/")
if blueprint:
widget = subsystem.spawn_and_register_tab(blueprint)
if widget:
unreal.log("🎯 AutoMatty main widget opened!")
else:
unreal.log_error("❌ Failed to spawn AutoMatty widget")
else:
unreal.log_error("❌ Could not load EUW_AutoMatty blueprint")
except Exception as e:
unreal.log_error(f"❌ Failed to open AutoMatty widget: {e}")
def register_automatty_menus():
"""Register AutoMatty menu entries"""
try:
# Get the Tools menu
menus = unreal.ToolMenus.get()
tools_menu = menus.find_menu("LevelEditor.MainMenu.Tools")
if not tools_menu:
unreal.log_error("❌ Could not find Tools menu")
return False
# 1. MAIN WIDGET ENTRY
widget_script = AutoMattyMainWidget()
widget_script.init_entry(
owner_name="AutoMatty",
menu="LevelEditor.MainMenu.Tools",
section="LevelEditorModules",
name="AutoMattyWidget",
label="AutoMatty",
tool_tip="Open AutoMatty main widget"
)
widget_script.register_menu_entry()
# 2. MATERIAL EDITOR ENTRY
editor_script = AutoMattyMaterialEditor()
editor_script.init_entry(
owner_name="AutoMatty",
menu="LevelEditor.MainMenu.Tools",
section="LevelEditorModules",
name="AutoMattyMaterialEditor",
label="AutoMatty Material Editor",
tool_tip="Open AutoMatty Material Instance Editor"
)
editor_script.register_menu_entry()
# Refresh menus
menus.refresh_all_widgets()
unreal.log("✅ AutoMatty menu entries registered!")
unreal.log("📋 Available in Tools menu:")
unreal.log(" • AutoMatty (main widget)")
unreal.log(" • AutoMatty Material Editor")
unreal.log("💡 Set hotkeys: Edit → Editor Preferences → Keyboard Shortcuts → Search 'AutoMatty'")
return True
except Exception as e:
unreal.log_error(f"❌ Menu registration failed: {e}")
return False
def main():
"""Main function called on startup"""
unreal.log("🚀 AutoMatty startup script running...")
register_automatty_menus()
from automatty_config import AutoMattyMenuManager
AutoMattyMenuManager.register_main_menu()
# Run the registration
if __name__ == '__main__':
main()
|
# Copyright (c) <2021> Side Effects Software Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. The name of Side Effects Software may not be used to endorse or
# promote products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
""" An example script that uses the API to instantiate an HDA and then
set 2 geometry inputs: one node input and one object path parameter
input. The inputs are set during post instantiation (before the first
cook). After the first cook and output creation (post processing) the
input structure is fetched and logged.
"""
import unreal
_g_wrapper = None
def get_test_hda_path():
return '/project/.subnet_test_2_0'
def get_test_hda():
return unreal.load_object(None, get_test_hda_path())
def get_geo_asset_path():
return '/project/.Cube'
def get_geo_asset():
return unreal.load_object(None, get_geo_asset_path())
def get_cylinder_asset_path():
return '/project/.Cylinder'
def get_cylinder_asset():
return unreal.load_object(None, get_cylinder_asset_path())
def configure_inputs(in_wrapper):
print('configure_inputs')
# Unbind from the delegate
in_wrapper.on_post_instantiation_delegate.remove_callable(configure_inputs)
# Deprecated input functions
# in_wrapper.set_input_type(0, unreal.HoudiniInputType.GEOMETRY)
# in_wrapper.set_input_objects(0, (get_geo_asset(), ))
# in_wrapper.set_input_type(1, unreal.HoudiniInputType.GEOMETRY)
# in_wrapper.set_input_objects(1, (get_geo_asset(), ))
# in_wrapper.set_input_import_as_reference(1, True)
# Create a geometry input
geo_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPIGeoInput)
# Set the input objects/assets for this input
geo_asset = get_geo_asset()
geo_input.set_input_objects((geo_asset, ))
# Set the transform of the input geo
geo_input.set_input_object_transform_offset(
0,
unreal.Transform(
(200, 0, 100),
(45, 0, 45),
(2, 2, 2),
)
)
# copy the input data to the HDA as node input 0
in_wrapper.set_input_at_index(0, geo_input)
# We can now discard the API input object
geo_input = None
# Create a another geometry input
geo_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPIGeoInput)
# Set the input objects/assets for this input (cylinder in this case)
geo_asset = get_cylinder_asset()
geo_input.set_input_objects((geo_asset, ))
# Set the transform of the input geo
geo_input.set_input_object_transform_offset(
0,
unreal.Transform(
(-200, 0, 0),
(0, 0, 0),
(2, 2, 2),
)
)
# copy the input data to the HDA as input parameter 'objpath1'
in_wrapper.set_input_parameter('objpath1', geo_input)
# We can now discard the API input object
geo_input = None
# Set the subnet_test HDA to output its first input
in_wrapper.set_int_parameter_value('enable_geo', 1)
def print_api_input(in_input):
print('\t\tInput type: {0}'.format(in_input.__class__))
print('\t\tbKeepWorldTransform: {0}'.format(in_input.keep_world_transform))
print('\t\tbImportAsReference: {0}'.format(in_input.import_as_reference))
if isinstance(in_input, unreal.HoudiniPublicAPIGeoInput):
print('\t\tbPackBeforeMerge: {0}'.format(in_input.pack_before_merge))
print('\t\tbExportLODs: {0}'.format(in_input.export_lo_ds))
print('\t\tbExportSockets: {0}'.format(in_input.export_sockets))
print('\t\tbExportColliders: {0}'.format(in_input.export_colliders))
input_objects = in_input.get_input_objects()
if not input_objects:
print('\t\tEmpty input!')
else:
print('\t\tNumber of objects in input: {0}'.format(len(input_objects)))
for idx, input_object in enumerate(input_objects):
print('\t\t\tInput object #{0}: {1}'.format(idx, input_object))
if hasattr(in_input, 'get_input_object_transform_offset'):
print('\t\t\tObject Transform Offset: {0}'.format(in_input.get_input_object_transform_offset(idx)))
def print_inputs(in_wrapper):
print('print_inputs')
# Unbind from the delegate
in_wrapper.on_post_processing_delegate.remove_callable(print_inputs)
# Fetch inputs, iterate over it and log
node_inputs = in_wrapper.get_inputs_at_indices()
parm_inputs = in_wrapper.get_input_parameters()
if not node_inputs:
print('No node inputs found!')
else:
print('Number of node inputs: {0}'.format(len(node_inputs)))
for input_index, input_wrapper in node_inputs.items():
print('\tInput index: {0}'.format(input_index))
print_api_input(input_wrapper)
if not parm_inputs:
print('No parameter inputs found!')
else:
print('Number of parameter inputs: {0}'.format(len(parm_inputs)))
for parm_name, input_wrapper in parm_inputs.items():
print('\tInput parameter name: {0}'.format(parm_name))
print_api_input(input_wrapper)
def run():
# get the API singleton
api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
global _g_wrapper
# instantiate an asset with auto-cook enabled
_g_wrapper = api.instantiate_asset(get_test_hda(), unreal.Transform())
# Configure inputs on_post_instantiation, after instantiation, but before first cook
_g_wrapper.on_post_instantiation_delegate.add_callable(configure_inputs)
# Bind on_post_processing, after cook + output creation
_g_wrapper.on_post_processing_delegate.add_callable(print_inputs)
if __name__ == '__main__':
run()
|
import unreal # type: ignore
import os
import datetime
import json
import tkinter as tk
from tkinter import filedialog
image_ext = ".jpeg"
floor_bp, room_bp, pano_point_bp = [
unreal.load_asset("/project/" + blueprint_name).generated_class()
for blueprint_name in ["BP_Floor", "BP_Room", "BP_PanoPoint"]
]
def getActorsOfClass(bp, all_actors):
return enumerate(sorted([actor for actor in all_actors if actor.get_class() == bp], key=lambda a: a.get_actor_label()))
def getActorEditorProperty(a, prop: str):
try:
return a.get_editor_property(prop)
except Exception:
return None
def print_dict(d, tabs=1):
for k, v in d.items():
print("\t" * tabs, k, " : ", v)
print("_" * 20)
def getThreeCoords(pano, height, con):
v = con.get_actor_location() - pano.get_actor_location() - unreal.Vector(0, 0, height)
return {
"x": -v.x,
"y": v.z,
"z": -v.y,
}
def collect_level_data(folder_path, floorData = {}, roomData = {}, panoPointData = {}):
# Initialize Tkinter root
print(f"Selected folder: {folder_path}")
# Remove exit() to allow script to continue
# exit()
# Setup
floor_id_inc = 0
room_id_inc = 0
pano_id_inc = 0
all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
# Collect floor data
for i, floor in getActorsOfClass(floor_bp, all_actors):
fl_data = {}
fl_data["floor_id"] = i + floor_id_inc
fl_data["floor_name"] = getActorEditorProperty(floor, 'FloorName')
fl_data["label"] = ""
floorData[floor] = fl_data
# Collect room data
for i, room in getActorsOfClass(room_bp, all_actors):
r_data = {}
r_data["Room_ID"] = i + room_id_inc
r_data["Room_Name"] = getActorEditorProperty(room, 'RoomName')
r_data["Floor"] = getActorEditorProperty(room, "Floor")
r_data["Location"] = room.get_actor_location(),
r_data["Main_Panorama"] = getActorEditorProperty(room, "MainPanorama")
roomData[room] = r_data
# Collect pano point data
for i, pano in getActorsOfClass(pano_point_bp, all_actors):
p_data = {}
p_data["PanoPoint_ID"] = i + pano_id_inc
p_data["PanoIdentifier"] = getActorEditorProperty(pano, "PanoIdentifier")
p_data["Room"] = getActorEditorProperty(pano, "Room")
p_data["Height"] = getActorEditorProperty(pano, "Height")
p_data["defaultRotation"] = getActorEditorProperty(pano, "defaultRotation")
p_data["2WayConnections"] = getActorEditorProperty(pano, "2WayConnections")
p_data["1WayConnections"] = getActorEditorProperty(pano, "1WayConnections")
panoPointData[pano] = p_data
return floorData, roomData, panoPointData
def write_pano_data(data_folder_path, floorData, panoPointData, roomData, processed_render_dir):
for floor in floorData:
floorData[floor]["floor_map"] = os.path.join(os.path.dirname(data_folder_path), "/project/", f"{floor['floor_id']}.jpeg")
floor_json = list(floorData.values())
room_json = []
for room, data in roomData.items():
room_json.append(
{
"room_id": data["Room_ID"],
"room_name": data["Room_Name"],
"main_panorama_id": panoPointData[data["Main_Panorama"]]["PanoPoint_ID"] if data["Main_Panorama"] else -1,
"position": {
"x": data["Location"][0].x,
"y": data["Location"][0].y,
},
"floor_id": floorData[data["Floor"]]["floor_id"] if data["Floor"] else -1,
}
)
pano_json = []
marker_json = []
for pano, data in panoPointData.items():
pano_json.append(
{
"panorma_id": data["PanoPoint_ID"],
"default_rotation": data["defaultRotation"],
"image_data":
{tod:
{fur:
{
f"{im_d}{im_ax}":
f"{processed_render_dir}/{roomData[data['Room']]['Room_Name']}_{data['PanoIdentifier']}_{'d'}_{'f' if (fur == 'furnished') else 'u'}/{im_d}{im_ax}{image_ext}"
for im_d in "pn" for im_ax in "xyz"}
for fur in ["furnished", "unfurnished"]}
for tod in ["day", "night"]
},
"room_id": roomData[data["Room"]]["Room_ID"] if data["Room"] else -1,
}
)
marker_count = 0
for con in list(data["2WayConnections"]) + list(data["1WayConnections"]):
try:
marker_json.append({
"marker_id": marker_count,
"panorma_id": data["PanoPoint_ID"],
"position": getThreeCoords(pano, data["Height"], con),
"target_panorama_id": panoPointData[con]["PanoPoint_ID"],
})
marker_count += 1
except Exception as e:
print(f"Error processing connection for pano {data['PanoIdentifier']} to {con}: {e}")
for file, dict in (("floor_data.json", floor_json), ("room_data.json", room_json), ("pano_data.json", pano_json), ("marker_data.json", marker_json)):
outpath = os.path.join(data_folder_path, file)
with open(outpath, "w") as f:
json.dump(dict, f, indent=4)
print(f"Data exported to {outpath}")
if __name__ == "__main__":
root = tk.Tk()
root.withdraw() # Hide the root window
fp = filedialog.askdirectory(title="Select the folder containing panorama data")
collect_level_data(fp)
|
# coding: utf-8
import unreal
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-vrm")
parser.add_argument("-rig")
parser.add_argument("-meta")
args = parser.parse_args()
print(args.vrm)
#print(dummy[3])
humanoidBoneList = [
"hips",
"leftUpperLeg",
"rightUpperLeg",
"leftLowerLeg",
"rightLowerLeg",
"leftFoot",
"rightFoot",
"spine",
"chest",
"upperChest", # 9 optional
"neck",
"head",
"leftShoulder",
"rightShoulder",
"leftUpperArm",
"rightUpperArm",
"leftLowerArm",
"rightLowerArm",
"leftHand",
"rightHand",
"leftToes",
"rightToes",
"leftEye",
"rightEye",
"jaw",
"leftThumbProximal", # 24
"leftThumbIntermediate",
"leftThumbDistal",
"leftIndexProximal",
"leftIndexIntermediate",
"leftIndexDistal",
"leftMiddleProximal",
"leftMiddleIntermediate",
"leftMiddleDistal",
"leftRingProximal",
"leftRingIntermediate",
"leftRingDistal",
"leftLittleProximal",
"leftLittleIntermediate",
"leftLittleDistal",
"rightThumbProximal",
"rightThumbIntermediate",
"rightThumbDistal",
"rightIndexProximal",
"rightIndexIntermediate",
"rightIndexDistal",
"rightMiddleProximal",
"rightMiddleIntermediate",
"rightMiddleDistal",
"rightRingProximal",
"rightRingIntermediate",
"rightRingDistal",
"rightLittleProximal",
"rightLittleIntermediate",
"rightLittleDistal", #54
]
humanoidBoneParentList = [
"", #"hips",
"hips",#"leftUpperLeg",
"hips",#"rightUpperLeg",
"leftUpperLeg",#"leftLowerLeg",
"rightUpperLeg",#"rightLowerLeg",
"leftLowerLeg",#"leftFoot",
"rightLowerLeg",#"rightFoot",
"hips",#"spine",
"spine",#"chest",
"chest",#"upperChest" 9 optional
"chest",#"neck",
"neck",#"head",
"chest",#"leftShoulder", # <-- upper..
"chest",#"rightShoulder",
"leftShoulder",#"leftUpperArm",
"rightShoulder",#"rightUpperArm",
"leftUpperArm",#"leftLowerArm",
"rightUpperArm",#"rightLowerArm",
"leftLowerArm",#"leftHand",
"rightLowerArm",#"rightHand",
"leftFoot",#"leftToes",
"rightFoot",#"rightToes",
"head",#"leftEye",
"head",#"rightEye",
"head",#"jaw",
"leftHand",#"leftThumbProximal",
"leftThumbProximal",#"leftThumbIntermediate",
"leftThumbIntermediate",#"leftThumbDistal",
"leftHand",#"leftIndexProximal",
"leftIndexProximal",#"leftIndexIntermediate",
"leftIndexIntermediate",#"leftIndexDistal",
"leftHand",#"leftMiddleProximal",
"leftMiddleProximal",#"leftMiddleIntermediate",
"leftMiddleIntermediate",#"leftMiddleDistal",
"leftHand",#"leftRingProximal",
"leftRingProximal",#"leftRingIntermediate",
"leftRingIntermediate",#"leftRingDistal",
"leftHand",#"leftLittleProximal",
"leftLittleProximal",#"leftLittleIntermediate",
"leftLittleIntermediate",#"leftLittleDistal",
"rightHand",#"rightThumbProximal",
"rightThumbProximal",#"rightThumbIntermediate",
"rightThumbIntermediate",#"rightThumbDistal",
"rightHand",#"rightIndexProximal",
"rightIndexProximal",#"rightIndexIntermediate",
"rightIndexIntermediate",#"rightIndexDistal",
"rightHand",#"rightMiddleProximal",
"rightMiddleProximal",#"rightMiddleIntermediate",
"rightMiddleIntermediate",#"rightMiddleDistal",
"rightHand",#"rightRingProximal",
"rightRingProximal",#"rightRingIntermediate",
"rightRingIntermediate",#"rightRingDistal",
"rightHand",#"rightLittleProximal",
"rightLittleProximal",#"rightLittleIntermediate",
"rightLittleIntermediate",#"rightLittleDistal",
]
for i in range(len(humanoidBoneList)):
humanoidBoneList[i] = humanoidBoneList[i].lower()
for i in range(len(humanoidBoneParentList)):
humanoidBoneParentList[i] = humanoidBoneParentList[i].lower()
######
reg = unreal.AssetRegistryHelpers.get_asset_registry();
##
rigs = unreal.ControlRigBlueprint.get_currently_open_rig_blueprints()
print(rigs)
for r in rigs:
s:str = r.get_path_name()
ss:str = args.rig
if (s.find(ss) < 0):
print("no rig")
else:
rig = r
#rig = rigs[10]
h_mod = rig.get_hierarchy_modifier()
#elements = h_mod.get_selection()
#sk = rig.get_preview_mesh()
#k = sk.skeleton
#print(k)
#print(sk.bone_tree)
#
#kk = unreal.RigElementKey(unreal.RigElementType.BONE, "hipssss");
#kk.name = ""
#kk.type = 1;
#print(h_mod.get_bone(kk))
#print(h_mod.get_elements())
### 全ての骨
modelBoneListAll = []
modelBoneNameList = []
#for e in reversed(h_mod.get_elements()):
# if (e.type != unreal.RigElementType.BONE):
# h_mod.remove_element(e)
for e in h_mod.get_elements():
if (e.type == unreal.RigElementType.BONE):
modelBoneListAll.append(e)
modelBoneNameList.append("{}".format(e.name).lower())
# else:
# h_mod.remove_element(e)
print(modelBoneListAll[0])
#exit
#print(k.get_editor_property("bone_tree")[0].get_editor_property("translation_retargeting_mode"))
#print(k.get_editor_property("bone_tree")[0].get_editor_property("parent_index"))
#unreal.select
#vrmlist = unreal.VrmAssetListObject
#vrmmeta = vrmlist.vrm_meta_object
#print(vrmmeta.humanoid_bone_table)
#selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
#selected_static_mesh_actors = unreal.EditorFilterLibrary.by_class(selected_actors,unreal.StaticMeshActor.static_class())
#static_meshes = np.array([])
## meta 取得
reg = unreal.AssetRegistryHelpers.get_asset_registry();
a = reg.get_all_assets();
if (args.meta):
for aa in a:
if (aa.get_editor_property("object_path") == args.meta):
v:unreal.VrmMetaObject = aa
vv = aa.get_asset()
if (vv == None):
for aa in a:
if (aa.get_editor_property("object_path") == args.vrm):
v:unreal.VrmAssetListObject = aa
vv = v.get_asset().vrm_meta_object
print(vv)
meta = vv
#v:unreal.VrmAssetListObject = None
#if (True):
# a = reg.get_assets_by_path(args.vrm)
# a = reg.get_all_assets();
# for aa in a:
# if (aa.get_editor_property("object_path") == args.vrm):
# v:unreal.VrmAssetListObject = aa
#v = unreal.VrmAssetListObject.cast(v)
#print(v)
#unreal.VrmAssetListObject.vrm_meta_object
#meta = v.vrm_meta_object()
#meta = unreal.EditorFilterLibrary.by_class(asset,unreal.VrmMetaObject.static_class())
print (meta)
#print(meta[0].humanoid_bone_table)
### モデル骨のうち、ヒューマノイドと同じもの
### 上の変換テーブル
humanoidBoneToModel = {"" : ""}
humanoidBoneToModel.clear()
### modelBoneでループ
#for bone_h in meta.humanoid_bone_table:
for bone_h_base in humanoidBoneList:
bone_h = None
for e in meta.humanoid_bone_table:
if ("{}".format(e).lower() == bone_h_base):
bone_h = e;
break;
print("{}".format(bone_h))
if (bone_h==None):
continue
bone_m = meta.humanoid_bone_table[bone_h]
try:
i = modelBoneNameList.index(bone_m.lower())
except:
i = -1
if (i < 0):
continue
if ("{}".format(bone_h).lower() == "upperchest"):
continue;
humanoidBoneToModel["{}".format(bone_h).lower()] = "{}".format(bone_m).lower()
if ("{}".format(bone_h).lower() == "chest"):
#upperchestがあれば、これの次に追加
bh = 'upperchest'
print("upperchest: check begin")
for e in meta.humanoid_bone_table:
if ("{}".format(e).lower() != 'upperchest'):
continue
bm = "{}".format(meta.humanoid_bone_table[e]).lower()
if (bm == ''):
continue
humanoidBoneToModel[bh] = bm
humanoidBoneParentList[10] = "upperchest"
humanoidBoneParentList[12] = "upperchest"
humanoidBoneParentList[13] = "upperchest"
print("upperchest: find and insert parent")
break
print("upperchest: check end")
parent=None
control_to_mat={None:None}
count = 0
### 骨名からControlへのテーブル
name_to_control = {"dummy_for_table" : None}
print("loop begin")
###### root
key = unreal.RigElementKey(unreal.RigElementType.SPACE, 'root_s')
space = h_mod.get_space(key)
if (space.get_editor_property('index') < 0):
space = h_mod.add_space('root_s', space_type=unreal.RigSpaceType.SPACE)
else:
space = key
key = unreal.RigElementKey(unreal.RigElementType.CONTROL, 'root_c')
control = h_mod.get_control(key)
if (control.get_editor_property('index') < 0):
control = h_mod.add_control('root_c',
space_name=space.name,
gizmo_color=[1.0, 0.0, 0.0, 1.0],
)
else:
control = key
h_mod.reparent_element(control, space)
parent = control
cc = h_mod.get_control(control)
cc.set_editor_property('gizmo_visible', False)
h_mod.set_control(cc)
for ee in humanoidBoneToModel:
element = humanoidBoneToModel[ee]
humanoidBone = ee
modelBoneNameSmall = element
# 対象の骨
#modelBoneNameSmall = "{}".format(element.name).lower()
#humanoidBone = modelBoneToHumanoid[modelBoneNameSmall];
boneNo = humanoidBoneList.index(humanoidBone)
print("{}_{}_{}__parent={}".format(modelBoneNameSmall, humanoidBone, boneNo,humanoidBoneParentList[boneNo]))
# 親
if count != 0:
parent = name_to_control[humanoidBoneParentList[boneNo]]
# 階層作成
bIsNew = False
name_s = "{}_s".format(humanoidBone)
key = unreal.RigElementKey(unreal.RigElementType.SPACE, name_s)
space = h_mod.get_space(key)
if (space.get_editor_property('index') < 0):
space = h_mod.add_space(name_s, space_type=unreal.RigSpaceType.SPACE)
bIsNew = True
else:
space = key
name_c = "{}_c".format(humanoidBone)
key = unreal.RigElementKey(unreal.RigElementType.CONTROL, name_c)
control = h_mod.get_control(key)
if (control.get_editor_property('index') < 0):
control = h_mod.add_control(name_c,
space_name=space.name,
gizmo_color=[1.0, 0.0, 0.0, 1.0],
)
#h_mod.get_control(control).gizmo_transform = gizmo_trans
if (24<=boneNo & boneNo<=53):
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.1, 0.1, 0.1])
else:
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1, 1, 1])
if (17<=boneNo & boneNo<=18):
gizmo_trans = unreal.Transform([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1, 1, 1])
cc = h_mod.get_control(control)
cc.set_editor_property('gizmo_transform', gizmo_trans)
cc.set_editor_property('control_type', unreal.RigControlType.ROTATOR)
h_mod.set_control(cc)
#h_mod.set_control_value_transform(control,gizmo_trans)
bIsNew = True
else:
control = key
if (bIsNew == True):
h_mod.reparent_element(control, space)
# テーブル登録
name_to_control[humanoidBone] = control
print(humanoidBone)
# ロケータ 座標更新
# 不要な上層階層を考慮
gTransform = h_mod.get_global_transform(modelBoneListAll[modelBoneNameList.index(modelBoneNameSmall)])
if count == 0:
bone_initial_transform = gTransform
else:
#bone_initial_transform = h_mod.get_initial_transform(element)
bone_initial_transform = gTransform.multiply(control_to_mat[parent].inverse())
h_mod.set_initial_transform(space, bone_initial_transform)
control_to_mat[control] = gTransform
# 階層修正
h_mod.reparent_element(space, parent)
count += 1
if (count >= 500):
break
|
import unreal
_seek_comp_name : str = 'CapsuleComponent'
selected = unreal.EditorUtilityLibrary.get_selected_assets()[0]
name_selected = unreal.EditorAssetLibrary.get_path_name_for_loaded_asset(selected)
name_bp_c = name_selected + '_C'
loaded_bp = unreal.EditorAssetLibrary.load_blueprint_class(name_bp_c)
|
# Copyright Epic Games, Inc. All Rights Reserved.
import os
import fzf
import unreal
import p4utils
import flow.cmd
import subprocess
from peafour import P4
#-------------------------------------------------------------------------------
class _RestorePoint(object):
def __init__(self):
self._files = {}
self._shelf = None
def __del__(self):
if not self._files:
return
print("Attemping to restore changelists")
if self._shelf:
print("Unshelving...")
for item in P4.unshelve(s=self._shelf).read(on_error=False):
pass
print("Restoring...")
for cl, paths in self._files.items():
print(" ", cl)
for item in P4.reopen(paths, c=cl).read(on_error=False):
print(" ", item.depotFile)
def set_shelf(self, shelf):
self._shelf = shelf
def add_file(self, changelist, path):
out = self._files.setdefault(changelist, [])
out.append(path)
def clear(self):
self._files.clear()
#-------------------------------------------------------------------------------
class _SwitchCmd(flow.cmd.Cmd):
def _read_streams(self):
depot = self._depot.lower()
yield from (x for x in P4.streams() if x.Stream.lower().startswith(depot))
def main(self):
self.print_info("Perforce environment")
# Ensure there's a valid branch and Perforce ticket
branch = unreal.Context(".").get_branch()
if not branch:
raise EnvironmentError("Unable to find a valid branch")
os.chdir(branch.get_dir())
self._username = p4utils.login()
# Find out where we are and the stream
self._depot = None
info = P4.info().run()
self._src_stream = getattr(info, "clientStream", None)
if self._src_stream:
self._depot = "//" + self._src_stream[2:].split("/")[0] + "/"
print("Client:", info.clientName)
print(" User:", self._username)
print("Stream:", self._src_stream)
print(" Depot:", self._depot)
if not self._src_stream:
self.print_error(info.clientName, "is not a stream-based client")
return False
return self._main_impl()
#-------------------------------------------------------------------------------
class List(_SwitchCmd):
""" Prints a tree of available streams relevant to the current branch """
def _main_impl(self):
self.print_info("Available streams")
streams = {}
for item in self._read_streams():
stream = streams.setdefault(item.Stream, [None, []])
stream[0] = item
parent = streams.setdefault(item.Parent, [None, []])
parent[1].append(item.Stream)
def print_stream(name, depth=0):
item, children = streams[name]
prefix = ("| " * depth) + "+ "
dots = "." * (64 - len(item.Name) - (2 * depth))
print(flow.cmd.text.grey(prefix), item.Name, sep="", end=" ")
print(flow.cmd.text.grey(dots), end=" ")
print(item.Type)
for child in sorted(children):
print_stream(child, depth + 1)
_, roots = streams.get("none", (None, None))
if not roots:
print("None?")
return False
for root in roots:
print_stream(root)
#-------------------------------------------------------------------------------
class Switch(_SwitchCmd):
""" Switch between streams and integrate any open files across to the new
stream. If no stream name is provided then the user will be prompted to
select a stream from a list. Operates on the current directory's branch.
There maybe occasions where a stream is only partially synced like a temporary
client used for cherrypicking. The '--haveonly' can be used in cases liek this
to avoid syncing the whole branch post-switch and instead just update the
files synced prior to switching. Use with extraordinary caution!"""
stream = flow.cmd.Arg("", "Name of the stream to switch to")
changelist = flow.cmd.Arg(-1, "The changelist to sync to ('head' if unspecified)")
haveonly = flow.cmd.Opt(False, "Only switch files synced prior to the switch")
saferesolve = flow.cmd.Opt(False, "Resolve safely and not automatically")
def _select_stream(self):
self.print_info("Stream select")
print("Enter the stream to switch to (fuzzy, move with arrows, enter to select)...", end="")
stream_iter = (x.Name for x in self._read_streams())
for reply in fzf.run(stream_iter, height=10, prompt=self._depot):
return reply
@flow.cmd.Cmd.summarise
def _main_impl(self):
# Work out the destination stream.
if not self.args.stream:
dest_stream = self._select_stream()
if not dest_stream:
self.print_error("No stream selected")
return False
else:
dest_stream = self.args.stream
dest_stream = self._depot + dest_stream
# Check for the destination stream and correct its name
self.print_info("Checking destination")
stream = P4.streams(dest_stream, m=1).run()
dest_stream = stream.Stream
print("Stream:", dest_stream)
print("Parent:", stream.Parent)
print(" Type:", stream.Type)
self._dest_stream = dest_stream
if self._src_stream.casefold() == self._dest_stream.casefold():
self.print_warning("Already on stream", self._dest_stream)
return
# Move the user's opened files into a changelist
self.print_info("Shelving and reverting open files")
self._get_opened_files()
if len(self._opened_files):
shelf_cl = self._shelve_revert()
# Do the switch
P4.client(S=self._dest_stream, s=True).run()
if self.args.haveonly:
self._do_have_table_update()
else:
self._do_sync()
# Unshelve to restore user's open files
if len(self._opened_files):
self._restore_changes(shelf_cl)
def _do_have_table_update(self):
# This probably isn't correct if stream specs diff significantly
# betweeen source and destination.
def read_have_table():
for item in P4.have():
depot_path = item.depotFile
yield self._dest_stream + depot_path[len(self._src_stream):]
print("Updating have table; ", end="")
for i, item in enumerate(P4.sync(read_have_table()).read(on_error=False)):
print(i, "\b" * len(str(i)), end="", sep="")
for x in P4.sync(self._src_stream + "/...#have").read(on_error=False):
pass
print()
def _do_sync(self):
self.print_info("Syncing")
self.print_warning("If the sync is interrupted the branch will be a mix of files synced pre-")
self.print_warning("and post-switch. Should this happen `.p4 sync` can be used to recover but")
self.print_warning("any open files at the time of the switch will remain shelved.")
sync_cmd = ("_p4", "sync", "--all", "--noresolve", "--nosummary")
if self.args.changelist >= 0:
sync_cmd = (*sync_cmd, str(self.args.changelist))
popen_kwargs = {}
if os.name == "nt":
popen_kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
proc = subprocess.Popen(sync_cmd, **popen_kwargs)
proc.wait()
def _get_opened_files(self):
self._restore_point = _RestorePoint();
self._opened_files = {}
src_len = len(self._src_stream) + 1
for item in P4.opened():
if not item.depotFile.startswith(self._src_stream):
raise ValueError(f"Open file {item.depotFile} is not from the current stream {self._src_stream}")
base_path = item.depotFile[src_len:]
out = self._opened_files.setdefault(item.change, [])
out.append(base_path)
self._restore_point.add_file(item.change, base_path)
prefix = item.change if len(out) == 1 else ""
print("%-9s" % prefix, base_path, sep=": ")
def _shelve_revert(self):
def _for_each_open(command, info_text):
def read_open_files():
for x in self._opened_files.values():
yield from x
print(info_text, "." * (22 - len(info_text)), end=" ")
runner = getattr(P4, command)
runner = runner(read_open_files(), c=shelf_cl)
for i, item in enumerate(runner):
print(i, "\b" * len(str(i)), sep="", end="")
print("done")
cl_desc = f"'.p4 switch {self.args.stream}' backup of opened files from {self._src_stream}\n\n#ushell-switch"
cl_spec = {"Change": "new", "Description": cl_desc}
P4.change(i=True).run(input_data=cl_spec)
shelf_cl = P4.changes(u=self._username, m=1, s="pending").change
_for_each_open("reopen", "Moving changelist")
_for_each_open("shelve", "Shelving")
_for_each_open("revert", "Reverting")
self._restore_point.set_shelf(shelf_cl)
return shelf_cl
def _restore_changes(self, shelf_cl):
# Unshelve each file into its original CL, integrating between streams
# at the same time.
self.print_info("Restoring changes")
branch_spec = p4utils.TempBranchSpec("switch", self._username, self._src_stream, self._dest_stream)
print("Branch spec:", branch_spec)
for orig_cl, files in self._opened_files.items():
print(orig_cl)
orig_cl = None if orig_cl == "default" else orig_cl
unshelve = P4.unshelve(files, b=branch_spec, s=shelf_cl, c=orig_cl)
for item in unshelve.read(on_error=False):
print("", item.depotFile)
del branch_spec
self._restore_point.clear()
# Resolve files
def print_error(error):
print("\r", end="")
self.print_error(error.data.rstrip())
resolve_count = 0
resolve_args = {
"as" : self.args.saferesolve,
"am" : not self.args.saferesolve,
}
resolve = P4.resolve(**resolve_args)
for item in resolve.read(on_error=print_error):
if getattr(item, "clientFile", None):
resolve_count += 1
print("\r" + str(resolve_count), "file(s) resolved", end="")
if resolve_count:
print("")
# Inform the user about conflicts
resolve = P4.resolve(n=True)
for item in resolve.read(on_error=False):
if name := getattr(item, "fromFile", None):
self.print_error(name[len(self._src_stream) + 1:])
|
import unreal
import scripts.popUp as popUp
class SequencerTools:
_instance = None # Class-level variable to store the singleton instance
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super(SequencerTools, cls).__new__(cls)
return cls._instance
def __init__(self, rootSequence, file):
"""
Initialize a SequencerTools instance.
Params:
- rootSequence (unreal.MovieSceneSequence): The root sequence to export.
- levelSequence (unreal.LevelSequence): The level sequence to export.
- file (str): The file path to export the sequence to.
Initializes 'params' with SequencerExportFBXParams containing the provided
parameters and executes the export.
"""
if not hasattr(self, 'initialized'): # Initialize once
self.initialized = True
self.rootSequence = ("" if rootSequence == None else rootSequence)
self.sequence = unreal.load_asset(self.rootSequence, unreal.LevelSequence)
bindings = self.sequence.get_bindings()
tracks = self.sequence.get_tracks()
self.export_options = unreal.FbxExportOption()
self.export_options.ascii = False
self.export_options.level_of_detail = True
self.export_options.export_source_mesh = True
self.export_options.map_skeletal_motion_to_root = True
self.export_options.export_source_mesh = True
self.export_options.vertex_color = True
self.export_options.export_morph_targets = True
self.export_options.export_preview_mesh = True
self.export_options.force_front_x_axis = False
self.params = unreal.SequencerExportFBXParams(
world=unreal.EditorLevelLibrary.get_editor_world(),
sequence=self.sequence,
root_sequence=self.sequence,
bindings=bindings,
tracks=tracks,
export_options=self.export_options,
fbx_file_name=("/project/.fbx" if file == "" else file),
)
def set_root_sequence(self, root_sequence):
"""
Set the root sequence to export.
Params:
- root_sequence (unreal.MovieSceneSequence): The root sequence to export.
"""
try:
self.rootSequence = unreal.load_asset(root_sequence, unreal.MovieSceneSequence)
except:
popUp.show_popup_message("SequencerTools", "Error: Could not load root sequence")
def set_level_sequence(self, level_sequence):
"""
Set the level sequence to export.
Params:
- level_sequence (unreal.LevelSequence): The level sequence to export.
"""
try:
self.sequence = unreal.load_asset(level_sequence, unreal.LevelSequence)
except:
popUp.show_popup_message("SequencerTools", "Error: Could not load level sequence")
def set_file(self, file):
"""
Set the file path to export the sequence to.
Params:
- file (str): The file path to export the sequence to.
"""
self.params.fbx_file_name = file
def execute_export(self) -> bool:
"""
Execute the export of the level sequence to FBX.
Returns:
bool: True if the export was successful, False otherwise.
"""
try:
return unreal.SequencerTools.export_level_sequence_fbx(params=self.params)
except:
popUp.show_popup_message("SequencerTools", "Error: Could not export level sequence")
return False
def set_sequence_and_export(self, file, sequence=None):
"""
Set the level sequence and file path and execute the export.
Params:
- sequence (unreal.LevelSequence): The level sequence to export.
- file (str): The file path to export the sequence to.
"""
if sequence is not None:
self.set_level_sequence(sequence)
else:
self.set_level_sequence(self.rootSequence)
self.set_file(file)
return self.execute_export()
def get_level_sequence_actor_by_name(name):
level_sequence_actors = unreal.EditorLevelLibrary.get_all_level_actors()
for level_sequence_actor in level_sequence_actors:
if level_sequence_actor.get_name() == name:
return level_sequence_actor
return None
|
import json
import os
import re
import time
from collections.abc import Iterable
from pathlib import Path
from subprocess import run
import unreal
SELECTIVE_OBJECTS = []
projectpath = unreal.Paths.project_plugins_dir()
newpath = projectpath + 'Uiana/project/.json'
f = open(newpath)
JsonMapTypeData = json.load(f)
FILEBROWSER_PATH = os.path.join(os.getenv('WINDIR'), 'explorer.exe')
# -------------------------- #
def clear_level():
AllActors = unreal.EditorLevelLibrary.get_all_level_actors()
for j in AllActors:
unreal.EditorLevelLibrary.destroy_actor(j)
def ReturnBPLoop(data, name):
for lop in data:
if lop["Name"] == name:
return lop
def return_parent(parent_name):
actual_shader_name = parent_name[parent_name.rfind(' ')+1:len(parent_name)]
DefEnv = import_shader(actual_shader_name)
if not DefEnv:
ParentName = "BaseEnv_MAT_V4"
else:
ParentName = actual_shader_name
return ParentName
def reduce_bp_json(BigData):
FullJson = {}
newjson = []
sceneroot = []
ChildNodes = []
GameObjects = []
for fnc in BigData:
fName = fnc["Name"]
fType = fnc["Type"]
if "Properties" not in fnc:
continue
FProps = fnc["Properties"]
if fType == "SimpleConstructionScript":
SceneRoot = FProps["DefaultSceneRootNode"]["ObjectName"]
sceneroot.append(SceneRoot[SceneRoot.rfind(':') + 1:len(SceneRoot)])
if "Node" in fName:
Name = FProps["ComponentTemplate"]["ObjectName"]
ActualName = Name[Name.rfind(':') + 1:len(Name)]
Component = ReturnBPLoop(BigData, ActualName)
FProps["CompProps"] = Component["Properties"] if "Properties" in Component else None
newjson.append(fnc)
if has_key("ChildNodes", FProps):
for CN in FProps["ChildNodes"]:
ChildObjectName = CN["ObjectName"]
ChildName = ChildObjectName[ChildObjectName.rfind('.') + 1:len(ChildObjectName)]
ChildNodes.append(ChildName)
if fName == "GameObjectMesh":
GameObjects.append(fnc)
FullJson["Nodes"] = newjson
FullJson["SceneRoot"] = sceneroot
FullJson["GameObjects"] = GameObjects
FullJson["ChildNodes"] = ChildNodes
return FullJson
def check_export(settings):
exp_path = settings.selected_map.folder_path.joinpath("exported.yo")
if exp_path.exists():
exp_data = json.load(open(exp_path))
val_version = exp_data[0]
current_val_version = get_valorant_version()
if settings.val_version != val_version or settings.dev_force_reexport:
return True
else:
return True
return False
def write_export_file():
new_json = [get_valorant_version()]
json_object = json.dumps(new_json, indent=4)
return json_object
def get_cubemap_texture(Seting):
pathCube = Seting["ObjectName"]
newtext = pathCube.replace("TextureCube ", "")
AssetPath = (f'/project/{newtext}.{newtext}')
TextureCubeMap = unreal.load_asset(AssetPath)
return TextureCubeMap
def get_valorant_version():
val_file = "/project/ Games\\Metadata\\valorant.live\\valorant.live.ok"
if os.path.exists(val_file):
with open(val_file, "r") as f:
file = f.read()
split_file = file.split('\n')
return split_file[0].split('/')[-1].split('.')[0]
else:
return None
def get_ies_texture(setting):
pathIES = setting["ObjectName"]
StartNewTextureName = pathIES
NewTextureName = return_formatted_string(StartNewTextureName, "_")
AssetPath = (f'/project/{NewTextureName}.{NewTextureName}')
TextureIES = unreal.load_asset(AssetPath)
return TextureIES
def set_material_vector_value(Mat, ParamName, Value):
unreal.MaterialEditingLibrary.set_material_instance_vector_parameter_value(Mat, ParamName, Value)
unreal.MaterialEditingLibrary.update_material_instance(Mat)
def set_material_scalar_value(Mat, ParamName, Value):
unreal.MaterialEditingLibrary.set_material_instance_scalar_parameter_value(Mat, ParamName, Value)
unreal.MaterialEditingLibrary.update_material_instance(Mat)
def GetReadableUMapType(mapname):
for j in JsonMapTypeData:
NewMapName = j["Name"]
MapType = j["StreamingType"]
if mapname == NewMapName:
return MapType
BLACKLIST = [
"navmesh",
"_breakable",
"_collision",
"windstreaks_plane",
"sm_port_snowflakes_boundmesh",
"M_Pitt_Caustics_Box",
"box_for_volumes",
"BombsiteMarker_0_BombsiteA_Glow",
"BombsiteMarker_0_BombsiteB_Glow",
"_col",
"M_Pitt_Lamps_Glow",
"SM_Pitt_Water_Lid",
"Bombsite_0_ASiteSide",
"Bombsite_0_BSiteSide"
"For_Volumes",
"Foxtrot_ASite_Plane_DU",
"Foxtrot_ASite_Side_DU",
"BombsiteMarker_0_BombsiteA_Glow",
"BombsiteMarker_0_BombsiteB_Glow",
"DirtSkirt",
"Tech_0_RebelSupplyCargoTarpLargeCollision",
]
def get_umap_type(mapname):
for j in JsonMapTypeData:
NewMapName = j["Name"]
MapType = j["StreamingType"]
if mapname == NewMapName:
return eval(f'unreal.{MapType}')
def import_shader(Shader):
BaseShader = unreal.load_asset(f'/project/{Shader}')
return BaseShader
def return_object_name(name):
rformPar = name.rfind(' ') + 1
return name[rformPar:len(name)]
def mesh_to_asset(Mesh, Type, ActualType):
if Mesh == None:
return None
Name = Mesh["ObjectName"]
typestring = str(Type)
NewName = Name.replace(f'{Type}', "")
PathToGo = f'/project/{ActualType}/{NewName}'
print(Mesh)
asset = unreal.load_asset(PathToGo)
print(asset)
return asset
def path_convert(path: str) -> str:
b, c, rest = path.split("\\", 2)
if b == "ShooterGame":
b = "Game"
if c == "Content":
c = ""
return "\\".join((b, c, rest))
def get_scene_transform(prop):
quat = unreal.Quat()
LocationUnreal = unreal.Vector(0.0, 0.0, 0.0)
ScaleUnreal = unreal.Vector(1.0, 1.0, 1.0)
RotationUnreal = unreal.Rotator(0.0, 0.0, 0.0)
if has_key("SceneAttachRelativeLocation",prop):
loc = prop["SceneAttachRelativeLocation"]
LocationUnreal = unreal.Vector(loc["X"], loc["Y"], loc["Z"])
if has_key("SceneAttachRelativeLocation",prop):
rot = prop["SceneAttachRelativeRotation"]
RotationUnreal = unreal.Rotator(rot["Roll"], rot["Pitch"], rot["Yaw"])
if has_key("SceneAttachRelativeLocation",prop):
scale = prop["SceneAttachRelativeScale3D"]
ScaleUnreal = unreal.Vector(scale["X"], scale["Y"], scale["Z"])
return unreal.Transform(LocationUnreal, RotationUnreal, ScaleUnreal)
def get_transform(Prop):
TransformData = None
bIsInstanced = False
Props = Prop
Quat = unreal.Quat()
if has_key("TransformData", Props):
TransformData = Props["TransformData"]
bIsInstanced = True
if has_key("RelativeLocation", Props) or has_key("OffsetLocation", Props) or has_key("Translation", TransformData) :
if bIsInstanced:
Location = TransformData["Translation"]
else:
Location = Props["RelativeLocation"]
LocationUnreal = unreal.Vector(Location["X"], Location["Y"], Location["Z"])
else:
LocationUnreal = unreal.Vector(0.0, 0.0, 0.0)
if has_key("RelativeScale3D", Props) or has_key("Scale3D", TransformData):
if bIsInstanced:
Scale = TransformData["Scale3D"]
ScaleUnreal = unreal.Vector(Scale["X"], Scale["Y"], Scale["Z"])
else:
Scale = Props["RelativeScale3D"]
ScaleUnreal = unreal.Vector(Scale["X"], Scale["Y"], Scale["Z"])
else:
ScaleUnreal = unreal.Vector(1.0, 1.0, 1.0)
if has_key("RelativeRotation", Props) or has_key("Rotation", TransformData):
if bIsInstanced:
Rotation = TransformData["Rotation"]
Quat = unreal.Quat(Rotation["X"], Rotation["Y"], Rotation["Z"], Rotation["W"])
RotationUnreal = unreal.Rotator(0.0, 0.0, 0.0)
else:
Rotation = Props["RelativeRotation"]
RotationUnreal = unreal.Rotator(Rotation["Roll"], Rotation["Pitch"], Rotation["Yaw"])
else:
RotationUnreal = unreal.Rotator(0.0, 0.0, 0.0)
Trans = unreal.Transform(LocationUnreal, RotationUnreal, ScaleUnreal)
if bIsInstanced:
Trans.set_editor_property("rotation", Quat)
return Trans
def has_key(key, array):
if array == None:
return False
if key in array:
return True
else:
return False
def GetClassName(self):
return type(self).__name__
def return_formatted_string(string, prefix):
start = string.rfind(prefix) + 1
end = len(string)
return string[start:end]
def has_transform(prop):
bFactualBool = False
if has_key("AttachParent", prop):
bFactualBool = False
if has_key("RelativeLocation", prop):
bFactualBool = True
if has_key("SceneAttachRelativeLocation", prop):
bFactualBool = True
if has_key("SceneAttachRelativeRotation", prop):
bFactualBool = True
if has_key("SceneAttachRelativeScale3D", prop):
bFactualBool = True
if has_key("RelativeRotation", prop):
bFactualBool = True
if has_key("RelativeScale3D", prop):
bFactualBool = True
if bFactualBool:
return get_transform(prop)
return bFactualBool
def return_python_unreal_enum(value):
ind = 0
value = re.sub(r'([a-z])([A-Z])', r'\1_\2', value)
if value[0] == "_":
ind = 1
return value[ind:len(value)].upper()
def filter_objects(umap_DATA, current_umap_name) -> list:
objects = umap_DATA
filtered_list = []
# Debug check
if SELECTIVE_OBJECTS:
for filter_model_name in SELECTIVE_OBJECTS:
for og_model in objects:
object_type = get_object_type(og_model)
if object_type == "mesh":
if filter_model_name in og_model["Properties"]["StaticMesh"]["ObjectPath"]:
og_model["Name"] = og_model["Properties"]["StaticMesh"]["ObjectPath"]
filtered_list.append(og_model)
elif object_type == "decal":
if filter_model_name in og_model["Outer"]:
og_model["Name"] = og_model["Outer"]
filtered_list.append(og_model)
elif object_type == "light":
if filter_model_name in og_model["Outer"]:
og_model["Name"] = og_model["Outer"]
filtered_list.append(og_model)
else:
filtered_list = objects
new_list = []
# Check for blacklisted items
for og_model in filtered_list:
objname = get_obj_name(data=og_model, mat=False)
if not objname:
continue
model_name_lower = objname.lower()
if is_blacklisted(model_name_lower):
continue
else:
new_list.append(og_model)
return new_list
def is_blacklisted(object_name: str) -> bool:
for blocked in BLACKLIST:
if blocked.lower() in object_name.lower():
return True
return False
def get_obj_name(data: dict, mat: bool):
if mat:
s = data["ObjectPath"]
else:
if has_key("Properties", data) == False:
return "None"
if "StaticMesh" in data["Properties"]:
d = data["Properties"]["StaticMesh"]
if not d:
return None
s = d["ObjectPath"]
else:
if not has_key("Outer", data):
return None
s = data["Outer"]
k = get_name(s)
return k
def get_name(s: str) -> str:
return Path(s).stem
def cast(object_to_cast=None, object_class=None):
try:
return object_class.cast(object_to_cast)
except:
return None
def open_folder(path):
"""
Open a file explorer to a path
:param path: path to folder
:return:
"""
path = os.path.normpath(path)
if os.path.isdir(path):
run([FILEBROWSER_PATH, path])
def get_files(path: str, extension: str = "") -> list:
"""
Get all files in a directory
:param path: path to directory
:param extension: extension of files to get
:return: list of files
"""
files = list()
for file in os.listdir(path):
if extension in file:
files.append(Path(os.path.join(path, file)))
return files
def open_folder(path):
"""
Open a file explorer to a path
:param path: path to folder
:return:
"""
path = os.path.normpath(path)
if os.path.isdir(path):
run([FILEBROWSER_PATH, path])
def save_list(filepath: Path, lines: list):
"""
Save a list to a file
:param filepath: path to file
:param lines: list of lines
:return:
"""
# Flatten umap objects
lines = list(flatten_list(lines))
# Remove Duplicates
lines = list(dict.fromkeys(lines))
with open(filepath.__str__(), 'w') as f:
f.write('\n'.join(lines))
return filepath.__str__()
def save_json(p: str, d):
"""
Save a dictionary to a json file
:param p: path to file
:param d: dictionary
:return:
"""
with open(p, 'w') as jsonfile:
json.dump(d, jsonfile, indent=4)
def read_json(p: str) -> dict:
"""
Read a json file and return a dictionary
:param p: path to file
:return:
"""
with open(p) as json_file:
return json.load(json_file)
def get_mat(decal_dict):
mat_name = get_obj_name(data=decal_dict, mat=True)
return unreal.load_asset(
f'/project/{mat_name}.{mat_name}')
def get_scene_parent(obj, OuterName, umapfile):
types = ["SceneComponent", "BrushComponent", "StaticMeshComponent"]
if OuterName == 'PersistentLevel':
OuterName = obj["Name"]
for j in umapfile:
tipo = j["Type"]
if not has_key("Outer", j):
continue
outer = j["Outer"]
if outer == "PersistentLevel":
outer = j["Name"]
# print(f'OuterName trying to find is {OuterName} and current outer is {outer} // also tipo is {tipo}')
if has_key("Properties", j) == False:
continue
KeyOuter = has_key("AttachParent", j["Properties"])
if outer == OuterName and tipo in types and KeyOuter == False:
return has_transform(j["Properties"])
# exit()
def set_unreal_prop(self,prop_name,prop_value):
try:
self.set_editor_property(prop_name,prop_value)
except:
print(f'UianaPropLOG: Error setting {prop_name} to {prop_value}')
def shorten_path(file_path, length) -> str:
"""
Shorten a path to a given length
:param file_path: path to shorten
:param length: length to shorten to
:return: shortened path
"""
return f"..\{os.sep.join(file_path.split(os.sep)[-length:])}"
def flatten_list(collection):
"""
Flatten a list of lists
:param collection: list of lists
:return: list
"""
for x in collection:
if isinstance(x, Iterable) and not isinstance(x, str):
yield from flatten_list(x)
else:
yield x
def create_folders(self):
for attr, value in self.__dict__.items():
if "path" in attr:
f = Path(value)
if not f.exists():
print(f"Creating folder {f}")
f.mkdir(parents=True)
# ANCHOR: Classes
# -------------------------- #
class Settings:
def __init__(self, UESet):
self.aes = UESet.vAesKey
self.texture_format = ".png"
########## have to fix so it gets actual dir
self.script_root = UESet.PPluginPath
self.tools_path = self.script_root.joinpath("tools")
self.importer_assets_path = self.script_root.joinpath("assets")
self.paks_path = UESet.PPakFolder
self.import_decals = UESet.bImportDecal
self.import_blueprints = UESet.bImportBlueprint
self.import_lights = UESet.bImportLights
self.import_Mesh = UESet.bImportMesh
self.import_materials = UESet.bImportMaterial
self.import_sublevel = UESet.bImportSubLevels
self.manual_lmres_mult = UESet.iManualLMResMult
self.combine_umaps = False
self.val_version = get_valorant_version()
self.dev_force_reexport = False
self.export_path = UESet.PExportPath
self.assets_path = self.export_path.joinpath("export")
self.maps_path = self.export_path.joinpath("maps")
self.umodel = self.script_root.joinpath("tools", "umodel.exe")
self.debug = False
self.cue4extractor = self.script_root.joinpath("tools", "cue4extractor.exe")
self.log = self.export_path.joinpath("import.log")
self.umap_list_path = self.importer_assets_path.joinpath("umaps.json")
self.umap_list = read_json(self.umap_list_path)
self.selected_map = Map(UESet.fMapName, self.maps_path, self.umap_list)
self.shaders = [
"VALORANT_Base",
"VALORANT_Decal",
"VALORANT_Emissive",
"VALORANT_Emissive_Scroll",
"VALORANT_Hologram",
"VALORANT_Glass",
"VALORANT_Blend",
"VALORANT_Decal",
"VALORANT_MRA_Splitter",
"VALORANT_Normal_Fix",
"VALORANT_Screen"
]
create_folders(self)
## Map Definitions
class Map:
def __init__(self, selected_map_name: str, maps_path: Path, all_umaps: list):
self.name = selected_map_name
# print(maps_path, self.name)
self.folder_path = maps_path.joinpath(self.name)
self.umaps = all_umaps[self.name]
# print(self)
self.actors_path = self.folder_path.joinpath("actors")
self.materials_path = self.folder_path.joinpath("materials")
self.materials_ovr_path = self.folder_path.joinpath("materials_ovr")
self.objects_path = self.folder_path.joinpath("objects")
self.scenes_path = self.folder_path.joinpath("scenes")
self.umaps_path = self.folder_path.joinpath("umaps")
create_folders(self)
# Actor definitions
class actor_defs():
def __init__(self, Actor):
self.data = Actor
self.name = Actor["Name"] if has_key("Name", Actor) else None
self.type = Actor["Type"] if has_key("Type", Actor) else None
self.props = Actor["Properties"] if has_key("Properties", Actor) else {}
## add new attribute that gets every key from props that starts with "SceneAttach" and adds it to a dict if Actor has_key else none
self.scene_props = {k: v for k, v in self.props.items() if k.startswith("SceneAttach")} if has_key("SceneAttach", self.props) else None
self.outer = Actor["Outer"] if has_key("Outer", Actor) else None
self.transform = has_transform(self.props)
self.debug = f'ActorName: {self.name} // ActorType: {self.type} // ActorOuter: {self.outer} // ActorTransform: {self.transform} // ActorProps: {self.props.keys()}'
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.