@pascal-app/viewer 1.0.7 → 1.1.0

package/dist/lib/daylight/rooms.js

@@ -1,6 +1,6 @@
-import { Box3, Color, DataTexture, FloatType, Frustum, MathUtils, Matrix4, Mesh, NearestFilter, Raycaster, RedFormat, RGBAFormat, SRGBColorSpace, Vector2, Vector3, } from 'three';
-import { abs, clamp, dot, Fn, float, If, int, ivec2, Loop, max, normalize, normalWorld, positionWorld, select, sharedUniformGroup, smoothstep, texture, uniform, uniformArray, vec3, vec4, } from 'three/tsl';
-const CELL = 0.1;
+import { Box3, Color, DataTexture, FloatType, Frustum, MathUtils, Matrix4, Mesh, NearestFilter, Raycaster, RGBAFormat, SRGBColorSpace, Vector2, Vector3, } from 'three';
+import { abs, clamp, dot, Fn, float, If, int, ivec2, Loop, max, normalize, normalWorld, positionWorld, select, smoothstep, texture, uniform, vec3, vec4, } from 'three/tsl';
+import { CELL, RoomMap, TILE } from './room-map';
 /** Texels per portal: [center, halfW] [normal, halfH] [radiance, neighbour] [floorY, mainLamp, gain, kind]. */
 const PSTRIDE = 4;
 /** Target average lamp irradiance of a room at night (same units as the ~1.5 sky irradiance of day). */
@@ -8,7 +8,6 @@ const LAMP_E_TARGET = 1.1;
 /** Lamps have a size (shade/diffuser): never evaluate the inverse square closer than ~0.8 m. */
 const LAMP_MIN_D2 = 0.64;
 const DATA_W = 256;
-const MAX_LEVELS = 8;
 /** Texels per exterior lamp: [pos, range] [rgb, cosInner] [spot dir, cosOuter]. */
 const EXT_STRIDE = 3;
 const _viewProj = new Matrix4();
