lighting: fixed daytime rig, real surface materials, crossing fix

Fixed daytime lighting and basic ambience for the DemoMap:

- Sun pitch -50 / yaw 120 (intensity 4, warm), sky light 2.6 with real-time
  capture, sky atmosphere, height fog, and an unbound post-process volume with
  fixed exposure (min = max brightness) so no shot washes out or crushes to
  black depending on how much sky it frames.
- Root cause of the washed-out look was NOT the sun: Blender's flat diffuse
  colours do not survive the FBX->Unreal import. Every site material arrived
  white and the terrain arrived with WorldGridMaterial. The demo builder now
  creates and assigns M_Asphalt / M_Concrete / M_Ground / M_RoadPaint.
- Crossing fix: each zebra band was its own object, so Blender renamed the
  duplicates .001/.002 and site assembly (exact-name append) kept only one.
  All bands are now a single Crossing_Markings mesh (36 verts, 3 bands).
- Terrain gets a Ground_Earth material in the builder so it stops importing
  as a white grid.
- Demo cameras: street-level no longer sits inside the facade body (was
  rendering its back face), and the crossing camera aims at the designated
  s=130.1 crossing (UE X -14956) looking along the crosswalk.

Screenshots re-rendered; the four demo views are marked needs-review for the
owner's approval. MEMORY.md records the material-import, exposure,
light_color, band-naming and camera-bounds traps.

Art/blender/street/street_mesh.py

@@ -261,20 +261,24 @@ def main():
     paint = bpy.data.materials.new("Road_Paint_White")
     paint.diffuse_color = (0.85, 0.85, 0.85, 1.0)
 
-    def crossing_band(s_c):
+    # All three bands live in ONE object. Creating one object per crossing used
+    # to produce Crossing_Markings, .001 and .002; site assembly appends by the
+    # exact name, so only the first crossing ever reached the game.
+    band_verts, band_faces = [], []
+
+    def add_crossing_band(s_c):
         # Stripes are emitted as two triangles each: the road crown makes the
         # quad non-planar and the FBX SDK refuses to triangulate it on import
         # ("unable to triangulate mesh" — the mesh is omitted entirely).
         zone = 3.0        # band length along the road, m
         w, g = 0.5, 0.5   # stripe width / gap, m
         span = (SOUTH_GUTTER + 0.2, NORTH_GUTTER - 0.2)
