@pascal-app/viewer 1.0.1 → 1.0.4

package/dist/systems/floor-elevation/floor-elevation-system.js

@@ -1,5 +1,7 @@
 import { getEffectiveNode, getFloorStackedPosition, nodeRegistry, sceneRegistry, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
+import { useEffect, useMemo } from 'react';
+import { Euler, Matrix4, Quaternion, Vector3 } from 'three';
 function withLiveTransform(node, liveTransform) {
     if (!liveTransform)
         return node;
@@ -15,6 +17,16 @@ function withLiveTransform(node, liveTransform) {
         ...(rotation !== undefined ? { rotation } : {}),
     };
 }
+function restoreMountedExitPose(saved) {
+    saved.mesh.matrixAutoUpdate = saved.autoUpdate;
+    saved.mesh.scale.copy(saved.scale);
+    if (!saved.mesh.parent || saved.mesh.parent === saved.parent) {
+        saved.mesh.position.copy(saved.position);
+        saved.mesh.quaternion.copy(saved.quaternion);
+    }
+    saved.mesh.updateMatrix();
+    saved.mesh.updateMatrixWorld(true);
+}
 /**
  * Generic floor-elevation system.
  *
@@ -31,11 +43,67 @@ function withLiveTransform(node, liveTransform) {
  * Runs at priority 1 — before the priority-2 systems (`GeometrySystem`,
  * `ItemSystem`) so the dirty mark survives long enough for those to do
  * their own work. Kinds with no geometry/system have no downstream dirty
- * consumer, so this system clears their dirty mark after applying the lift.
+ * consumer, so this system clears their dirty mark after applying the lift,
+ * at priority 2 like every other consumer: the node batch snapshots marks at
+ * priority 1, and a mark cleared there could run before that snapshot.
  */
 export const FloorElevationSystem = () => {
     const dirtyNodes = useScene((s) => s.dirtyNodes);
     const clearDirty = useScene((s) => s.clearDirty);
+    const consumed = useMemo(() => new Set(), []);
+    // Meshes already lifted once. A mesh mounts at its base Y, and a remount (entering Preview
+    // builds a fresh viewer tree) raises no dirty mark, so the lift would never be applied.
+    const mounted = useMemo(() => ({ revision: -1, meshes: new WeakSet() }), []);
+    const preview = useMemo(() => ({
+        local: new Matrix4(),
+        target: new Matrix4(),
+        position: new Vector3(),
+        rotation: new Euler(),
+        quaternion: new Quaternion(),
+        unit: new Vector3(1, 1, 1),
+        saved: new Map(),
+    }), []);
+    useEffect(() => {
+        const restore = (id) => {
+            const saved = preview.saved.get(id);
+            if (!saved)
+                return;
+            restoreMountedExitPose(saved);
+            preview.saved.delete(id);
+        };
+        const sync = () => {
+            const { nodes } = useScene.getState();
+            const overrides = useLiveNodeOverrides.getState().overrides;
+            for (const id of preview.saved.keys()) {
+                const node = nodes[id];
+                const patch = overrides.get(id);
+                if (!node || !patch?.parentId || patch.parentId === node.parentId)
+                    restore(id);
+            }
+            for (const [id, patch] of overrides) {
+                const node = nodes[id];
+                if (!node || !patch.parentId || patch.parentId === node.parentId || preview.saved.has(id))
+                    continue;
+                const mesh = sceneRegistry.nodes.get(id);
+                if (!mesh?.parent)
+                    continue;
+                preview.saved.set(id, {
+                    mesh,
+                    parent: mesh.parent,
+                    position: mesh.position.clone(),
+                    quaternion: mesh.quaternion.clone(),
+                    scale: mesh.scale.clone(),
+                    autoUpdate: mesh.matrixAutoUpdate,
+                });
+            }
+        };
+        const unsubscribe = useLiveNodeOverrides.subscribe(sync);
+        return () => {
+            unsubscribe();
+            for (const id of preview.saved.keys())
+                restore(id);
+        };
+    }, [preview]);
     useFrame(() => {
         // Nodes with a live preview (override / transform) are reapplied EVERY
         // frame, not only while dirty: the React commit that rebinds the group's
@@ -45,7 +113,8 @@ export const FloorElevationSystem = () => {
         // during group drags over elevated slabs).
         const overrides = useLiveNodeOverrides.getState().overrides;
         const transforms = useLiveTransforms.getState().transforms;
-        if (dirtyNodes.size === 0 && overrides.size === 0 && transforms.size === 0)
+        const registryChanged = sceneRegistry.revision !== mounted.revision;
+        if (dirtyNodes.size === 0 && overrides.size === 0 && transforms.size === 0 && !registryChanged)
             return;
         const nodes = useScene.getState().nodes;
         const applyLift = (id) => {
@@ -64,9 +133,13 @@ export const FloorElevationSystem = () => {
             const position = effectiveNode.position;
             if (!position)
                 return;
-            if (!(def.geometry || def.system) && dirtyNodes.has(id)) {
-                clearDirty(id);
-            }
+            if (effectiveNode.parentId !== node.parentId)
+                return;
+            // A mounted object still loading (a scripted column's artifact) keeps its mark, so
+            // scene-ready and bakes wait for it; settling marks the node dirty again.
+            const settled = def.capabilities?.batchable?.settled?.(mesh.userData) ?? true;
+            if (!(def.geometry || def.system) && dirtyNodes.has(id) && settled)
+                consumed.add(id);
             // `applies === false` means the kind opts OUT of floor stacking for this
             // node: its Y belongs to a host frame (a wall/ceiling-mounted item, a
             // cabinet module inside a run, a wall duct terminal). `getFloorPlacedElevation`
@@ -98,6 +171,20 @@ export const FloorElevationSystem = () => {
             });
             mesh.position.y = visualPosition[1];
         };
+        if (registryChanged) {
+            mounted.revision = sceneRegistry.revision;
+            for (const [kind, ids] of Object.entries(sceneRegistry.byType)) {
+                if (!nodeRegistry.get(kind)?.capabilities?.floorPlaced)
+                    continue;
+                for (const id of ids) {
+                    const mesh = sceneRegistry.nodes.get(id);
+                    if (!mesh || mounted.meshes.has(mesh))
+                        continue;
+                    mounted.meshes.add(mesh);
+                    applyLift(id);
+                }
+            }
+        }
         dirtyNodes.forEach((id) => {
             applyLift(id);
         });
@@ -110,5 +197,61 @@ export const FloorElevationSystem = () => {
                 applyLift(id);
         });
     }, 1);
+    useFrame(() => {
+        for (const id of consumed)
+            clearDirty(id);
+        consumed.clear();
+    }, 2);
+    // PostProcessing draws at priority 1 after this system; later callbacks would show one wrong frame per move.
+    useFrame(() => {
+        const nodes = useScene.getState().nodes;
+        for (const [id, patch] of useLiveNodeOverrides.getState().overrides) {
+            const node = nodes[id];
+            if (!node || !patch.parentId || patch.parentId === node.parentId)
+                continue;
+            const effective = getEffectiveNode(node);
+            if (effective.parentId === node.parentId || !effective.position)
+                continue;
+            if (!effective.parentId || nodes[effective.parentId]?.type !== 'level')
+                continue;
+            const mesh = sceneRegistry.nodes.get(id);
+            const level = sceneRegistry.nodes.get(effective.parentId);
+            if (!mesh?.parent || !level)
+                continue;
+            const previous = preview.saved.get(id);
+            if (previous?.mesh !== mesh) {
+                if (previous)
+                    restoreMountedExitPose(previous);
+                preview.saved.set(id, {
+                    mesh,
+                    parent: mesh.parent,
+                    position: mesh.position.clone(),
+                    quaternion: mesh.quaternion.clone(),
+                    scale: mesh.scale.clone(),
+                    autoUpdate: mesh.matrixAutoUpdate,
+                });
+            }
+            const position = getFloorStackedPosition({
+                node: effective,
+                nodes,
+                position: effective.position,
+            });
+            const rotation = typeof effective.rotation === 'number'
+                ? [0, effective.rotation, 0]
+                : (effective.rotation ?? [0, 0, 0]);
+            level.updateWorldMatrix(true, false);
+            mesh.parent.updateWorldMatrix(true, false);
+            // The override's parent is logical; the mesh still inherits the mounted host and surface wrapper.
+            preview.local
+                .copy(mesh.parent.matrixWorld)
+                .invert()
+                .multiply(level.matrixWorld)
+                .multiply(preview.target.compose(preview.position.fromArray(position), preview.quaternion.setFromEuler(preview.rotation.set(rotation[0], rotation[1], rotation[2])), preview.unit));
+            // Keep the full matrix: a rotated child beneath nonuniform scale can require shear.
+            mesh.matrixAutoUpdate = false;
+            mesh.matrix.copy(preview.local);
+            mesh.updateMatrixWorld(true);
+        }
+    }, 1);
     return null;
 };

package/dist/systems/geometry/geometry-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry-system.d.ts","sourceRoot":"","sources":["../../../src/systems/geometry/geometry-system.tsx"],"names":[],"mappings":"AAkBA,OAAO,EAAa,KAAK,KAAK,EAA4B,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAUtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,cAAc,YAuM1B,CAAA;AAiJD,eAAe,cAAc,CAAA;AAE7B,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,KAAK,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAU7D;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC3C,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,GACV,OAAO,CAKT"}
+{"version":3,"file":"geometry-system.d.ts","sourceRoot":"","sources":["../../../src/systems/geometry/geometry-system.tsx"],"names":[],"mappings":"AAkBA,OAAO,EAAa,KAAK,KAAK,EAA4B,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAatF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,cAAc,YA8N1B,CAAA;AA+KD,eAAe,cAAc,CAAA;AAE7B,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,KAAK,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAY7D;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC3C,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,GACV,OAAO,CAKT"}

package/dist/systems/geometry/geometry-system.js

@@ -4,8 +4,10 @@ import { useFrame } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import { FrontSide } from 'three';
 import { disposeObject3DResources } from '../../lib/dispose-object3d';
-import { createSurfaceRoleMaterial, } from '../../lib/materials';
+import { createSurfaceRoleMaterial, materialCastsShadow, } from '../../lib/materials';
+import { createNodeTopSurfaceHeightSampler } from '../../lib/node-top-surface-height';
 import { timeSpan } from '../../lib/perf-tracks';
+import { createSceneSupportHeightSampler } from '../../lib/scene-support-height';
 import useViewer from '../../store/use-viewer';
 /**
  * Generic geometry system.
@@ -55,6 +57,22 @@ export const GeometrySystem = () => {
     // but its geometry inputs are unchanged — e.g. an item reparenting onto a
     // shelf dirties the shelf without altering its boards.
     const builtGeometryKeyRef = useRef(new Map());
+    const liveBuildIds = useRef(new Set());
+    useEffect(() => {
+        const unsubscribe = useLiveNodeOverrides.subscribe((state, previous) => {
+            for (const id of new Set([...state.overrides.keys(), ...previous.overrides.keys()])) {
+                if (state.overrides.get(id) === previous.overrides.get(id))
+                    continue;
+                const node = useScene.getState().nodes[id];
+                if (node && nodeRegistry.get(node.type)?.geometry)
+                    liveBuildIds.current.add(id);
+            }
+        });
+        return () => {
+            unsubscribe();
+            liveBuildIds.current.clear();
+        };
+    }, []);
     // Re-mark every geometry-backed node dirty whenever a viewer appearance
     // value changes, so `def.geometry` builders re-run and pick up the new
     // shading / texture / preset / theme. These four are deliberate re-run
@@ -92,19 +110,23 @@ export const GeometrySystem = () => {
         }
     }, [sceneMaterials]);
     useFrame(() => {
-        if (dirtyNodes.size === 0)
+        if (dirtyNodes.size === 0 && liveBuildIds.current.size === 0)
             return;
         const nodes = useScene.getState().nodes;
         let rebuiltGeometry = false;
         const batches = new Map();
         const dirtyIds = [];
-        dirtyNodes.forEach((id) => {
+        for (const id of new Set([...dirtyNodes, ...liveBuildIds.current])) {
             const node = nodes[id];
-            if (!node)
-                return;
+            if (!node) {
+                liveBuildIds.current.delete(id);
+                continue;
+            }
             const def = nodeRegistry.get(node.type);
-            if (!def?.geometry)
-                return;
+            if (!def?.geometry) {
+                liveBuildIds.current.delete(id);
+                continue;
+            }
             dirtyIds.push(id);
             const parentId = (node.parentId ?? null);
             const key = `${node.type}::${parentId ?? ''}`;
@@ -113,7 +135,7 @@ export const GeometrySystem = () => {
                 existing.ids.push(id);
             else
                 batches.set(key, { kind: node.type, parentId, ids: [id] });
-        });
+        }
         // Phase 2 — for each batch whose kind declares `computeLevelData`,
         // collect every sibling in the level + run the precompute once.
         const levelDataByBatch = new Map();
@@ -170,7 +192,9 @@ export const GeometrySystem = () => {
                 const childLiveOverrideKey = liveChildOverrideKey(node);
                 const builtKey = `${shading}|${textures}|${colorPreset}|${sceneTheme}|${def.geometryKey(effectiveNode)}|${childLiveOverrideKey}`;
                 if (shouldReuseGeometryBuild(builtGeometryKeyRef.current, id, group, builtKey)) {
-                    clearDirty(id);
+                    liveBuildIds.current.delete(id);
+                    if (dirtyNodes.has(id))
+                        clearDirty(id);
                     continue;
                 }
             }
@@ -199,7 +223,9 @@ export const GeometrySystem = () => {
             // because the renderer doesn't necessarily re-render on the rebuild
             // tick, R3F wouldn't re-apply the props, leaving the group stuck at
             // origin. Geometry builders are expected to emit local-space children.
-            clearDirty(id);
+            liveBuildIds.current.delete(id);
+            if (dirtyNodes.has(id))
+                clearDirty(id);
         }
         if (rebuiltGeometry)
             bumpGeometryRevision();
@@ -281,7 +307,38 @@ function buildGeometryContext(node, nodes, levelData, materials) {
         noteLevelBaseConsumer(node.type);
         return levelId ? levelBaseElevationAt(nodes, levelId, x, z) : 0;
     };
-    return { resolve, children, siblings, parent, levelBaseAt, levelData, materials };
+    const surfaceSamplers = new Map();
+    const surfaceHeightAt = (hostId, x, z) => {
+        if (!levelId)
+            return null;
+        if (!surfaceSamplers.has(hostId)) {
+            surfaceSamplers.set(hostId, createNodeTopSurfaceHeightSampler(hostId, levelId));
+        }
+        return surfaceSamplers.get(hostId)?.(x, z) ?? null;
+    };
+    const supportSamplers = new Map();
+    const supportHeightAt = (x, z, selectedHostId) => {
+        if (!levelId)
+            return levelBaseAt(x, z);
+        const key = selectedHostId ?? 'auto';
+        let sampler = supportSamplers.get(key);
+        if (!sampler) {
+            sampler = createSceneSupportHeightSampler(nodes, levelId, selectedHostId);
+            supportSamplers.set(key, sampler);
+        }
+        return sampler(x, z);
+    };
+    return {
+        resolve,
+        children,
+        siblings,
+        parent,
+        levelBaseAt,
+        surfaceHeightAt,
+        supportHeightAt,
+        levelData,
+        materials,
+    };
 }
 function disposeChildren(group) {
     // Only dispose meshes the geometry builder produced on the previous
@@ -330,6 +387,9 @@ export function markGeometryBuildOutput(child) {
     // example a cabinet sink faucet handle), while disposal still removes only
     // top-level builder children from the registered group.
     child.traverse((object) => {
+        const mesh = object;
+        if (mesh.isMesh)
+            mesh.castShadow = mesh.castShadow && materialCastsShadow(mesh.material);
         object.userData = {
             ...object.userData,
             __fromGeometry: true,

package/dist/systems/interactive/interactive-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interactive-system.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/interactive-system.tsx"],"names":[],"mappings":"AAiCA,eAAO,MAAM,iBAAiB,mCAsB7B,CAAA"}
+{"version":3,"file":"interactive-system.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/interactive-system.tsx"],"names":[],"mappings":"AAmCA,eAAO,MAAM,iBAAiB,mCAmC7B,CAAA"}

package/dist/systems/interactive/interactive-system.js

@@ -1,27 +1,27 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { pointInPolygon, sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
+import { evaluateRecipe, operableParts, } from '@pascal-app/core/procedural-items';
 import { Html } from '@react-three/drei';
 import { createPortal, useFrame } from '@react-three/fiber';
-import { useEffect, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 import { Vector3 } from 'three';
 import { useShallow } from 'zustand/react/shallow';
 import useViewer from '../../store/use-viewer';
 import { ControlWidget } from './control-widget';
+import { proceduralControlDescriptors } from './procedural-controls';
 const _tempVec = new Vector3();
-// ---- Parent: one overlay per interactive item inside the selected zone ----
+// ---- Parent: overlays for selected interactive items and the selected zone ----
 //
-// The <Html> overlays only exist while a zone is selected and the item sits
-// inside it. Mounting them unconditionally is not an option: each drei <Html>
+// Mounting <Html> overlays unconditionally is not an option: each drei <Html>
 // repositions and re-sorts its DOM element on every camera-move frame, and
 // with `occlude` it also raycasts the entire scene per overlay per frame. On
 // large scenes (hundreds of interactive items) that starves the frame budget
 // and the display/z-index churn makes the whole DOM UI flicker.
 //
-// The child components stay rendered (returning null) so an overlay can fade
-// out before its <Html> unmounts.
 export const InteractiveSystem = () => {
     const zoneId = useViewer((s) => s.selection.zoneId);
+    const selectedIds = useViewer((s) => s.selection.selectedIds);
     const zonePolygon = useScene((s) => {
         if (!zoneId)
             return null;
@@ -29,13 +29,17 @@ export const InteractiveSystem = () => {
         return z?.polygon ?? null;
     });
     const interactiveNodeIds = useScene(useShallow((state) => Object.values(state.nodes)
-        .filter((n) => n.type === 'item' && n.asset.interactive != null)
+        .filter((n) => (n.type === 'item' && n.asset.interactive != null) ||
+        (n.type === 'procedural-item' &&
+            (operableParts(n.recipe).length > 0 || n.recipe.parts.some((part) => part.light))))
         .map((n) => n.id)));
-    return (_jsx(_Fragment, { children: interactiveNodeIds.map((id) => (_jsx(ItemControlsOverlay, { nodeId: id, zonePolygon: zonePolygon }, id))) }));
+    return (_jsx(_Fragment, { children: interactiveNodeIds
+            .filter((id) => zonePolygon?.length || selectedIds.includes(id))
+            .map((id) => (_jsx(ItemControlsOverlay, { isSelected: selectedIds.includes(id), nodeId: id, zonePolygon: zonePolygon }, id))) }));
 };
 // ---- Child: polls sceneRegistry then portals controls into the item group ----
 const FADE_MS = 300;
-const ItemControlsOverlay = ({ nodeId, zonePolygon, }) => {
+const ItemControlsOverlay = ({ nodeId, zonePolygon, isSelected, }) => {
     const node = useScene((state) => state.nodes[nodeId]);
     const [itemObj, setItemObj] = useState(null);
     useFrame(() => {
@@ -46,11 +50,34 @@ const ItemControlsOverlay = ({ nodeId, zonePolygon, }) => {
             setItemObj(obj);
     });
     const controlValues = useInteractive(useShallow((state) => state.items[nodeId]?.controlValues));
+    const proceduralState = useInteractive((state) => state.procedural[nodeId]);
+    const lampDefault = useInteractive((state) => state.lampDefault);
     const setControlValue = useInteractive((state) => state.setControlValue);
-    let visible = false;
+    const togglePart = useInteractive((state) => state.toggleProceduralPart);
+    const toggleLights = useInteractive((state) => state.toggleProceduralLights);
+    const proceduralHeight = useMemo(() => node?.type === 'procedural-item' ? evaluateRecipe(node.recipe, node.parameters).max[1] : 0, [
+        node?.type === 'procedural-item' ? node.recipe : null,
+        node?.type === 'procedural-item' ? node.parameters : null,
+    ]);
+    let descriptors = [];
+    let height = 0;
+    if (node?.type === 'item' && node.asset.interactive && controlValues) {
+        descriptors = node.asset.interactive.controls.map((control, i) => ({
+            key: String(i),
+            control,
+            value: controlValues[i] ?? false,
+            onChange: (value) => setControlValue(nodeId, i, value),
+        }));
+        height = node.asset.dimensions[1];
+    }
+    else if (node?.type === 'procedural-item') {
+        descriptors = proceduralControlDescriptors(node.recipe, proceduralState, (partId) => togglePart(nodeId, partId), () => toggleLights(nodeId), lampDefault);
+        height = proceduralHeight;
+    }
+    let visible = isSelected;
     if (itemObj && zonePolygon?.length) {
         itemObj.getWorldPosition(_tempVec);
-        visible = pointInPolygon(_tempVec.x, _tempVec.z, zonePolygon);
+        visible = visible || pointInPolygon(_tempVec.x, _tempVec.z, zonePolygon);
     }
     // Fade in on mount and fade out before unmounting the <Html>.
     const [mounted, setMounted] = useState(false);
@@ -73,10 +100,8 @@ const ItemControlsOverlay = ({ nodeId, zonePolygon, }) => {
         const timeout = setTimeout(() => setMounted(false), FADE_MS);
         return () => clearTimeout(timeout);
     }, [visible]);
-    if (!(mounted && itemObj && controlValues && node?.asset.interactive))
+    if (!(mounted && itemObj && descriptors.length))
         return null;
-    const { controls } = node.asset.interactive;
-    const [, height] = node.asset.dimensions;
     return createPortal(_jsx(Html, { center: true, distanceFactor: 8, eps: -1, position: [0, height + 0.3, 0], zIndexRange: [20, 0], children: _jsx("div", { style: {
                 display: 'flex',
                 flexDirection: 'column',
@@ -90,5 +115,5 @@ const ItemControlsOverlay = ({ nodeId, zonePolygon, }) => {
                 userSelect: 'none',
                 opacity: shown ? 1 : 0,
                 transition: `opacity ${FADE_MS}ms ease`,
-            }, children: controls.map((control, i) => (_jsx(ControlWidget, { control: control, onChange: (v) => setControlValue(nodeId, i, v), value: controlValues[i] ?? false }, i))) }) }), itemObj);
+            }, children: descriptors.map((descriptor) => (_jsx(ControlWidget, { control: descriptor.control, onChange: descriptor.onChange, value: descriptor.value }, descriptor.key))) }) }), itemObj);
 };

package/dist/systems/interactive/procedural-controls.d.ts

@@ -0,0 +1,13 @@
+import type { Control, ControlValue } from '@pascal-app/core';
+import { type ProceduralItemNode } from '@pascal-app/core/procedural-items';
+export type ControlDescriptor = {
+    key: string;
+    control: Control;
+    value: ControlValue;
+    onChange: (value: ControlValue) => void;
+};
+export declare function proceduralControlDescriptors(recipe: Pick<ProceduralItemNode['recipe'], 'parts' | 'joints'>, state: {
+    parts: Record<string, boolean>;
+    lightsOn: boolean;
+} | undefined, togglePart: (partId: string) => void, toggleLights: () => void, lampDefault?: boolean): ControlDescriptor[];
+//# sourceMappingURL=procedural-controls.d.ts.map

package/dist/systems/interactive/procedural-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedural-controls.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/procedural-controls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC7D,OAAO,EAAiB,KAAK,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE1F,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,YAAY,CAAA;IACnB,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;CACxC,CAAA;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC,EAC9D,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,EACxE,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACpC,YAAY,EAAE,MAAM,IAAI,EACxB,WAAW,UAAQ,GAClB,iBAAiB,EAAE,CAerB"}

package/dist/systems/interactive/procedural-controls.js

@@ -0,0 +1,17 @@
+import { operableParts } from '@pascal-app/core/procedural-items';
+export function proceduralControlDescriptors(recipe, state, togglePart, toggleLights, lampDefault = false) {
+    const controls = operableParts(recipe).map((part) => ({
+        key: part.id,
+        control: { kind: 'toggle', label: part.label },
+        value: state?.parts[part.id] ?? part.kind === 'spin',
+        onChange: () => togglePart(part.id),
+    }));
+    if (recipe.parts.some((part) => part.light))
+        controls.push({
+            key: 'lights',
+            control: { kind: 'toggle', label: 'Lights' },
+            value: state?.lightsOn ?? lampDefault,
+            onChange: toggleLights,
+        });
+    return controls;
+}

package/dist/systems/interactive/scripted-clips.d.ts

@@ -0,0 +1,19 @@
+import { type AnyNodeId, type Interactive } from '@pascal-app/core';
+import { type RefObject } from 'react';
+import { type AnimationAction, type AnimationClip, Object3D } from 'three';
+/** Actions keyed by the clip names the script wrote (`open`, `loop`, `Princess twirl`). */
+export type ScriptedClipActions = Record<string, AnimationAction | null | undefined>;
+/** Own the action cache so replacing clips cannot retain bindings to an old artifact. */
+export declare function useClipActions(clips: AnimationClip[], root: RefObject<Object3D | null>): Record<string, AnimationAction | null>;
+/**
+ * An authored object's clips, each driven by its own toggle: an open-close
+ * effect plays `open` once and holds, closing plays `close` or `open` reversed;
+ * an ambient effect plays its clip while its toggle is on (always, for `loop`).
+ * Shared by the live item renderer and the baked viewer.
+ */
+export declare function ScriptedClips({ nodeId, interactive, actions, }: {
+    nodeId: AnyNodeId;
+    interactive: Interactive;
+    actions: ScriptedClipActions;
+}): import("react").JSX.Element;
+//# sourceMappingURL=scripted-clips.d.ts.map

package/dist/systems/interactive/scripted-clips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scripted-clips.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/scripted-clips.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,WAAW,EAEjB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,KAAK,SAAS,EAA+C,MAAM,OAAO,CAAA;AACnF,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,aAAa,EAIlB,QAAQ,EACT,MAAM,OAAO,CAAA;AAEd,2FAA2F;AAC3F,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,CAAC,CAAA;AAEpF,yFAAyF;AACzF,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,QAAQ,GAAG,IAAI,CAAC,0CAoCtF;AAQD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,WAAW,EACX,OAAO,GACR,EAAE;IACD,MAAM,EAAE,SAAS,CAAA;IACjB,WAAW,EAAE,WAAW,CAAA;IACxB,OAAO,EAAE,mBAAmB,CAAA;CAC7B,+BAoBA"}

package/dist/systems/interactive/scripted-clips.js

@@ -0,0 +1,134 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useInteractive, } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import { AnimationMixer, LoopOnce, LoopRepeat, Object3D, } from 'three';
+/** Own the action cache so replacing clips cannot retain bindings to an old artifact. */
+export function useClipActions(clips, root) {
+    const { mixer, actions, cached, lifecycle } = useMemo(() => {
+        const mixer = new AnimationMixer(new Object3D());
+        const cached = new Map();
+        const lifecycle = { active: true };
+        const actions = {};
+        for (const clip of clips) {
+            Object.defineProperty(actions, clip.name, {
+                enumerable: true,
+                configurable: true,
+                get: () => {
+                    if (!lifecycle.active || !root.current)
+                        return null;
+                    let action = cached.get(clip.name);
+                    if (!action) {
+                        action = mixer.clipAction(clip, root.current);
+                        cached.set(clip.name, action);
+                    }
+                    return action;
+                },
+            });
+        }
+        return { mixer, actions, cached, lifecycle };
+    }, [clips, root]);
+    useFrame((_, delta) => mixer.update(delta));
+    useLayoutEffect(() => {
+        lifecycle.active = true;
+        return () => {
+            // React's development prop diff can read old getters after cleanup.
+            lifecycle.active = false;
+            mixer.stopAllAction();
+            const roots = new Set([...cached.values()].map((action) => action.getRoot()));
+            cached.clear();
+            for (const object of roots)
+                mixer.uncacheRoot(object);
+        };
+    }, [mixer, cached, lifecycle]);
+    return actions;
+}
+/** Whether an effect's toggle is on; an effect without one always runs. */
+const useEffectControl = (nodeId, control) => useInteractive((s) => control === undefined ? true : Boolean(s.items[nodeId]?.controlValues[control]));
+/**
+ * An authored object's clips, each driven by its own toggle: an open-close
+ * effect plays `open` once and holds, closing plays `close` or `open` reversed;
+ * an ambient effect plays its clip while its toggle is on (always, for `loop`).
+ * Shared by the live item renderer and the baked viewer.
+ */
+export function ScriptedClips({ nodeId, interactive, actions, }) {
+    const effects = interactive.effects.filter((effect) => effect.kind === 'animation');
+    return (_jsx(_Fragment, { children: effects.map((effect) => effect.mode === 'open-close' ? (_jsx(OpenCloseClip, { actions: actions, effect: effect, nodeId: nodeId }, effect.clips.on)) : (_jsx(PlayClip, { actions: actions, effect: effect, nodeId: nodeId }, effect.clips.on ?? effect.clips.loop))) }));
+}
+const PlayClip = ({ nodeId, effect, actions, }) => {
+    const on = useEffectControl(nodeId, effect.control);
+    const name = effect.clips.on ?? effect.clips.loop;
+    useEffect(() => {
+        const action = name ? actions[name] : undefined;
+        return () => {
+            action?.stop();
+        };
+    }, [actions, name]);
+    useEffect(() => {
+        const action = name ? actions[name] : undefined;
+        if (!action)
+            return;
+        if (on) {
+            action.setLoop(LoopRepeat, Number.POSITIVE_INFINITY);
+            action.clampWhenFinished = false;
+            action.paused = false;
+            action.play();
+        }
+        else {
+            // Hold the pose where it was, like pausing a music box.
+            action.paused = true;
+        }
+    }, [actions, name, on]);
+    return null;
+};
+const OpenCloseClip = ({ nodeId, effect, actions, }) => {
+    const isOpen = useEffectControl(nodeId, effect.control);
+    const mounted = useRef(false);
+    useEffect(() => {
+        const open = effect.clips.on ? actions[effect.clips.on] : undefined;
+        const close = effect.clips.off ? actions[effect.clips.off] : undefined;
+        return () => {
+            open?.stop();
+            close?.stop();
+            mounted.current = false;
+        };
+    }, [actions, effect.clips.on, effect.clips.off]);
+    useEffect(() => {
+        const open = effect.clips.on ? actions[effect.clips.on] : undefined;
+        const close = effect.clips.off ? actions[effect.clips.off] : undefined;
+        if (!open)
+            return;
+        const first = !mounted.current;
+        mounted.current = true;
+        for (const action of [open, close]) {
+            if (!action)
+                continue;
+            action.setLoop(LoopOnce, 1);
+            action.clampWhenFinished = true;
+        }
+        if (isOpen) {
+            close?.stop();
+            open.paused = false;
+            open.timeScale = 1;
+            if (!open.isRunning())
+                open.reset();
+            open.play();
+            // Already open when the scene loads: hold the open pose, no swing.
+            if (first)
+                open.time = open.getClip().duration;
+            return;
+        }
+        if (first)
+            return;
+        if (close) {
+            open.stop();
+            close.reset().play();
+            return;
+        }
+        open.paused = false;
+        open.timeScale = -1;
+        open.play();
+    }, [actions, effect.clips.on, effect.clips.off, isOpen]);
+    return null;
+};