Photoreal Blender scenes from a one-paragraph brief, built by AI agents: image→3D props on fal, scripted layout, lighting, camera and grade.
Python
"""Build one LevelSequence per baked camrig shot in the demo project (headless commandlet):
UnrealEditor-Cmd.exe AnySceneHKDemo.uproject -run=pythonscript -script="<path>/make_seqs.py" -unattended -nosplash -nop4
Env:
DEMO_CAMS folder of <shot>.json from bake_cams.py (required)
DEMO_SHOTS comma list of shots (default: every json in DEMO_CAMS)
DEMO_OUT MRQ output folder on disk (frames land in <DEMO_OUT>/<SEQ name>/)
DEMO_TS MRQ temporal samples (default 6)
DEMO_LEVEL level path (default /Game/AnyScene/HK/L_HK)
Per shot: a CineCameraActor DEMO_<shot> in the level (filmback = Blender sensor width x width*h/w), and
/Game/AnySceneDemo/Sequences/SEQ_<shot> at the shot's fps with frames 0..N-1 (= Blender frames 1..N), a camera cut
over the whole range, and a key on every frame (linear) for location, rotation (unwrapped), CurrentFocalLength,
CurrentAperture and FocusSettings.ManualFocusDistance. Extra keys at -1 and N (Blender frames 0 and N+1) cover the
motion-blur subframes at the ends. The camera's own post-process sets motion blur to the shot's shutter (180 deg =
amount 0.5); the level's grade volume turns it off for its stills.
MRQ configs: /Game/AnySceneDemo/MRQ/MRQ_Demo (deferred, PNG, TSR, DEMO_TS temporal samples, 64 warm-up frames with
use_camera_cut_for_warm_up False) and MRQ_DemoCheck (same, 1 temporal sample, for the camera-match check).
"""
import json
import math
import os
import time
import unreal
import warnings
warnings.simplefilter("ignore", DeprecationWarning)
CAMS = os.environ["DEMO_CAMS"]
SHOTS = [s for s in os.environ.get("DEMO_SHOTS", "").split(",") if s] or \
sorted(f[:-5] for f in os.listdir(CAMS) if f.endswith(".json"))
OUT = os.environ.get("DEMO_OUT", os.path.join(CAMS, "..", "mrq")).replace("\\", "/")
TS = int(os.environ.get("DEMO_TS", "6"))
LEVEL = os.environ.get("DEMO_LEVEL", "/Game/AnyScene/HK/L_HK")
DEST = "/Game/AnySceneDemo"
EAL = unreal.EditorAssetLibrary
AT = unreal.AssetToolsHelpers.get_asset_tools()
T0 = time.time()
def log(*a):
unreal.log_warning("DEMO " + " ".join(str(x) for x in a))
def V(v):
return unreal.Vector(v[0], v[1], v[2])
def unwrap(prev, cur):
if prev is None:
return cur
while cur - prev > 180:
cur -= 360
while cur - prev < -180:
cur += 360
return cur
def channels(sec):
for fn in ("get_all_channels", "get_channels"):
if hasattr(sec, fn):
return list(getattr(sec, fn)())
return list(unreal.MovieSceneSectionExtensions.get_all_channels(sec))
def key(ch, f, v):
ch.add_key(unreal.FrameNumber(f), float(v), 0.0, unreal.MovieSceneTimeUnit.DISPLAY_RATE,
unreal.MovieSceneKeyInterpolation.LINEAR)
def float_track(binding, prop, path, n, vals):
tr = binding.add_track(unreal.MovieSceneFloatTrack)
tr.set_property_name_and_path(prop, path)
sec = tr.add_section()
sec.set_range(-1, n + 1)
ch = channels(sec)[0]
for f, v in vals:
key(ch, f, v)
return tr
les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
eas = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
les.load_level(LEVEL)
log("level", LEVEL, "actors", len(eas.get_all_level_actors()), "shots", SHOTS)
for shot in SHOTS:
d = json.load(open(os.path.join(CAMS, shot + ".json")))
n, fps = d["frames_n"], d["fps"]
label = "DEMO_" + shot
for a in eas.get_all_level_actors():
if a.get_actor_label() == label:
eas.destroy_actor(a)
fr = d["frames"] # blender frames 0..n+1 -> UE frames -1..n
f1 = fr[1]
cam = eas.spawn_actor_from_class(unreal.CineCameraActor, V(f1["loc"]),
unreal.MathLibrary.make_rot_from_xz(V(f1["forward"]), V(f1["up"])))
cam.set_actor_label(label)
cam.set_folder_path("DemoCameras")
cc = cam.get_cine_camera_component()
fb = cc.get_editor_property("filmback")
fb.set_editor_property("sensor_width", d["sensor_width_mm"])
fb.set_editor_property("sensor_height", d["sensor_height_mm"])
cc.set_editor_property("filmback", fb)
lens = cc.get_editor_property("lens_settings")
lens.set_editor_property("min_f_stop", 0.7)
lens.set_editor_property("max_f_stop", 32.0)
cc.set_editor_property("lens_settings", lens)
cc.set_editor_property("current_focal_length", f1["lens_mm"])
cc.set_editor_property("current_aperture", f1["fstop"])
fs = cc.get_editor_property("focus_settings")
fs.set_editor_property("focus_method", unreal.CameraFocusMethod.MANUAL if d["dof"] else unreal.CameraFocusMethod.DISABLE)
fs.set_editor_property("manual_focus_distance", f1["focus_cm"] or 100000.0)
cc.set_editor_property("focus_settings", fs)
pp = cc.get_editor_property("post_process_settings")
pp.set_editor_property("override_motion_blur_amount", True)
pp.set_editor_property("motion_blur_amount", d["shutter_deg"] / 360.0)
pp.set_editor_property("override_motion_blur_max", True)
pp.set_editor_property("motion_blur_max", 100.0)
cc.set_editor_property("post_process_settings", pp)
cc.set_editor_property("post_process_blend_weight", 1.0)
sp = f"{DEST}/Sequences/SEQ_{shot}"
if EAL.does_asset_exist(sp):
EAL.delete_asset(sp)
seq = AT.create_asset(f"SEQ_{shot}", f"{DEST}/Sequences", unreal.LevelSequence, unreal.LevelSequenceFactoryNew())
seq.set_display_rate(unreal.FrameRate(fps, 1))
seq.set_playback_start(0)
seq.set_playback_end(n)
b = seq.add_possessable(cam)
cb = seq.add_possessable(cc)
try:
if not cb.get_parent().is_valid():
cb.set_parent(b)
except Exception:
cb.set_parent(b)
# Transform: one key per frame, rotation unwrapped so subframes never spin through +-180.
tr = b.add_track(unreal.MovieScene3DTransformTrack)
sec = tr.add_section()
sec.set_range(-1, n + 1)
ch = channels(sec)
prev = [None, None, None]
for i, F in enumerate(fr):
f = F["blender_frame"] - 1
r = unreal.MathLibrary.make_rot_from_xz(V(F["forward"]), V(F["up"]))
rpy = [unwrap(prev[0], r.roll), unwrap(prev[1], r.pitch), unwrap(prev[2], r.yaw)]
prev = rpy
for c, v in zip(ch[0:6], F["loc"] + rpy):
key(c, f, v)
for c in ch[6:9]:
key(c, -1, 1.0)
float_track(cb, "CurrentFocalLength", "CurrentFocalLength", n, [(F["blender_frame"] - 1, F["lens_mm"]) for F in fr])
if d["dof"]:
float_track(cb, "CurrentAperture", "CurrentAperture", n, [(F["blender_frame"] - 1, F["fstop"]) for F in fr])
float_track(cb, "ManualFocusDistance", "FocusSettings.ManualFocusDistance", n,
[(F["blender_frame"] - 1, F["focus_cm"]) for F in fr])
try:
cut = seq.add_track(unreal.MovieSceneCameraCutTrack)
except Exception:
cut = seq.add_master_track(unreal.MovieSceneCameraCutTrack)
cs = cut.add_section()
cs.set_range(0, n)
cs.set_camera_binding_id(seq.get_binding_id(b) if hasattr(seq, "get_binding_id")
else unreal.MovieSceneSequenceExtensions.get_binding_id(seq, b))
EAL.save_loaded_asset(seq, False)
log("sequence", sp, n, "frames @", fps, "keys/channel", len(fr), "tracks", [t.get_display_name() for t in cb.get_tracks()])
if not les.save_current_level():
log("save_current_level returned False")
for name, ts in (("MRQ_Demo", TS), ("MRQ_DemoCheck", 1)):
cp = f"{DEST}/MRQ/{name}"
if EAL.does_asset_exist(cp):
EAL.delete_asset(cp)
cfg = AT.create_asset(name, f"{DEST}/MRQ", unreal.MoviePipelinePrimaryConfig, None)
cfg.find_or_add_setting_by_class(unreal.MoviePipelineDeferredPassBase)
png = cfg.find_or_add_setting_by_class(unreal.MoviePipelineImageSequenceOutput_PNG)
cfg.find_or_add_setting_by_class(unreal.MoviePipelineGameOverrideSetting)
out = cfg.find_or_add_setting_by_class(unreal.MoviePipelineOutputSetting)
out.output_directory = unreal.DirectoryPath(OUT + ("" if ts > 1 else "/check"))
out.file_name_format = "{sequence_name}/{frame_number}"
out.output_resolution = unreal.IntPoint(1920, 804)
out.zero_pad_frame_numbers = 4
out.override_existing_output = True
aa = cfg.find_or_add_setting_by_class(unreal.MoviePipelineAntiAliasingSetting)
aa.override_anti_aliasing = True
aa.anti_aliasing_method = unreal.AntiAliasingMethod.AAM_TSR
aa.spatial_sample_count = 1
aa.temporal_sample_count = ts
aa.engine_warm_up_count = 64
aa.render_warm_up_frames = True
aa.use_camera_cut_for_warm_up = False
EAL.save_loaded_asset(cfg, False)
log("config", cp, "temporal", ts, "out", out.output_directory.path)
log("done", f"{time.time() - T0:.0f}s")