-        verts, faces = [], []
         n = int(zone // (w + g))
         covered = n * w + (n - 1) * g   # actual stripe coverage, centred on s_c
         for k in range(n):
             s0 = s_c - covered / 2 + k * (w + g)
-            corners = []
-            base_idx = len(verts)  # verts grows only after the stripe is sampled
+            base_idx = len(band_verts)  # sampled positions, then vertices
+            pts = []
             for s_edge in (s0, s0 + w):
                 base, normal, _ = at(s_edge)
                 for off in span:
@@ -284,23 +288,23 @@ def main():
                     # interpolates the DEM along 1 m rows while the markings sample
                     # only their own corners, so a 1 cm lift left parts of the
                     # stripes sunk under the road and invisible in game.
-                    corners.append((base_idx + len(corners), (x, y, (dem_z(x, y) or 0.0) + 0.06)))
-            # corners order: (s0,off_s), (s0,off_n), (s1,off_s), (s1,off_n)
-            idx = [c[0] for c in corners]
-            verts.extend(c[1] for c in corners)
-            faces.append((idx[0], idx[3], idx[1]))
-            faces.append((idx[0], idx[2], idx[3]))
-        mesh = bpy.data.meshes.new("Crossing_Markings")
-        mesh.from_pydata(verts, [], faces)
-        mesh.update()
-        mesh.materials.append(paint)
-        obj = bpy.data.objects.new("Crossing_Markings", mesh)
-        bpy.context.scene.collection.objects.link(obj)
-        return obj
+                    pts.append((x, y, (dem_z(x, y) or 0.0) + 0.06))
+            # pts order: (s0,off_s), (s0,off_n), (s1,off_s), (s1,off_n)
+            band_verts.extend(pts)
+            band_faces.append((base_idx + 0, base_idx + 3, base_idx + 1))
+            band_faces.append((base_idx + 0, base_idx + 2, base_idx + 3))
 
     for s_c in CROSSINGS:
-        band = crossing_band(s_c)
-        print(f"crossing band at s={s_c:.1f}: {len(band.data.polygons)} stripes")
+        add_crossing_band(s_c)
+
+    mesh = bpy.data.meshes.new("Crossing_Markings")
+    mesh.from_pydata(band_verts, [], band_faces)
+    mesh.update()
+    mesh.materials.append(paint)
+    markings = bpy.data.objects.new("Crossing_Markings", mesh)
+    bpy.context.scene.collection.objects.link(markings)
+    print(f"crossing markings: {len(CROSSINGS)} bands, "
+          f"{len(markings.data.vertices)} verts, {len(markings.data.polygons)} faces")
 
     for obj in (road, sw_s, sw_n):
         print(f"{obj.name:16} verts {len(obj.data.vertices):5} faces {len(obj.data.polygons):5}")

Art/blender/terrain/terrain_from_dem.py

@@ -224,6 +224,12 @@ def main():
     mesh = bpy.data.meshes.new("Terrain_DEM")
     mesh.from_pydata(verts, [], faces)
     mesh.update()
+    # Without a material the mesh imports into Unreal with the default white
+    # material and blows out under the demo sun. A muted earth tone keeps the
+    # ground reading as ground.
+    ground = bpy.data.materials.new("Ground_Earth")
+    ground.diffuse_color = (0.30, 0.28, 0.25, 1.0)
+    mesh.materials.append(ground)
     obj = bpy.data.objects.new("Terrain_DEM", mesh)
     bpy.context.scene.collection.objects.link(obj)
 

MEMORY.md

@@ -174,3 +174,12 @@ Scope: facts and traps that cost time to establish. Planned work lives in [TODO.
 - **`EditorLevelLibrary.load_level`/`new_level` are deprecated no-ops in `-nullrhi` commandlets** (they return without switching worlds, so staged actors land in whatever world is current and get saved over the wrong map). Use the `LevelEditorSubsystem`: `unreal.get_editor_subsystem(unreal.LevelEditorSubsystem).load_level(path)` actually switches. Symptom was ReviewMap containing Demo actors + `ShotSequencer`.
 - **Map-save ordering bug in `Tools/ue_build_review_map.py`**: the script saved ReviewMap *after* the DemoMap section, but the switch back to ReviewMap fails silently because the map only exists in memory at that point — so the final `save_map` wrote the demo world over ReviewMap. Fix: save ReviewMap first, then stage the demo cameras, and never switch back. Both maps verified by probe (ReviewMap lists Review actors; DemoMap lists Demo actors).
 - Rebuilt ReviewMap after the fixes: character, both cubes (A grounded, B floating at 2 m), pawn, NPC prefab, hero facade all present; user re-approved the shots. README cube naming corrected (README had A/B swapped vs the script).
+
+## 2026-11-07 — Materials and lighting in the demo map
+
+- **Blender flat diffuse colours do not survive FBX -> Unreal.** Every site mesh (road, sidewalks, kerbs, crossing paint) imported with a material asset that had a default *white* base colour, and the terrain imported with `WorldGridMaterial` (UE's bright grey grid). That — not the sun — is what made the demo look blown out and washed white. Fix: create the colours in UE (`M_Asphalt`, `M_Concrete`, `M_Ground`, `M_RoadPaint` via `Constant3Vector`) and assign them per actor in `Tools/ue_build_demo_map.py`.
+- **Auto-exposure makes review shots non-comparable**: the same road rendered washed-out in one framing and near-black in another because each camera saw a different amount of sky. Fix: an unbound `PostProcessVolume` with `AEM_HISTOGRAM` and `auto_exposure_min_brightness == auto_exposure_max_brightness` (fixed exposure). Do not use `AEM_MANUAL` + `auto_exposure_bias` — a bias of 11 blew the whole frame out.
+- **`DirectionalLightComponent.light_color` takes a `Color` struct, not `LinearColor`** (`unreal.Color(r=255,g=245,b=230,a=255)`); passing `LinearColor` raises a nativize error.
+- **One band per object loses geometry downstream.** `crossing_band()` created `Crossing_Markings` each call, so Blender renamed the second and third to `.001`/`.002`; `site_assembly.py` appends by exact name, so only one crossing ever reached the game. Build all bands into a single mesh instead of one object per band.
+- **Street arc length -> UE X:** s=0 is the west end of the block (UE X −27966 cm) and s increases eastward, so the designated mid-block crossing at s=130.1 m is UE X ≈ −14956, not the −24291 used by an earlier camera (that is the s=36.6 crossing).
+- **Camera placement in the demo map needs the mesh bounds, not intuition.** The hero façade body spans UE Y −1457..−200, so a "street level" camera at Y −400 is *inside* the building and renders its unlit back face. Read `get_bounding_box()` on the staged meshes before choosing a camera.

Screenshots/README.md

@@ -22,8 +22,14 @@ and exits — about a minute. The camera list lives in
 - **Floor**: 160 m square, top face at Z 0. The character measures Z 0..83 cm.
 - **Cubes**: `Cube_ScaleTest_A` rests on the floor, `Cube_ScaleTest_B` floats at
   Z 2 m; both are exactly 1 m — the scale reference.
-- **Lighting**: one warm key light plus sky fill (review rig, not the `0.1.0`
-  daytime look). Beyond the floor is open: the horizon is a black band.
+- **Lighting (review map)**: one warm key light plus sky fill, neutral exposure.
+- **Lighting (demo map)**: fixed daytime — sun at pitch -50 / yaw 120 (intensity
+  4, warm), sky light 2.6, sky atmosphere, height fog, and a manual-exposure
+  post-process volume (min = max brightness 1.0) so a shot cannot wash out or
+  crush to black depending on how much sky it frames. Surface colours are
+  assigned explicitly in `Tools/ue_build_demo_map.py` (`M_Asphalt`, `M_Concrete`,
+  `M_Ground`, `M_RoadPaint`) because Blender's flat diffuse colours do not
+  survive the FBX → Unreal import.
 
 ## Review-map shots
 
@@ -53,10 +59,10 @@ Rendered from `/Game/Hollywood/DemoMap`, the walkable level. Click an image for
 
 | File | Preview | Approval | What it shows |
 | --- | --- | --- | --- |
-| `demo/review-demo-spawn-view.png` | [<img src="demo/review-demo-spawn-view.png" alt="spawn view" width="200">](demo/review-demo-spawn-view.png) | ☑ | Spawn view: north sidewalk, the hero façade across the road |
-| `demo/review-demo-street-level.png` | [<img src="demo/review-demo-street-level.png" alt="street level" width="200">](demo/review-demo-street-level.png) | ☑ | Street level: portals, flights, banners, colonnade |
-| `demo/review-demo-crossing.png` | [<img src="demo/review-demo-crossing.png" alt="crossing" width="200">](demo/review-demo-crossing.png) | ☑ | The designated mid-block crossing (s=130 m): zebra markings on the road, kerbs flushed to ramps. Camera on the north sidewalk looking south-west. Note: the road renders near-black in shadow — the fixed-daytime-lighting item, not the markings |
-| `demo/review-demo-north-buildings.png` | [<img src="demo/review-demo-north-buildings.png" alt="north buildings" width="200">](demo/review-demo-north-buildings.png) | ☑ | North-side background buildings (TCL, Tussaud's) across the Blvd |
+| `demo/review-demo-spawn-view.png` | [<img src="demo/review-demo-spawn-view.png" alt="spawn view" width="200">](demo/review-demo-spawn-view.png) | needs review | Spawn view from the north sidewalk: the hero façade across the road under fixed daytime light |
+| `demo/review-demo-street-level.png` | [<img src="demo/review-demo-street-level.png" alt="street level" width="200">](demo/review-demo-street-level.png) | needs review | Street level from the north sidewalk: the façade colonnade and columns at eye height, now sunlit with cast shadows (was backlit and near-black) |
+| `demo/review-demo-crossing.png` | [<img src="demo/review-demo-crossing.png" alt="crossing" width="200">](demo/review-demo-crossing.png) | needs review | The designated mid-block crossing at s=130 m (UE X -14956): three continental zebra bars on the dark asphalt, kerbs flushed to ramps, camera on the north sidewalk looking along the crosswalk |
+| `demo/review-demo-north-buildings.png` | [<img src="demo/review-demo-north-buildings.png" alt="north buildings" width="200">](demo/review-demo-north-buildings.png) | needs review | North-side background buildings (TCL, Tussaud's) across the Blvd, lit against the sky |
 
 ## What to look for
 

TODO.md

@@ -95,7 +95,7 @@ The MPFB character asset is planned as the NPC template (see `ROADMAP.md`). Keep
 - [~] Collision, reset, and pause functionality. Reset (**R**) and pause (**Escape**, a real game pause that releases the cursor) are implemented in `AGigLineCharacter` with `/Game/Input/IA_Reset` and `IA_Pause`. Collision now exists — terrain, road and sidewalks import as complex-as-simple, so a simple hull cannot ramp over the kerbs. **Not verified by hand**: walk, reset and pause need a human at the keyboard. No pause menu widget yet, only the pause itself.
 - [x] Build the walkable demo level: terrain, street, and hero facade assembled into one map with a start point on the north sidewalk, so the demo is something a player can walk rather than a review staging. **Built 2026-11-07** by `Tools/ue_build_demo_map.py` → `/Game/Hollywood/DemoMap`: sun/sky, `Hero_Facade`, six site meshes imported with collision (`Terrain_DEM`, `Road_Hollywood`, both sidewalks and both kerbs), and a `Demo_PlayerStart` on the north sidewalk 20 m back from the frontage. Demo views in `Screenshots/demo/` re-rendered and ☑ approved 2026-11-07.
 - [x] Walkable sidewalks and a designated street crossing. Crossing chosen: mid-block signalised crossing, OSM way 385648319, at 130 m along the block (`Geo/verification/2026-11-06-street-profile.md`). Done 2026-11-07: continental zebra markings (0.5 m bars / 0.5 m gaps, 3 m band) at all three signalised crossings, no collision on the paint; kerbs were already flushed at the crossings. Enablers found on the way: the street surfaces were 100 % down-facing (invisible in engine) — winding flipped; the terrain buried the street — 10.7 m corridor cut around the centreline (sidewalks cover the transition, walk-check 0 holes); LFS-lockable `.blend`/`.umap` check out read-only — builders now chmod before saving and fail loudly. Screenshot ☑ approved 2026-11-07 (`Screenshots/demo/review-demo-crossing`); the corridor renders near-black in shadow — that is the still-open **Fixed daytime lighting** item, not the crossing.
-- [-] Fixed daytime lighting and basic ambience. Current state: `Demo_Sun` at pitch −35, yaw 200 puts the street corridor in shadow — the crossing shot renders near-black. Plan: rotate sun yaw so light comes down the street axis (e/w), raise sun intensity, boost skylight fill, set fixed daytime (no time-of-day motion).
+- [-] Fixed daytime lighting and basic ambience. **Implemented 2026-11-07**, pending screenshot approval. Demo map now has a fixed daytime rig in `Tools/ue_build_demo_map.py`: sun pitch −50 / yaw 120 (intensity 4, warm 255/245/230, atmosphere sun light), sky light 2.6 with real-time capture, sky atmosphere, height fog (density 0.008), and a manual-exposure post-process volume (min = max brightness 1.0) so a shot cannot wash out or crush to black. Two root causes found while doing it: (a) **Blender flat diffuse colours do not survive the FBX→UE import** — every site mesh arrived white and the terrain arrived with `WorldGridMaterial`, which is what actually made the scene look blown out; explicit `M_Asphalt` / `M_Concrete` / `M_Ground` / `M_RoadPaint` materials are now created and assigned in the demo builder. (b) only **one of the three crossings** was reaching the game: each band was its own object and Blender renamed the duplicates `.001`/`.002`, which site assembly skips; all bands are now one `Crossing_Markings` object. Demo cameras also fixed: street-level sat inside the façade body, and the crossing camera aimed at the wrong crossing (s=36.6 instead of the designated s=130.1 at UE X −14956).
 - [ ] Geographic attribution display ("© OpenStreetMap contributors" + license link).
 
 ### Repository publication

Tools/ue_build_demo_map.py

@@ -50,6 +50,29 @@ def spawn(cls, loc, label, rot=None):
     return actor
 
 
+def ensure_material(asset_name, rgb):
+    """Create/reuse a flat-colour material under /Game/Hollywood/Site.
+
+    Used where the FBX material round-trip does not survive import: the terrain
+    arrives with WorldGridMaterial (UE's bright default grid), which reads as a
+    blown-out white field under the demo sun.
+    """
+    path = f"/Game/Hollywood/Site/{asset_name}"
+    if unreal.EditorAssetLibrary.does_asset_exist(path):
+        return unreal.EditorAssetLibrary.load_asset(path)
+    mat = unreal.AssetToolsHelpers.get_asset_tools().create_asset(
+        asset_name, "/Game/Hollywood/Site", unreal.Material, unreal.MaterialFactoryNew())
+    node = unreal.MaterialEditingLibrary.create_material_expression(
+        mat, unreal.MaterialExpressionConstant3Vector)
+    node.set_editor_property("constant", unreal.LinearColor(rgb[0], rgb[1], rgb[2], 1.0))
+    unreal.MaterialEditingLibrary.connect_material_property(
+        node, "", unreal.MaterialProperty.MP_BASE_COLOR)
+    unreal.MaterialEditingLibrary.recompile_material(mat)
+    unreal.EditorAssetLibrary.save_loaded_asset(mat)
+    log(f"created material {asset_name} rgb={rgb}")
+    return mat
+
+
 def clear(prefixes=()):
     removed = 0
     for actor in unreal.EditorLevelLibrary.get_all_level_actors():
@@ -74,12 +97,87 @@ def build():
     removed = clear(("Demo_", "PlayerStart", "Hero_Facade"))
     log(f"cleared {removed} previous demo actors")
 
-    # --- lighting ---------------------------------------------------------
-    spawn(unreal.DirectionalLight, unreal.Vector(0, 0, 2000), "Demo_Sun",
-          unreal.Rotator(pitch=-35.0, yaw=200.0, roll=0.0))
-    spawn(unreal.SkyLight, unreal.Vector(0, 0, 2000), "Demo_SkyLight")
+    # --- lighting: fixed daytime ------------------------------------------
+    # The demo is a fixed daytime scene, not a time-of-day simulation. Three
+    # things matter and each was wrong before:
+    #
+    # 1. Sun angle. The hero facade front faces -Y and the road faces +Z. A sun
+    #    at yaw 120 / pitch -50 shines toward (-X, +Y, down), so it lights both
+    #    the facade front and the carriageway instead of raking across them.
+    # 2. Exposure. Auto-exposure made the same road washed-out in one shot and
+    #    near-black in the next, because each camera framed a different amount
+    #    of sky. A manual-exposure post-process volume pins it.
+    # 3. Ambience. A height fog gives the street depth and hides the terrain
+    #    edge that otherwise reads as a black band at the horizon.
+    sun = spawn(unreal.DirectionalLight, unreal.Vector(0, 0, 2000), "Demo_Sun",
+                unreal.Rotator(pitch=-50.0, yaw=120.0, roll=0.0))
+    if sun:
+        comp = sun.get_component_by_class(unreal.DirectionalLightComponent)
+        if comp:
+            for prop, value in (
+                ("intensity", 4.0),
+                ("light_color", unreal.Color(r=255, g=245, b=230, a=255)),
+                ("atmosphere_sun_light", True),
+            ):
+                try:
+                    comp.set_editor_property(prop, value)
+                except Exception as exc:  # noqa: BLE001
+                    log(f"sun.{prop} not set: {exc!r}")
+        log("staged: Demo_Sun (pitch -50, yaw 120, intensity 4, warm)")
+
+    sky = spawn(unreal.SkyLight, unreal.Vector(0, 0, 2000), "Demo_SkyLight")
+    if sky:
+        comp = sky.get_component_by_class(unreal.SkyLightComponent)
+        if comp:
+            for prop, value in (("intensity", 2.6), ("real_time_capture", True)):
+                try:
+                    comp.set_editor_property(prop, value)
+                except Exception as exc:  # noqa: BLE001
+                    log(f"sky.{prop} not set: {exc!r}")
+        log("staged: Demo_SkyLight (intensity 2.6, real-time capture)")
+
     spawn(unreal.SkyAtmosphere, unreal.Vector(0, 0, 0), "Demo_Sky")
-    log("staged: sun, sky light, sky atmosphere")
+    log("staged: Demo_Sky (sky atmosphere)")
+
+    fog = spawn(unreal.ExponentialHeightFog, unreal.Vector(0, 0, 0), "Demo_Fog")
+    if fog:
+        comp = fog.get_component_by_class(unreal.ExponentialHeightFogComponent)
+        if comp:
+            for prop, value in (
+                ("fog_density", 0.008),
+                ("fog_height_falloff", 0.15),
+                ("start_distance", 3000.0),
+            ):
+                try:
+                    comp.set_editor_property(prop, value)
+                except Exception as exc:  # noqa: BLE001
+                    log(f"fog.{prop} not set: {exc!r}")
+        log("staged: Demo_Fog (height fog, density 0.008)")
+
+    # Fixed exposure: without this the same road renders washed out or black
+    # depending on how much sky the camera frames. Pinning min == max brightness
+    # freezes the exposure at one value (the classic fixed-exposure trick);
+    # AEM_MANUAL with a bias was tried first and blew the frame out.
+    ppv = spawn(unreal.PostProcessVolume, unreal.Vector(0, 0, 0), "Demo_PostProcess")
+    if ppv:
+        ppv.set_editor_property("unbound", True)
+        settings = ppv.get_editor_property("settings")
+        for prop, value in (
+            ("override_auto_exposure_method", True),
+            ("auto_exposure_method", unreal.AutoExposureMethod.AEM_HISTOGRAM),
+            ("override_auto_exposure_min_brightness", True),
+            ("auto_exposure_min_brightness", 1.0),
+            ("override_auto_exposure_max_brightness", True),
+            ("auto_exposure_max_brightness", 1.0),
+            ("override_auto_exposure_bias", True),
+            ("auto_exposure_bias", 0.0),
+        ):
+            try:
+                settings.set_editor_property(prop, value)
+            except Exception as exc:  # noqa: BLE001
+                log(f"pp.{prop} not set: {exc!r}")
+        ppv.set_editor_property("settings", settings)
+        log("staged: Demo_PostProcess (fixed exposure, min=max brightness 1.0)")
 
     # --- hero facade on the measured building line ------------------------
     hero = unreal.EditorAssetLibrary.load_asset("/Game/Hollywood/ElCapitan/SM_HeroFacade")
@@ -93,9 +191,21 @@ def build():
         log("MISSING: SM_HeroFacade — run Tools/ue_hero_facade_import.py")
 
     # --- site meshes, if they have been imported --------------------------
+    # Blender's flat diffuse colours do not survive FBX -> Unreal: Interchange
+    # builds a material with a default white base colour, and the terrain even
+    # lands with WorldGridMaterial. Every site surface therefore rendered white,
+    # which is what washed out the demo. Assign explicit colours per mesh here.
+    SURFACE_MATERIALS = {
+        "Terrain_DEM": ("M_Ground", (0.30, 0.28, 0.25)),
+        "Road_Hollywood": ("M_Asphalt", (0.055, 0.055, 0.06)),
+        "Sidewalk_South": ("M_Concrete", (0.52, 0.50, 0.47)),
+        "Sidewalk_North": ("M_Concrete", (0.52, 0.50, 0.47)),
+        "Kerb_South": ("M_Concrete", (0.52, 0.50, 0.47)),
+        "Kerb_North": ("M_Concrete", (0.52, 0.50, 0.47)),
+        "Crossing_Markings": ("M_RoadPaint", (0.80, 0.80, 0.78)),
+    }
     imported = 0
-    for name in ("Terrain_DEM", "Road_Hollywood", "Sidewalk_South", "Sidewalk_North",
-                 "Kerb_South", "Kerb_North", "Crossing_Markings"):
+    for name, (mat_name, rgb) in SURFACE_MATERIALS.items():
         mesh = unreal.EditorAssetLibrary.load_asset(f"/Game/Hollywood/Site/{name}")
         if mesh is None:
             continue
@@ -103,8 +213,11 @@ def build():
         if actor:
             actor.static_mesh_component.set_static_mesh(mesh)
             actor.static_mesh_component.set_mobility(unreal.ComponentMobility.STATIC)
+            mat = ensure_material(mat_name, rgb)
+            if mat:
+                actor.static_mesh_component.set_material(0, mat)
             imported += 1
-    log(f"staged {imported} site meshes from /Game/Hollywood/Site")
+    log(f"staged {imported} site meshes with explicit surface materials")
 
     # --- player start: north sidewalk, facing the hero frontage -------------
     # Signs were measured from the imported meshes rather than assumed: the FBX

Tools/ue_build_review_map.py

@@ -258,8 +258,17 @@ try:
             # 14 m back so the 14.5 m elevation fits: at 2 m the camera sees only
             # the colonnade's underside.
             ("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(-23750, -1800, 480), unreal.Vector(-24291, -1400, 300)),
+            # Street level, from the north sidewalk: the old camera sat at Y -400,
+            # inside the facade body (which spans Y -1457..-200), so it looked at
+            # the unlit back face. Y -2600 is on the sidewalk in front of the lit
+            # elevation.
+            ("demo-street-level", unreal.Vector(-10850, -2600, 170), unreal.Vector(-10722.5, -1450, 400)),
+            # The designated mid-block crossing. Street arc length runs from the
+            # west end (s=0 at X -27966 cm), so s=130.1 m is UE X -14956, not the
+            # -24291 the old camera used (that is the s=36.6 crossing). Camera sits
+            # on the north sidewalk looking along the crosswalk itself, which is
+            # the pedestrian's view and shows the zebra bars as bars.
+            ("demo-crossing", unreal.Vector(-15250, -2500, 400), unreal.Vector(-14956, 400, 150)),
             # 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)),