@pascal-app/viewer 1.0.6 → 1.1.0

package/dist/lib/daylight/room-map.js

@@ -0,0 +1,630 @@
+import { DataTexture, FloatType, NearestFilter, RGBAFormat, RGFormat, UnsignedByteType, Vector2, } from 'three';
+import { Fn, floor, If, int, ivec2, Loop, round, texture, uniform } from 'three/tsl';
+export const CELL = 0.1;
+/** Cells per tile side. */
+export const TILE = 16;
+const TILE_M = CELL * TILE;
+/** Margin around a room: the 2-cell dilation plus polygon slop. */
+const APRON = 0.35;
+/** Cells built around a tile so its 2-pass dilation and its edges' neighbours are exact. */
+const MARGIN = 3;
+/** Rooms of a level closer than this (in tiles) share a cluster. */
+const CLUSTER_GAP = 2;
+const LEVEL_W = 256;
+/** Directory cells, at most (they grow coarser on vast sites). */
+const MAX_DIR_CELLS = 65536;
+/** Room ids are stored as two bytes (id + 1). */
+export const MAX_ROOMS = 65535;
+/** WebGPU guarantees 8192 texels a side; the renderer asks for no more. */
+export const DEFAULT_TEXTURE_LIMIT = 8192;
+export class RoomMap {
+    /** The device's largest 2D texture side; set before `build`. */
+    textureLimit = DEFAULT_TEXTURE_LIMIT;
+    levels = [];
+    /** Level indices sorted by building, then height: the order the GPU searches in. */
+    order = [];
+    position = [];
+    /** Per building: its range in `order`. */
+    buildingRange = [];
+    originX = 0;
+    originZ = 0;
+    dirTiles = 8;
+    dirW = 0;
+    dirH = 0;
+    /** Per directory cell: the buildings whose rooms reach it. */
+    dirLists = [];
+    atlas = new Uint8Array(2);
+    atlasTilesW = 1;
+    atlasTiles = 0;
+    indexBytes = 0;
+    warnedOverflow = false;
+    u = {
+        origin: uniform(new Vector2()),
+        dirTiles: uniform(8, 'int'),
+        dirW: uniform(0, 'int'),
+        dirH: uniform(0, 'int'),
+        /** One building: its level range is the only candidate (no directory reads). */
+        single: uniform(1, 'int'),
+        singleCount: uniform(0, 'int'),
+        /** Binary-search steps for the tallest building. */
+        searchSteps: uniform(0, 'int'),
+        atlasTilesW: uniform(1, 'int'),
+        indexW: uniform(1, 'int'),
+        index: texture(floatTexture(new Float32Array(4), 1, 1)),
+        levels: texture(floatTexture(new Float32Array(8), 2, 1)),
+        atlas: texture(byteTexture(new Uint8Array(2), 1, 1)),
+    };
+    levelData = new Float32Array(8);
+    /** Rebuild from rooms. `onTile` sees every built tile (the doorway search walks room edges). */
+    build(levels, rooms, onTile) {
+        this.levels = levels.map((l) => ({ y: l.y, building: l.building, clusters: [] }));
+        this.order = levels
+            .map((_, i) => i)
+            .sort((a, b) => levels[a].building - levels[b].building || levels[a].y - levels[b].y);
+        this.position = new Array(levels.length);
+        this.order.forEach((level, pos) => {
+            this.position[level] = pos;
+        });
+        const buildings = levels.reduce((n, l) => Math.max(n, l.building + 1), 0);
+        this.buildingRange = Array.from({ length: buildings }, () => [0, 0]);
+        this.order.forEach((level, pos) => {
+            const range = this.buildingRange[levels[level].building];
+            if (range[1] === 0)
+                range[0] = pos;
+            range[1]++;
+        });
+        if (rooms.length > MAX_ROOMS)
+            console.warn(`[daylight] ${rooms.length} rooms: only the first ${MAX_ROOMS} get room light`);
+        const used = rooms.slice(0, MAX_ROOMS);
+        // Site origin on the tile grid; every rect below is in whole tiles from it.
+        let minX = Number.POSITIVE_INFINITY;
+        let minZ = Number.POSITIVE_INFINITY;
+        for (const room of used)
+            for (const [x, z] of room.polygon) {
+                minX = Math.min(minX, x);
+                minZ = Math.min(minZ, z);
+            }
+        if (!Number.isFinite(minX))
+            minX = minZ = 0;
+        const originTx = Math.floor((minX - APRON) / TILE_M);
+        const originTz = Math.floor((minZ - APRON) / TILE_M);
+        this.originX = originTx * TILE_M;
+        this.originZ = originTz * TILE_M;
+        // Each room's tile rect (padded by the apron).
+        const rects = used.map((room) => {
+            let x0 = Number.POSITIVE_INFINITY;
+            let z0 = Number.POSITIVE_INFINITY;
+            let x1 = Number.NEGATIVE_INFINITY;
+            let z1 = Number.NEGATIVE_INFINITY;
+            for (const [x, z] of room.polygon) {
+                x0 = Math.min(x0, x);
+                z0 = Math.min(z0, z);
+                x1 = Math.max(x1, x);
+                z1 = Math.max(z1, z);
+            }
+            return {
+                tx0: Math.floor((x0 - APRON) / TILE_M) - originTx,
+                tz0: Math.floor((z0 - APRON) / TILE_M) - originTz,
+                tx1: Math.floor((x1 + APRON) / TILE_M) - originTx,
+                tz1: Math.floor((z1 + APRON) / TILE_M) - originTz,
+            };
+        });
+        const atlasTilesW = Math.max(1, Math.floor(Math.min(this.textureLimit, 4096) / TILE));
+        const atlasCapacity = atlasTilesW * Math.max(1, Math.floor(this.textureLimit / TILE));
+        const detailTiles = [];
+        let buffer = new Uint16Array(0);
+        let scratch = new Uint16Array(0);
+        // Where rooms overlap (an automatic room under drawn ones, a unit around its rooms), the
+        // smallest wins: rasterized last, so each level's rooms go largest first.
+        const area = used.map((room) => Math.abs(ringArea(room.polygon)));
+        const byLevel = levels.map(() => []);
+        used.forEach((room, ri) => {
+            byLevel[room.level]?.push(ri);
+        });
+        for (const list of byLevel)
+            list.sort((a, b) => area[b] - area[a] || a - b);
+        for (let li = 0; li < levels.length; li++) {
+            const level = this.levels[li];
+            for (const members of clusterRooms(byLevel[li], rects)) {
+                let tx0 = Number.POSITIVE_INFINITY;
+                let tz0 = Number.POSITIVE_INFINITY;
+                let tx1 = Number.NEGATIVE_INFINITY;
+                let tz1 = Number.NEGATIVE_INFINITY;
+                for (const ri of members) {
+                    const r = rects[ri];
+                    tx0 = Math.min(tx0, r.tx0);
+                    tz0 = Math.min(tz0, r.tz0);
+                    tx1 = Math.max(tx1, r.tx1);
+                    tz1 = Math.max(tz1, r.tz1);
+                }
+                const cluster = {
+                    tx0,
+                    tz0,
+                    tw: tx1 - tx0 + 1,
+                    th: tz1 - tz0 + 1,
+                    entries: new Float32Array((tx1 - tx0 + 1) * (tz1 - tz0 + 1)),
+                };
+                level.clusters.push(cluster);
+                // Rooms per tile, from each room's own rect.
+                const buckets = Array.from({ length: cluster.entries.length }, () => []);
+                for (const ri of members) {
+                    const r = rects[ri];
+                    for (let tz = r.tz0; tz <= r.tz1; tz++)
+                        for (let tx = r.tx0; tx <= r.tx1; tx++)
+                            buckets[(tz - tz0) * cluster.tw + (tx - tx0)].push(ri);
+                }
+                // One row of tiles at a time (plus a margin all round): each room rasterizes once per row.
+                const stride = cluster.tw * TILE + 2 * MARGIN;
+                const rowH = TILE + 2 * MARGIN;
+                if (buffer.length < stride * rowH) {
+                    buffer = new Uint16Array(stride * rowH);
+                    scratch = new Uint16Array(stride * rowH);
+                }
+                const strip = buffer.subarray(0, stride * rowH);
+                const inRow = new Set();
+                for (let tz = tz0; tz <= tz1; tz++) {
+                    inRow.clear();
+                    for (let tx = tx0; tx <= tx1; tx++)
+                        for (const ri of buckets[(tz - tz0) * cluster.tw + (tx - tx0)])
+                            inRow.add(ri);
+                    if (!inRow.size)
+                        continue;
+                    const ci0 = tx0 * TILE - MARGIN;
+                    const cj0 = tz * TILE - MARGIN;
+                    const x0 = this.originX + ci0 * CELL;
+                    const z0 = this.originZ + cj0 * CELL;
+                    strip.fill(0);
+                    for (const ri of [...inRow].sort((a, b) => area[b] - area[a] || a - b))
+                        rasterize(used[ri], ri + 1, strip, stride, rowH, x0, z0);
+                    // Growth only fills empty cells: inside a big room there are none.
+                    if (strip.includes(0))
+                        dilate(strip, scratch, stride, rowH);
+                    for (let tx = tx0; tx <= tx1; tx++) {
+                        const t = (tz - tz0) * cluster.tw + (tx - tx0);
+                        if (!buckets[t].length)
+                            continue;
+                        const i0 = MARGIN + (tx - tx0) * TILE;
+                        const first = strip[MARGIN * stride + i0];
+                        let same = true;
+                        for (let j = MARGIN; j < MARGIN + TILE && same; j++)
+                            for (let i = i0; i < i0 + TILE; i++)
+                                if (strip[j * stride + i] !== first) {
+                                    same = false;
+                                    break;
+                                }
+                        if (same)
+                            cluster.entries[t] = first;
+                        else if (detailTiles.length >= atlasCapacity) {
+                            // Out of atlas: the tile's most common room stands for all of it.
+                            if (!this.warnedOverflow) {
+                                console.warn('[daylight] room map atlas full: some room edges are coarse');
+                                this.warnedOverflow = true;
+                            }
+                            cluster.entries[t] = majority(strip, stride, i0);
+                        }
+                        else {
+                            const tile = new Uint16Array(TILE * TILE);
+                            for (let j = 0; j < TILE; j++)
+                                tile.set(strip.subarray((MARGIN + j) * stride + i0, (MARGIN + j) * stride + i0 + TILE), j * TILE);
+                            detailTiles.push(tile);
+                            cluster.entries[t] = -detailTiles.length;
+                        }
+                        onTile?.({
+                            level: li,
+                            ci0,
+                            cj0,
+                            x0,
+                            z0,
+                            stride,
+                            i0,
+                            j0: MARGIN,
+                            cells: strip,
+                            uniform: same,
+                        });
+                    }
+                }
+            }
+        }
+        // Atlas: detailed tiles in rows, two bytes (room + 1) per cell.
+        this.atlasTilesW = atlasTilesW;
+        this.atlasTiles = detailTiles.length;
+        const atlasRows = Math.max(1, Math.ceil(detailTiles.length / atlasTilesW));
+        const aw = atlasTilesW * TILE;
+        this.atlas = new Uint8Array(aw * atlasRows * TILE * 2);
+        detailTiles.forEach((tile, a) => {
+            const ox = (a % atlasTilesW) * TILE;
+            const oz = Math.floor(a / atlasTilesW) * TILE;
+            for (let j = 0; j < TILE; j++)
+                for (let i = 0; i < TILE; i++) {
+                    const v = tile[j * TILE + i];
+                    const k = ((oz + j) * aw + ox + i) * 2;
+                    this.atlas[k] = v & 255;
+                    this.atlas[k + 1] = v >> 8;
+                }
+        });
+        // Directory: per cell, the buildings whose clusters reach it (coarser cells on vast sites).
+        let maxTx = 0;
+        let maxTz = 0;
+        for (const l of this.levels)
+            for (const c of l.clusters) {
+                maxTx = Math.max(maxTx, c.tx0 + c.tw);
+                maxTz = Math.max(maxTz, c.tz0 + c.th);
+            }
+        this.dirTiles = Math.max(8, Math.ceil(Math.sqrt((maxTx * maxTz) / MAX_DIR_CELLS)));
+        this.dirW = Math.max(1, Math.ceil(maxTx / this.dirTiles));
+        this.dirH = Math.max(1, Math.ceil(maxTz / this.dirTiles));
+        this.dirLists = Array.from({ length: this.dirW * this.dirH }, () => []);
+        for (const l of this.levels)
+            for (const c of l.clusters)
+                for (let dz = Math.floor(c.tz0 / this.dirTiles); dz <= Math.floor((c.tz0 + c.th - 1) / this.dirTiles); dz++)
+                    for (let dx = Math.floor(c.tx0 / this.dirTiles); dx <= Math.floor((c.tx0 + c.tw - 1) / this.dirTiles); dx++) {
+                        const list = this.dirLists[dz * this.dirW + dx];
+                        if (!list.includes(l.building))
+                            list.push(l.building);
+                    }
+        this.upload();
+    }
+    /** CPU lookup in assembled space (same rule as the shader). */
+    roomAt(x, y, z) {
+        const tx = Math.floor((x - this.originX) / TILE_M);
+        const tz = Math.floor((z - this.originZ) / TILE_M);
+        const dx = Math.floor(tx / this.dirTiles);
+        const dz = Math.floor(tz / this.dirTiles);
+        if (dx < 0 || dz < 0 || dx >= this.dirW || dz >= this.dirH)
+            return -1;
+        for (const b of this.dirLists[dz * this.dirW + dx]) {
+            const [start, count] = this.buildingRange[b];
+            let found = start;
+            for (let pos = start; pos < start + count; pos++)
+                if (this.levels[this.order[pos]].y <= y - 0.12)
+                    found = pos;
+            const room = this.levelRoomAt(this.order[found], x, z, tx, tz);
+            if (room >= 0)
+                return room;
+        }
+        return -1;
+    }
+    /** A level's room at a point; clusters' rects can overlap (a wing around a courtyard pavilion). */
+    levelRoomAt(li, x, z, tx, tz) {
+        for (const c of this.levels[li].clusters) {
+            const lx = tx - c.tx0;
+            const lz = tz - c.tz0;
+            if (lx < 0 || lz < 0 || lx >= c.tw || lz >= c.th)
+                continue;
+            const e = c.entries[lz * c.tw + lx];
+            if (e > 0)
+                return e - 1;
+            if (e === 0)
+                continue;
+            const a = -e - 1;
+            const ci = Math.floor((x - this.originX) / CELL) - tx * TILE;
+            const cj = Math.floor((z - this.originZ) / CELL) - tz * TILE;
+            const aw = this.atlasTilesW * TILE;
+            const k = ((Math.floor(a / this.atlasTilesW) * TILE + cj) * aw + (a % this.atlasTilesW) * TILE + ci) *
+                2;
+            const room = this.atlas[k] + this.atlas[k + 1] * 256 - 1;
+            if (room >= 0)
+                return room;
+        }
+        return -1;
+    }
+    /** The level stacked right above `level` in its building, or −1. */
+    levelAbove(level) {
+        const pos = this.position[level];
+        if (pos === undefined)
+            return -1;
+        const next = this.order[pos + 1];
+        return next !== undefined && this.levels[next].building === this.levels[level].building
+            ? next
+            : -1;
+    }
+    /** Index the GPU uses for `level` (rooms store it). */
+    gpuLevel(level) {
+        return this.position[level] ?? 0;
+    }
+    /**
+     * Live presentation per level (input order): explode offset, whether it is shown, and whether
+     * the levels over it are hidden (its rooms open to the sky from above).
+     */
+    setPresentation(offsets, shown, focused) {
+        let changed = false;
+        this.order.forEach((level, pos) => {
+            const off = offsets[level] ?? 0;
+            const flags = (focused[level] ? 1 : 0) + (shown[level] !== false ? 2 : 0);
+            const t = pos * 8;
+            const liveY = this.levels[level].y + off;
+            if (this.levelData[t] !== liveY) {
+                this.levelData[t] = liveY;
+                changed = true;
+            }
+            if (this.levelData[t + 6] !== off || this.levelData[t + 7] !== flags) {
+                this.levelData[t + 6] = off;
+                this.levelData[t + 7] = flags;
+                changed = true;
+            }
+        });
+        if (changed)
+            this.u.levels.value.needsUpdate = true;
+    }
+    memoryBytes() {
+        return this.atlas.byteLength + this.indexBytes + this.levelData.byteLength;
+    }
+    get stats() {
+        return { atlasTiles: this.atlasTiles, dirW: this.dirW, dirH: this.dirH };
+    }
+    upload() {
+        // index: [directory cells] [directory lists] [clusters, 2 texels] [entries]
+        const dirCells = this.dirW * this.dirH;
+        const listTexels = this.dirLists.reduce((s, l) => s + l.length, 0);
+        const clusterCount = this.levels.reduce((s, l) => s + l.clusters.length, 0);
+        const entryTexels = this.levels.reduce((s, l) => s + l.clusters.reduce((t, c) => t + c.entries.length, 0), 0);
+        const texels = dirCells + listTexels + clusterCount * 2 + entryTexels + 1;
+        // As wide as the device allows, so a vast site's directory still fits.
+        const indexW = Math.min(this.textureLimit, 4096);
+        const rows = Math.max(1, Math.ceil(texels / indexW));
+        if (rows > this.textureLimit)
+            console.warn('[daylight] room map index exceeds the device texture limit');
+        const index = new Float32Array(indexW * rows * 4);
+        let list = dirCells;
+        this.dirLists.forEach((buildings, c) => {
+            index[c * 4] = list;
+            index[c * 4 + 1] = buildings.length;
+            for (const b of buildings) {
+                const [start, count] = this.buildingRange[b];
+                index[list * 4] = start;
+                index[list * 4 + 1] = count;
+                list++;
+            }
+        });
+        const clusterStart = new Array(this.levels.length).fill(0);
+        let cluster = list;
+        let entry = list + clusterCount * 2;
+        this.levels.forEach((l, li) => {
+            clusterStart[li] = cluster;
+            for (const c of l.clusters) {
+                index.set([c.tx0, c.tz0, c.tw, c.th, entry, 0, 0, 0], cluster * 4);
+                for (let k = 0; k < c.entries.length; k++)
+                    index[(entry + k) * 4] = c.entries[k];
+                entry += c.entries.length;
+                cluster += 2;
+            }
+        });
+        this.indexBytes = index.byteLength;
+        // levels (GPU order): [liveY, clusterStart, clusterCount, 0] [0, 0, offset, flags]
+        const levelRows = Math.max(1, Math.ceil((this.order.length * 2) / LEVEL_W));
+        this.levelData = new Float32Array(LEVEL_W * levelRows * 4);
+        this.order.forEach((level, pos) => {
+            const l = this.levels[level];
+            this.levelData.set([l.y, clusterStart[level], l.clusters.length, 0, 0, 0, 0, 2], pos * 8);
+        });
+        const aw = this.atlasTilesW * TILE;
+        replace(this.u.index, floatTexture(index, indexW, rows));
+        replace(this.u.levels, floatTexture(this.levelData, LEVEL_W, levelRows));
+        replace(this.u.atlas, byteTexture(this.atlas, aw, this.atlas.length / 2 / aw));
+        this.u.origin.value.set(this.originX, this.originZ);
+        this.u.indexW.value = indexW;
+        this.u.dirTiles.value = this.dirTiles;
+        this.u.dirW.value = this.dirW;
+        this.u.dirH.value = this.dirH;
+        this.u.atlasTilesW.value = this.atlasTilesW;
+        this.u.single.value = this.buildingRange.length <= 1 ? 1 : 0;
+        this.u.singleCount.value = this.buildingRange[0]?.[1] ?? 0;
+        this.u.searchSteps.value = this.buildingRange.reduce((steps, [, count]) => Math.max(steps, Math.ceil(Math.log2(count + 1))), 0);
+    }
+    // ---- TSL ---------------------------------------------------------------------------------
+    indexTexel(i) {
+        const k = int(i);
+        return this.u.index.load(ivec2(k.mod(this.u.indexW), k.div(this.u.indexW)));
+    }
+    /** [liveY, clusterStart, clusterCount, 0] of the level at GPU position `pos`. */
+    levelTexel0(pos) {
+        const k = int(pos).mul(2);
+        return this.u.levels.load(ivec2(k.mod(LEVEL_W), k.div(LEVEL_W)));
+    }
+    /** [0, 0, offset, flags] of the level at GPU position `pos`. */
+    levelTexel1(pos) {
+        const k = int(pos).mul(2).add(1);
+        return this.u.levels.load(ivec2(k.mod(LEVEL_W), k.div(LEVEL_W)));
+    }
+    /** Room index (−1 outside) at a world-space position (live heights). */
+    roomAtNode = Fn(([p]) => {
+        const u = this.u;
+        const room = int(-1).toVar();
+        const tileF = p.xz.sub(u.origin).div(TILE_M);
+        const tile = ivec2(floor(tileF));
+        // Candidate buildings: the only one, or the directory cell's list.
+        const count = int(0).toVar();
+        const listStart = int(0).toVar();
+        If(u.single.equal(1), () => {
+            count.assign(1);
+        }).Else(() => {
+            const dir = ivec2(floor(tileF.div(u.dirTiles)));
+            If(dir.x
+                .greaterThanEqual(0)
+                .and(dir.y.greaterThanEqual(0))
+                .and(dir.x.lessThan(u.dirW))
+                .and(dir.y.lessThan(u.dirH)), () => {
+                const d = this.indexTexel(dir.y.mul(u.dirW).add(dir.x));
+                listStart.assign(int(d.x));
+                count.assign(int(d.y));
+            });
+        });
+        const y = p.y.sub(0.12);
+        Loop({ start: int(0), end: count, type: 'int', condition: '<' }, ({ i }) => {
+            If(room.lessThan(0), () => {
+                const start = int(0).toVar();
+                const levels = u.singleCount.toVar();
+                If(u.single.equal(0), () => {
+                    const range = this.indexTexel(listStart.add(i));
+                    start.assign(int(range.x));
+                    levels.assign(int(range.y));
+                });
+                // Last level of the building whose live floor is at or below the point (else its lowest).
+                const lo = start.toVar();
+                const hi = start.add(levels).sub(1).toVar();
+                const found = start.toVar();
+                Loop({ start: int(0), end: u.searchSteps, type: 'int', condition: '<' }, () => {
+                    If(lo.lessThanEqual(hi), () => {
+                        const mid = lo.add(hi).div(2);
+                        If(this.levelTexel0(mid).x.lessThanEqual(y), () => {
+                            found.assign(mid);
+                            lo.assign(mid.add(1));
+                        }).Else(() => {
+                            hi.assign(mid.sub(1));
+                        });
+                    });
+                });
+                const level = this.levelTexel0(found);
+                // Clusters' rects can overlap: the first one holding a room at the point wins.
+                Loop({ start: int(0), end: int(level.z), type: 'int', condition: '<' }, ({ i: c }) => {
+                    If(room.lessThan(0), () => {
+                        const base = int(level.y).add(c.mul(2));
+                        const rect = this.indexTexel(base);
+                        const local = tile.sub(ivec2(int(rect.x), int(rect.y)));
+                        If(local.x
+                            .greaterThanEqual(0)
+                            .and(local.y.greaterThanEqual(0))
+                            .and(local.x.lessThan(int(rect.z)))
+                            .and(local.y.lessThan(int(rect.w))), () => {
+                            const entryStart = int(this.indexTexel(base.add(1)).x);
+                            const e = this.indexTexel(entryStart.add(local.y.mul(int(rect.z))).add(local.x)).x;
+                            If(e.greaterThan(0.5), () => {
+                                room.assign(int(round(e)).sub(1));
+                            }).ElseIf(e.lessThan(-0.5), () => {
+                                const a = int(round(e.negate())).sub(1);
+                                const cell = ivec2(floor(p.xz.sub(u.origin).div(CELL))).sub(tile.mul(TILE));
+                                const at = ivec2(a.mod(u.atlasTilesW).mul(TILE).add(cell.x), a.div(u.atlasTilesW).mul(TILE).add(cell.y));
+                                const texel = u.atlas.load(at);
+                                const id = int(round(texel.x.mul(255))).add(int(round(texel.y.mul(255))).mul(256));
+                                room.assign(id.sub(1));
+                            });
+                        });
+                    });
+                });
+            });
+        });
+        return room;
+    });
+}
+// ---- build helpers --------------------------------------------------------------------------
+/** Groups a level's rooms whose padded tile rects lie within `CLUSTER_GAP` tiles of each other. */
+function clusterRooms(members, rects) {
+    const parent = members.map((_, i) => i);
+    const find = (i) => {
+        while (parent[i] !== i) {
+            parent[i] = parent[parent[i]];
+            i = parent[i];
+        }
+        return i;
+    };
+    const order = members
+        .map((_, i) => i)
+        .sort((a, b) => rects[members[a]].tx0 - rects[members[b]].tx0);
+    for (let a = 0; a < order.length; a++) {
+        const ra = rects[members[order[a]]];
+        for (let b = a + 1; b < order.length; b++) {
+            const rb = rects[members[order[b]]];
+            if (rb.tx0 > ra.tx1 + CLUSTER_GAP)
+                break;
+            if (rb.tz0 <= ra.tz1 + CLUSTER_GAP && ra.tz0 <= rb.tz1 + CLUSTER_GAP)
+                parent[find(order[a])] = find(order[b]);
+        }
+    }
+    const groups = new Map();
+    members.forEach((ri, i) => {
+        const root = find(i);
+        const group = groups.get(root);
+        if (group)
+            group.push(ri);
+        else
+            groups.set(root, [ri]);
+    });
+    return [...groups.values()];
+}
+function ringArea(ring) {
+    let a = 0;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++)
+        a += ring[j][0] * ring[i][1] - ring[i][0] * ring[j][1];
+    return a / 2;
+}
+/** Scanline fill of a room (holes subtracted, even-odd) at cell centres. */
+function rasterize(room, value, cells, width, height, x0, z0) {
+    const rings = [room.polygon, ...(room.holes ?? [])];
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const [, z] of room.polygon) {
+        minZ = Math.min(minZ, z);
+        maxZ = Math.max(maxZ, z);
+    }
+    const j0 = Math.max(0, Math.floor((minZ - z0) / CELL));
+    const j1 = Math.min(height - 1, Math.ceil((maxZ - z0) / CELL));
+    const xs = [];
+    for (let j = j0; j <= j1; j++) {
+        const z = z0 + (j + 0.5) * CELL;
+        xs.length = 0;
+        for (const ring of rings)
+            for (let a = 0, b = ring.length - 1; a < ring.length; b = a++) {
+                const [xa, za] = ring[a];
+                const [xb, zb] = ring[b];
+                if (za > z !== zb > z)
+                    xs.push(((xb - xa) * (z - za)) / (zb - za) + xa);
+            }
+        xs.sort((p, q) => p - q);
+        for (let k = 0; k + 1 < xs.length; k += 2) {
+            // Cells whose centre lies in (xs[k], xs[k+1]].
+            const i0 = Math.max(0, Math.floor((xs[k] - x0) / CELL - 0.5) + 1);
+            const i1 = Math.min(width - 1, Math.floor((xs[k + 1] - x0) / CELL - 0.5));
+            if (i1 >= i0)
+                cells.fill(value, j * width + i0, j * width + i1 + 1);
+        }
+    }
+}
+/** Two passes of 4-neighbour growth into empty cells: wall thickness and polygon slop resolve. */
+function dilate(cells, scratch, width, height) {
+    for (let pass = 0; pass < 2; pass++) {
+        scratch.set(cells);
+        for (let j = 1; j < height - 1; j++)
+            for (let i = 1; i < width - 1; i++) {
+                const k = j * width + i;
+                if (scratch[k])
+                    continue;
+                const n = scratch[k - 1] || scratch[k + 1] || scratch[k - width] || scratch[k + width];
+                if (n)
+                    cells[k] = n;
+            }
+    }
+}
+/** The most common value among a tile's own cells. */
+function majority(cells, stride, i0) {
+    const counts = new Map();
+    for (let j = MARGIN; j < MARGIN + TILE; j++)
+        for (let i = i0; i < i0 + TILE; i++) {
+            const v = cells[j * stride + i];
+            counts.set(v, (counts.get(v) ?? 0) + 1);
+        }
+    let best = 0;
+    let bestCount = -1;
+    for (const [v, c] of counts)
+        if (c > bestCount) {
+            best = v;
+            bestCount = c;
+        }
+    return best;
+}
+function floatTexture(data, width, height) {
+    const tex = new DataTexture(data, width, height, RGBAFormat, FloatType);
+    tex.magFilter = tex.minFilter = NearestFilter;
+    tex.needsUpdate = true;
+    return tex;
+}
+function byteTexture(data, width, height) {
+    const tex = new DataTexture(data, width, height, RGFormat, UnsignedByteType);
+    tex.magFilter = tex.minFilter = NearestFilter;
+    tex.needsUpdate = true;
+    return tex;
+}
+function replace(node, tex) {
+    const previous = node.value;
+    node.value = tex;
+    previous.dispose();
+}

