@pascal-app/viewer 1.0.6 → 1.0.7

package/dist/systems/interactive/opening-settled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-settled.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/opening-settled.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAA2B,MAAM,kBAAkB,CAAA;AAK1E;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAClC,IAAI,GAAE,MAAM,GAAG,UAAmB,GACjC,OAAO,CAAC,IAAI,CAAC,CAmBf;AAKD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAclE"}

package/dist/systems/interactive/opening-settled.js

@@ -0,0 +1,53 @@
+import { emitter, useInteractive } from '@pascal-app/core';
+/** Longer than any built-in leaf, sash or shutter run, so a missed event never strands a sound. */
+const FALLBACK_MS = 2000;
+/**
+ * Resolves when a built-in door's leaf or a window's sash (or, with `shutters`,
+ * its shutters) finishes the run just started, so the latch can sound on the
+ * frame the leaf lands.
+ */
+export function openingSettled(node, part = 'leaf') {
+    return new Promise((resolve) => {
+        const done = () => {
+            clearTimeout(timer);
+            emitter.off('door:animation-completed', onDoor);
+            emitter.off('window:animation-completed', onWindow);
+            resolve();
+        };
+        const onDoor = (event) => {
+            if (node.type === 'door' && event.doorId === node.id)
+                done();
+        };
+        const onWindow = (event) => {
+            if (node.type !== 'window' || event.windowId !== node.id)
+                return;
+            if ((event.field === 'operationState') === (part === 'leaf'))
+                done();
+        };
+        const timer = setTimeout(done, FALLBACK_MS);
+        emitter.on('door:animation-completed', onDoor);
+        emitter.on('window:animation-completed', onWindow);
+    });
+}
+/** Recipe timelines run longer than a door leaf; past this, a lost event still frees the sound. */
+const MOTION_FALLBACK_MS = 6000;
+/**
+ * Resolves when a procedural item's latest commanded run (a cabinet door, a
+ * drawer, a lid) has its moving parts at rest. Call it right after the toggle.
+ */
+export function proceduralSettled(nodeId) {
+    const sequence = useInteractive.getState().procedural[nodeId]?.motionCommand?.sequence ?? 0;
+    return new Promise((resolve) => {
+        const done = () => {
+            clearTimeout(timer);
+            emitter.off('procedural:motion-settled', onSettled);
+            resolve();
+        };
+        const onSettled = (event) => {
+            if (event.nodeId === nodeId && event.sequence >= sequence)
+                done();
+        };
+        const timer = setTimeout(done, MOTION_FALLBACK_MS);
+        emitter.on('procedural:motion-settled', onSettled);
+    });
+}

package/dist/systems/item-light/item-light-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"item-light-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item-light/item-light-system.tsx"],"names":[],"mappings":"AAgGA,wBAAgB,eAAe,uCA0M9B"}
+{"version":3,"file":"item-light-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item-light/item-light-system.tsx"],"names":[],"mappings":"AA+CA,wBAAgB,eAAe,uCAoB9B"}

package/dist/systems/item-light/item-light-system.js

@@ -1,25 +1,10 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { findLevelAncestorId, sceneRegistry, useScene } from '@pascal-app/core';
-import { useFrame, useThree } from '@react-three/fiber';
-import { useRef } from 'react';
-import { MathUtils, Vector3 } from 'three';
+import { useThree } from '@react-three/fiber';
 import { SCENE_LAYER } from '../../lib/layers';
 import { useItemLightPool } from '../../store/use-item-light-pool';
 import useViewer from '../../store/use-viewer';
