@pascal-app/viewer 1.0.6 → 1.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"room-scene.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/room-scene.ts"],"names":[],"mappings":"AAQA,OAAO,EAAoD,KAAK,QAAQ,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAMhG,OAAO,KAAK,EAAE,QAAQ,EAAmB,cAAc,EAAY,MAAM,SAAS,CAAA;AAGlF;;;GAGG;AAEH,mGAAmG;AACnG,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,0BAA0B;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,gBAAgB,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAA;IAC3C,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,QAAQ,CAAA;IACjB,yFAAyF;IACzF,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC3F,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;CAC3C,CAAA;AAED,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,QAAQ,CAAC,aAAa,CAAC,CAAA;IACrC,SAAS,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,MAAM,CAAA;CAC5C,CAAA;AAED,8FAA8F;AAC9F,eAAO,MAAM,SAAS,eAAsB,CAAA;AAU5C,oEAAoE;AACpE,wBAAgB,SAAS,IAAI,QAAQ,EAAE,CAuBtC;AAeD,6CAA6C;AAC7C,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAK3D;AAkCD,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,cAAc,EAAE,OAAO,GAAG,cAAc,GAAG,IAAI,CAuE5E;AAED,gGAAgG;AAChG,wBAAgB,gBAAgB,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC,EAAE,CAE3D;AAqBD,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,QAAQ,EAAE,CAEnE;AAED,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAanD;AASD,0FAA0F;AAC1F,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,OAAO,GAAG,cAAc,GAAG,IAAI,CA2E7F;AAiED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CA2CvC;AAED,8DAA8D;AAC9D,wBAAgB,mBAAmB,IAAI,IAAI,CAM1C"}

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

