importOptions.static_mesh_import_data.set_editor_property(
"normal_import_method",
getattr(FBXNormalImportMethod,
"FBXNIM_" + jsonSetting["normal_import_method"]))
importOptions.static_mesh_import_data.set_editor_property(
"normal_generation_method",
getattr(FBXNormalGenerationMethod,
jsonSetting["normal_generation_method"]))
importOptions.static_mesh_import_data.set_editor_property(
"compute_weighted_normals",
jsonSetting["compute_weighted_normals"])
# Transform
importOptions.static_mesh_import_data.set_editor_property(
"import_translation", Vector(*jsonSetting["import_translation"]))
importOptions.static_mesh_import_data.set_editor_property(
"import_rotation", Rotator(*jsonSetting["import_rotation"]))
importOptions.static_mesh_import_data.set_editor_property(
"import_uniform_scale", jsonSetting["import_uniform_scale"])
# Misc.
importOptions.static_mesh_import_data.set_editor_property(
"convert_scene", jsonSetting["convert_scene"])
importOptions.static_mesh_import_data.set_editor_property(
"force_front_x_axis", jsonSetting["force_front_x_axis"])
importOptions.static_mesh_import_data.set_editor_property(
"convert_scene_unit", jsonSetting["convert_scene_unit"])
importOptions.set_editor_property("override_full_name",
jsonSetting["override_full_name"])
'compute_weighted_normals',
unreal_engine_import_setting['compute_weighted_normals']),
(import_options.skeletal_mesh_import_data, 'threshold_position',
unreal_engine_import_setting['threshold_position']),
(import_options.skeletal_mesh_import_data,
'threshold_tangent_normal',
unreal_engine_import_setting['threshold_tangent_normal']),
(import_options.skeletal_mesh_import_data, 'threshold_uv',
unreal_engine_import_setting['threshold_uv']),
(import_options, 'create_physics_asset',
(unreal_engine_import_setting['create_physics_asset'] == 'CREATE'
)),
# Transform
(import_options.skeletal_mesh_import_data, 'import_translation',
Vector(*unreal_engine_import_setting['import_translation'])),
(import_options.skeletal_mesh_import_data, 'import_rotation',
Rotator(*unreal_engine_import_setting['import_rotation'])),
(import_options.skeletal_mesh_import_data, 'import_uniform_scale',
unreal_engine_import_setting['import_uniform_scale']),
# Misc.
(import_options.skeletal_mesh_import_data, 'convert_scene',
unreal_engine_import_setting['convert_scene']),
(import_options.skeletal_mesh_import_data, 'force_front_x_axis',
unreal_engine_import_setting['force_front_x_axis']),
(import_options.skeletal_mesh_import_data, 'convert_scene_unit',
unreal_engine_import_setting['convert_scene_unit']),
(import_options, 'override_full_name',
unreal_engine_import_setting['override_full_name']),
"Game", "Blender", jsonSetting["subfolder"]).replace(os.sep, "/")
if EditorAssetLibrary.does_directory_exist(directory_path=targetFolder):
EditorAssetLibrary.make_directory(directory_path=targetFolder)
for file in jsonSetting["files"]:
sourceFile = os.path.join(jsonSetting["folder"],
file["name"] + ".abc").replace(os.sep, "/")
if os.path.exists(sourceFile):
importOptions = GroomImportOptions()
# Conversion
importOptions.conversion_settings.set_editor_property(
"rotation", Vector(*jsonSetting["rotation"]))
importOptions.conversion_settings.set_editor_property(
"scale", Vector(*jsonSetting["scale"]))
# Build settings
importOptions.build_settings.set_editor_property(
"override_guides", jsonSetting["override_guides"])
importOptions.build_settings.set_editor_property(
"hair_to_guide_density", jsonSetting["hair_to_guide_density"])
importOptions.build_settings.set_editor_property(
"interpolation_quality",
getattr(GroomInterpolationQuality,
jsonSetting["interpolation_quality"]))
importOptions.build_settings.set_editor_property(
"interpolation_distance",
maze, maze_x_dim, maze_y_dim, _, _ = read_maze_file(maze_filepath)
CUBE_SCALE = 100
WALL_Z_OFFSET = CUBE_SCALE
MAZE_X_OFFSET = -(CUBE_SCALE * maze_x_dim) / 2 + CUBE_SCALE / 2
MAZE_Y_OFFSET = -(CUBE_SCALE * maze_y_dim) / 2 + CUBE_SCALE / 2
OPEN_SPACE = 0
WALL_NORM = 2
WALL_RIGHT = 3
WALL_LEFT = 4
WALL_GOAL = 5
floor = spawn_actor(Vector(8, 8, 0), "/Game/Floor.Floor")
floor.set_actor_scale3d(Vector(maze_x_dim, maze_y_dim, 1)) # type: ignore
walls = []
for yi, row in enumerate(maze):
y = yi * CUBE_SCALE + MAZE_X_OFFSET
# Unreal Engine uses left-handed coordinate system
for xi, col in enumerate(reversed(row)):
x = xi * CUBE_SCALE + MAZE_Y_OFFSET
if col == WALL_NORM:
walls.append(
spawn_actor(Vector(x, y, WALL_Z_OFFSET), "/Game/Wall.Wall"))
import unreal
import os
import cPickle as pickle
from unreal import Vector
START_POSITIONS = {
'Cube': Vector(1, 2, 3),
'Sphere': Vector(5, 5, 5),
'Wall': Vector(20, 20, 20)
}
DIRECTIONS_AND_GAP = {
'Cube': Vector(100, 0, 0),
'Sphere': Vector(0, 500, 0),
'Wall': Vector(0, 0, 200)
}
LOG = False
SAVE_FILENAME = 'Save.txt'
SAVE_ABS_PATH = os.path.join(os.path.dirname(__file__), SAVE_FILENAME)
log_start()
save_actors_positions()
# # # # # IO # # # # #
def save_actors_positions():
backup = open(SAVE_ABS_PATH, "w+")
backup.write(pickle.dumps(get_all_actors_positions()))
backup.close()