asset: two north-side background buildings across Hollywood Blvd

- TCL Chinese Theatre (6925) and Madame Tussaud's (6933) exported from the
  verified OSM blockout with ue_metric_v1 (export_north_buildings.py), with a
  Y-mirror so they land north of the road, across from the hero facade.
- ue_import_north_buildings.py imports + stages them in the DemoMap as
  North_TCL_Chinese / North_Madame_Tussauds (TCL Y 1802..9431, Tussaud's
  1888..7586; hero at Y -1450, road centreline ~0).
- render_screenshots.sh now also runs the DemoMap capture pass; added a
  demo-north-buildings camera, so the new buildings get a review shot.
- README/roadmap updated; flat facade materials pending the 0.1.4 patch.

Tools/export_north_buildings.py

@@ -0,0 +1,91 @@
+# Export the two in-scope north-side background buildings from the OSM blockout.
+#
+#   blender -b --factory-startup Art/blender/blockout/blockout-2026-11-06.blend \
+#       --python Tools/export_north_buildings.py -- --out /tmp/gigline/north
+#
+# The blockout is already in the shared project frame (metres, X east / Y north /
+# Z up, origin Hollywood x Highland), so exporting each object at its own world
+# position preserves the offset from the hero facade. The site export preset
+# (`ue_metric_v1`) is reused verbatim so the metre->centimetre mapping matches.
+
+import argparse
+import os
+import sys
+
+import bpy
+
+BUILDINGS = ("TCL Chinese Theatre", "Madame Tussaud's")
+
+
+def main():
+    argv = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else []
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default="/tmp/gigline/north")
+    args = ap.parse_args(argv)
+    os.makedirs(args.out, exist_ok=True)
+
+    print(f"[north] scene objects: {len(bpy.data.objects)}")
+    for name in BUILDINGS:
+        obj = bpy.data.objects.get(name)
+        if obj is None or obj.type != "MESH":
+            print(f"[north] MISSING {name}")
+            continue
+        bpy.ops.object.select_all(action="DESELECT")
+        obj.select_set(True)
+        bpy.context.view_layer.objects.active = obj
+        mesh = obj.data
+        if not mesh.materials:
+            mat = bpy.data.materials.new(f"M_{name.replace(' ', '_')}")
+            mat.diffuse_color = (0.75, 0.72, 0.68, 1.0)
+            mat.use_nodes = False
+            mesh.materials.append(mat)
+
+        # The blockout sits with the hero (6840, south side) at negative Y. The two
+        # in-scope north buildings must land ACROSS Hollywood Blvd at positive Y in
+        # Unreal. Mirror the exported geometry across the road centreline (Y=0) and
+        # reverse winding; the FBX exporter does not do this for us.
+        new_mesh = mesh.copy()
+        new_obj = obj.copy()
+        new_obj.data = new_mesh
+        new_obj.matrix_world = obj.matrix_world.copy()
+        bpy.context.collection.objects.link(new_obj)
+        import mathutils as mu
+        world = new_obj.matrix_world
+        inv = world.inverted()
+        for v in new_mesh.vertices:
+            wp = world @ v.co
+            wp.y = -wp.y
+            v.co = inv @ wp
+        for poly in new_mesh.polygons:
+            verts = list(poly.vertices)
+            verts.reverse()
+            poly.vertices = verts
+        new_mesh.update()
+        bpy.ops.object.select_all(action="DESELECT")
+        new_obj.select_set(True)
+        bpy.context.view_layer.objects.active = new_obj
+
+        path = os.path.join(args.out, name.replace(" ", "_").replace("'", "") + ".fbx")
+        bpy.ops.export_scene.fbx(
+            filepath=path,
+            use_selection=True,
+            object_types={"MESH"},
+            apply_unit_scale=True,
+            apply_scale_options="FBX_SCALE_NONE",
+            axis_forward="-Y",
+            axis_up="Z",
+            use_space_transform=True,
+            use_mesh_modifiers=True,
+            mesh_smooth_type="OFF",
+            path_mode="AUTO",
+            bake_space_transform=False,
+        )
+        zs = [(world @ v.co).z for v in new_mesh.vertices]
+        print(f"[north] {name:22} verts {len(new_mesh.vertices):5}  z {min(zs):+.2f}..{max(zs):+.2f} m "
+              f"-> {path}")
+        bpy.data.objects.remove(new_obj, do_unlink=True)
+
+    print(f"[north] done")
+
+
+main()

Tools/render_screenshots.sh

@@ -2,38 +2,55 @@
 # Render in-game screenshots for visual review into <repo>/Screenshots/ (gitignored).
 #
 # Usage: Tools/render_screenshots.sh
-# Rebuilds /Game/Test/ReviewMap from current content, runs the game on it
-# (the GigLineShotActor walks three cameras, captures, quits), then copies
-# the PNGs into Screenshots/.
+# Rebuilds /Game/Test/ReviewMap and /Game/Hollywood/DemoMap (shot lists), runs
+# the game on each map (the GigLineShotActor walks the cameras, captures, quits),
+# and copies the PNGs into Screenshots/. PNGs are never committed.
 set -euo pipefail
 
 REPO="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 ENGINE="${UE_ENGINE_DIR:-/run/media/system/DATA/Engines/UE_5.8.4}"
 PROJ="$REPO/Game/GigLine/GigLine.uproject"
 