@@ -0,0 +1,391 @@
+import { getLevelElevations, sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
+import { Box3, Color, MathUtils, Vector3 } from 'three';
+import { materialEmissive, smoothstep, uniform, vec3 } from 'three/tsl';
+import { MeshStandardNodeMaterial } from 'three/webgpu';
+import { isHighlight } from '../editor-highlight';
+import { setSurfaceRaycastLayers } from '../layers';
+import { daylightUniforms } from './runtime';
+/** Item-light pools hand their lamps to the room system while the daylight look is active. */
+export const lampFeeds = new Set();
+const COVER_TYPES = {
+    ceiling: 'ceiling',
+    roof: 'roof',
+    'roof-segment': 'roof',
+    slab: 'slab',
+};
+const OPENING_TYPES = ['window', 'door'];
+/** Lamps from every registered feed, in the room system's units. */
+export function feedLamps() {
+    const lamps = [];
+    const position = new Vector3();
+    for (const feed of lampFeeds) {
+        for (const light of feed.lights()) {
+            if (!light.getWorldPosition(position))
+                continue;
+            // Light effects mix conventions: artist numbers (0.6–2) and physical-looking ones
+            // (110, 1800 cd with 55 m reach). Log-compress so both land in a sane band; rooms are
+            // soft-capped later.
+            const peak = light.peak ?? 1;
+            lamps.push({
+                itemId: light.key,
+                position: position.clone(),
+                color: new Color(light.color || '#ffe6c4'),
+                intensity: 4 + 3 * Math.log2(1 + Math.max(0, peak)),
+                candela: Math.max(0, peak),
+                range: MathUtils.clamp(light.distance || 5.5, 2.5, 9),
+                on: feed.intensity(light) > 0,
+                spot: light.spot ? lampSpot(light) : undefined,
+            });
+        }
+    }
+    return lamps;
+}
+/** A spot's cone, as the light pools read it (half-angle = angle / 2, penumbra = softness). */
+function lampSpot(light) {
+    const direction = new Vector3(...(light.spot?.direction ?? [0, -1, 0]));
+    if (light.getWorldDirection)
+        light.getWorldDirection(direction);
+    const half = Math.min(Math.PI / 2, MathUtils.degToRad((light.spot?.angle ?? 60) / 2));
+    const penumbra = MathUtils.clamp(light.spot?.softness ?? 0, 0, 1);
+    return {
+        direction: direction.normalize(),
+        cosOuter: Math.cos(half),
+        cosInner: Math.cos(half * (1 - penumbra)),
+    };
+}
+/** Current on/off of a fed lamp (by key). */
+export function feedLampOn(key) {
+    for (const feed of lampFeeds) {
+        for (const light of feed.lights())
+            if (light.key === key)
+                return feed.intensity(light) > 0;
+    }
+    return undefined;
+}
+/** Meshes under a root, minus skipped subtrees and invisible helpers (hole-less collision proxies). */
+function meshesOf(root, skip) {
+    const out = [];
+    const visit = (object, isRoot) => {
+        if (!isRoot && (skip(object) || !object.visible))
+            return;
+        if (object.isMesh)
+            out.push(object);
+        for (const child of object.children)
+            visit(child, false);
+    };
+    visit(root, true);
+    return out;
+}
+/** Every live level, in one stable order: its building and assembled world floor height. */
+function liveLevels() {
+    const { nodes } = useScene.getState();
+    const elevations = getLevelElevations(nodes);
+    const buildings = new Map();
+    const ids = [];
+    const levels = [];
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'level')
+            continue;
+        const elevation = elevations.get(node.id);
+        const buildingId = elevation?.buildingId ?? null;
+        if (!buildings.has(buildingId))
+            buildings.set(buildingId, buildings.size);
+        const building = buildingId ? nodes[buildingId] : undefined;
+        const siteY = building?.type === 'building' ? building.position[1] : 0;
+        ids.push(node.id);
+        levels.push({ y: siteY + (elevation?.baseY ?? 0), building: buildings.get(buildingId) });
+    }
+    return { ids, levels };
+}
+/** The live parametric scene (registry + node data), or null while it has no zones. */
+export function liveRoomScene(virtualLampsOn) {
+    const zoneIds = sceneRegistry.byType.zone;
+    if (!zoneIds || zoneIds.size === 0)
+        return null;
+    const { nodes } = useScene.getState();
+    const { ids, levels } = liveLevels();
+    const levelIndex = new Map(ids.map((id, index) => [id, index]));
+    const zones = [];
+    const point = new Vector3();
+    for (const id of zoneIds) {
+        const node = nodes[id];
+        const object = sceneRegistry.nodes.get(id);
+        if (!node?.polygon || node.polygon.length < 3 || !object || node.visible === false)
+            continue;
+        object.updateWorldMatrix(true, false);
+        const toWorld = (ring) => ring.map(([x, z]) => {
+            object.localToWorld(point.set(x, 0, z));
+            return [point.x, point.z];
+        });
+        zones.push({
+            id,
+            polygon: toWorld(node.polygon),
+            holes: (node.holes ?? []).filter((hole) => hole.length >= 3).map(toWorld),
+            levelIndex: levelIndex.get(node.parentId ?? '') ?? 0,
+        });
+    }
+    if (!zones.length)
+        return null;
+    const registered = new Set(sceneRegistry.nodes.values());
+    const covers = [];
+    for (const [type, kind] of Object.entries(COVER_TYPES)) {
+        for (const id of sceneRegistry.byType[type] ?? []) {
+            const object = sceneRegistry.nodes.get(id);
+            if (object)
+                covers.push({ object, kind });
+        }
+    }
+    const walls = [];
+    for (const id of sceneRegistry.byType.wall ?? []) {
+        const object = sceneRegistry.nodes.get(id);
+        // Doors, windows and items hang under their wall: a closed leaf mustn't close its doorway.
+        if (object)
+            walls.push(...meshesOf(object, (child) => registered.has(child)));
+    }
+    const openings = [];
+    for (const kind of OPENING_TYPES) {
+        for (const id of sceneRegistry.byType[kind] ?? []) {
+            const object = sceneRegistry.nodes.get(id);
+            if (object)
+                openings.push({ object, kind, id });
+        }
+    }
+    const bounds = new Box3();
+    for (const zone of zones)
+        for (const [x, z] of zone.polygon)
+            bounds.expandByPoint(point.set(x, 0, z));
+    return {
+        bounds,
+        levels,
+        zones,
+        covers,
+        walls,
+        openings,
+        lamps: feedLamps(),
+        virtualLampsOn,
+        configureRaycaster: (raycaster) => setSurfaceRaycastLayers(raycaster.layers),
+    };
+}
+/** Live level objects in the room system's level order (explode offsets, visibility, focus). */
+export function liveLevelObjects() {
+    return liveLevels().ids.map((id) => sceneRegistry.nodes.get(id));
+}
+/** A baked artifact's levels: their objects and, per level, its building and floor height. */
+function bakedLevels(root) {
+    const objects = [];
+    root.traverse((object) => {
+        if (object.userData.kind === 'level')
+            objects.push(object);
+    });
+    root.updateWorldMatrix(true, true);
+    const buildings = new Map();
+    const point = new Vector3();
+    const levels = objects.map((object) => {
+        let building = object.parent;
+        while (building && building.userData.kind !== 'building')
+            building = building.parent;
+        if (!buildings.has(building))
+            buildings.set(building, buildings.size);
+        return { y: object.getWorldPosition(point).y, building: buildings.get(building) };
+    });
+    return { objects, levels };
+}
+/** A baked artifact's level objects in the room system's level order. */
+export function bakedLevelObjects(root) {
+    return root ? bakedLevels(root).objects : [];
+}
+/** How open a live door is (0 closed … 1 fully open), the transient state first. */
+export function liveDoorOpenness(id) {
+    const node = useScene.getState().nodes[id];
+    const transient = useInteractive.getState().doors[id];
+    const swing = transient?.swingAngle ?? node?.swingAngle ?? 0;
+    const operation = transient?.operationState ?? node?.operationState ?? 0;
+    return Math.max(operation, swing / (Math.PI / 2));
+}
+/** A baked artifact's identity tree (levels, zones, covers, walls, openings), or null. */
+export function bakedRoomScene(root, virtualLampsOn) {
+    const zoneObjects = [];
+    const covers = [];
+    const wallRoots = [];
+    const openings = [];
+    root.traverse((object) => {
+        const extras = object.userData;
+        switch (extras.kind) {
+            case 'zone':
+                zoneObjects.push(object);
+                break;
+            case 'ceiling':
+            case 'roof':
+            case 'roof-segment':
+            case 'slab':
+                covers.push({ object, kind: COVER_TYPES[extras.kind] });
+                break;
+            case 'wall':
+                wallRoots.push(object);
+                break;
+            case 'window':
+            case 'door':
+                openings.push({ object, kind: extras.kind, id: extras.pascalId ?? object.uuid });
+                break;
+        }
+    });
+    if (!zoneObjects.length)
+        return null;
+    const levels = bakedLevels(root);
+    const levelOf = (object) => {
+        for (let x = object; x; x = x.parent) {
+            const index = levels.objects.indexOf(x);
+            if (index >= 0)
+                return { index, frame: x };
+        }
+        return { index: 0, frame: null };
+    };
+    const point = new Vector3();
+    const zones = [];
+    for (const object of zoneObjects) {
+        const { polygon, holes } = object.userData;
+        if (!polygon || polygon.length < 3)
+            continue;
+        const level = levelOf(object);
+        // Polygons are level-local [x, z]: bring them to world XZ through the level's frame.
+        const frame = level.frame ?? object.parent ?? object;
+        const toWorld = (ring) => ring.map(([x, z]) => {
+            point.set(x, 0, z).applyMatrix4(frame.matrixWorld);
+            return [point.x, point.z];
+        });
+        zones.push({
+            id: object.userData.pascalId ?? object.uuid,
+            polygon: toWorld(polygon),
+            holes: (holes ?? []).filter((hole) => hole.length >= 3).map(toWorld),
+            levelIndex: level.index,
+        });
+    }
+    if (!zones.length)
+        return null;
+    const isIdentity = (object) => {
+        const kind = object.userData.kind;
+        return kind === 'door' || kind === 'window' || kind === 'item';
+    };
+    const walls = wallRoots.flatMap((object) => meshesOf(object, isIdentity));
+    const bounds = new Box3();
+    for (const zone of zones)
+        for (const [x, z] of zone.polygon)
+            bounds.expandByPoint(point.set(x, 0, z));
+    return {
+        bounds,
+        levels: levels.levels,
+        zones,
+        covers,
+        walls,
+        openings,
+        lamps: feedLamps(),
+        virtualLampsOn,
+        configureRaycaster: (raycaster) => setSurfaceRaycastLayers(raycaster.layers),
+    };
+}
+function isEmitter(material) {
+    return (!material.transparent &&
+        // An editor highlight's tint isn't a glow: a selected lamp's frame must not light up.
+        !isHighlight(material) &&
+        !!material.emissive &&
+        material.emissive.getHex() !== 0 &&
+        (material.emissiveIntensity ?? 1) > 0);
+}
+function emissiveMeshes(root) {
+    const out = [];
+    root.traverse((object) => {
+        const mesh = object;
+        if (!mesh.isMesh || !mesh.material)
+            return;
+        const materials = (Array.isArray(mesh.material) ? mesh.material : [mesh.material]);
+        if (materials.some(isEmitter))
+            out.push(mesh);
+    });
+    return out;
+}
+/**
+ * A lamp's private emitter material: the exported hue at a fixed display brightness (× display
+ * white, ÷ exposure) while its lamp is on — always reads as lit and blooms; dark when off, even
+ * by day. Dark emissive parts (cords, trims) stay dark.
+ */
+function lampEmitterMaterial(source, on) {
+    const material = new MeshStandardNodeMaterial();
+    for (const key of Object.keys(source)) {
+        if (key === 'type' || key === 'uuid' || key === 'id' || key === 'defines')
+            continue;
+        material[key] = source[key];
+    }
+    material.name = source.name;
+    material.userData = { ...source.userData, daylightLampMaterial: true };
+    const emissive = materialEmissive;
+    const lum = emissive.dot(vec3(0.2126, 0.7152, 0.0722)).max(1e-4);
+    material.emissiveNode = emissive
+        .div(lum)
+        .mul(smoothstep(0.02, 0.08, lum))
+        .mul(on)
+        .mul(daylightUniforms.emitterDisplay)
+        .mul(daylightUniforms.emitterExpInv);
+    return material;
+}
+const lampEmitters = new Map();
+/**
+ * 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 function syncLampEmitters() {
+    const registered = new Set(sceneRegistry.nodes.values());
+    for (const feed of lampFeeds) {
+        for (const light of feed.lights()) {
+            const root = light.object ?? (light.nodeId ? sceneRegistry.nodes.get(light.nodeId) : undefined);
+            if (!root)
+                continue;
+            let meshes = emissiveMeshes(root);
+            for (let parent = root.parent; !meshes.length && parent; parent = parent.parent) {
+                const extras = parent.userData;
+                if (extras.pascalId || registered.has(parent)) {
+                    if (extras.kind === undefined || extras.kind === 'item')
+                        meshes = emissiveMeshes(parent);
+                    break;
+                }
+            }
+            const on = feed.intensity(light) > 0 ? 1 : 0;
+            for (const mesh of meshes) {
+                let emitter = lampEmitters.get(mesh);
+                if (emitter && mesh.material !== emitter.installed) {
+                    for (const clone of emitter.clones)
+                        clone.dispose();
+                    emitter = undefined;
+                }
+                if (!emitter) {
+                    const lit = uniform(on);
+                    const originals = (Array.isArray(mesh.material) ? mesh.material : [mesh.material]);
+                    const clones = [];
+                    const next = originals.map((material) => {
+                        if (!isEmitter(material))
+                            return material;
+                        const clone = lampEmitterMaterial(material, lit);
+                        clones.push(clone);
+                        return clone;
+                    });
+                    const installed = Array.isArray(mesh.material) ? next : next[0];
+                    emitter = { original: mesh.material, installed, clones, on: lit };
+                    lampEmitters.set(mesh, emitter);
+                    mesh.material = installed;
+                }
+                emitter.on.value = on;
+            }
+        }
+    }
+}
+/** The lamps' own materials back (the daylight look left). */
+export function restoreLampEmitters() {
+    for (const [mesh, emitter] of lampEmitters) {
+        if (mesh.material === emitter.installed)
+            mesh.material = emitter.original;
+        for (const clone of emitter.clones)
+            clone.dispose();
+    }
+    lampEmitters.clear();
+}