-const POOL_SIZE = 12;
-// How often (in seconds) to re-evaluate which items have lights assigned (fallback timer)
-const REASSIGN_INTERVAL = 0.2;
-// Hysteresis: a currently-assigned slot keeps its key unless an unassigned
-// candidate beats it by at least this much (prevents flickering at the boundary)
-const HYSTERESIS = 0.15;
-// Camera movement thresholds that trigger an early re-evaluation
-const CAM_MOVE_DIST = 0.5; // units
-const CAM_ROT_DOT = 0.995; // cos(~5.7°)
-// Module-level temp vectors reused every frame (avoids GC pressure)
-const _dir = new Vector3();
-const _camPos = new Vector3();
-const _camFwd = new Vector3();
-const _itemPos = new Vector3();
+import { PooledLights } from './pooled-lights';
 function isRendered(nodeId) {
     let object = sceneRegistry.nodes.get(nodeId);
     if (!object?.layers.isEnabled(SCENE_LAYER))
@@ -31,213 +16,36 @@ function isRendered(nodeId) {
     }
     return true;
 }
-function scoreRegistration(reg, nodes, selectedLevelId, levelMode, hideAbove) {
-    if (!reg.isEligible() || !isRendered(reg.nodeId) || !reg.getWorldPosition(_itemPos))
-        return Number.POSITIVE_INFINITY;
+// A light on another storey than the one being edited counts for this much of what it adds.
+const OTHER_LEVEL_WEIGHT = 0.25;
+/** 0 while the light cannot be seen lit (off, hidden, on a hidden level), else its level factor. */
+function registrationWeight(reg, nodes, selectedLevelId, levelMode, hideAbove) {
+    if (!reg.isEligible() || !isRendered(reg.nodeId))
+        return 0;
     const { nodeId } = reg;
     let current = nodes[nodeId];
     while (current) {
         if (current.type !== 'site' && current.visible === false)
-            return Number.POSITIVE_INFINITY;
+            return 0;
         current = current.parentId ? nodes[current.parentId] : undefined;
     }
     const itemLevelId = findLevelAncestorId(nodeId, nodes);
-    if (selectedLevelId && itemLevelId !== selectedLevelId && levelMode === 'solo')
-        return Number.POSITIVE_INFINITY;
-    _dir.copy(_itemPos).sub(_camPos).normalize();
-    const dot = _camFwd.dot(_dir); // 1 = ahead, -1 = behind
-    // Angular component (0 = dead ahead, 2 = directly behind)
-    const angular = 1 - dot;
-    // Normalised distance component (assumes scenes < 200 units)
-    const dist = _camPos.distanceTo(_itemPos) / 200;
-    // ── Level factor ──────────────────────────────────────────────────────────
-    let levelPenalty = 0;
-    if (selectedLevelId) {
-        if (itemLevelId !== selectedLevelId) {
-            // Items on hidden levels (every other one in solo, those above the
-            // selected one while editing) are invisible — deprioritize strongly
-            const itemIndex = nodes[itemLevelId]?.level ?? 0;
-            const selectedIndex = nodes[selectedLevelId]?.level ?? 0;
-            const hidden = levelMode === 'solo' || (hideAbove && itemIndex > selectedIndex);
-            levelPenalty = hidden ? 100 : 0.8;
-        }
-    }
-    else if (itemLevelId) {
-        // No level selected — lightly prefer items on level index 0
-        const levelNode = nodes[itemLevelId];
-        const levelIndex = levelNode?.level ?? 0;
-        if (levelIndex !== 0)
-            levelPenalty = 0.3;
-    }
-    return angular * 0.7 + dist * 0.3 + levelPenalty;
+    if (!selectedLevelId || itemLevelId === selectedLevelId)
+        return 1;
+    if (levelMode === 'solo')
+        return 0;
+    // Above the selected level while editing, a storey is hidden.
+    const itemIndex = nodes[itemLevelId]?.level ?? 0;
+    const selectedIndex = nodes[selectedLevelId]?.level ?? 0;
+    return hideAbove && itemIndex > selectedIndex ? 0 : OTHER_LEVEL_WEIGHT;
 }
 export function ItemLightSystem() {
     const scene = useThree((state) => state.scene);
     const bakedOwner = useItemLightPool((state) => state.bakedCanvases.has(scene));
-    const lightRefs = useRef(Array.from({ length: POOL_SIZE }, () => null));
-    const slots = useRef(Array.from({ length: POOL_SIZE }, () => ({ key: null, pendingKey: null, isFadingOut: false })));
-    const reassignTimer = useRef(0);
-    // Track camera state at last reassignment to detect meaningful movement
-    const prevReassignCamPos = useRef(new Vector3());
-    const prevReassignCamFwd = useRef(new Vector3(0, 0, -1));
-    useFrame(({ camera }, delta) => {
-        if (bakedOwner)
-            return;
-        const dt = Math.min(delta, 0.1);
-        const { registrations } = useItemLightPool.getState();
-        // ── 1. Throttled priority reassignment ──────────────────────────────────
-        camera.getWorldPosition(_camPos);
-        camera.getWorldDirection(_camFwd);
-        const camMoved = _camPos.distanceTo(prevReassignCamPos.current) > CAM_MOVE_DIST ||
-            _camFwd.dot(prevReassignCamFwd.current) < CAM_ROT_DOT;
-        reassignTimer.current -= delta;
-        const shouldReassign = reassignTimer.current <= 0 || camMoved;
-        if (shouldReassign) {
-            reassignTimer.current = REASSIGN_INTERVAL;
-            prevReassignCamPos.current.copy(_camPos);
-            prevReassignCamFwd.current.copy(_camFwd);
-            // Read level/scene state once for the whole tick
-            const nodes = useScene.getState().nodes;
-            const viewerState = useViewer.getState();
-            const selectedLevelId = viewerState.selection.levelId;
-            const levelMode = viewerState.levelMode;
-            const hideAbove = viewerState.hideLevelsAboveSelection;
-            // Score every registration
-            const scored = [];
-            for (const [key, reg] of registrations) {
-                scored.push({
-                    key,
-                    score: scoreRegistration(reg, nodes, selectedLevelId, levelMode, hideAbove),
-                });
-            }
-            scored.sort((a, b) => a.score - b.score);
-            // Build the desired assignment (top POOL_SIZE keys)
-            const desired = scored
-                .filter((s) => Number.isFinite(s.score))
-                .slice(0, POOL_SIZE)
-                .map((s) => s.key);
-            // Build a map of currently-assigned keys → slot index for hysteresis
-            const currentlyAssigned = new Map();
-            for (let i = 0; i < POOL_SIZE; i++) {
-                const s = slots.current[i];
-                if (!s)
-                    continue;
-                const k = s.key ?? s.pendingKey;
-                if (k)
-                    currentlyAssigned.set(k, i);
-            }
-            // Assign desired keys to slots — prefer keeping existing assignments
-            const usedSlots = new Set();
-            const assignedKeys = new Set();
-            // Pass 1: keep existing slots where the key is still in desired
-            for (const key of desired) {
-                const existingSlot = currentlyAssigned.get(key);
-                if (existingSlot !== undefined && !usedSlots.has(existingSlot)) {
-                    usedSlots.add(existingSlot);
-                    assignedKeys.add(key);
-                }
-            }
-            // Pass 2: assign remaining desired keys to free slots
-            let freeSlot = 0;
-            for (const key of desired) {
-                if (assignedKeys.has(key))
-                    continue;
-                while (freeSlot < POOL_SIZE && usedSlots.has(freeSlot))
-                    freeSlot++;
-                if (freeSlot >= POOL_SIZE)
-                    break;
-                // Hysteresis: only evict the current occupant if the new key scores
-                // meaningfully better than it
-                const freeSlotData = slots.current[freeSlot];
-                const currentKey = freeSlotData ? (freeSlotData.key ?? freeSlotData.pendingKey) : null;
-                if (currentKey && !desired.includes(currentKey)) {
-                    const currentScore = scored.find((s) => s.key === currentKey)?.score ?? Number.POSITIVE_INFINITY;
-                    const newScore = scored.find((s) => s.key === key)?.score ?? 0;
-                    if (currentScore - newScore < HYSTERESIS) {
-                        freeSlot++;
-                        continue;
-                    }
-                }
-                usedSlots.add(freeSlot);
-                assignedKeys.add(key);
-                const slot = slots.current[freeSlot];
-                if (slot && slot.key !== key) {
-                    slot.pendingKey = key;
-                    slot.isFadingOut = slot.key !== null;
-                    if (!slot.isFadingOut) {
-                        // Slot was idle — skip fade-out, assign immediately
-                        slot.key = key;
-                        slot.pendingKey = null;
-                        const light = lightRefs.current[freeSlot];
-                        const reg = registrations.get(key);
-                        if (light && reg) {
-                            light.color.set(reg.color);
-                            light.distance = reg.distance;
-                        }
-                    }
-                }
-                freeSlot++;
-            }
-            // Clear slots whose key is no longer in desired and not pending
-            for (let i = 0; i < POOL_SIZE; i++) {
-                if (!usedSlots.has(i)) {
-                    const slot = slots.current[i];
-                    if (slot?.key && !desired.includes(slot.key)) {
-                        slot.pendingKey = null;
-                        slot.isFadingOut = true;
-                    }
-                }
-            }
-        }
-        // ── 2. Per-frame light updates ───────────────────────────────────────────
-        for (let i = 0; i < POOL_SIZE; i++) {
-            const light = lightRefs.current[i];
-            if (!light)
-                continue;
-            const slot = slots.current[i];
-            if (!slot)
-                continue;
-            // Fade-out phase: lerp intensity → 0, then complete the transition
-            if (slot.isFadingOut) {
-                light.intensity = MathUtils.lerp(light.intensity, 0, dt * 12);
-                if (light.intensity < 0.01) {
-                    light.intensity = 0;
-                    slot.isFadingOut = false;
-                    slot.key = slot.pendingKey;
-                    slot.pendingKey = null;
-                    if (slot.key) {
-                        const reg = registrations.get(slot.key);
-                        if (reg) {
-                            light.color.set(reg.color);
-                            light.distance = reg.distance;
-                        }
-                    }
-                }
-                continue;
-            }
-            if (!slot.key) {
-                // Idle slot — keep dark
-                light.intensity = 0;
-                continue;
-            }
-            const reg = registrations.get(slot.key);
-            if (!reg) {
-                slot.key = null;
-                light.intensity = 0;
-                continue;
-            }
-            if (reg.getWorldPosition(_itemPos))
-                light.position.copy(_itemPos);
-            const targetIntensity = reg.isEligible() && isRendered(reg.nodeId) ? reg.getIntensity() : 0;
-            light.intensity = MathUtils.lerp(light.intensity, targetIntensity, dt * 12);
-            if (targetIntensity <= 0 && light.intensity < 0.01) {
-                light.intensity = 0;
-            }
-        }
-    }, 6);
     if (bakedOwner)
         return null;
-    return (_jsx(_Fragment, { children: Array.from({ length: POOL_SIZE }, (_, i) => (_jsx("pointLight", { castShadow: false, intensity: 0, visible: true, ref: (el) => {
-                lightRefs.current[i] = el;
-            } }, i))) }));
+    return (_jsx(PooledLights, { getLights: () => useItemLightPool.getState().registrations.values(), intensity: (reg) => (reg.isEligible() && isRendered(reg.nodeId) ? reg.getIntensity() : 0), weight: (reg) => {
+            const viewer = useViewer.getState();
+            return registrationWeight(reg, useScene.getState().nodes, viewer.selection.levelId, viewer.levelMode, viewer.hideLevelsAboveSelection);
+        } }));
 }

package/dist/systems/item-light/pooled-lights.d.ts

@@ -0,0 +1,70 @@
+import type { LightSpot } from '@pascal-app/core';
+import { type Camera, Frustum, type Object3D, Vector3 } from 'three/webgpu';
+/** A light an item holds, as the pools drive it. */
+export type PooledLight = {
+    key: string;
+    color: string;
+    distance: number;
+    spot?: LightSpot;
+    shadows?: boolean;
+    glow?: {
+        size: number;
+        strength?: number;
+    };
+    /** Its fully-on intensity, so its glow dims with it. */
+    peak?: number;
+    /** Where it shines from; false while its object is not mounted. */
+    getWorldPosition: (out: Vector3) => boolean;
+    /** Its spot's aim in world space, turned with its item. */
+    getWorldDirection?: (out: Vector3) => void;
+};
+type Props<T extends PooledLight> = {
+    getLights: () => Iterable<T>;
+    /**
+     * 0 while it cannot be seen lit (off, hidden, on a hidden level); otherwise a factor on what it
+     * adds to the view (a light on another storey than the one being edited counts for less).
+     */
+    weight: (light: T) => number;
+    /** What it shines at now: 0 while off or not drawn. */
+    intensity: (light: T) => number;
+};
+type Slot = {
+    key: string | null;
+    pendingKey: string | null;
+    isFadingOut: boolean;
+};
+type Candidate = {
+    key: string;
+    priority: number;
+};
+/**
+ * Roughly what a light adds to a view: its intensity over its squared distance from the eye, or 0
+ * when its reach (its distance, else where it falls under REACH_CUTOFF) misses the view.
+ */
+export declare function lightContribution(position: Vector3, intensity: number, distance: number, eye: Vector3, frustum: Frustum): number;
+/**
+ * Gives the wanted keys (most first) the pool's slots: a key that holds a slot keeps it, and a
+ * newcomer evicts a key no longer wanted only on a clear win. A slot changing hands fades out
+ * first; an idle slot takes its key at once.
+ */
+export declare function assignSlots(slots: Slot[], wanted: Candidate[], priorityByKey: Map<string, number>): void;
+/** How much a glow shows: 1 at night, nearly nothing in daylight. */
+export declare function glowDarkness(sunDirection: Vector3 | null, appearance: 'light' | 'dark'): number;
+/**
+ * Sets the item lights of `scene` for a picture taken through `camera`: the pools re-ranked for
+ * what that camera sees and every light straight at its strength, no fade. A capture camera is not
+ * the live view's, and a theme switched for the picture leaves no time for lamps to fade in.
+ * Returns what puts the live view's lights back.
+ */
+export declare function itemLightsForCapture(scene: Object3D, camera: Camera): () => void;
+/**
+ * The lights items hold, through fixed pools of point lights, spots and two shadow-casting slots,
+ * handed to the lights that add most to the view (intensity over squared distance, among those
+ * whose reach meets the view frustum), with hysteresis, and faded across reassignment. Every pool
+ * light stays mounted and visible and only its intensity moves: changing the light count
+ * recompiles every material. The spot and shadow pools mount the first time a light needs them,
+ * and stay. Glows are one instanced sprite for every glowing lamp, pooled or not.
+ */
+export declare function PooledLights<T extends PooledLight>(props: Props<T>): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=pooled-lights.d.ts.map

package/dist/systems/item-light/pooled-lights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pooled-lights.d.ts","sourceRoot":"","sources":["../../../src/systems/item-light/pooled-lights.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAYjD,OAAO,EAEL,KAAK,MAAM,EAGX,OAAO,EAIP,KAAK,QAAQ,EAMb,OAAO,EACR,MAAM,cAAc,CAAA;AAMrB,oDAAoD;AACpD,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB,IAAI,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1C,wDAAwD;IACxD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,mEAAmE;IACnE,gBAAgB,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAA;IAC3C,2DAA2D;IAC3D,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;CAC3C,CAAA;AAED,KAAK,KAAK,CAAC,CAAC,SAAS,WAAW,IAAI;IAClC,SAAS,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAA;IAC5B;;;OAGG;IACH,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAA;IAC5B,uDAAuD;IACvD,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAA;CAChC,CAAA;AAmCD,KAAK,IAAI,GAAG;IAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAAA;AACnF,KAAK,SAAS,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAoBlD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,OAAO,GACf,MAAM,CAKR;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,IAAI,EAAE,EACb,MAAM,EAAE,SAAS,EAAE,EACnB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,QAiDnC;AAWD,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAI/F;AAuGD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,CAKhF;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,+BAKlE"}