def handle_transform_camera(usd_prim, actor):
global unit_scale
global stage_up_axis
if actor.root_component == None:
return
unreal_transform = actor.root_component.get_relative_transform()
unreal_location = unreal_transform.translation
unreal_rotation = unreal_transform.rotation.rotator()
rotz = unreal.Rotator(90,0,0)
additional_rotation = unreal.Rotator(0,90,0)
if stage_up_axis == 'z':
additional_rotation = additional_rotation.combine(rotz)
unreal_rotation = additional_rotation.combine(unreal_rotation)
location = convert_location_from_unreal(unreal_location.to_tuple(),unit_scale)
rotation = convert_rotation_from_unreal(unreal_rotation.to_tuple(), unit_scale)
scale = convert_scale_from_unreal(unreal_transform.scale3d.to_tuple(), unit_scale)
usd_transform = (location, rotation, scale)
#usd_transform = usd_transform_from_unreal_transform(unreal_transform, unit_scale, stage_up_axis)
xform_api = UsdGeom.XformCommonAPI(usd_prim)
xform_api.SetTranslate(usd_transform[0])
xform_api.SetRotate(usd_transform[1], UsdGeom.XformCommonAPI.RotationOrderXYZ)
xform_api.SetScale(usd_transform[2])
def deferredSpawnActor():
world = unreal.EditorLevelLibrary.get_editor_world()
# ! blueprint actor
actor_class = unreal.EditorAssetLibrary.load_blueprint_class(
'/Game/BluePrint/bp_actor')
actor_location = unreal.Vector(random.uniform(0.0, 2000.0),
random.uniform(0.0, 2000.0), 0.0)
actor_rotation = unreal.Rotator(random.uniform(0.0, 360.0),
random.uniform(0.0, 360.0),
random.uniform(0.0, 360.0))
actor_scale = unreal.Vector(random.uniform(0.1, 2.0),
random.uniform(0.1, 2.0),
random.uniform(0.1, 2.0))
actor_transform = unreal.Transform(actor_location, actor_rotation,
actor_scale)
# ! "GameplayStatics.begin_spawning_actor_from_class()" is deprecated. Use BeginDeferredActorSpawnFromClass instead.
# actor = unreal.GameplayStatics.begin_spawning_actor_from_class(world, actor_class, actor_transform)
# unreal.GameplayStatics.finish_spawning_actor(actor, actor_transform)
actor = unreal.EditorCppLib.begin_spawn_actor(world, actor_class,
actor_transform)
unreal.EditorCppLib.finish_spawn_actor(actor, actor_transform)
# import EditorFunction_1 as ef
# reload(ef)
# ef.executeSlowTask()
def build_import_options():
options = unreal.FbxImportUI()
# ---- MESH
options.set_editor_property('import_mesh', True)
options.set_editor_property('import_textures', False)
options.set_editor_property('import_materials', False)
options.set_editor_property('import_as_skeletal', False) # Static Mesh
options.static_mesh_import_data.set_editor_property(
'auto_generate_collision', False)
# ---- Transform
options.static_mesh_import_data.set_editor_property(
'import_translation', unreal.Vector(0.0, 0.0, 0.0))
options.static_mesh_import_data.set_editor_property(
'import_rotation', unreal.Rotator(0.0, 0.0, 0.0))
options.static_mesh_import_data.set_editor_property(
'import_uniform_scale', 1.0)
# ---- Miscellaneous
options.static_mesh_import_data.set_editor_property(
'convert_scene', True)
options.static_mesh_import_data.set_editor_property(
'force_front_x_axis', False)
options.static_mesh_import_data.set_editor_property(
'convert_scene_unit', True)
options.set_editor_property('override_full_name', True)
return options
def spawnBlueprintActor_EXAMPLE():
path = '/Game/MyBlueprint'
location = unreal.Vector(1000.0, 400.0, 0.0)
rotation = unreal.Rotator(90.0, 0.0, 0.0)
scale = unreal.Vector(1.0, 1.0, 5.0)
properties = {'tags': ['MyFirstTag', 'MySecondTag'], 'hidden': False}
print WorldFunctions.spawnBlueprintActor(path, location, rotation, scale,
None, properties)
def test_spawn_actor(unreal_object, scale=None):
location = unreal.Vector(10, 20, 30)
rotation = unreal.Rotator(44, 55, 66)
actor = unreal.EditorLevelLibrary.spawn_actor_from_object(
unreal_object, location, rotation)
if scale != None:
actor.set_actor_scale3d(scale)
return actor
def myTick(self, delta_seconds):
# Set Time
self.time_while_this_window_is_open += delta_seconds
self.widget.lbl_Seconds.setText("%.1f Seconds" %
self.time_while_this_window_is_open)
# Affect Actor
if self.random_actor:
speed = 90.0 * delta_seconds
self.random_actor.add_actor_world_rotation(
unreal.Rotator(0.0, 0.0, speed), False, False)
def add_mesh_to_level():
static_mesh_actor = unreal.StaticMeshActor()
location1 = unreal.Vector(1000.0, 400.0, 0.0)
rotation1 = unreal.Rotator(0.0, 0.0, 0.0)
new_actor = unreal.EditorLevelLibrary.spawn_actor_from_object(
static_mesh_actor, location1, rotation1)
yourmesh = unreal.EditorAssetLibrary.load_asset('/Game/EGC_Bake/abc1.abc1')
# static_mesh_ins = unreal.StaticMeshComponent()
# static_mesh_ins.set_static_mesh(yourmesh)
unreal.EditorLevelLibrary.replace_mesh_components_meshes_on_actors(
[new_actor], None, yourmesh)
def create_camera(self):
# 添加相机剪辑轨道
camera_cut_track = self.ass.add_master_track(unreal.MovieSceneCameraCutTrack)
# 添加相机剪裁的可视
camera_cut_section = camera_cut_track.add_section()
self.make_range(camera_cut_section)
camera_actor = unreal.EditorLevelLibrary().spawn_actor_from_class(
unreal.CineCameraActor, unreal.Vector(0, 0, 0), unreal.Rotator(0, 0, 0))
camera_actor.set_actor_label("doodle_camera")
camera_component = camera_actor.get_cine_camera_component()
# ratio = math.tan(film_fov / 360.0 * math.pi) * 2
# 添加一些相机熟悉
filmback = camera_component.get_editor_property("filmback")
# focal_length = camera_component.get_editor_property("current_focal_length")
filmback.set_editor_property("sensor_height", 20.25)
filmback.set_editor_property("sensor_width", 36.0)
focus_settings = camera_component.get_editor_property("focus_settings")
focus_settings.set_editor_property(
"focus_method", unreal.CameraFocusMethod.DISABLE)
# 添加相机绑定
camera_binding = self.ass.add_possessable(camera_actor)
camera_binding_id = self.ass.make_binding_id(
camera_binding, unreal.MovieSceneObjectBindingSpace.LOCAL)
camera_cut_section.set_camera_binding_id(camera_binding_id)
# 添加transform_track轨道
transform_track = camera_binding.add_track(unreal.MovieScene3DTransformTrack)
transform_section = transform_track.add_section()
self.make_range(transform_section)
# 添加子组件绑定
camera_component_binding = self.ass.add_possessable(camera_component)
# 添加当前焦距
camera_component_focal_track = camera_component_binding.add_track(unreal.MovieSceneFloatTrack)
camera_component_focal_track.set_property_name_and_path("当前焦距", "CurrentFocalLength")
camera_component_focal_track_section = camera_component_focal_track.add_section()
self.make_range(camera_component_focal_track_section)
# channels = camera_component_focal_track_section.get_channels()[0]
# channels.add_key(unreal.FrameNumber(950), 35, 0.0, unreal.SequenceTimeUnit.DISPLAY_RATE)
# 添加当前光圈
camera_component_focal_track = camera_component_binding.add_track(unreal.MovieSceneFloatTrack)
camera_component_focal_track.set_property_name_and_path("当前光圈", "CurrentAperture")
camera_component_focal_track_section = camera_component_focal_track.add_section()
self.make_range(camera_component_focal_track_section)
# 添加手动聚焦
camera_component_focal_track = camera_component_binding.add_track(unreal.MovieSceneFloatTrack)
camera_component_focal_track.set_property_name_and_path("手动聚焦距离(聚焦设置)", "FocusSettings.ManualFocusDistance")
camera_component_focal_track_section = camera_component_focal_track.add_section()
self.make_range(camera_component_focal_track_section)
def buildAnimationImportOptions(skeleton_path=''):
options = unreal.FbxImportUI()
# unreal.FbxImportUI
options.set_editor_property('import_animations', True)
options.skeleton = unreal.load_asset(skeleton_path)
# unreal.FbxMeshImportData
options.anim_sequence_import_data.set_editor_property('import_translation', unreal.Vector(0.0, 0.0, 0.0))
options.anim_sequence_import_data.set_editor_property('import_rotation', unreal.Rotator(0.0, 0.0, 0.0))
options.anim_sequence_import_data.set_editor_property('import_uniform_scale', 1.0)
# unreal.FbxAnimSequenceImportData
options.anim_sequence_import_data.set_editor_property('animation_length', unreal.FBXAnimationLengthImportType.FBXALIT_EXPORTED_TIME)
options.anim_sequence_import_data.set_editor_property('remove_redundant_keys', False)
return options
def test_populate_world():
actors = []
def spawn_actor(unreal_object, scale=None):
a = test_spawn_actor(unreal_object)
actors.append(a)
return a
# empty actor
actor = spawn_actor(unreal.Actor.static_class())
# lights
actor = spawn_actor(unreal.RectLight.static_class())
actor = spawn_actor(unreal.PointLight.static_class())
actor = spawn_actor(unreal.DirectionalLight.static_class())
actor = spawn_actor(unreal.SpotLight.static_class())
# sky light
actor = unreal.EditorLevelLibrary.spawn_actor_from_object(
unreal.SkyLight.static_class(), unreal.Vector(0, 0, 0),
unreal.Rotator(0, 0, 0))
actor = spawn_actor(unreal.CineCameraActor.static_class())
actor.set_actor_label("CineCameraPlaced")
actor = unreal.EditorLevelLibrary.spawn_actor_from_object(
unreal.load_asset("/Engine/BasicShapes/Cube.Cube"),
unreal.Vector(0, 0, -200), unreal.Rotator(0, 0, 0))
actor.set_actor_scale3d(unreal.Vector(7, 5, 1))
actor.set_actor_label("CubePlaced")
actor = unreal.EditorLevelLibrary.spawn_actor_from_object(
unreal.load_asset("/Engine/BasicShapes/Cube.Cube"),
unreal.Vector(0, 100, -100), unreal.Rotator(0, 0, 0))
actor.set_actor_scale3d(unreal.Vector(1, 1, 0.5))
actor.set_actor_label("CubeToDelete")
return actors
def buildSkeletalMeshImportOptions():
options = unreal.FbxImportUI()
# unreal.FbxImportUI
options.set_editor_property('import_mesh', True)
options.set_editor_property('import_textures', False)
options.set_editor_property('import_materials', False)
options.set_editor_property('import_as_skeletal', True) # Skeletal Mesh
# unreal.FbxMeshImportData
options.skeletal_mesh_import_data.set_editor_property('import_translation', unreal.Vector(0.0, 0.0, 0.0))
options.skeletal_mesh_import_data.set_editor_property('import_rotation', unreal.Rotator(0.0, 0.0, 0.0))
options.skeletal_mesh_import_data.set_editor_property('import_uniform_scale', 1.0)
# unreal.FbxSkeletalMeshImportData
options.skeletal_mesh_import_data.set_editor_property('import_morph_targets', True)
options.skeletal_mesh_import_data.set_editor_property('update_skeleton_reference_pose', False)
return options
def import_camera(self, node):
if node.unreal_class == None:
return None
if not isinstance(unreal.get_default_object(node.unreal_class),
unreal.CineCameraActor):
return None
actor = None
if node.unreal_class != None:
actor = self.spawn_actor(node, node.unreal_class,
unreal.Rotator(yaw=-90))
if actor != None:
self.apply_attributes(actor,
usd_unreal.attributes.camera.attributes,
node)
return actor
def buildStaticMeshImportOptions():
options = unreal.FbxImportUI()
# unreal.FbxImportUI
options.set_editor_property('import_mesh', True)
options.set_editor_property('import_textures', False)
options.set_editor_property('import_materials', False)
options.set_editor_property('import_as_skeletal', False) # Static Mesh
# unreal.FbxMeshImportData
options.static_mesh_import_data.set_editor_property('import_translation', unreal.Vector(0.0, 0.0, 0.0))
options.static_mesh_import_data.set_editor_property('import_rotation', unreal.Rotator(0.0, 0.0, 0.0))
options.static_mesh_import_data.set_editor_property('import_uniform_scale', 1.0)
# unreal.FbxStaticMeshImportData
options.static_mesh_import_data.set_editor_property('combine_meshes', True)
options.static_mesh_import_data.set_editor_property('generate_lightmap_u_vs', True)
options.static_mesh_import_data.set_editor_property('auto_generate_collision', True)
return options
def spawn_wall(x, y, z, yaw):
if plane:
location = unreal.Vector()
location.x = x
location.y = y
location.z = z
rotation = unreal.Rotator()
rotation.yaw = yaw
rotation.roll = 90
spawned_actor = unreal.EditorLevelLibrary.spawn_actor_from_object(
plane, location, rotation)
scale = unreal.Vector()
scale.x = 5
scale.y = 3
scale.z = 0.2
spawned_actor.set_actor_relative_scale3d(scale)
def build_import_options():
options = unreal.FbxImportUI()
# ---- MESH
options.set_editor_property('mesh_type_to_import',
unreal.FBXImportType.FBXIT_SKELETAL_MESH)
options.set_editor_property('import_mesh', True)
options.set_editor_property('import_textures', False)
options.set_editor_property('import_materials', False)
options.set_editor_property('import_as_skeletal', True) # Static Mesh
options.skeletal_mesh_import_data.set_editor_property(
'vertex_color_import_option',
unreal.VertexColorImportOption.REPLACE)
options.skeletal_mesh_import_data.set_editor_property(
'update_skeleton_reference_pose', True)
options.skeletal_mesh_import_data.set_editor_property(
'use_t0_as_ref_pose', True)
options.skeletal_mesh_import_data.set_editor_property(
'preserve_smoothing_groups', True)
options.skeletal_mesh_import_data.set_editor_property(
'import_meshes_in_bone_hierarchy', True)
options.skeletal_mesh_import_data.set_editor_property(
'import_morph_targets', False)
options.skeletal_mesh_import_data.set_editor_property(
'import_mesh_lo_ds', False)
options.skeletal_mesh_import_data.set_editor_property(
'normal_import_method',
unreal.FBXNormalImportMethod.FBXNIM_IMPORT_NORMALS_AND_TANGENTS)
# ---- Transform
options.skeletal_mesh_import_data.set_editor_property(
'import_translation', unreal.Vector(0.0, 0.0, 0.0))
options.skeletal_mesh_import_data.set_editor_property(
'import_rotation', unreal.Rotator(0.0, 0.0, 0.0))
options.skeletal_mesh_import_data.set_editor_property(
'import_uniform_scale', 1.0)
# ---- Miscellaneous
options.skeletal_mesh_import_data.set_editor_property(
'convert_scene', True)
options.skeletal_mesh_import_data.set_editor_property(
'force_front_x_axis', False)
options.skeletal_mesh_import_data.set_editor_property(
'convert_scene_unit', True)
options.set_editor_property('override_full_name', True)
return options
def createSplash(json_path):
with open(json_path, "r") as json_file:
data = json.load(json_file)
for asset_name in data:
pos = data[asset_name]["position"]
rot = data[asset_name]["rotation"]
splash_scale = data[asset_name]["splash_scale"]
foam_scale = data[asset_name]["foam_scale"]
splash_type = data[asset_name]["splash_type"]
if splash_type == 1: # splash bottom
splash = lib.load_asset(
'/Game/Test_assets/WaterfallTool/Particles/PS_BottomSplash.PS_BottomSplash'
)
splash_scale *= 2
elif splash_type == 0: # splash top
splash = lib.load_asset(
'/Game/Test_assets/WaterfallTool/Particles/PS_TopSplash.PS_TopSplash'
)
actor_location = unreal.Vector(pos[0] * 100, pos[1] * 100,
pos[2] * 100)
#actor_rotation = unreal.Rotator(rot[0],rot[2],rot[1])
m_vector = unreal.Vector()
m_vector.set(0, 0, 1)
m_rot = m_vector.rotator_from_axis_and_angle(rot[1])
actor_rotation = unreal.Rotator(rot[0], rot[2], rot[1])
#actor_rotation = m_rot
actor_splash_scale = unreal.Vector(splash_scale[0],
splash_scale[1],
splash_scale[2])
actor_foam_scale = unreal.Vector(foam_scale[0], foam_scale[1],
foam_scale[2])
m_name = "streamSplash"
actor_splash = unreal.EditorLevelLibrary.spawn_actor_from_object(
splash, actor_location, actor_rotation)
actor_splash.set_folder_path('/' + m_name + '/')
actor_splash_tags = actor_splash.get_editor_property('tags')
actor_splash_tags.append('stream splash')
actor_splash.set_editor_property('tags', actor_splash_tags)
actor_splash.set_actor_scale3d(actor_splash_scale)
actor_splash_componet = actor_splash.get_components_by_class(
unreal.ParticleSystemComponent)[0]
actor_splash_componet.set_translucent_sort_priority(100)
def deferredSpawnActor():
world = unreal.EditorLevelLibrary.get_editor_world()
actor_class = unreal.EditorAssetLibrary.load_blueprint_class('/Game/BluePrint/MyActor')
actor_location = unreal.Vector(0.0, 0.0, 0.0)
actor_rotation = unreal.Rotator(0.0, 0.0, 0.0)
actor_scale = unreal.Vector(1.0, 1.0, 1.0)
actor_transform = unreal.Transform(actor_location, actor_rotation, actor_scale)
actor = unreal.EditorCppLib.begin_spawn_actor(world, actor_class, actor_transform)
actor_tags = actor.get_editor_property('tags')
actor_tags.append('My Python Tag')
actor.set_editor_property('tags', actor_tags)
unreal.EditorCppLib.finish_spawn_actor(actor, actor_transform)
# import WorldFunctions as wf
# reload(wf)
# wf.spawnActor()
def test_level_export_import_main():
unreal.EditorLoadingAndSavingUtils.new_blank_map(False)
test_populate_world()
#print(" call export_level")
export_level_path = 'level_export/export_level.usda'
export_task = usd_unreal.export_level.USDExportLevel()
export_task.export_level(
os.path.join(test_directory_generated, export_level_path),
unreal.EditorLevelLibrary.get_editor_world())
#if not compare_usd_files(os.path.join(test_directory_generated, export_level_path), os.path.join(test_directory_expected, export_level_path)):
# return False
unreal.EditorLoadingAndSavingUtils.new_blank_map(False)
# import the exported level
import_exported_level(export_level_path)
# export 'deltas' version of level before making changes
export_level_unchanged_path = 'level_export/export_level_unchanged.usda'
usd_unreal.export_level.export_current_level(
os.path.join(test_directory_generated, export_level_unchanged_path))
#if not compare_usd_files(os.path.join(test_directory_generated, export_level_unchanged_path), os.path.join(test_directory_expected, export_level_unchanged_path)):
# return False
# change level then export 'deltas' version after making changes
actor = unreal.EditorLevelLibrary.spawn_actor_from_object(
unreal.load_asset("/Engine/BasicShapes/Cube.Cube"),
unreal.Vector(0, 0, -100), unreal.Rotator(0, 0, 0))
actor.set_actor_label("CubeAdded")
actor = find_actor_by_label("CubePlaced")
actor.set_actor_location(unreal.Vector(100, 60, -250), False, True)
actor = find_actor_by_label("CubeToDelete")
unreal.EditorLevelLibrary.destroy_actor(actor)
export_level_changed_path = 'level_export/export_level_changed.usda'
usd_unreal.export_level.export_current_level(
os.path.join(test_directory_generated, export_level_changed_path))
#if not compare_usd_files(os.path.join(test_directory_generated, export_level_changed_path), os.path.join(test_directory_expected, export_level_changed_path)):
# return False
return True
def buildSkeletalMeshImportOptions(self):
skeletal_mesh_import_data = unreal.FbxSkeletalMeshImportData()
skeletal_mesh_import_data.set_editor_property(
'update_skeleton_reference_pose', False)
skeletal_mesh_import_data.set_editor_property(
'import_meshes_in_bone_hierarchy', True)
skeletal_mesh_import_data.set_editor_property('use_t0_as_ref_pose',
False)
skeletal_mesh_import_data.set_editor_property(
'preserve_smoothing_groups', True)
skeletal_mesh_import_data.set_editor_property('import_morph_targets',
True)
import_translation = unreal.Vector(0, 0, 0)
skeletal_mesh_import_data.set_editor_property('import_translation',
import_translation)
import_rotation = unreal.Rotator(0, 0, 0)
skeletal_mesh_import_data.set_editor_property('import_rotation',
import_rotation)
skeletal_mesh_import_data.set_editor_property('import_uniform_scale',
1.0)
skeletal_mesh_import_data.set_editor_property('convert_scene', True)
skeletal_mesh_import_data.set_editor_property('force_front_x_axis',
False)
skeletal_mesh_import_data.set_editor_property('convert_scene_unit',
False)
# SkeletalMeshImportData->bImportAsScene = false;
options = unreal.FbxImportUI()
options.set_editor_property('skeletal_mesh_import_data',
skeletal_mesh_import_data)
options.set_editor_property('import_mesh', True)
options.set_editor_property('import_textures', False)
options.set_editor_property('import_materials', False)
options.set_editor_property('import_as_skeletal', True)
options.set_editor_property('skeleton', None)
# options.skeletal_mesh_import_data.set_edtitor_property('import_translation')
# options.skeletal_mesh_import_data.set_edtitor_property('import_rotation')
# options.skeletal_mesh_import_data.set_edtitor_property('import_uniform_scale')
# options.skeletal_mesh_import_data.set_edtitor_property('combine_meshes',False)
# options.skeletal_mesh_import_data.set_edtitor_property('generate_lightmap_u_v')
# options.skeletal_mesh_import_data.set_edtitor_property('generate_lightmap')
return options
def build_static_mesh_import_options():
options = unreal.FbxImportUI()
# unreal.FbxImportUI https://api.unrealengine.com/INT/PythonAPI/class/FbxImportUI.html
options.set_editor_property('import_mesh', True)
options.set_editor_property('import_textures', False)
options.set_editor_property('import_materials', False)
options.set_editor_property('import_as_skeletal', False) # Static Mesh
# unreal.FbxMeshImportData https://api.unrealengine.com/INT/PythonAPI/class/FbxMeshImportData.html
options.static_mesh_import_data.set_editor_property(
'import_translation', unreal.Vector(0.0, 0.0, 0.0))
options.static_mesh_import_data.set_editor_property(
'import_rotation', unreal.Rotator(0.0, 0.0, 0.0))
options.static_mesh_import_data.set_editor_property(
'import_uniform_scale', 1.0)
# unreal.FbxStaticMeshImportData https://api.unrealengine.com/INT/PythonAPI/class/FbxStaticMeshImportData.html
options.static_mesh_import_data.set_editor_property('combine_meshes', True)
options.static_mesh_import_data.set_editor_property(
'generate_lightmap_u_vs', True)
options.static_mesh_import_data.set_editor_property(
'auto_generate_collision', True)
return options
def build_skeletal_mesh_import_options():
options = unreal.FbxImportUI()
# unreal.FbxImportUI https://api.unrealengine.com/INT/PythonAPI/class/FbxImportUI.html
options.set_editor_property('import_mesh', True)
options.set_editor_property('import_textures', True)
options.set_editor_property('import_materials', True)
options.set_editor_property('import_as_skeletal', True) # Skeletal Mesh
# unreal.FbxMeshImportData https://api.unrealengine.com/INT/PythonAPI/class/FbxMeshImportData.html
options.skeletal_mesh_import_data.set_editor_property(
'import_translation', unreal.Vector(0.0, 0.0, 0.0))
options.skeletal_mesh_import_data.set_editor_property(
'import_rotation', unreal.Rotator(0.0, 0.0, 0.0))
options.skeletal_mesh_import_data.set_editor_property(
'import_uniform_scale', 1.0)
# unreal.FbxSkeletalMeshImportData
# https://api.unrealengine.com/INT/PythonAPI/class/FbxSkeletalMeshImportData.html
options.skeletal_mesh_import_data.set_editor_property(
'import_morph_targets', True)
options.skeletal_mesh_import_data.set_editor_property(
'update_skeleton_reference_pose', False)
return options
def create_level_sequence_with_spawnable_camera(asset_name,
package_path='/Game/'):
sequence = unreal.AssetToolsHelpers.get_asset_tools().create_asset(
asset_name, package_path, unreal.LevelSequence,
unreal.LevelSequenceFactoryNew())
# Create a cine camera actor
camera_actor = unreal.EditorLevelLibrary().spawn_actor_from_class(
unreal.CineCameraActor, unreal.Vector(0, 0, 0),
unreal.Rotator(0, 0, 0))
# Add a spawnable using that cine camera actor
camera_binding = sequence.add_spawnable_from_instance(camera_actor)
# Add a cine camera component binding using the component of the camera actor
camera_component_binding = sequence.add_possessable(
camera_actor.get_cine_camera_component())
camera_component_binding.set_parent(camera_binding)
# Add a focal length track and default it to 60
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(0)
for channel in focal_length_section.find_channels_by_type(
unreal.MovieSceneScriptingFloatChannel):
channel.set_default(60.0)
# Add a transform track
camera_transform_track = camera_binding.add_track(
unreal.MovieScene3DTransformTrack)
populate_track(sequence, camera_transform_track, 1, 5)
return sequence
def CreateSequencer():
import unreal
import os.path
import sys
import time
import json
'''
if int(unreal.SystemLibrary.get_engine_version()[:4][2:]) >= 26:
import configparser as ConfigParser
else:
import ConfigParser
'''
# Prepare process import
json_data_file = 'ImportSequencerData.json'
dir_path = os.path.dirname(os.path.realpath(__file__))
with open(os.path.join(dir_path, json_data_file), "r") as json_file:
sequence_data = json.load(json_file)
spawnable_camera = sequence_data['spawnable_camera']
startFrame = sequence_data['startFrame']
endFrame = sequence_data['endFrame'] + 1
render_resolution_x = sequence_data['render_resolution_x']
render_resolution_y = sequence_data['render_resolution_y']
frameRateDenominator = sequence_data['frameRateDenominator']
frameRateNumerator = sequence_data['frameRateNumerator']
secureCrop = sequence_data[
'secureCrop'] # add end crop for avoid section overlay
unreal_import_location = sequence_data['unreal_import_location']
ImportedCamera = [] # (CameraName, CameraGuid)
def AddSequencerSectionTransformKeysByIniFile(sequencer_section,
track_dict):
for key in track_dict.keys():
value = track_dict[key] # (x,y,z x,y,z x,y,z)
frame = unreal.FrameNumber(int(key))
sequencer_section.get_channels()[0].add_key(
frame, value["location_x"])
sequencer_section.get_channels()[1].add_key(
frame, value["location_y"])
sequencer_section.get_channels()[2].add_key(
frame, value["location_z"])
sequencer_section.get_channels()[3].add_key(
frame, value["rotation_x"])
sequencer_section.get_channels()[4].add_key(
frame, value["rotation_y"])
sequencer_section.get_channels()[5].add_key(
frame, value["rotation_z"])
sequencer_section.get_channels()[6].add_key(
frame, value["scale_x"])
sequencer_section.get_channels()[7].add_key(
frame, value["scale_y"])
sequencer_section.get_channels()[8].add_key(
frame, value["scale_z"])
def AddSequencerSectionFloatKeysByIniFile(sequencer_section, track_dict):
for key in track_dict.keys():
frame = unreal.FrameNumber(int(key))
value = track_dict[key]
sequencer_section.get_channels()[0].add_key(frame, value)
def AddSequencerSectionBoolKeysByIniFile(sequencer_section, track_dict):
for key in track_dict.keys():
frame = unreal.FrameNumber(int(key))
value = track_dict[key]
sequencer_section.get_channels()[0].add_key(frame, value)
print("Warning this file already exists") # ???
factory = unreal.LevelSequenceFactoryNew()
asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
seq = asset_tools.create_asset_with_dialog('MySequence', '/Game', None,
factory)
if seq is None:
return 'ERROR: level sequencer factory_create fail'
print("Sequencer reference created")
print(seq)
# Process import
print(
"========================= Import started ! =========================")
# Set frame rate
myFFrameRate = unreal.FrameRate()
myFFrameRate.denominator = frameRateDenominator
myFFrameRate.numerator = frameRateNumerator
seq.set_display_rate(myFFrameRate)
# Set playback range
seq.set_playback_end_seconds(
(endFrame - secureCrop) / float(frameRateNumerator))
seq.set_playback_start_seconds(
startFrame / float(frameRateNumerator)) # set_playback_end_seconds
camera_cut_track = seq.add_master_track(unreal.MovieSceneCameraCutTrack)
camera_cut_track.set_editor_property('display_name',
'Imported Camera Cuts')
if int(unreal.SystemLibrary.get_engine_version()[:4][2:]) >= 26:
camera_cut_track.set_color_tint(unreal.Color(b=200, g=0, r=0, a=0))
else:
pass
for x, camera_data in enumerate(sequence_data["cameras"]):
# import camera
print("Start camera import " + str(x + 1) + "/" +
str(len(sequence_data["cameras"])) + " :" + camera_data["name"])
# Import camera tracks transform
with open(camera_data["additional_tracks_path"], "r") as json_file:
camera_tracks = json.load(json_file)
# Create spawnable camera and add camera in sequencer
cine_camera_actor = unreal.EditorLevelLibrary().spawn_actor_from_class(
unreal.CineCameraActor, unreal.Vector(0, 0, 0),
unreal.Rotator(0, 0, 0))
# Import additional tracks (camera_component)
camera_component_binding = seq.add_possessable(
cine_camera_actor.get_cine_camera_component())
# Get the last
TrackFocalLength = camera_component_binding.add_track(
unreal.MovieSceneFloatTrack)
TrackFocalLength.set_property_name_and_path('CurrentFocalLength',
'CurrentFocalLength')
TrackFocalLength.set_editor_property('display_name',
'Current Focal Length')
sectionFocalLength = TrackFocalLength.add_section()
sectionFocalLength.set_end_frame_bounded(False)
sectionFocalLength.set_start_frame_bounded(False)
AddSequencerSectionFloatKeysByIniFile(
sectionFocalLength, camera_tracks['Camera FocalLength'])
TrackSensorWidth = camera_component_binding.add_track(
unreal.MovieSceneFloatTrack)
TrackSensorWidth.set_property_name_and_path('Filmback.SensorWidth',
'Filmback.SensorWidth')
TrackSensorWidth.set_editor_property('display_name',
'Sensor Width (Filmback)')
sectionSensorWidth = TrackSensorWidth.add_section()
sectionSensorWidth.set_end_frame_bounded(False)
sectionSensorWidth.set_start_frame_bounded(False)
AddSequencerSectionFloatKeysByIniFile(
sectionSensorWidth, camera_tracks['Camera SensorWidth'])
TrackSensorHeight = camera_component_binding.add_track(
unreal.MovieSceneFloatTrack)
TrackSensorHeight.set_property_name_and_path('Filmback.SensorHeight',
'Filmback.SensorHeight')
TrackSensorHeight.set_editor_property('display_name',
'Sensor Height (Filmback)')
sectionSensorHeight = TrackSensorHeight.add_section()
sectionSensorHeight.set_end_frame_bounded(False)
sectionSensorHeight.set_start_frame_bounded(False)
crop_camera_sensor_height = {}
for key in camera_tracks['Camera SensorHeight'].keys():
original_width = float(camera_tracks['Camera SensorWidth'][key])
original_height = float(camera_tracks['Camera SensorHeight'][key])
res_x = float(sequence_data['render_resolution_x'])
res_y = float(sequence_data['render_resolution_y'])
pixel_x = float(sequence_data['pixel_aspect_x'])
pixel_y = float(sequence_data['pixel_aspect_y'])
res_ratio = res_x / res_y
pixel_ratio = pixel_x / pixel_y
crop_camera_sensor_height[key] = (original_width /
(res_ratio * pixel_ratio))
AddSequencerSectionFloatKeysByIniFile(sectionSensorHeight,
crop_camera_sensor_height)
TrackFocusDistance = camera_component_binding.add_track(
unreal.MovieSceneFloatTrack)
# Wtf this var name change every version or I do someting wrong??? :v
if int(unreal.SystemLibrary.get_engine_version()[:4][2:]) >= 26:
TrackFocusDistance.set_property_name_and_path(
'FocusSettings.ManualFocusDistance',
'FocusSettings.ManualFocusDistance')
TrackFocusDistance.set_editor_property(
'display_name', 'Manual Focus Distance (Focus Settings)')
elif int(unreal.SystemLibrary.get_engine_version()[:4][2:]) >= 25:
TrackFocusDistance.set_property_name_and_path(
'FocusSettings.ManualFocusDistance',
'FocusSettings.ManualFocusDistance')
TrackFocusDistance.set_editor_property(
'display_name', 'Manual Focus Distance (Focus Settings)')
elif int(unreal.SystemLibrary.get_engine_version()[:4][2:]) >= 24:
TrackFocusDistance.set_property_name_and_path(
'CurrentFocusDistance', 'CurrentFocusDistance')
TrackFocusDistance.set_editor_property('display_name',
'Current Focus Distance')
else:
TrackFocusDistance.set_property_name_and_path(
'ManualFocusDistance', 'ManualFocusDistance')
TrackFocusDistance.set_editor_property('display_name',
'Current Focus Distance')
sectionFocusDistance = TrackFocusDistance.add_section()
sectionFocusDistance.set_end_frame_bounded(False)
sectionFocusDistance.set_start_frame_bounded(False)
AddSequencerSectionFloatKeysByIniFile(
sectionFocusDistance, camera_tracks['Camera FocusDistance'])
TracknAperture = camera_component_binding.add_track(
unreal.MovieSceneFloatTrack)
TracknAperture.set_property_name_and_path('CurrentAperture',
'CurrentAperture')
TracknAperture.set_editor_property('display_name', 'Current Aperture')
sectionAperture = TracknAperture.add_section()
sectionAperture.set_end_frame_bounded(False)
sectionAperture.set_start_frame_bounded(False)
AddSequencerSectionFloatKeysByIniFile(sectionAperture,
camera_tracks['Camera Aperture'])
# add a binding for the camera
camera_binding = seq.add_possessable(cine_camera_actor)
if spawnable_camera:
# Transfer to spawnable camera
camera_spawnable = seq.add_spawnable_from_class(
unreal.CineCameraActor) # Add camera in sequencer
camera_component_binding.set_parent(camera_spawnable)
# Import transform tracks
if spawnable_camera:
transform_track = camera_spawnable.add_track(
unreal.MovieScene3DTransformTrack)
else:
transform_track = camera_binding.add_track(
unreal.MovieScene3DTransformTrack)
transform_section = transform_track.add_section()
transform_section.set_end_frame_bounded(False)
transform_section.set_start_frame_bounded(False)
AddSequencerSectionTransformKeysByIniFile(
transform_section, camera_tracks['Camera transform'])
# Set property binding
if spawnable_camera:
current_camera_binding = camera_spawnable
else:
current_camera_binding = camera_binding
if int(unreal.SystemLibrary.get_engine_version()[:4][2:]) >= 26:
current_camera_binding.set_display_name(camera_data["name"])
else:
pass
tracksSpawned = current_camera_binding.find_tracks_by_exact_type(
unreal.MovieSceneSpawnTrack)
if len(tracksSpawned) > 0:
sectionSpawned = tracksSpawned[0].get_sections()[0]
AddSequencerSectionBoolKeysByIniFile(
sectionSpawned, camera_tracks['Camera Spawned'])
# Set property actor
if spawnable_camera:
current_cine_camera_actor = camera_spawnable.get_object_template()
else:
current_cine_camera_actor = cine_camera_actor
current_cine_camera_actor.set_actor_label(camera_data["name"])
camera_component = cine_camera_actor.camera_component
camera_component.aspect_ratio = render_resolution_x / render_resolution_y
camera_component.lens_settings.min_f_stop = 0
camera_component.lens_settings.max_f_stop = 1000
# Clean the created assets
if spawnable_camera:
cine_camera_actor.destroy_actor()
camera_binding.remove()
if spawnable_camera:
ImportedCamera.append((camera_data["name"], camera_spawnable))
else:
ImportedCamera.append((camera_data["name"], camera_binding))
# Import camera cut section
for section in sequence_data['marker_sections']:
camera_cut_section = camera_cut_track.add_section()
if section["has_camera"] is not None:
for camera in ImportedCamera:
if camera[0] == section["camera_name"]:
camera_binding_id = unreal.MovieSceneObjectBindingID()
camera_binding_id = seq.make_binding_id(
camera[1], unreal.MovieSceneObjectBindingSpace.LOCAL)
camera_cut_section.set_camera_binding_id(camera_binding_id)
camera_cut_section.set_end_frame_seconds(
(section["end_time"] - secureCrop) / float(frameRateNumerator))
camera_cut_section.set_start_frame_seconds(section["start_time"] /
float(frameRateNumerator))
# Import result
print(
'========================= Imports completed ! ========================='
)
ImportedCameraStr = []
for cam in ImportedCamera:
ImportedCameraStr.append(cam[0])
print(ImportedCameraStr)
print('=========================')
# Select and open seq in content browser
if int(unreal.SystemLibrary.get_engine_version()[:4][2:]) >= 26:
unreal.AssetEditorSubsystem.open_editor_for_assets(
unreal.AssetEditorSubsystem(),
[unreal.load_asset(seq.get_path_name())])
else:
unreal.AssetToolsHelpers.get_asset_tools().open_editor_for_assets(
[unreal.load_asset(seq.get_path_name())])
unreal.EditorAssetLibrary.sync_browser_to_objects([seq.get_path_name()])
return 'Sequencer created with success !'
def setViewportLocationAndRotation_EXAMPLE():
viewport_index = getActiveViewportIndex()
setViewportLocationAndRotation(viewport_index,
unreal.Vector(0.0, 0.0, 0.0),
unreal.Rotator(0.0, 90.0, 0.0))
def setViewportLocationAndRotation(viewport_index=1,
location=unreal.Vector(),
rotation=unreal.Rotator()):
unreal.CppLib.set_viewport_location_and_rotation(viewport_index, location,
rotation)
import unreal
#Spawn Actor
#Video:https://www.youtube.com/watch?v=UGnbx7iNMBQ
actor_location = unreal.Vector(0,0,0)
actor_rotation = unreal.Rotator(0,0,0)
actor_class = unreal.EditorAssetLibrary.load_blueprint_class('/Game/Blueprints/BPAviao')
unreal.EditorLevelLibrary.spawn_actor_from_class(actor_class,actor_location,actor_rotation)
LINE += 1
jsond = jsond[:-1] + '}'
ldata = json.loads(jsond)
ed = unreal.EditorLevelLibrary
for key in ldata:
zvalue = ldata[key][0]['zvalue']
print(zvalue)
line = ldata[key][1]['coordinates']
if zvalue != 0:
zvalue = (float(zvalue) - float(hpointreference)) * 100.0
pi = 0
for coord in line:
xx = (float(coord[0]) - UTMx) * 100.0
yy = (UTMy - float(coord[1])) * 100.0
nv = unreal.Vector(x=xx, y=yy, z=zvalue)
if pi == 0:
rt = unreal.Rotator(roll=0.0, pitch=0.0, yaw=0.0)
actorObject = ed.spawn_actor_from_class(importlines,
nv,
rt,
transient=False)
SceneComponent = actorObject.root_component
SplineComponent = SceneComponent.get_child_component(1)
SplineComponent.clear_spline_points()
SplineComponent.add_spline_point_at_index(
nv, pi, unreal.SplineCoordinateSpace.WORLD)
SplineComponent.set_spline_point_type(pi,
SplinePointType,
update_spline=True)
pi += 1
def spawnActor():
actor_class = unreal.EditorAssetLibrary.load_blueprint_class('/Game/BluePrint/MyActor')
actor_location = unreal.Vector(0.0, 0.0, 0.0)
actor_rotation = unreal.Rotator(0.0, 0.0, 0.0)
unreal.EditorLevelLibrary.spawn_actor_from_class(actor_class, actor_location, actor_rotation)
def run():
# Spawn CurveInputExample and call run_curve_input_example
curve_input_example_actor = unreal.EditorLevelLibrary.spawn_actor_from_class(CurveInputExample.static_class(), unreal.Vector.ZERO, unreal.Rotator())
curve_input_example_actor.run_curve_input_example()
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'/Engine/BasicShapes/Cube.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(
