def SpawnSurroundingActor(ActorToSpawn, Core, CenterObject, Distance=10, NumberOfWalls=0) :
if NumberOfWalls <= 0 : NumberOfWalls = Distance
spawningActorAsset = unreal.EditorAssetLibrary().find_asset_data(ActorToSpawn)
spawningActorObject = spawningActorAsset.get_asset()
level_actor_list = unreal.EditorLevelLibrary().get_all_level_actors()
for a in level_actor_list:
if a.get_name() == Core : core_object = a
if a.get_name() == CenterObject : center_object = a
ForwardVector = center_object.get_actor_forward_vector()
PerpendicularVector = unreal.Vector(1, 1, ((ForwardVector.x + ForwardVector.y) * -1) / ForwardVector.z )
PerpendicularVector = PerpendicularVector * Distance
NewPosition = PerpendicularVector + center_object.get_actor_location()
RotationAxis = center_object.get_actor_location() - core_object.get_actor_location()
with unreal.ScopedEditorTransaction("Spawn Surrounding Actors") as trans:
for i in range(0, NumberOfWalls, 2) :
ResultPosition = unreal.MathLibrary().rotate_angle_axis(NewPosition, i * 360 / Distance, RotationAxis)
unit_direction = unreal.MathLibrary().get_direction_unit_vector(core_object.get_actor_location(), ResultPosition)
ResultLocation = (unit_direction * 590) + core_object.get_actor_location()
spawned_actor = unreal.EditorLevelLibrary().spawn_actor_from_object(spawningActorObject, ResultLocation)
spawned_actor.set_actor_relative_scale3d(unreal.Vector(0.1, 0.1, 2.0))
spawned_actor.set_actor_rotation(GetCoreBasedRotation(core_object.get_actor_location(), spawned_actor), True)
def create_level(self):
self.ass_lev = unreal.AssetToolsHelpers.get_asset_tools().create_asset(
asset_name=self.ass_lev_name,
package_path=self.ass_lev_path,
asset_class=unreal.World,
factory=unreal.WorldFactory())
self.ass = unreal.AssetToolsHelpers.get_asset_tools().create_asset(
asset_name=self.ass_name,
package_path=self.ass_path,
asset_class=unreal.LevelSequence,
factory=unreal.LevelSequenceFactoryNew())
self.ass.set_display_rate(unreal.FrameRate(self.fps, 1))
# 设置关卡序列的开始帧
self.ass.make_range(self.start, self.end)
self.ass.set_playback_start(self.start)
self.ass.set_playback_end(self.end)
self.ass.set_work_range_start(self.start / self.fps)
self.ass.set_work_range_end(self.end / self.fps)
self.ass.set_view_range_start(self.start / self.fps)
self.ass.set_view_range_end(self.end / self.fps)
# 添加摄像机关卡
unreal.EditorLevelLibrary().load_level("{path}{name}.{name}".format(
path=self.ass_lev_path, name=self.ass_lev_name)) # 打开创建的关卡
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 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 !'
import unreal
# instances of unreal classes
editor_level_lib = unreal.EditorLevelLibrary()
editor_filter_lib = unreal.EditorFilterLibrary()
# get all level actors and filter by StaticMeshActor
level_actors = editor_level_lib.get_all_level_actors()
static_mesh_actors = editor_filter_lib.by_class(level_actors,
unreal.StaticMeshActor)
deleted = 0
for actor in static_mesh_actors:
actor_name = actor.get_fname()
# get the static mesh through the static mesh component
actor_mesh_comp = actor.static_mesh_component
actor_mesh = actor_mesh_comp.static_mesh
is_valid_actor = actor_mesh != None
# if mesh not valid, destroy
if not is_valid_actor:
actor.destroy_actor()
deleted += 1
unreal.log(
"The Mesh Component of Actor {} is invalid and was deleted".format(
actor_name))
unreal.log("Deleted {} Actors with invalid Mesh Component".format(deleted))
import unreal
project_id = "000"
project_name = "MaterialsTest"
prefix = ["SE", "SM"]
sub_directories = ["materials", "textures", "meshes", "blueprints"]
directory = unreal.EditorAssetLibrary()
directory_path = "/Game/" + prefix[0] + project_id + "_" + project_name
level = unreal.EditorLevelLibrary()
level_name = prefix[1] + "_" + project_name
level_asset = directory_path + "/" + level_name
def make_directory():
does_exist = True
if directory.does_directory_exist == does_exist:
print(str(directory_path) + ' already exists')
else:
directory.make_directory(directory_path)
for i in sub_directories:
directory.make_directory(directory_path + "/" + i)
print(str(directory_path) + ' created')
make_directory()
import unreal
# for i in dir(unreal.Actor()):
# print i
# unreal.EditorLevelLibrary().new_level("/Game/MyFolder/MyMap")
world = unreal.EditorLevelLibrary.get_editor_world()
actor = unreal.EditorLevelLibrary().spawn_actor_from_class(
unreal.StaticMeshActor, [0, 0, 0])
actor.static_mesh_component.set_static_mesh(
"StaticMesh'/Game/StarterContent/Props/SM_MatPreviewMesh_02.SM_MatPreviewMesh_02'"
)
# unreal.EditorLevelLibrary().destroy_actor(actor)
for i in dir(actor.static_mesh_component):
print i