-echo "== 1/3 build review map =="
+echo "== 1/4 build review + demo shot maps =="
 cd "$ENGINE"
 ./Engine/Binaries/Linux/UnrealEditor-Cmd "$PROJ" \
   -run=pythonscript -script="$REPO/Tools/ue_build_review_map.py" \
   -nullrhi -unattended -nopause -stdout
-cat /tmp/ue-review-map-result.txt
+cat /tmp/ue-review-map-result.txt | tail -3
 
-echo "== 2/3 run game on review map =="
-# -windowed -NoSplash: a fullscreen swap can leave the first frame uncaptured.
-./Engine/Binaries/Linux/UnrealEditor-Cmd "$PROJ" /Game/Test/ReviewMap \
-  -game -windowed -ResX=1920 -ResY=1080 -nopause -nosplash -stdout
+run_capture() {
+  local map="$1" label="$2"
+  echo "== capture: $label =="
+  ./Engine/Binaries/Linux/UnrealEditor-Cmd "$PROJ" "$map" \
+    -game -windowed -ResX=1920 -ResY=1080 -nopause -nosplash -stdout
+}
 
-echo "== 3/3 collect screenshots =="
-mkdir -p "$REPO/Screenshots"
-rm -f "$REPO"/Screenshots/review-*.png
+echo "== 2/4 run game on review map (hero/scene shots) =="
+run_capture "/Game/Test/ReviewMap" "review"
+
+echo "== 3/4 run game on demo map (walkable-demo shots) =="
+run_capture "/Game/Hollywood/DemoMap" "demo"
+
+echo "== 4/4 collect screenshots =="
+mkdir -p "$REPO/Screenshots/demo"
+rm -f "$REPO"/Screenshots/review-*.png "$REPO"/Screenshots/demo/review-*.png
 found=0
 for src in \
   "$REPO/Game/GigLine/Saved/Screenshots"/*/review-*.png \
   "$REPO/Game/GigLine/Saved/Screenshots"/*/*/review-*.png \
   "$HOME/.config/Epic/GigLine/Saved/Screenshots"/*/review-*.png; do
   [ -e "$src" ] || continue
-  cp -f "$src" "$REPO/Screenshots/"
+  name=$(basename "$src")
+  if [[ "$name" == review-?("")-demo-* || "$name" == review-*-demo-* || "$name" == review-0?-demo-* ]] \
+     || [[ "$name" == *demo-* ]]; then
+    cp -f "$src" "$REPO/Screenshots/demo/$name"
+  else
+    cp -f "$src" "$REPO/Screenshots/$name"
+  fi
   found=1
 done
 [ "$found" = "1" ] || { echo "ERROR: no review-*.png found"; exit 1; }
-ls -la "$REPO/Screenshots"
+echo "--- Screenshots/ ---"
+ls -1 "$REPO/Screenshots"
+echo "--- Screenshots/demo/ ---"
+ls -1 "$REPO/Screenshots/demo"

Tools/ue_build_review_map.py

@@ -201,6 +201,9 @@ try:
             ("demo-spawn-view", unreal.Vector(-10722.5, -3500, 165), unreal.Vector(-10722.5, -1450, 700)),
             ("demo-street-level", unreal.Vector(-11000, -400, 165), unreal.Vector(-10722.5, -1450, 500)),
             ("demo-crossing", unreal.Vector(-13600, -1650, 165), unreal.Vector(-12722.5, -1450, 500)),
+            # the two north-side background buildings (TCL, Tussaud's) seen from
+            # the south sidewalk, across Hollywood Blvd: their frontage and mass.
+            ("demo-north-buildings", unreal.Vector(-22800, -1000, 400), unreal.Vector(-22800, 3000, 300)),
         ]
         seq = spawn(unreal.GigLineShotActor, unreal.Vector(0, 0, 300), "ShotSequencer")
         if seq:
@@ -208,7 +211,9 @@ try:
             seq.set_editor_property("shot_rotations",
                                     [unreal.MathLibrary.find_look_at_rotation(c[1], c[2]) for c in demo_shots])
             seq.set_editor_property("shot_names", [c[0] for c in demo_shots])
-            seq.set_editor_property("quit_when_done", False)
+            # quit after the demo shots so a dedicated DemoMap capture run
+            # terminates cleanly (render_screenshots.sh runs both maps).
+            seq.set_editor_property("quit_when_done", True)
         saved = unreal.EditorLoadingAndSavingUtils.save_map(
             unreal.EditorLevelLibrary.get_editor_world(), "/Game/Hollywood/DemoMap")
         log(f"demo map staged: {len(demo_shots)} cameras, save {saved}")

Tools/ue_import_north_buildings.py

@@ -0,0 +1,115 @@
+# Import the two north-side background buildings (TCL Chinese Theatre, Madame
+# Tussaud's) into Unreal and stage them in the demo map, across the street from
+# the hero facade.
+#
+# Placement: these blockout meshes live in the same local frame as the site
+# meshes (X east / Y north / Z up, metres, origin Hollywood x Highland), which
+# are imported at the Unreal origin and land correctly via the `ue_metric_v1`
+# FBX axis mapping (north -> -Y). So the buildings are spawned at Unreal
+# (0,0,0) like the site meshes, not at the pivot-shifted hero facade position.
+#
+#   UnrealEditor-Cmd <uproject> -run=pythonscript \
+#     -script=<repo>/Tools/ue_import_north_buildings.py -nullrhi -unattended -nopause -stdout
+
+import os
+
+import unreal
+
+SRC = "/tmp/gigline/north"
+DEST = "/Game/Hollywood/North"
+LEVEL = "/Game/Hollywood/DemoMap"
+RESULT = "/tmp/gigline/north-import.txt"
+lines = []
+
+
+def log(msg):
+    lines.append(str(msg))
+    unreal.log(str(msg))
+
+
+IMPORTS = [
+    ("TCL_Chinese_Theatre.fbx", "SM_TCL_Chinese_Theatre"),
+    ("Madame_Tussauds.fbx", "SM_Madame_Tussauds"),
+]
+
+
+def import_meshes():
+    assets = unreal.EditorAssetLibrary.list_assets(DEST) if unreal.EditorAssetLibrary.does_directory_exist(DEST) else []
+    for fn, asset_name in IMPORTS:
+        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([unreal.AssetImportTask(
+            filename=os.path.join(SRC, fn),
+            destination_path=DEST,
+            destination_name=asset_name,
+            automated=True,
+            save=True,
+            replace_existing=True,
+            options=unreal.FbxImportUI(
+                import_mesh=True, import_materials=True, import_textures=False,
+                import_as_skeletal=False) if False else None,
+        )])
+    # FbxImportUI kwargs are unreliable across 5.8; configure explicitly below.
+
+
+def stage():
+    if unreal.EditorAssetLibrary.does_asset_exist(LEVEL):
+        unreal.EditorLevelLibrary.load_level(LEVEL)
+    for actor in list(unreal.EditorLevelLibrary.get_all_level_actors()):
+        if actor.get_actor_label().startswith("North_"):
+            unreal.EditorLevelLibrary.destroy_actor(actor)
+    for asset_name, label in (("SM_TCL_Chinese_Theatre", "North_TCL_Chinese"), ("SM_Madame_Tussauds", "North_Madame_Tussauds")):
+        mesh = unreal.EditorAssetLibrary.load_asset(f"{DEST}/{asset_name}")
+        if mesh is None:
+            log(f"MISSING {DEST}/{asset_name}")
+            continue
+        actor = unreal.EditorLevelLibrary.spawn_actor_from_class(
+            unreal.StaticMeshActor, unreal.Vector(0, 0, 0))
+        actor.set_actor_label(label)
+        comp = actor.static_mesh_component
+        comp.set_static_mesh(mesh)
+        comp.set_mobility(unreal.ComponentMobility.STATIC)
+        # Report where the mesh actually lands in world space (site-frame → Unreal).
+        box = mesh.get_bounding_box()
+        mn, mx = box.min, box.max
+        log(f"{label}: mesh world-space X {mn.x:.0f}..{mx.x:.0f}  Y {mn.y:.0f}..{mx.y:.0f}  size "
+            f"{mx.x-mn.x:.0f}x{mx.y-mn.y:.0f} cm")
+    saved = unreal.EditorLoadingAndSavingUtils.save_map(
+        unreal.EditorLevelLibrary.get_editor_world(), LEVEL)
+    log(f"save_map {LEVEL}: {saved}")
+
+
+def main():
+    for fn, asset_name in IMPORTS:
+        task = unreal.AssetImportTask()
+        task.filename = os.path.join(SRC, fn)
+        task.destination_path = DEST
+        task.destination_name = asset_name
+        task.automated = True
+        task.save = True
+        task.replace_existing = True
+        ui = unreal.FbxImportUI()
+        ui.import_mesh = True
+        ui.import_materials = True
+        ui.import_textures = False
+        ui.import_as_skeletal = False
+        smd = ui.static_mesh_import_data
+        smd.import_uniform_scale = 1.0
+        smd.combine_meshes = True
+        smd.convert_scene_unit = False
+        smd.force_front_x_axis = False
+        smd.normal_import_method = unreal.FBXNormalImportMethod.FBXNIM_IMPORT_NORMALS
+        task.options = ui
+        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
+        log(f"imported {asset_name}")
+    unreal.EditorLoadingAndSavingUtils.save_dirty_packages(True, True)
+    stage()
+
+
+try:
+    main()
+except Exception as exc:  # noqa
+    import traceback
+    log(f"FAILED: {type(exc).__name__}: {exc}")
+    log(traceback.format_exc())
+
+with open(RESULT, "w") as f:
+    f.write("\n".join(lines) + "\n")