@@ -21,13 +20,10 @@ export class RoomLighting {
     exteriorLamps = [];
     portals = [];
     openings = [];
-    levelY = [0];
+    levels = [];
+    /** Which room a point is in (tiled per level; see `room-map.ts`). */
+    map = new RoomMap();
     data = new Float32Array(4);
-    map = new Float32Array(1);
-    origin = new Vector2();
-    gridW = 1;
-    gridH = 1;
-    levels = 1;
     lampTexel = new Map();
     lastSky = null;
     // ---- runtime controls (the enhanced viewer's daylight preset) -------------------------------
@@ -49,22 +45,10 @@ export class RoomLighting {
     skyPatch = uniform(3);
     /** Light through interior openings + threshold crossfade (off on the Low tier). */
     softRooms = uniform(1);
+    /** Camera world Y (live). */
     cameraY = uniform(0);
-    focusedLevel = uniform(-1, 'int');
     // ---- shader inputs that change with the scene ----------------------------------------------
-    /**
-     * The level arrays live in one shared group, uploaded when a level moves: an array uniform in
-     * the default (per-object) group is re-sent for every object in every pass, whether it changed
-     * or not — some 760 uploads a frame in a furnished flat.
-     */
-    levelGroup = sharedUniformGroup('daylightLevels');
     u = {
-        levelYs: uniformArray(new Array(MAX_LEVELS).fill(1e9), 'float').setGroup(this.levelGroup),
-        levelOffsets: uniformArray(new Array(MAX_LEVELS).fill(0), 'float').setGroup(this.levelGroup),
-        levelCount: uniform(1, 'int'),
-        origin: uniform(new Vector2()),
-        gridW: uniform(1, 'int'),
-        gridH: uniform(1, 'int'),
         portalCount: uniform(0, 'int'),
         portalBase: uniform(0, 'int'),
         extLampStart: uniform(0, 'int'),
@@ -73,8 +57,7 @@ export class RoomLighting {
         activeBase: uniform(0, 'int'),
         spillCount: uniform(0, 'int'),
         extActiveCount: uniform(0, 'int'),
-        map: texture(emptyTexture(RedFormat)),
-        data: texture(emptyTexture(RGBAFormat)),
+        data: texture(emptyTexture()),
     };
     /** Rebuild from a scene: rooms, lamps, portals, openings, room-id map. */
     build(input) {
@@ -83,24 +66,11 @@ export class RoomLighting {
         this.portals = [];
         this.openings = [];
         this.lampTexel.clear();
-        const b = input.bounds;
-        if (b.isEmpty()) {
-            this.levelY = [0];
-            this.gridW = this.gridH = this.levels = 1;
-            this.map = new Float32Array(1);
-            this.uploadMap();
-            this.allocateData();
-            return;
-        }
-        this.origin.set(b.min.x - 1, b.min.z - 1);
-        this.gridW = Math.max(1, Math.ceil((b.max.x - b.min.x + 2) / CELL));
-        this.gridH = Math.max(1, Math.ceil((b.max.z - b.min.z + 2) / CELL));
-        this.levelY = input.levelY.length ? input.levelY.slice(0, MAX_LEVELS) : [0];
-        this.levels = this.levelY.length;
+        this.levels = input.levels.length ? input.levels : [{ y: 0, building: 0 }];
         // ---- rooms ---------------------------------------------------------------------------
         const raycaster = new Raycaster();
         input.configureRaycaster?.(raycaster);
-        const coverObjects = input.covers.map((c) => c.object);
+        const coverGrid = new MeshGrid(input.covers.map((c) => c.object));
         const coverKind = new Map();
         for (const c of input.covers)
             c.object.traverse((o) => coverKind.set(o, c.kind));
@@ -112,16 +82,29 @@ export class RoomLighting {
             }
             return '';
         };
+        // Level order inside each building (for the ceiling fallback) before the map is built.
+        const above = this.levels.map((level, i) => {
+            let next = -1;
+            this.levels.forEach((other, j) => {
+                if (j === i || other.building !== level.building || other.y <= level.y)
+                    return;
+                if (next < 0 || other.y < this.levels[next].y)
+                    next = j;
+            });
+            return next;
+        });
         for (const zone of input.zones) {
-            const levelIndex = MathUtils.clamp(zone.levelIndex, 0, this.levels - 1);
-            const floorY = this.levelY[levelIndex] ?? 0;
-            const nextY = this.levelY[levelIndex + 1];
-            const area = Math.abs(polygonArea(zone.polygon));
-            const c = polygonCentroid(zone.polygon);
+            const levelIndex = MathUtils.clamp(zone.levelIndex, 0, this.levels.length - 1);
+            const floorY = this.levels[levelIndex].y;
+            const nextY = above[levelIndex] >= 0 ? this.levels[above[levelIndex]].y : undefined;
+            const holes = zone.holes ?? [];
+            const area = Math.max(0, Math.abs(polygonArea(zone.polygon)) -
+                holes.reduce((sum, hole) => sum + Math.abs(polygonArea(hole)), 0));
+            const c = interiorPoint(zone.polygon, holes);
             // Enclosed = something overhead (ceiling / roof / slab above). Open terraces get sky light.
             raycaster.set(new Vector3(c.x, floorY + 1.2, c.y), new Vector3(0, 1, 0));
             raycaster.far = 30;
-            const hits = intersectGeometry(raycaster, coverObjects, true);
+            const hits = intersectGeometry(raycaster, coverGrid.near(c.x, c.y, c.x, c.y), false);
             const hit = hits[0];
             const top = hits[hits.length - 1];
             const topKind = top ? kindOf(top.object) : '';
@@ -142,52 +125,14 @@ export class RoomLighting {
                 portals: [],
             });
         }
-        // ---- room-id map (levels stacked along Y of the texture) -----------------------------
-        const map = new Float32Array(this.gridW * this.gridH * this.levels);
-        this.rooms.forEach((room, ri) => {
-            const poly = room.zone.polygon;
-            let minX = Number.POSITIVE_INFINITY;
-            let minZ = Number.POSITIVE_INFINITY;
-            let maxX = Number.NEGATIVE_INFINITY;
-            let maxZ = Number.NEGATIVE_INFINITY;
-            for (const [x, z] of poly) {
-                minX = Math.min(minX, x);
-                maxX = Math.max(maxX, x);
-                minZ = Math.min(minZ, z);
-                maxZ = Math.max(maxZ, z);
-            }
-            const i0 = Math.max(0, Math.floor((minX - this.origin.x) / CELL));
-            const i1 = Math.min(this.gridW - 1, Math.ceil((maxX - this.origin.x) / CELL));
-            const j0 = Math.max(0, Math.floor((minZ - this.origin.y) / CELL));
-            const j1 = Math.min(this.gridH - 1, Math.ceil((maxZ - this.origin.y) / CELL));
-            const rowBase = room.levelIndex * this.gridH;
-            for (let j = j0; j <= j1; j++) {
-                const z = this.origin.y + (j + 0.5) * CELL;
-                for (let i = i0; i <= i1; i++) {
-                    const x = this.origin.x + (i + 0.5) * CELL;
-                    if (pointInPolygon(x, z, poly))
-                        map[(rowBase + j) * this.gridW + i] = ri + 1;
-                }
-            }
-        });
-        // Dilate by 2 cells into empty cells so wall-thickness gaps and polygon slop still resolve.
-        for (let pass = 0; pass < 2; pass++) {
-            const src = map.slice();
-            for (let l = 0; l < this.levels; l++)
-                for (let j = 1; j < this.gridH - 1; j++)
-                    for (let i = 1; i < this.gridW - 1; i++) {
-                        const k = (l * this.gridH + j) * this.gridW + i;
-                        if (src[k])
-                            continue;
-                        const n = src[k - 1] || src[k + 1] || src[k - this.gridW] || src[k + this.gridW];
-                        if (n)
-                            map[k] = n;
-                    }
-        }
-        this.map = map;
-        this.uploadMap();
-        // ---- openings between rooms (soft room map) -------------------------------------------
-        this.openings = this.detectOpenings(input, raycaster);
+        // ---- room map + openings between rooms (walked on each level's grid) ---------------------
+        const openings = this.openingSearch(input, raycaster);
+        this.map.build(this.levels, this.rooms.map((room) => ({
+            level: room.levelIndex,
+            polygon: room.zone.polygon,
+            holes: room.zone.holes,
+        })), openings.walk);
+        this.openings = openings.finish();
         // ---- lamps ---------------------------------------------------------------------------
         for (const lamp of input.lamps) {
             const ri = this.roomAt(lamp.position.clone().add(new Vector3(0, -0.3, 0)));
@@ -318,18 +263,9 @@ export class RoomLighting {
         if (this.lastSky)
             this.updateSky(...this.lastSky);
     }
-    /** CPU-side room lookup (same rule as the shader, without the normal offset). */
+    /** CPU-side room lookup in assembled space (same rule as the shader, without the normal offset). */
     roomAt(p) {
-        let level = 0;
-        for (let i = 0; i < this.levelY.length; i++)
-            if (this.levelY[i] <= p.y - 0.12)
-                level = i;
-        const i = Math.floor((p.x - this.origin.x) / CELL);
-        const j = Math.floor((p.z - this.origin.y) / CELL);
-        if (i < 0 || j < 0 || i >= this.gridW || j >= this.gridH)
-            return -1;
-        const v = this.map[(level * this.gridH + j) * this.gridW + i];
-        return v ? v - 1 : -1;
+        return this.map.roomAt(p.x, p.y, p.z);
     }
     /**
      * Whether each level is on screen. A camera over a level whose upper floors are hidden stands
@@ -337,6 +273,10 @@ export class RoomLighting {
      * such, not as a lamplit room it cannot see.
      */
     levelShown = [];
+    /** Per level: focused (its rooms open from above when the camera is over their cover). */
+    levelFocused = [];
+    /** Per level: the highest one shown in its building (its rooms seen from above). */
+    levelTopShown = [];
     /**
      * What the lit rooms in view add to an outside camera's meter: a blend of the exterior reading
      * and the rooms' own irradiance (their indoor meter), weighted by the share of the frame each
@@ -360,10 +300,6 @@ export class RoomLighting {
                 const t = Math.tan(MathUtils.degToRad(c.fov) / 2);
                 return 4 * t * t * c.aspect;
             })();
-        let topShown = -1;
-        for (let i = 0; i < this.levelY.length; i++)
-            if (this.levelShown[i] !== false)
-                topShown = i;
         let weight = 0;
         let weighted = 0;
         _roomsLight.setRGB(0, 0, 0);
@@ -375,7 +311,7 @@ export class RoomLighting {
             _toCamera.subVectors(camera.position, r.centroid);
             const facing = Math.max(0.2, _toCamera.y / Math.max(_toCamera.length(), 1e-4));
             const reach = ortho ? 1 : Math.max(_toCamera.lengthSq(), 1);
-            const open = r.levelIndex === topShown ? 1 : 0.15;
+            const open = this.levelTopShown[r.levelIndex] !== false ? 1 : 0.15;
             const w = (r.area * facing * open) / reach / view;
             const E = this.meter(index, skyE);
             weight += w;
@@ -407,33 +343,43 @@ export class RoomLighting {
         return { sceneE, roomsE, illuminant };
     }
     isEnclosedAt(p) {
-        let level = 0;
-        for (let i = 0; i < this.levelY.length; i++)
-            if (this.levelY[i] <= p.y - 0.12)
-                level = i;
-        if (this.levelShown[level] === false)
-            return { room: -1, inside: false };
         const room = this.roomAt(p);
         const r = room >= 0 ? this.rooms[room] : undefined;
-        return { room, inside: !!r?.enclosed && p.y < r.ceilingY };
+        if (!r || this.levelShown[r.levelIndex] === false)
+            return { room: -1, inside: false };
+        return { room, inside: r.enclosed && p.y < r.ceilingY };
     }
-    /** Explode / level motion: live world Y of each level (assembled + offset). */
-    setLevelOffsets(offsets) {
-        const ys = this.u.levelYs.array;
-        const offs = this.u.levelOffsets.array;
-        let changed = false;
-        for (let i = 0; i < MAX_LEVELS; i++) {
-            const base = this.levelY[i];
-            const off = offsets[i] ?? 0;
-            const y = base === undefined ? 1e9 : base + off;
-            if (ys[i] === y && offs[i] === off)
-                continue;
-            ys[i] = y;
-            offs[i] = off;
-            changed = true;
-        }
-        if (changed)
-            this.levelGroup.needsUpdate = true;
+    /**
+     * Live level presentation, per level: explode offset (live world Y − assembled), whether it is
+     * shown, and whether it is the selected level of a cutaway (solo / levels above hidden). A shown
+     * level is focused — its rooms open from above — when selected so, or when every level over it
+     * in its building is hidden.
+     */
+    setLevelPresentation(offsets, shown, selected) {
+        this.levelShown = shown;
+        const focused = this.levels.map((_, i) => {
+            if (shown[i] === false)
+                return false;
+            if (selected[i])
+                return true;
+            let up = this.map.levelAbove(i);
+            if (up < 0)
+                return false;
+            for (; up >= 0; up = this.map.levelAbove(up))
+                if (shown[up] !== false)
+                    return false;
+            return true;
+        });
+        this.levelFocused = focused;
+        this.levelTopShown = this.levels.map((_, i) => {
+            if (shown[i] === false)
+                return false;
+            for (let up = this.map.levelAbove(i); up >= 0; up = this.map.levelAbove(up))
+                if (shown[up] !== false)
+                    return false;
+            return true;
+        });
+        this.map.setPresentation(offsets, shown, focused);
     }
     /** Re-run the light transfer (after a quality-tier change of the soft room map). */
     refresh() {
@@ -608,7 +554,7 @@ export class RoomLighting {
         this.rooms.forEach((r, i) => {
             this.set(i * 3, r.enclosed ? 1 : 0, lampBase + lamp * 2, r.lamps.length, 0);
             this.set(i * 3 + 1, r.portals.length, 0, 0, 0);
-            this.set(i * 3 + 2, r.coverY, r.coverIsRoof ? 1 : 0, r.levelIndex, 0);
+            this.set(i * 3 + 2, r.coverY, r.coverIsRoof ? 1 : 0, this.map.gpuLevel(r.levelIndex), 0);
             for (const l of r.lamps) {
                 this.lampTexel.set(l, lampBase + lamp * 2);
                 this.set(lampBase + lamp * 2, l.position.x, l.position.y, l.position.z, l.range);
@@ -644,7 +590,7 @@ export class RoomLighting {
             const room = this.rooms[p.room];
             const main = room.lamps.slice().sort((a, b) => b.intensity - a.intensity)[0];
             this.set(t + 2, 0, 0, 0, p.neighbor);
-            this.set(t + 3, this.levelY[room.levelIndex] ?? 0, main ? this.lampTexel.get(main) : -1, p.gain, p.kind);
+            this.set(t + 3, this.levels[room.levelIndex]?.y ?? 0, main ? this.lampTexel.get(main) : -1, p.gain, p.kind);
         });
         const previous = this.u.data.value;
         const tex = new DataTexture(this.data, DATA_W, rows, RGBAFormat, FloatType);
@@ -686,19 +632,6 @@ export class RoomLighting {
         this.u.spillCount.value = spill;
         this.u.extActiveCount.value = lit;
     }
-    uploadMap() {
-        const previous = this.u.map.value;
-        const tex = new DataTexture(this.map, this.gridW, this.gridH * this.levels, RedFormat, FloatType);
-        tex.magFilter = tex.minFilter = NearestFilter;
-        tex.needsUpdate = true;
-        this.u.map.value = tex;
-        previous.dispose();
-        this.u.origin.value.copy(this.origin);
-        this.u.gridW.value = this.gridW;
-        this.u.gridH.value = this.gridH;
-        this.u.levelCount.value = this.levels;
-        this.setLevelOffsets([]);
-    }
     markData() {
         ;
         this.u.data.value.needsUpdate = true;
@@ -732,148 +665,183 @@ export class RoomLighting {
         this.data.set([a, b, c, d], texel * 4);
     }
     /**
-     * Walk every boundary between two room cells (or a room and outside) on the room map and cast
-     * short horizontal rays against the walls at 0.35 m and 1.6 m: open at both heights = a walkable
-     * opening (doorway, arch, open-plan edge). Windows don't count (sills are above 0.35 m).
+     * Walk every boundary between two room cells (or a room and outside) on each level's grid and
+     * cast short horizontal rays against the walls at 0.35 m and 1.6 m: open at both heights = a
+     * walkable opening (doorway, arch, open-plan edge). Windows don't count (sills are above 0.35 m).
+     * `walk` runs per level while its grid exists; `finish` clusters the samples into openings.
      */
-    detectOpenings(input, ray) {
+    openingSearch(input, ray) {
         const doors = input.openings
             .filter((o) => o.kind === 'door')
             .map((o) => ({ id: o.id, box: new Box3().setFromObject(o.object) }));
         const doorHoles = doors.map((door) => door.box.clone().expandByScalar(0.05));
         ray.far = 0.9;
+        const wallGrid = new MeshGrid(input.walls);
         const samples = new Map();
-        const W = this.gridW;
-        const H = this.gridH;
-        const map = this.map;
         const v = new Vector3();
         const dirV = new Vector3();
-        for (let l = 0; l < this.levels; l++) {
-            const floorY = this.levelY[l] ?? 0;
-            for (let j = 0; j < H - 1; j++) {
-                for (let i = 0; i < W - 1; i++) {
-                    const k = (l * H + j) * W + i;
-                    const A = map[k];
-                    for (const [di, dj, axis] of [
-                        [1, 0, 'x'],
-                        [0, 1, 'z'],
-                    ]) {
-                        if ((axis === 'x' ? j : i) % 2)
-                            continue; // sample every 2nd cell along the edge (0.2 m)
-                        const B = map[k + di + dj * W];
-                        if (A === B || (!A && !B))
-                            continue;
-                        const a = A ? A - 1 : -1;
-                        const b = B ? B - 1 : -1;
-                        // Outside openings only from enclosed rooms.
-                        if (a < 0 && !this.rooms[b].enclosed)
-                            continue;
-                        if (b < 0 && !this.rooms[a].enclosed)
-                            continue;
-                        const x = this.origin.x + (i + 0.5 + di * 0.5) * CELL;
-                        const z = this.origin.y + (j + 0.5 + dj * 0.5) * CELL;
-                        dirV.set(di, 0, dj);
-                        let open = true;
-                        for (const h of [0.35, 1.6]) {
-                            v.set(x, floorY + h, z).addScaledVector(dirV, -0.45);
-                            ray.set(v, dirV);
-                            // A doorway is open whatever wall-attached geometry crosses it (finishes, trims).
-                            const blocked = intersectGeometry(ray, input.walls, false).some((hit) => !doorHoles.some((hole) => hole.containsPoint(hit.point)));
-                            if (blocked) {
-                                open = false;
-                                break;
+        const walk = (tile) => {
+            const { cells, stride, i0, j0, x0, z0, ci0, cj0, level: l } = tile;
+            const floorY = this.levels[l]?.y ?? 0;
+            const visit = (i, j, axis) => {
+                const di = axis === 'x' ? 1 : 0;
+                const dj = axis === 'z' ? 1 : 0;
+                if ((axis === 'x' ? cj0 + j : ci0 + i) % 2)
+                    return; // every 2nd cell along the edge (0.2 m)
+                const A = cells[j * stride + i];
+                const B = cells[(j + dj) * stride + i + di];
+                if (A === B)
+                    return;
+                const a = A ? A - 1 : -1;
+                const b = B ? B - 1 : -1;
+                // Outside openings only from enclosed rooms.
+                if (a < 0 && !this.rooms[b].enclosed)
+                    return;
+                if (b < 0 && !this.rooms[a].enclosed)
+                    return;
+                const x = x0 + (i + 0.5 + di * 0.5) * CELL;
+                const z = z0 + (j + 0.5 + dj * 0.5) * CELL;
+                dirV.set(di, 0, dj);
+                for (const h of [0.35, 1.6]) {
+                    v.set(x, floorY + h, z).addScaledVector(dirV, -0.45);
+                    ray.set(v, dirV);
+                    // A doorway is open whatever wall-attached geometry crosses it (finishes, trims).
+                    const near = wallGrid.near(Math.min(v.x, v.x + dirV.x * 0.9), Math.min(v.z, v.z + dirV.z * 0.9), Math.max(v.x, v.x + dirV.x * 0.9), Math.max(v.z, v.z + dirV.z * 0.9));
+                    const blocked = intersectGeometry(ray, near, false).some((hit) => !doorHoles.some((hole) => hole.containsPoint(hit.point)));
+                    if (blocked)
+                        return;
+                }
+                // Normalise so key/direction are from the lower room id (outside = last).
+                const lo = a < 0 ? b : b < 0 ? a : Math.min(a, b);
+                const hi = lo === a ? b : a;
+                const dir = lo === a ? 1 : -1;
+                const key = `${l}|${lo}|${hi}`;
+                let s = samples.get(key);
+                if (!s) {
+                    s = { a: lo, b: hi, pts: [], facing: [], level: l };
+                    samples.set(key, s);
+                }
+                s.pts.push(new Vector3(x, floorY, z));
+                s.facing.push(new Vector3(di * dir, 0, dj * dir));
+            };
+            // Each edge belongs to the tile of the cell before it. A uniform tile has none inside: only
+            // its borders with the next tiles can hold one.
+            const iEnd = i0 + TILE;
+            const jEnd = j0 + TILE;
+            if (tile.uniform) {
+                for (let j = j0; j < jEnd; j++)
+                    visit(iEnd - 1, j, 'x');
+                for (let i = i0; i < iEnd; i++)
+                    visit(i, jEnd - 1, 'z');
+                return;
+            }
+            for (let j = j0; j < jEnd; j++)
+                for (let i = i0; i < iEnd; i++) {
+                    visit(i, j, 'x');
+                    visit(i, j, 'z');
+                }
+        };
+        const finish = () => {
+            const openings = [];
+            // Boundary samples a step apart along an edge belong to one opening. Off the grid axes (a
+            // rotated building) the edge is a staircase of cells, so adjacency is by distance.
+            const gap = Math.max(0.45, CELL * 3);
+            for (const s of samples.values()) {
+                const order = s.pts.map((_, k) => k).sort((p, q) => s.pts[p].x - s.pts[q].x);
+                const seen = new Uint8Array(order.length);
+                for (let seed = 0; seed < order.length; seed++) {
+                    if (seen[seed])
+                        continue;
+                    seen[seed] = 1;
+                    const members = [];
+                    const queue = [seed];
+                    while (queue.length) {
+                        const k = queue.pop();
+                        const p = s.pts[order[k]];
+                        members.push(order[k]);
+                        for (const step of [-1, 1]) {
+                            for (let m = k + step; m >= 0 && m < order.length; m += step) {
+                                const q = s.pts[order[m]];
+                                if (Math.abs(q.x - p.x) > gap)
+                                    break;
+                                if (seen[m] || Math.hypot(q.x - p.x, q.z - p.z) > gap)
+                                    continue;
+                                seen[m] = 1;
+                                queue.push(m);
                             }
                         }
-                        if (!open)
-                            continue;
-                        // Normalise so key/direction are from the lower room id (outside = last).
-                        const lo = a < 0 ? b : b < 0 ? a : Math.min(a, b);
-                        const hi = lo === a ? b : a;
-                        const dir = lo === a ? 1 : -1;
-                        const key = `${l}|${lo}|${hi}|${axis}`;
-                        let s = samples.get(key);
-                        if (!s) {
-                            s = { a: lo, b: hi, axis, dir, pts: [], level: l };
-                            samples.set(key, s);
-                        }
-                        s.pts.push(new Vector3(x, floorY, z));
                     }
+                    if (members.length < 3)
+                        continue; // < 0.5 m
+                    openings.push(this.openingFromRun(members, s, doors));
                 }
             }
+            return openings;
+        };
+        return { walk, finish };
+    }
+    /** One opening from its boundary samples: measured along their own line, facing room b. */
+    openingFromRun(members, s, doors) {
+        const run = members.map((k) => s.pts[k]);
+        const c = run.reduce((acc, p) => acc.add(p), new Vector3()).multiplyScalar(1 / run.length);
+        // Principal direction of the samples (2×2 covariance in XZ).
+        let xx = 0;
+        let xz = 0;
+        let zz = 0;
+        for (const p of run) {
+            const dx = p.x - c.x;
+            const dz = p.z - c.z;
+            xx += dx * dx;
+            xz += dx * dz;
+            zz += dz * dz;
         }
-        const openings = [];
-        for (const s of samples.values()) {
-            // Cluster along the edge: sort by the coordinate running along the boundary.
-            const along = (p) => (s.axis === 'x' ? p.z : p.x);
-            const across = (p) => (s.axis === 'x' ? p.x : p.z);
-            s.pts.sort((p, q) => across(p) - across(q) || along(p) - along(q));
-            let run = [];
-            const flush = () => {
-                if (run.length < 3) {
-                    run = []; // < 0.5 m
-                    return;
-                }
-                const c = run.reduce((acc, p) => acc.add(p), new Vector3()).multiplyScalar(1 / run.length);
-                const width = along(run[run.length - 1]) - along(run[0]) + 0.2;
-                const normal = new Vector3(s.axis === 'x' ? s.dir : 0, 0, s.axis === 'z' ? s.dir : 0);
-                const roomA = this.rooms[s.a];
-                const roomB = s.b >= 0 ? this.rooms[s.b] : undefined;
-                const floorY = this.levelY[s.level] ?? 0;
-                // Door in this opening? → its height + state. Otherwise floor to the lower ceiling.
-                const door = doors.find((d) => d.box
-                    .clone()
-                    .expandByScalar(0.25)
-                    .containsPoint(c.clone().setY(floorY + 1)));
-                const ceil = Math.min(roomA.ceilingY, roomB?.ceilingY ?? roomA.ceilingY);
-                const height = door
-                    ? Math.min(door.box.max.y - floorY, ceil - floorY)
-                    : Math.max(1.9, ceil - floorY);
-                openings.push({
-                    a: s.a,
-                    b: s.b,
-                    center: c.setY(floorY + height / 2),
-                    normal,
-                    width: door ? Math.min(width, door.box.getSize(new Vector3()).length()) : width,
-                    height,
-                    doorId: door?.id,
-                });
-                run = [];
-            };
-            for (const p of s.pts) {
-                const last = run[run.length - 1];
-                if (last && (Math.abs(across(p) - across(last)) > 0.11 || along(p) - along(last) > 0.45))
-                    flush();
-                run.push(p);
-            }
-            flush();
+        const angle = 0.5 * Math.atan2(2 * xz, xx - zz);
+        const tangent = new Vector3(Math.cos(angle), 0, Math.sin(angle));
+        let lo = Number.POSITIVE_INFINITY;
+        let hi = Number.NEGATIVE_INFINITY;
+        for (const p of run) {
+            const t = (p.x - c.x) * tangent.x + (p.z - c.z) * tangent.z;
+            lo = Math.min(lo, t);
+            hi = Math.max(hi, t);
         }
-        return openings;
+        c.addScaledVector(tangent, (lo + hi) / 2);
+        const width = hi - lo + 2 * CELL;
+        const facing = members.reduce((acc, k) => acc.add(s.facing[k]), new Vector3());
+        const normal = new Vector3(-tangent.z, 0, tangent.x);
+        if (normal.dot(facing) < 0)
+            normal.negate();
+        const roomA = this.rooms[s.a];
+        const roomB = s.b >= 0 ? this.rooms[s.b] : undefined;
+        const floorY = this.levels[s.level]?.y ?? 0;
+        // Door in this opening? → its height + state. Otherwise floor to the lower ceiling.
+        const door = doors.find((d) => d.box
+            .clone()
+            .expandByScalar(0.25)
+            .containsPoint(c.clone().setY(floorY + 1)));
+        const ceil = Math.min(roomA.ceilingY, roomB?.ceilingY ?? roomA.ceilingY);
+        const height = door
+            ? Math.min(door.box.max.y - floorY, ceil - floorY)
+            : Math.max(1.9, ceil - floorY);
+        return {
+            a: s.a,
+            b: s.b,
+            center: c.setY(floorY + height / 2),
+            normal,
+            width: door ? Math.min(width, door.box.getSize(new Vector3()).length()) : width,
+            height,
+            doorId: door?.id,
+        };
     }
     // ---- TSL ---------------------------------------------------------------------------------
-    /** Level index for a world-space height (live, explode-offset level heights). */
-    levelOfNode(y) {
-        const level = int(0).toVar();
-        Loop({ start: int(1), end: this.u.levelCount, type: 'int', condition: '<' }, ({ i }) => {
-            If(this.u.levelYs.element(i).lessThanEqual(y.sub(0.12)), () => {
-                level.assign(i);
-            });
-        });
-        return level;
+    /** Room index (−1 outside) at a world-space position (live heights). */
+    roomAtNode = Fn(([p]) => this.map.roomAtNode(p));
+    /**
+     * The room a surface faces (probed 18 cm off it along its normal). One node per material: its
+     * lighting and its exterior mask share the lookup.
+     */
+    probeRoomNode() {
+        return this.roomAtNode(positionWorld.add(normalWorld.mul(0.18)));
     }
-    /** Room index (−1 outside) at a world-space position. */
-    roomAtNode = Fn(([p]) => {
-        const u = this.u;
-        const level = this.levelOfNode(p.y);
-        const cell = ivec2(p.xz.sub(u.origin).div(CELL).floor());
-        const inside = cell.x
-            .greaterThanEqual(0)
-            .and(cell.y.greaterThanEqual(0))
-            .and(cell.x.lessThan(u.gridW))
-            .and(cell.y.lessThan(u.gridH));
-        const safe = ivec2(clamp(cell.x, int(0), u.gridW.sub(1)), clamp(cell.y, int(0), u.gridH.sub(1)));
-        const id = u.map.load(ivec2(safe.x, safe.y.add(level.mul(u.gridH)))).r;
-        return select(inside, int(id).sub(1), int(-1));
-    });
     /** E' = Emax·(1 − e^(−E/Emax)), on luminance, hue kept — near-field hot spots compress, never blow out. */
     softClampLamps(e) {
         const L = dot(e, vec3(0.2126, 0.7152, 0.0722)).max(1e-5);
@@ -885,11 +853,12 @@ export class RoomLighting {
      * topmost cover and that cover is hidden from there: a ceiling (hidden from above), or anything
      * once its level is focused (the levels over it hidden). From inside, under the cover, the room
      * stays enclosed whatever is focused: it must not take the full sky on top of its windows.
-     * `h2` is the room's third header texel: [coverY, roof, level, 0].
+     * `h2` is the room's third header texel: [coverY, roof, level, 0]; `level` its level's
+     * [th, entryOffset, offset, flags] (flag 1: focused).
      */
-    openToSky(h2) {
-        const focused = this.focusedLevel.greaterThanEqual(0).and(int(h2.z).equal(this.focusedLevel));
-        return this.cameraY.greaterThan(h2.x).and(h2.y.lessThan(0.5).or(focused));
+    openToSky(h2, level) {
+        const focused = level.w.mod(2).greaterThan(0.5);
+        return this.cameraY.sub(level.z).greaterThan(h2.x).and(h2.y.lessThan(0.5).or(focused));
     }
     texel(i) {
         const idx = int(i);
@@ -900,21 +869,20 @@ export class RoomLighting {
      *  irradiance — lamp + portal + bounce diffuse irradiance (linear)
      *  enclosure  — multiplier for the sky IBL (1 outdoors, `indoorEnv` in enclosed rooms)
      */
-    lightingNode = Fn(() => {
-        const probe = positionWorld.add(normalWorld.mul(0.18));
-        const room = this.roomAtNode(probe).toVar();
-        // Shade in assembled space so exploded floors stay lit exactly as when stacked.
-        const assembled = positionWorld.sub(vec3(0, this.u.levelOffsets.element(this.levelOfNode(probe.y)), 0));
+    lightingNode = Fn(([probeRoom]) => {
+        const room = int(probeRoom).toVar();
         const irr = vec3(0).toVar();
         const enclosure = float(1).toVar();
         If(room.greaterThanEqual(0), () => {
             const h0 = this.texel(room.mul(3));
             const h1 = this.texel(room.mul(3).add(1));
             const h2 = this.texel(room.mul(3).add(2));
-            If(h0.x.greaterThan(0.5).and(this.openToSky(h2).not()), () => {
+            const level = this.map.levelTexel1(h2.z);
+            If(h0.x.greaterThan(0.5).and(this.openToSky(h2, level).not()), () => {
                 enclosure.assign(this.indoorEnv);
             });
-            const P = assembled;
+            // Shade in assembled space so exploded floors stay lit exactly as when stacked.
+            const P = positionWorld.sub(vec3(0, level.z, 0));
             const Nw = normalWorld;
             // Lamps: smooth windowed inverse-square, wrapped diffuse so the room reads as filled
             // rather than spotlit — stands in for the bounce we don't compute.
@@ -1114,13 +1082,13 @@ export class RoomLighting {
         return this.softClampLamps(out).mul(this.lampGain).mul(this.lampView);
     });
     /** 1 where exterior lights may shine (outside, or rooms open to the sky), 0 inside. */
-    exteriorMaskNode = Fn(() => {
-        const room = this.roomAtNode(positionWorld.add(normalWorld.mul(0.18))).toVar();
+    exteriorMaskNode = Fn(([probeRoom]) => {
+        const room = int(probeRoom).toVar();
         const mask = float(1).toVar();
         If(room.greaterThanEqual(0), () => {
             const h0 = this.texel(room.mul(3));
             const h2 = this.texel(room.mul(3).add(2));
-            If(h0.x.greaterThan(0.5).and(this.openToSky(h2).not()), () => {
+            If(h0.x.greaterThan(0.5).and(this.openToSky(h2, this.map.levelTexel1(h2.z)).not()), () => {
                 mask.assign(0);
             });
         });
@@ -1157,8 +1125,59 @@ function intersectGeometry(ray, objects, recursive) {
         visit(object);
     return hits.sort((a, b) => a.distance - b.distance);
 }
-function emptyTexture(format) {
-    const tex = new DataTexture(new Float32Array(format === RedFormat ? 1 : 4), 1, 1, format, FloatType);
+/**
+ * Meshes (and the meshes under them) bucketed by their world XZ bounds, so a short doorway ray or
+ * a vertical cover ray tests its neighbours, not every wall and slab of the scene.
+ */
+class MeshGrid {
+    static SIZE = 2;
+    cells = new Map();
+    seen = new Set();
+    constructor(roots) {
+        const box = new Box3();
+        for (const root of roots)
+            root.traverse((object) => {
+                const mesh = object;
+                if (!mesh.isMesh)
+                    return;
+                // From the vertices as they are now: a cached bounding box can predate geometry that was
+                // rebuilt in place (walls finishing while a large scene loads).
+                const position = mesh.geometry?.getAttribute('position');
+                if (!position || position.count === 0)
+                    return;
+                box.setFromBufferAttribute(position).applyMatrix4(mesh.matrixWorld);
+                if (box.isEmpty())
+                    return;
+                const s = MeshGrid.SIZE;
+                for (let iz = Math.floor(box.min.z / s); iz <= Math.floor(box.max.z / s); iz++)
+                    for (let ix = Math.floor(box.min.x / s); ix <= Math.floor(box.max.x / s); ix++) {
+                        const key = cellKey(ix, iz);
+                        const list = this.cells.get(key);
+                        if (list)
+                            list.push(mesh);
+                        else
+                            this.cells.set(key, [mesh]);
+                    }
+            });
+    }
+    /** Meshes whose bounds may reach the XZ rect. */
+    near(minX, minZ, maxX, maxZ) {
+        const s = MeshGrid.SIZE;
+        const out = [];
+        this.seen.clear();
+        for (let iz = Math.floor(minZ / s); iz <= Math.floor(maxZ / s); iz++)
+            for (let ix = Math.floor(minX / s); ix <= Math.floor(maxX / s); ix++)
+                for (const mesh of this.cells.get(cellKey(ix, iz)) ?? [])
+                    if (!this.seen.has(mesh)) {
+                        this.seen.add(mesh);
+                        out.push(mesh);
+                    }
+        return out;
+    }
+}
+const cellKey = (ix, iz) => (ix + 1_000_000) * 2_000_003 + (iz + 1_000_000);
+function emptyTexture() {
+    const tex = new DataTexture(new Float32Array(4), 1, 1, RGBAFormat, FloatType);
     tex.magFilter = tex.minFilter = NearestFilter;
     tex.needsUpdate = true;
     return tex;
@@ -1201,6 +1220,32 @@ export function polygonCentroid(poly) {
     return new Vector2(cx / (3 * a), cz / (3 * a));
 }
 /** Tanner Helland blackbody fit → linear RGB. */
+/** A point inside the polygon and outside its holes: the centroid when it is, else a scan. */
+export function interiorPoint(poly, holes = []) {
+    const inside = (x, z) => pointInPolygon(x, z, poly) && !holes.some((hole) => pointInPolygon(x, z, hole));
+    const c = polygonCentroid(poly);
+    if (inside(c.x, c.y))
+        return c;
+    let minX = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const [x, z] of poly) {
+        minX = Math.min(minX, x);
+        maxX = Math.max(maxX, x);
+        minZ = Math.min(minZ, z);
+        maxZ = Math.max(maxZ, z);
+    }
+    for (let n = 4; n <= 32; n *= 2)
+        for (let j = 1; j < n; j++)
+            for (let i = 1; i < n; i++) {
+                const x = minX + ((maxX - minX) * i) / n;
+                const z = minZ + ((maxZ - minZ) * j) / n;
+                if (inside(x, z))
+                    return new Vector2(x, z);
+            }
+    return c;
+}
 export function kelvin(k) {
     const t = k / 100;
     let r;