package/dist/lib/daylight/room-scene.d.ts

@@ -0,0 +1,56 @@
+import { type Object3D, Vector3 } from 'three';
+import type { RoomLamp, RoomSceneInput } from './rooms';
+/**
+ * Builds the room system's input from a scene: the live parametric graph (scene registry +
+ * node data) or a baked artifact (identity `userData` stamped by the GLB export).
+ */
+/** A lamp as the item-light pools see it (live catalog/procedural items and baked items alike). */
+export type LampFeedLight = {
+    key: string;
+    color: string;
+    distance: number;
+    /** Fully-on intensity. */
+    peak?: number;
+    getWorldPosition: (out: Vector3) => boolean;
+    /** The lamp's item: its node id (live) or object (baked). */
+    nodeId?: string;
+    object?: Object3D;
+    /** A spotlight's cone (angle in degrees, full cone; softness = penumbra) and its aim. */
+    spot?: {
+        direction?: readonly [number, number, number];
+        angle?: number;
+        softness?: number;
+    };
+    getWorldDirection?: (out: Vector3) => void;
+};
+type LampFeed = {
+    lights: () => Iterable<LampFeedLight>;
+    intensity: (light: LampFeedLight) => number;
+};
+/** Item-light pools hand their lamps to the room system while the daylight look is active. */
+export declare const lampFeeds: Set<LampFeed>;
+/** Lamps from every registered feed, in the room system's units. */
+export declare function feedLamps(): RoomLamp[];
+/** Current on/off of a fed lamp (by key). */
+export declare function feedLampOn(key: string): boolean | undefined;
+/** The live parametric scene (registry + node data), or null while it has no zones. */
+export declare function liveRoomScene(virtualLampsOn: boolean): RoomSceneInput | null;
+/** Live level objects in the room system's level order (explode offsets, visibility, focus). */
+export declare function liveLevelObjects(): (Object3D | undefined)[];
+/** A baked artifact's level objects in the room system's level order. */
+export declare function bakedLevelObjects(root: Object3D | null): Object3D[];
+/** How open a live door is (0 closed … 1 fully open), the transient state first. */
+export declare function liveDoorOpenness(id: string): number;
+/** A baked artifact's identity tree (levels, zones, covers, walls, openings), or null. */
+export declare function bakedRoomScene(root: Object3D, virtualLampsOn: boolean): RoomSceneInput | null;
+/**
+ * Lamp shades and bulbs follow their own lamp (the enhanced viewer's isolated emitters): each
+ * lamp's emissive meshes get private materials whose emission follows that lamp's switch. A light
+ * can sit on a child item while the glowing mesh belongs to its parent item: search the item, then
+ * its nearest item ancestor. Re-installed if the item swaps its materials.
+ */
+export declare function syncLampEmitters(): void;
+/** The lamps' own materials back (the daylight look left). */
+export declare function restoreLampEmitters(): void;
+export {};
+//# sourceMappingURL=room-scene.d.ts.map