@pascal-app/viewer 1.0.6 → 1.0.7

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

@@ -0,0 +1,356 @@
+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;
+}
+/** 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 elevations = getLevelElevations(nodes);
+    const levels = Object.values(nodes)
+        .filter((node) => node?.type === 'level')
+        .map((node) => ({ id: node.id, y: elevations.get(node.id)?.baseY ?? 0 }))
+        .sort((a, b) => a.y - b.y);
+    const levelIndex = new Map(levels.map((level, index) => [level.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 polygon = node.polygon.map(([x, z]) => {
+            object.localToWorld(point.set(x, 0, z));
+            return [point.x, point.z];
+        });
+        zones.push({ id, polygon, 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,
+        levelY: levels.map((level) => level.y),
+        zones,
+        covers,
+        walls,
+        openings,
+        lamps: feedLamps(),
+        virtualLampsOn,
+        configureRaycaster: (raycaster) => setSurfaceRaycastLayers(raycaster.layers),
+    };
+}
+/** Live level objects in the room system's level order (for explode offsets). */
+export function liveLevelObjects() {
+    const { nodes } = useScene.getState();
+    const elevations = getLevelElevations(nodes);
+    return Object.values(nodes)
+        .filter((node) => node?.type === 'level')
+        .sort((a, b) => (elevations.get(a.id)?.baseY ?? 0) - (elevations.get(b.id)?.baseY ?? 0))
+        .map((node) => sceneRegistry.nodes.get(node.id))
+        .filter((object) => !!object);
+}
+/** 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 levelObjects = [];
+    const zoneObjects = [];
+    const covers = [];
+    const wallRoots = [];
+    const openings = [];
+    root.traverse((object) => {
+        const extras = object.userData;
+        switch (extras.kind) {
+            case 'level':
+                levelObjects.push(object);
+                break;
+            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;
+    root.updateWorldMatrix(true, true);
+    const levels = levelObjects
+        .map((object) => ({ object, y: object.getWorldPosition(new Vector3()).y }))
+        .sort((a, b) => a.y - b.y);
+    const levelOf = (object) => {
+        for (let x = object; x; x = x.parent) {
+            const index = levels.findIndex((level) => level.object === x);
+            if (index >= 0)
+                return index;
+        }
+        return 0;
+    };
+    const point = new Vector3();
+    const zones = [];
+    for (const object of zoneObjects) {
+        const polygon = object.userData.polygon;
+        if (!polygon || polygon.length < 3)
+            continue;
+        const levelIndex = levelOf(object);
+        // Polygons are level-local [x, z]: bring them to world XZ through the level's frame.
+        const frame = levels[levelIndex]?.object ?? object.parent ?? object;
+        zones.push({
+            id: object.userData.pascalId ?? object.uuid,
+            polygon: polygon.map(([x, z]) => {
+                point.set(x, 0, z).applyMatrix4(frame.matrixWorld);
+                return [point.x, point.z];
+            }),
+            levelIndex,
+        });
+    }
+    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,
+        levelY: levels.map((level) => level.y),
+        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,262 @@
+import { Box3, type Camera, Color, type Object3D, Raycaster, Vector2, Vector3 } from 'three';
+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][];
+    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;
+    /** World Y of each level, assembled (not exploded), ascending. */
+    levelY: number[];
+    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[];
+    levelY: number[];
+    private data;
+    private map;
+    private origin;
+    private gridW;
+    private gridH;
+    private levels;
+    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>;
+    readonly cameraY: import("three/webgpu").UniformNode<"float", number>;
+    readonly focusedLevel: import("three/webgpu").UniformNode<"int", number>;
+    /**
+     * 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.
+     */
+    private readonly levelGroup;
+    private readonly u;
+    /** Rebuild from a scene: rooms, lamps, portals, openings, room-id map. */
+    build(input: RoomSceneInput): void;
+    /** CPU-side room lookup (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[];
+    /**
+     * 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;
+    };
+    /** Explode / level motion: live world Y of each level (assembled + offset). */
+    setLevelOffsets(offsets: number[]): 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 uploadMap;
+    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 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).
+     */
+    private detectOpenings;
+    /** Level index for a world-space height (live, explode-offset level heights). */
+    private levelOfNode;
+    /** Room index (−1 outside) at a world-space position. */
+    roomAtNode: import("three/tsl").FnNode<[any], import("three/webgpu").Node<"int">>;
+    /** 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].
+     */
+    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<[], 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<[], 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. */
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rooms.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/rooms.ts"],"names":[],"mappings":"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"}