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(