def main():
"""Execute the main functionality of the example script"""
locations = []
for x in range(ACTOR_COUNT_DIMENSIONS[0]):
for y in range(ACTOR_COUNT_DIMENSIONS[1]):
for z in range(ACTOR_COUNT_DIMENSIONS[2]):
locations.append((x * ACTOR_SEPARATION_DISTANCE,
y * ACTOR_SEPARATION_DISTANCE,
z * ACTOR_SEPARATION_DISTANCE))
total_frames = len(locations)
text_label = 'Generating Example Sequence'
new_sequence = create_new_level_sequence('/Game', 'ExamplePythonSequence')
with unreal.ScopedSlowTask(total_frames, text_label) as example_task:
example_task.make_dialog(True)
for cube_location in locations:
if example_task.should_cancel():
break
cube = spawn_actor(unreal.Vector(*cube_location))
# Add the cube to the generated sequence
add_actor_to_sequence(new_sequence, cube)
# Move the progress bar
example_task.enter_progress_frame()
# Automatically open the sequence
unreal.AssetToolsHelpers.get_asset_tools().open_editor_for_assets(
[new_sequence])
def main():
selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
level_boundaries = get_all_level_boundaries()
total_frames = len(selected_actors)
text_label = "Sorting objects"
with unreal.ScopedSlowTask(total_frames, text_label) as slow_task:
slow_task.make_dialog(True)
for x in selected_actors:
if slow_task.should_cancel():
break
b = get_closest_level_boundary(x, level_boundaries)
#Calls c++ function that will find the level streaming of the respective name
ls = unreal.LevelBoundarySortUtilities.get_level_streaming_from_name(
b.streaming_level_names[0], x)
a = [
x
] #Puts the current actor in an array for move actors to level (EditorLevelUtils wants it in an array)
#moves actors to level
unreal.EditorLevelUtils.move_actors_to_level(a, ls, True)
slow_task.enter_progress_frame(1)
def get_dict(self):
info = {}
with tempfile.TemporaryDirectory() as temp_dir:
total_frames = len(self)
with unreal.ScopedSlowTask(total_frames, "Getting Info...") as slow_task:
slow_task.make_dialog(True)
for name, texture in self.items():
slow_task.enter_progress_frame(1, 'Getting Info: ' + name)
if slow_task.should_cancel():
raise BaseException("Aborted.")
t3d_filename = os.path.join(temp_dir, name + '.t3d')
unreal.ObjectExporterT3D.run_asset_export_task(get_export_task(t3d_filename , texture))
with open(t3d_filename, 'r',encoding='utf-8') as t3d_file:
t3d = parse_t3d(t3d_file.readlines())
format = t3d['subitems'][0]['attrs']['Source']['Format']
info[name] = {
'flip_green_channel': texture.flip_green_channel,
'is_bugged_bgr': format == "TSF_RGBA16",
'format': format
}
return info
def unreal_progress(tasks):
with unreal.ScopedSlowTask(len(tasks), u"读取资源") as task:
task.make_dialog(True)
for i, item in enumerate(tasks):
if task.should_cancel():
break
task.enter_progress_frame(1, "进度 %s/%s" % (i, len(tasks)))
yield i, item
def setMaterialBySlotName():
# Gets all materials instances & material slot info dict
materials = getMaterialInstances()
slot_info = getMaterialSlotInformation()
# Collects the name of our materials and their paths
material_asset_name = [str(m.asset_name) for m in materials]
material_paths = [str(m.object_path) for m in materials]
# Create a dictionary from two lists with the material name used as the key
material_dictionary = dict(zip(material_asset_name, material_paths))
# Dumps dictionary into a json file
# with open(material_list, "w") as write_file:
# json.dump(material_dictionary, write_file, sort_keys=True, indent=4)
# Retrieves the value information for each slot
material_slot_values = [v.values() for v in slot_info]
# Begins a slow task dialog box for unique material slot
with unreal.ScopedSlowTask(len(material_slot_values)) as slow_task:
slow_task.make_dialog(True)
for x in range(len(material_slot_values)):
# Add an option to cancel out of the material assignment
if slow_task.should_cancel():
break
slow_task.enter_progress_frame(
1,
"Assigning materials to slots... " + str(x) + " / " +
str(len(material_slot_values)),
)
for v in material_slot_values:
material_index = v[0]
material_name = v[1]
# Runs a check to find a match material in our library
if material_name in material_dictionary:
# Collects our static mesh
static_mesh = getMeshes()
mesh = static_mesh[0]
# print 'found ' + material_name
# Sets the material path for our material
material_path = material_dictionary[material_name]
# Iterates over each static mesh, takes our material slot info, and sets the material
for d in mesh:
mesh_path = d.get_full_name()
mesh_example = unreal.EditorAssetLibrary.load_asset(
mesh_path)
material_example = unreal.EditorAssetLibrary.load_asset(
material_path)
mesh_example.set_material(int(material_index),
material_example)
else:
pass
print("no matches found")
def unreal_progress(tasks, label=u"进度", total=None):
total = total if total else len(tasks)
with unreal.ScopedSlowTask(total, label) as task:
task.make_dialog(True)
for i, item in enumerate(tasks):
if task.should_cancel():
break
task.enter_progress_frame(1, "%s %s/%s" % (label, i, total))
yield i, item
def execute(cls, label, callback, iteratable):
if len(iteratable) != 0:
with unreal.ScopedSlowTask(len(iteratable), label) as task:
task.make_dialog(True)
for row in iteratable:
if task.should_cancel():
break
callback(row)
task.enter_progress_frame(1)
def map(cls, label, callback, iteratable):
result = []
if len(iteratable) != 0:
with unreal.ScopedSlowTask(len(iteratable), label) as task:
task.make_dialog()
result = map(
lambda x: ProcessSlotTask.map_internal(task, x, callback),
iteratable)
return result
def executeSlowTask_EXAMPLE():
quantity_steps_in_slow_task = 1000
with unreal.ScopedSlowTask(quantity_steps_in_slow_task,
'My Slow Task Text ...') as slow_task:
slow_task.make_dialog(True)
for x in range(quantity_steps_in_slow_task):
if slow_task.should_cancel_EXAMPLE():
break
slow_task.enter_progress_frame(
1, 'My Slow Task Text ... ' + str(x) + ' / ' +
str(quantity_steps_in_slow_task))
# Execute slow logic here
print 'Executing Slow Task'
def executeSlowTask():
quantity_steps_in_slow_task = 10
with unreal.ScopedSlowTask(quantity_steps_in_slow_task,
'My Slow Task Text ...') as slow_task:
slow_task.make_dialog(True)
for x in range(quantity_steps_in_slow_task):
if slow_task.should_cancel():
break
slow_task.enter_progress_frame(
1, 'My Slow Task Text ...' + str(x) + ' / ' +
str(quantity_steps_in_slow_task))
# Execute slow logic
deferredSpawnActor()
time.sleep(1)
def export(assets, dir_path):
textures = Textures()
materials = Materials(textures)
meshes = Meshes(materials)
for asset in assets:
type = asset.__class__.__name__
if type in ('StaticMesh', 'SkeletalMesh'):
meshes.append(asset)
elif type in ('Material', 'MaterialInstanceConstant'):
materials.append(asset)
elif type in ('Texture2D', 'Texture'):
textures.append(asset)
else:
print(f"Asset '{asset.get_name()}' has unsupported type '{type}'.")
if not any((textures, materials, meshes)):
return
os.makedirs(dir_path, exist_ok = True)
texture_info = textures.get_dict()
info = {
"meshes": meshes.get_dict(),
"materials": materials.get_dict(texture_info),
"textures": texture_info
}
info_path = os.path.join(dir_path, "__unreal_assets__.json")
with open(info_path, 'w') as info_file:
json.dump(info, info_file, indent = 4, ensure_ascii = False)
total_frames = len(textures) + len(meshes)
with unreal.ScopedSlowTask(total_frames, "Exporting...") as slow_task:
slow_task.make_dialog(True)
import itertools
for name in itertools.chain(textures.export_iter(dir_path, texture_info), meshes.export_iter(dir_path)):
if slow_task.should_cancel():
break
slow_task.enter_progress_frame(1, 'Exporting: ' + name)
def spawn_preview_mesh():
materials = get_material_instances()
material_asset_name = [str(m.asset_name) for m in materials]
material_paths = [str(m.object_path) for m in materials]
material_dictionary = sorted(dict(zip(material_asset_name, material_paths)), reverse=True)
mesh = get_mesh_by_name()
with unreal.ScopedSlowTask(len(material_dictionary), 'Spawning meshes... ') as slow_task:
slow_task.make_dialog(True)
for x in range(len(material_dictionary)):
if slow_task.should_cancel():
break
slow_task.enter_progress_frame(1, 'Assigning meshes... ' + str(x) + ' / ' + str(len(material_dictionary)))
# unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.StaticMeshActor.static_class(), unreal.Vector(
# 0, 0, 0), unreal.Rotator(0, 0, 0))
for d in material_dictionary:
print(d)
def delete_unused_assets(): editorAssetLib = GetEditorAssetLibrary() workingPath = "/Game" allAssets = editorAssetLib.list_assets(workingPath, True, False) processingAssetPath = "" allAssetsCount = len(allAssets) if ( allAssetsCount > 0): with unreal.ScopedSlowTask(allAssetsCount, processingAssetPath) as slowTask: slowTask.make_dialog(True) for asset in allAssets: processingAssetPath = asset deps = editorAssetLib.find_package_referencers_for_asset(asset, False) if (len(deps) <= 0): print ">>> Deleting >>> %s" % asset editorAssetLib.delete_asset(asset) if slowTask.should_cancel(): break slowTask.enter_progress_frame(1, processingAssetPath)
def prefix_all_assets():
#You can set the prefix of your choice here
prefixAnimationBlueprint = "Anim_BP"
prefixAnimationSequence = "Seq"
prefixAnimation = "Anim"
prefixBlendSpace = "BS"
prefixBlueprint = "BP"
prefixCurveFloat = "crvF"
prefixCurveLinearColor = "crvL"
prefixLevel = "Lv"
prefixMaterial = "M"
prefixMaterialFunction = "MF"
prefixMaterialInstance = "MI"
prefixParticleSystem = "FX"
prefixPhysicsAsset = "Phy"
prefixSkeletalMesh = "SKM"
prefixSkeleton = "SK"
prefixSoundCue = "Cue"
prefixSoundWave = "wv"
prefixStaticMesh = "SM"
prefixTexture2D = "T"
prefixTextureCube = "HDRI"
def GetProperPrefix(className):
_prefix = ""
if className == "AnimBlueprint":
_prefix = prefixAnimationBlueprint
elif className == "AnimSequence":
_prefix = prefixAnimationSequence
elif className == "Animation":
_prefix = prefixAnimation
elif className == "BlendSpace1D":
_prefix = prefixBlendSpace
elif className == "Blueprint":
_prefix = prefixBlueprint
elif className == "CurveFloat":
_prefix = prefixCurveFloat
elif className == "CurveLinearColor":
_prefix = prefixCurveLinearColor
elif className == "Material":
_prefix = prefixMaterial
elif className == "MaterialFunction":
_prefix = prefixMaterialFunction
elif className == "MaterialInstance":
_prefix = prefixMaterialInstance
elif className == "ParticleSystem":
_prefix = prefixParticleSystem
elif className == "PhysicsAsset":
_prefix = prefixPhysicsAsset
elif className == "SkeletalMesh":
_prefix = prefixSkeletalMesh
elif className == "Skeleton":
_prefix = prefixSkeleton
elif className == "SoundCue":
_prefix = prefixSoundCue
elif className == "SoundWave":
_prefix = prefixSoundWave
elif className == "StaticMesh":
_prefix = prefixStaticMesh
elif className == "Texture2D":
_prefix = prefixTexture2D
elif className == "TextureCube":
_prefix = prefixTextureCube
else:
_prefix = ""
return _prefix
editorAssetLib = GetEditorAssetLibrary()
workingPath = "/Game"
allAssets = editorAssetLib.list_assets(workingPath, True, False)
allAssetsCount = len(allAssets)
selectedAssetPath = workingPath
with unreal.ScopedSlowTask(allAssetsCount, selectedAssetPath) as slowTask:
slowTask.make_dialog(True)
for asset in allAssets:
_assetData = editorAssetLib.find_asset_data(asset)
_assetName = _assetData.get_asset().get_name()
_assetPathName = _assetData.get_asset().get_path_name()
_assetPathOnly = _assetPathName.replace((_assetName + "." + _assetName), "")
_assetClassName = _assetData.get_asset().get_class().get_name()
_assetPrefix = GetProperPrefix(_assetClassName)
if _assetPrefix in _assetName:
continue
elif _assetPrefix == "":
continue
else:
_targetPathName = _assetPathOnly + ("%s%s%s%s%s%s%s" % (_assetPrefix, "_", _assetName, ".", _assetPrefix, "_", _assetName))
editorAssetLib.rename_asset(_assetPathName, _targetPathName)
print ">>> Renaming [%s] to [%s]" % (_assetPathName, _targetPathName)
if slowTask.should_cancel():
break
slowTask.enter_progress_frame(1, asset)
import unreal
# Collect all assets
all_asset_string = unreal.EditorAssetLibrary.list_assets("/Game/", True, False)
num_target_assets = len(all_asset_string)
referenced_assets = []
non_referenced_assets = []
with unreal.ScopedSlowTask(num_target_assets) as slow_find_task:
slow_find_task.make_dialog(True)
for asset_string in all_asset_string:
asset_data = unreal.EditorAssetLibrary.find_asset_data(asset_string)
if (asset_data.is_valid() and not asset_data.is_redirector()):
# Find referencers
referencers = unreal.EditorAssetLibrary.find_package_referencers_for_asset(
asset_string, False)
if (len(referencers) > 0):
referenced_assets.append(asset_string)
else:
non_referenced_assets.append(asset_string)
# if pressed "Cancel" button on dialog, task is cancel.
if slow_find_task.should_cancel():
print("Task cancelled.")
del referenced_assets[:]
del non_referenced_assets[:]
break
# Advance progress
# save level
saved_level = unreal.EditorLevelLibrary.save_all_dirty_levels()
if not saved_level:
print("Error: Cannot save level")
return
# get the number of JT files in the directory
nb_jt_files = count_jt_files_in_directory(input_directory)
# global variable
file_index = 0
# progress bar
with unreal.ScopedSlowTask(nb_jt_files, "Data Preparation") as slow_task:
slow_task.make_dialog(True)
level_path = content_folder + "/ImportedLevel"
if unreal.EditorAssetLibrary.does_asset_exist(level_path):
# if the level already exists, we just load it
unreal.EditorLevelLibrary.load_level(level_path)
else:
# create a new level to hold the imported scene
created_new_level = unreal.EditorLevelLibrary.new_level_from_template(
level_path, "/Engine/Maps/Templates/Template_Default")
if not created_new_level:
print("Error: Cannot create new level")
quit()
process_directory(input_directory, None, slow_task)
import unreal
import time
total_frames = 90
text_label = 'Working...'
with unreal.ScopedSlowTask(total_frames, text_label) as slow_task:
slow_task.make_dialog(True)
for i in range(total_frames):
if slow_task.should_cancel():
break
slow_task.enter_progress_frame(1)
time.sleep(1)
print(i)
start_time = time.time()
# instances of unreal classes
editor_util = unreal.EditorUtilityLibrary()
editor_asset_lib = unreal.EditorAssetLibrary()
# get the selected assets
selected_assets = editor_util.get_selected_assets()
num_assets = len(selected_assets)
num_copies = 50
total_num_copies = num_assets * num_copies
text_label = "Duplicating Assets"
running = True
with unreal.ScopedSlowTask(total_num_copies, text_label) as slow_task:
slow_task.make_dialog(True)
for asset in selected_assets:
# get the asset name and path to be duplicate
asset_name = asset.get_fname()
asset_path = editor_asset_lib.get_path_name_for_loaded_asset(asset)
source_path = os.path.dirname(asset_path)
for i in range(num_copies):
# if user pressed the cancel button, stop duplicate
if slow_task.should_cancel():
running = False
break
new_name = "{}_{}".format(asset_name, i)
workingPath = "/Game/"
@unreal.uclass()
class GetEditorAssetLibrary(unreal.EditorAssetLibrary):
pass
editorAssetLib = GetEditorAssetLibrary()
allAssets = editorAssetLib.list_assets(workingPath, True, False)
allAssetsCount = len(allAssets)
selectedAssetPath = workingPath
with unreal.ScopedSlowTask(allAssetsCount, selectedAssetPath) as slowTask:
slowTask.make_dialog(True)
for asset in allAssets:
_assetData = editorAssetLib.find_asset_data(asset)
_assetName = _assetData.get_asset().get_name()
_assetPathName = _assetData.get_asset().get_path_name()
_assetClassName = _assetData.get_asset().get_class().get_name()
_targetPathName = "/Game/%s%s%s%s%s" % (_assetClassName, "/", _assetName, ".", _assetName)
editorAssetLib.rename_asset(_assetPathName, _targetPathName)
if slowTask.should_cancel():
break
slowTask.enter_progress_frame(1, asset)
for a in w:
if (a.get_class().get_name().startswith("GeoReferenceBP")):
print("GeoReference Found")
ref = a
ref.initialize_geo_conv()
return ref
# ----------------------------------------------------------------------------------------
lx, ly, hx, hy, size = getLandscapeBBox()
ref = getGeoReference()
text_label = "Projecting coordinates"
nFrames = 5
with unreal.ScopedSlowTask(nFrames, text_label) as slow_task:
slow_task.make_dialog(True)
tl = tuple(map(Decode60, ref.get_bl(lx, ly)))
bl = tuple(map(Decode60, ref.get_bl(lx, hy)))
br = tuple(map(Decode60, ref.get_bl(hx, hy)))
tr = tuple(map(Decode60, ref.get_bl(hx, ly)))
print("Reference Quad=tl:{0} bl:{1} br:{2} tr:{3}".format(tl, bl, br, tr))
zo = ref.get_actor_location()
zobl = tuple(map(Decode60, ref.get_bl(zo.x, zo.y)))
print("GeoReference in BL {0} {1}".format(zobl[0], zobl[1]))
print("GeoReference in UE {0}".format(zo))
print(ref.get_xy(Encode60(zobl[0]), Encode60(zobl[1])))
gt = GeoTIFF(inputGeotiff)
tluv = gt.getUV(tl)
import random
import unreal
all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
unreal.log_warning("total actors: {}".format(len(all_actors)))
#for act in all_actors:
# name = act.get_name()
# rand = random.randint(1,100)
# if(name.startswith("SM_ProductWithAN") and rand < 25):
# unreal.log_warning("delete {}".format(name))
# act.destroy_actor()
with unreal.ScopedSlowTask(len(all_actors), "Removing Products Randomly") as slow_task:
slow_task.make_dialog(True)
frame = 1
for act in all_actors:
if slow_task.should_cancel():
break
frame += 1
slow_task.enter_progress_frame(frame)
name = act.get_name()
rand = random.randint(1,100)
if(name.startswith("SM_ProductWithAN") and rand < 75):
unreal.log_warning("delete {}".format(name))
act.destroy_actor()
workingPath = "/Game/"
@unreal.uclass()
class GetEditorAssetLibrary(unreal.EditorAssetLibrary):
pass
editorAssetLib = GetEditorAssetLibrary()
processAssetPath = ""
allAssets = editorAssetLib.list_assets(workingPath, True, False)
allAssetsCount = len(allAssets)
with unreal.ScopedSlowTask(allAssetsCount, processAssetPath) as slowTask:
slowTask.make_dialog(True)
for processAsset in allAssets:
_processAssetData = editorAssetLib.find_asset_data(processAsset)
_processAsset = _processAssetData.get_asset()
_processAssetName = _processAssetData.get_asset().get_name()
processAssetPath = _processAssetData.get_asset().get_path_name()
assetsMatching = []
for asset in allAssets:
_assetData = editorAssetLib.find_asset_data(asset)
_assetName = _assetData.get_asset().get_name()
if (_assetName == _processAssetName):
if (asset != processAssetPath):
___________________________________
""")
editor_selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
content_browser_selected_assets = unreal.EditorUtilityLibrary.get_selected_assets(
)
if not editor_selected_actors or not content_browser_selected_assets:
unreal.log_warning(
"Select actors from the level to be replaced with the asset selected from the content browser!"
)
else:
asset_name = content_browser_selected_assets[0].get_full_name()
loading_text = "Replacing actors..."
actors_count = len(editor_selected_actors)
with unreal.ScopedSlowTask(actors_count, loading_text) as ST:
ST.make_dialog(True)
for actor in editor_selected_actors:
if ST.should_cancel():
break
# Get actor rotation
rotation = actor.get_actor_eyes_view_point()[1]
# Get actor position
location = actor.get_actor_location()
# Get actor name
actor_name = actor.get_name()
# Spawn asset at [location, rotation]
unreal.EditorLevelLibrary.spawn_actor_from_object(
content_browser_selected_assets[0], location, rotation)
# Delete actor