package/dist/lib/daylight/rooms.d.ts

@@ -0,0 +1,292 @@
+import { Box3, type Camera, Color, type Object3D, Raycaster, Vector2, Vector3 } from 'three';
+import { type MapLevel, RoomMap } from './room-map';
+/**
+ * "Room-aware" interior light, the game-engine way (ported from the enhanced viewer):
+ *
+ * - Zone polygons are rasterized per level into a top-down room-id map (10 cm cells). A fragment
+ *   finds its room by looking up `p + n·0.18` — a wall face looks *into* the room it faces, so
+ *   light never leaks through walls and there are no shadow maps to pay for.
+ * - Each room owns its lamps and window "portals": glass rectangles that emit sky (+ ground
+ *   bounce) radiance inwards with an analytic rectangle form factor, plus the internally
+ *   reflected component (split-flux) and the sky patch on the floor. Enclosed rooms see only
+ *   a tenth of the sky environment.
+ * - Openings between rooms (doorways, arches, open plan) carry light from the neighbour and
+ *   crossfade room-wide terms at the threshold.
+ * - At night, lit rooms throw light out through their windows (a gobo of the main lamp + the
+ *   pane glow), and lamps outside every room light exterior surfaces analytically.
+ *
+ * Everything feeds the material lighting through `getGI` / `getAO` contexts: real diffuse
+ * irradiance (× albedo, × AO), not a post overlay. Shader inputs are uniforms and data textures,
+ * so rebuilding after an edit never recompiles a material.
+ */
+type N = any;
+export type RoomLamp = {
+    position: Vector3;
+    color: Color;
+    /** Candela-ish, after the per-room soft cap. */
+    intensity: number;
+    range: number;
+    itemId?: string;
+    /** Lit right now (the lamp's own switch). */
+    on: boolean;
+    /** Spotlight cone (exterior lamps keep it; inside, lamps fill their room). */
+    spot?: {
+        direction: Vector3;
+        cosOuter: number;
+        cosInner: number;
+    };
+    /**
+     * The light's authored intensity (cd, as the real light shines at it). Exterior lamps light
+     * façades and ground with it, as the scene's lights do — `intensity` is a room-metering value,
+     * log-compressed from it, and only caps it (layouts with physical-looking 1800 cd stay tame).
+     */
+    candela?: number;
+};
+export type RoomZone = {
+    id: string;
+    /** World XZ. */
+    polygon: [number, number][];
+    holes?: [number, number][][];
+    levelIndex: number;
+};
+export type RoomOpeningRoot = {
+    object: Object3D;
+    kind: 'window' | 'door';
+    id: string;
+};
+/** What the room system needs from a scene (live parametric or baked artifact). */
+export type RoomSceneInput = {
+    bounds: Box3;
+    /** Every level: assembled (not exploded) world Y of its floor and its building's index. */
+    levels: MapLevel[];
+    zones: RoomZone[];
+    /** Ceilings, roofs and slabs (enclosure rays) with their kind. */
+    covers: {
+        object: Object3D;
+        kind: 'ceiling' | 'roof' | 'slab';
+    }[];
+    /** Wall meshes only (openings and their parts excluded), for walkable-opening rays. */
+    walls: Object3D[];
+    openings: RoomOpeningRoot[];
+    lamps: RoomLamp[];
+    /** Whether rooms without lamps of their own get their virtual ceiling lamp lit. */
+    virtualLampsOn: boolean;
+    /** Layers the enclosure/opening rays test (batched originals live off layer 0). */
+    configureRaycaster?: (raycaster: Raycaster) => void;
+};
+type Portal = {
+    center: Vector3;
+    /** Points into the room. */
+    normal: Vector3;
+    width: number;
+    height: number;
+    room: number;
+    /** 0 window glass · 1 interior opening (neighbour light) · 2 exterior opening. */
+    kind: 0 | 1 | 2;
+    neighbor: number;
+    doorId?: string;
+    gain: number;
+};
+type Opening = {
+    a: number;
+    b: number;
+    center: Vector3;
+    /** Horizontal, from room a towards b. */
+    normal: Vector3;
+    width: number;
+    height: number;
+    doorId?: string;
+};
+type Room = {
+    zone: RoomZone;
+    levelIndex: number;
+    enclosed: boolean;
+    area: number;
+    centroid: Vector3;
+    ceilingY: number;
+    /** Height of the topmost cover above the room, and whether it is opaque from above. */
+    coverY: number;
+    coverIsRoof: boolean;
+    /** Interior surface area (floor + ceiling + walls) — used by the meters. */
+    surfaces: number;
+    /** Average irradiance from lamps at full level (after the soft cap), and from daylight. */
+    lampE: number;
+    dayE: number;
+    lamps: RoomLamp[];
+    portals: Portal[];
+};
+export type SkySampler = (outward: Vector3) => Color;
+export declare class RoomLighting {
+    rooms: Room[];
+    /** Lamps outside every room (lanterns, garden lights), lit analytically on outside surfaces. */
+    exteriorLamps: RoomLamp[];
+    portals: Portal[];
+    openings: Opening[];
+    levels: MapLevel[];
+    /** Which room a point is in (tiled per level; see `room-map.ts`). */
+    readonly map: RoomMap;
+    private data;
+    private lampTexel;
+    private lastSky;
+    readonly portalGain: import("three/webgpu").UniformNode<"float", number>;
+    readonly bounceGain: import("three/webgpu").UniformNode<"float", number>;
+    readonly lampGain: import("three/webgpu").UniformNode<"float", number>;
+    /**
+     * Lamp light as drawn, not as metered: eased below 1 while the camera is outside at night, so
+     * lit rooms seen from out there keep an indoor-like exposure (the meters ignore it).
+     */
+    readonly lampView: import("three/webgpu").UniformNode<"float", number>;
+    /** Sky-IBL multiplier in enclosed rooms. */
+    readonly indoorEnv: import("three/webgpu").UniformNode<"float", number>;
+    /** Window spill outside at night. */
+    readonly spillGain: import("three/webgpu").UniformNode<"float", number>;
+    /** Ceiling for lamp irradiance on any surface (soft): ≈3× the room-average target. */
+    readonly lampMaxE: import("three/webgpu").UniformNode<"float", number>;
+    /** Sky patch on the floor (0 on the Low tier). */
+    readonly skyPatch: import("three/webgpu").UniformNode<"float", number>;
+    /** Light through interior openings + threshold crossfade (off on the Low tier). */
+    readonly softRooms: import("three/webgpu").UniformNode<"float", number>;
+    /** Camera world Y (live). */
+    readonly cameraY: import("three/webgpu").UniformNode<"float", number>;
+    private readonly u;
+    /** Rebuild from a scene: rooms, lamps, portals, openings, room-id map. */
+    build(input: RoomSceneInput): void;
+    /** CPU-side room lookup in assembled space (same rule as the shader, without the normal offset). */
+    roomAt(p: Vector3): number;
+    /**
+     * Whether each level is on screen. A camera over a level whose upper floors are hidden stands
+     * in those floors' rooms by height alone, but it is outdoors: metered and white-balanced as
+     * such, not as a lamplit room it cannot see.
+     */
+    levelShown: boolean[];
+    /** Per level: focused (its rooms open from above when the camera is over their cover). */
+    levelFocused: boolean[];
+    /** Per level: the highest one shown in its building (its rooms seen from above). */
+    private 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
+     * fills — fully where it is open from above (its level the top one shown), a little where only
+     * its windows show — counted twice over, as the eye goes to the lit rooms. Rooms only ever
+     * brighten the reading, so daytime views are unchanged. `roomsE` is the rooms' own reading (0
+     * with none in view): what they meter at from inside. Given the outdoor illuminant, `illuminant`
+     * is the light the eye adapts to: the outdoors shifted towards the rooms' light by their pull.
+     */
+    viewedMeter(camera: Camera, exteriorE: number, skyE: number, outdoor?: Color, skyLum?: number): {
+        sceneE: number;
+        roomsE: number;
+        illuminant: Color | null;
+    };
+    isEnclosedAt(p: Vector3): {
+        room: number;
+        inside: boolean;
+    };
+    /**
+     * 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: number[], shown: boolean[], selected: boolean[]): void;
+    /** Re-run the light transfer (after a quality-tier change of the soft room map). */
+    refresh(): void;
+    /** Lamp switches changed: rewrite lamp texels (+ the light carried through openings). */
+    setLampStates(isOn: (lamp: RoomLamp) => boolean): boolean;
+    /** Door openness (0 closed … 1 open) → portal gain; a closed interior door leaves a crack. */
+    updateDoors(openness: (doorId: string) => number): void;
+    /** 0…1: share of the room's lamp power currently lit. */
+    lampFraction(room: number): number;
+    /**
+     * Analytic light meter: the average irradiance a camera standing in `room` would see —
+     * daylight (portals + bounce, scaled like the shader's gains) + lamps + leftover sky IBL.
+     */
+    meter(room: number, skyE: number): number;
+    /** The illuminant colour inside `room` (daylight through the windows + its lit lamps). */
+    roomIlluminant(room: number, outdoor: Color, skyLum: number): Color | null;
+    /**
+     * Per sun/sky change: radiance leaving each portal into the room, and the per-room sun
+     * bounce (sun patch on the floor re-radiating — the main thing screen-space GI misses).
+     * `skyRadiance(dir)` returns linear sky radiance seen *through* the window (outward dir).
+     */
+    updateSky(skyRadiance: SkySampler, sunDir: Vector3, sunColor: Color, sunIrradiance: number): void;
+    private portalBase;
+    private activeBase;
+    private allocateData;
+    /**
+     * The outside is lit only by windows of rooms whose lamp is on and by exterior lamps that are
+     * on: list just those, so the per-pixel spill and lantern loops run over nothing by day and
+     * over the lit few at night, not over every window of the building.
+     */
+    private writeActiveLists;
+    private markData;
+    private writeLamp;
+    /** Interior portals emit the neighbour room's average radiance: L = E_avg·ρ/π (lamps + daylight). */
+    private writeInteriorPortals;
+    private set;
+    /**
+     * 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.
+     */
+    private openingSearch;
+    /** One opening from its boundary samples: measured along their own line, facing room b. */
+    private openingFromRun;
+    /** Room index (−1 outside) at a world-space position (live heights). */
+    roomAtNode: import("three/tsl").FnNode<[any], import("three/webgpu").VarNode<"int", import("three/webgpu").ConstNode<"int", number>>>;
+    /**
+     * 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(): N;
+    /** E' = Emax·(1 − e^(−E/Emax)), on luminance, hue kept — near-field hot spots compress, never blow out. */
+    private softClampLamps;
+    /**
+     * Dollhouse / roofless views: an enclosed room is open to the sky when the camera is above its
+     * 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]; `level` its level's
+     * [th, entryOffset, offset, flags] (flag 1: focused).
+     */
+    private openToSky;
+    private texel;
+    /**
+     * vec4(irradiance, enclosure):
+     *  irradiance — lamp + portal + bounce diffuse irradiance (linear)
+     *  enclosure  — multiplier for the sky IBL (1 outdoors, `indoorEnv` in enclosed rooms)
+     */
+    lightingNode: import("three/tsl").FnNode<[any], import("three/webgpu").JoinNode<"vec4">>;
+    /**
+     * Light thrown *out* of lit rooms through their windows onto exterior surfaces (ground,
+     * terraces, balconies, reveals). Two terms per exterior portal:
+     *  - gobo: the room's main lamp projected through the window rectangle — the crisp,
+     *    window-shaped pool on a lawn at night (exact for an unoccluded point lamp)
+     *  - glow: the pane as a soft area emitter (lamp-lit room radiance), for the halo
+     * Receivers below the window's storey floor − 0.18 m get nothing, so upper windows can't
+     * project through slabs onto the ground.
+     */
+    exteriorSpillNode: import("three/tsl").FnNode<[any, any], import("three/webgpu").Node<"vec3">>;
+    /**
+     * Exterior lamps (lanterns, bollards, garden lights) as sized sources with the same falloff and
+     * soft clamp as room lamps — no hot spots a bollard's height from the paving. Applied to
+     * outside surfaces only.
+     */
+    exteriorLampsNode: import("three/tsl").FnNode<[any, any], any>;
+    /** 1 where exterior lights may shine (outside, or rooms open to the sky), 0 inside. */
+    exteriorMaskNode: import("three/tsl").FnNode<[any], import("three/webgpu").VarNode<"float", import("three/webgpu").ConstNode<"float", number>>>;
+    /** Linear lamp radiance of a room (its lit lamps) — the night tint of its window panes. */
+    roomGlowNode: import("three/tsl").FnNode<[any], import("three/webgpu").Node<"vec3">>;
+}
+export declare function pointInPolygon(x: number, z: number, poly: [number, number][]): boolean;
+export declare function polygonPerimeter(poly: [number, number][]): number;
+export declare function polygonArea(poly: [number, number][]): number;
+export declare function polygonCentroid(poly: [number, number][]): Vector2;
+/** Tanner Helland blackbody fit → linear RGB. */
+/** A point inside the polygon and outside its holes: the centroid when it is, else a scan. */
+export declare function interiorPoint(poly: [number, number][], holes?: [number, number][][]): Vector2;
+export declare function kelvin(k: number): Color;
+/** The daylight look's room system (one viewer canvas at a time). */
+export declare const daylightRooms: RoomLighting;
+export {};
+//# sourceMappingURL=rooms.d.ts.map