@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/procedural-item/geometry.js

@@ -1,7 +1,182 @@
-import { evaluateRecipe, } from '@pascal-app/core/procedural-items';
-import { BoxGeometry, CylinderGeometry, Euler, Matrix4, Quaternion, Vector3, } from 'three';
+import { evaluateRecipe, revolveIsClosed, sectionRings, usesPartTree, } from '@pascal-app/core/procedural-items';
+import { BoxGeometry, BufferGeometry, CylinderGeometry, Euler, ExtrudeGeometry, Float32BufferAttribute, LatheGeometry, Matrix4, Path, Quaternion, Shape, SphereGeometry, Vector2, Vector3, } from 'three';
 import { RoundedBoxGeometry } from 'three/addons/geometries/RoundedBoxGeometry.js';
 import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js';
+const TAU = 2 * Math.PI;
+function flipped(geometry) {
+    const flat = geometry.index ? geometry.toNonIndexed() : geometry.clone();
+    if (geometry.index)
+        geometry.dispose();
+    for (const name of ['position', 'normal', 'uv']) {
+        const attribute = flat.getAttribute(name);
+        for (let i = 0; i < attribute.count; i += 3)
+            for (let k = 0; k < attribute.itemSize; k++) {
+                const a = attribute.getComponent(i + 1, k);
+                attribute.setComponent(i + 1, k, attribute.getComponent(i + 2, k));
+                attribute.setComponent(i + 2, k, a);
+            }
+    }
+    const normal = flat.getAttribute('normal');
+    for (let i = 0; i < normal.count; i++)
+        normal.setXYZ(i, -normal.getX(i), -normal.getY(i), -normal.getZ(i));
+    return flat;
+}
+/** Flat triangles facing `normal` (winding fixed per triangle), with placeholder UVs. */
+function facing(triangles, normal) {
+    const position = [], normals = [];
+    const ab = new Vector3(), ac = new Vector3();
+    for (const triangle of triangles) {
+        const want = normal(triangle);
+        const face = ab
+            .subVectors(triangle[1], triangle[0])
+            .cross(ac.subVectors(triangle[2], triangle[0]));
+        const [a, b, c] = face.dot(want) < 0
+            ? [triangle[0], triangle[2], triangle[1]]
+            : [triangle[0], triangle[1], triangle[2]];
+        for (const v of [a, b, c]) {
+            position.push(v.x, v.y, v.z);
+            normals.push(want.x, want.y, want.z);
+        }
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(position, 3));
+    geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
+    geometry.setAttribute('uv', new Float32BufferAttribute(new Float32Array((position.length / 3) * 2), 2));
+    return geometry;
+}
+// A unit cylinder (diameter 1, height 1, centred) with v2's segments, open, inner and arc.
+// Counts match `shapeTriangles`; with no options this is exactly today's 24-gon.
+function cylinderSource(shape) {
+    const { segments = 24, open = false, inner, arc = TAU } = shape;
+    const top = 0.5 * shape.topScale;
+    if (shape.segments === undefined && !open && inner === undefined && shape.arc === undefined)
+        return new CylinderGeometry(top, 0.5, 1, 24, 1);
+    const hollow = inner !== undefined;
+    const pieces = [
+        new CylinderGeometry(top, 0.5, 1, segments, 1, open || hollow, 0, arc).toNonIndexed(),
+    ];
+    const at = (radius, theta, y) => new Vector3(radius * Math.sin(theta), y, radius * Math.cos(theta));
+    // Materials are front-sided, so an open solid also draws the back of its wall.
+    if (open && !hollow)
+        pieces.push(flipped(new CylinderGeometry(top, 0.5, 1, segments, 1, true, 0, arc)));
+    if (hollow) {
+        pieces.push(flipped(new CylinderGeometry(top * inner, 0.5 * inner, 1, segments, 1, true, 0, arc)));
+        if (!open)
+            for (const [y, outer] of [
+                [-0.5, 0.5],
+                [0.5, top],
+            ]) {
+                if (outer === 0)
+                    continue;
+                const rings = [];
+                for (let i = 0; i < segments; i++) {
+                    const a = (arc * i) / segments, b = (arc * (i + 1)) / segments;
+                    const quad = [
+                        at(outer * inner, a, y),
+                        at(outer, a, y),
+                        at(outer, b, y),
+                        at(outer * inner, b, y),
+                    ];
+                    rings.push([quad[0], quad[1], quad[2]], [quad[0], quad[2], quad[3]]);
+                }
+                pieces.push(facing(rings, () => new Vector3(0, Math.sign(y), 0)));
+            }
+    }
+    if (arc < TAU - 1e-9 && !open)
+        for (const theta of [0, arc]) {
+            const from = hollow ? inner : 0;
+            const quad = [
+                at(0.5 * from, theta, -0.5),
+                at(0.5, theta, -0.5),
+                at(top, theta, 0.5),
+                at(top * from, theta, 0.5),
+            ];
+            const outward = new Vector3(Math.cos(theta), 0, -Math.sin(theta)).multiplyScalar(theta === 0 ? -1 : 1);
+            pieces.push(facing([
+                [quad[0], quad[1], quad[2]],
+                [quad[0], quad[2], quad[3]],
+            ], () => outward));
+        }
+    const merged = mergeGeometries(pieces, false);
+    for (const piece of pieces)
+        piece.dispose();
+    return merged;
+}
+/** v2 geometry (cylinder options and later primitives); v1 shapes keep their projection. */
+function usesV2Geometry(shape) {
+    return (shape.primitive === 'extrude' ||
+        shape.primitive === 'revolve' ||
+        (shape.primitive === 'cylinder' &&
+            [shape.segments, shape.open, shape.inner, shape.arc].some((v) => v !== undefined)));
+}
+/**
+ * World-scale UVs from each triangle's own frame, in metres: u runs horizontally across the
+ * face (or along x on a level face), v = normal × u. Same contract as block faces.
+ */
+function faceFrameUvs(geometry) {
+    const position = geometry.getAttribute('position'), uv = geometry.getAttribute('uv');
+    const a = new Vector3(), b = new Vector3(), c = new Vector3(), n = new Vector3(), u = new Vector3(), v = new Vector3();
+    const up = new Vector3(0, 1, 0);
+    for (let t = 0; t < position.count; t += 3) {
+        a.fromBufferAttribute(position, t);
+        b.fromBufferAttribute(position, t + 1);
+        c.fromBufferAttribute(position, t + 2);
+        n.subVectors(b, a).cross(v.subVectors(c, a));
+        if (n.lengthSq() < 1e-20)
+            n.set(0, 0, 1);
+        n.normalize();
+        if (Math.abs(n.y) > 0.99)
+            u.set(1, 0, 0);
+        else
+            u.crossVectors(up, n).normalize();
+        v.crossVectors(n, u);
+        for (let k = 0; k < 3; k++) {
+            const p = [a, b, c][k];
+            uv.setXY(t + k, p.dot(u), p.dot(v));
+        }
+    }
+    uv.needsUpdate = true;
+}
+// The evaluated section, centred in its box, extruded along z over size[2]. A bevel shrinks the
+// outline by its size, then bevels back out, so the box does not grow.
+function extrudeSource(shape) {
+    const { outer, holes } = sectionRings(shape.section);
+    const outline = new Shape(outer.map(([x, y]) => new Vector2(x, y)));
+    outline.holes = holes.map((hole) => new Path(hole.map(([x, y]) => new Vector2(x, y))));
+    const bevel = shape.bevel ?? 0;
+    const depth = shape.size[2] - 2 * bevel;
+    const geometry = new ExtrudeGeometry(outline, {
+        depth,
+        steps: 1,
+        curveSegments: 1,
+        bevelEnabled: bevel > 0,
+        bevelThickness: bevel,
+        bevelSize: bevel,
+        bevelOffset: -bevel,
+        bevelSegments: 2,
+    });
+    geometry.translate(0, 0, -depth / 2);
+    return geometry;
+}
+// The profile turned about local Y. LatheGeometry's normals face away from the region the
+// profile encloses with the axis, so the profile runs counter-clockwise around it. An open
+// surface (off the axis at an end, or a partial turn) also draws its back face.
+function revolveSource(shape) {
+    const { segments = 24, arc = TAU } = shape;
+    const points = shape.profile.map(([r, y]) => new Vector2(r, y));
+    const closure = [...points, new Vector2(0, points.at(-1).y), new Vector2(0, points[0].y)];
+    let twice = 0;
+    for (let k = 0; k < closure.length; k++)
+        twice += closure[k].cross(closure[(k + 1) % closure.length]);
+    if (twice < 0)
+        points.reverse();
+    const outer = new LatheGeometry(points, segments, 0, arc).toNonIndexed();
+    if (revolveIsClosed(shape))
+        return outer;
+    const both = mergeGeometries([outer, flipped(outer)], false);
+    outer.dispose();
+    return both;
+}
 export const proceduralMetrics = { builds: 0, cacheHits: 0, lastBuildMs: 0, liveEntries: 0 };
 const cache = new Map();
 export const geometrySignature = (node) => JSON.stringify([node.recipe, node.parameters]);
@@ -13,29 +188,62 @@ export function buildProceduralGeometry(node) {
         const source = shape.primitive === 'roundedBox'
             ? new RoundedBoxGeometry(w, h, d, 2, shape.radius)
             : shape.primitive === 'cylinder'
-                ? new CylinderGeometry(0.5, 0.5, 1, 24, 1)
-                : new BoxGeometry(w, h, d);
-        if (shape.primitive === 'cylinder')
+                ? cylinderSource(shape)
+                : shape.primitive === 'extrude'
+                    ? extrudeSource(shape)
+                    : shape.primitive === 'revolve'
+                        ? revolveSource(shape)
+                        : shape.primitive === 'ellipsoid'
+                            ? new SphereGeometry(0.5, 24, 16)
+                            : new BoxGeometry(w, h, d);
+        if (shape.primitive === 'cylinder' || shape.primitive === 'ellipsoid')
             source.scale(w, h, d);
         const geometry = source.index ? source.toNonIndexed() : source;
         if (geometry !== source)
             source.dispose();
         geometry.clearGroups();
-        const vertices = geometry.getAttribute('position'), normals = geometry.getAttribute('normal'), uv = geometry.getAttribute('uv');
-        for (let i = 0; i < vertices.count; i++) {
-            const x = vertices.getX(i), y = vertices.getY(i), z = vertices.getZ(i);
-            const nx = Math.abs(normals.getX(i)), ny = Math.abs(normals.getY(i)), nz = Math.abs(normals.getZ(i));
-            uv.setXY(i, nx > ny && nx > nz ? z : x, ny > nx && ny > nz ? z : y);
+        if (usesV2Geometry(shape))
+            faceFrameUvs(geometry);
+        else {
+            const vertices = geometry.getAttribute('position'), normals = geometry.getAttribute('normal'), uv = geometry.getAttribute('uv');
+            for (let i = 0; i < vertices.count; i++) {
+                const x = vertices.getX(i), y = vertices.getY(i), z = vertices.getZ(i);
+                const nx = Math.abs(normals.getX(i)), ny = Math.abs(normals.getY(i)), nz = Math.abs(normals.getZ(i));
+                uv.setXY(i, nx > ny && nx > nz ? z : x, ny > nx && ny > nz ? z : y);
+            }
         }
         geometry.applyMatrix4(new Matrix4().compose(new Vector3(...shape.position), new Quaternion().setFromEuler(new Euler(...shape.rotation)), new Vector3(1, 1, 1)));
-        const entry = bySlot.get(shape.slot) ?? { geometries: [], ranges: [], faces: 0 };
+        const key = JSON.stringify([shape.motionGroup ?? null, shape.slot]);
+        const entry = bySlot.get(key) ?? { geometries: [], ranges: [], faces: 0 };
         entry.geometries.push(geometry);
         entry.faces += geometry.getAttribute('position').count / 3;
         entry.ranges.push({ end: entry.faces, partId: shape.partId, shapeId: shape.id });
-        bySlot.set(shape.slot, entry);
+        bySlot.set(key, entry);
+    }
+    // Joint trees split into many groups; idle, they draw as one mesh per slot instead.
+    let rest;
+    if (usesPartTree(node.recipe) && evaluation.motions.length) {
+        const restBySlot = new Map();
+        for (const [key, entry] of bySlot) {
+            const slot = JSON.parse(key)[1];
+            const merged = restBySlot.get(slot) ?? { geometries: [], ranges: [] };
+            const offset = merged.ranges.at(-1)?.end ?? 0;
+            merged.geometries.push(...entry.geometries);
+            merged.ranges.push(...entry.ranges.map((range) => ({ ...range, end: range.end + offset })));
+            restBySlot.set(slot, merged);
+        }
+        rest = [...restBySlot].map(([slot, entry]) => {
+            const geometry = mergeGeometries(entry.geometries, false);
+            if (!geometry)
+                throw new Error('Unable to batch procedural geometry');
+            geometry.computeBoundingBox();
+            geometry.computeBoundingSphere();
+            return { slot, geometry, ranges: entry.ranges };
+        });
     }
     const batches = [];
-    for (const [slot, entry] of bySlot) {
+    for (const [key, entry] of bySlot) {
+        const [motionGroup, slot] = JSON.parse(key);
         const geometry = mergeGeometries(entry.geometries, false);
         for (const g of entry.geometries)
             g.dispose();
@@ -43,13 +251,27 @@ export function buildProceduralGeometry(node) {
             throw new Error('Unable to batch procedural geometry');
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
-        batches.push({ slot, geometry, ranges: entry.ranges });
+        // Catalog captures and placement previews consume geometry in design coordinates.
+        const pivot = evaluation.motions.find((motion) => motion.id === motionGroup)?.pivot;
+        const motionGeometry = pivot
+            ? geometry.clone().translate(-pivot[0], -pivot[1], -pivot[2])
+            : undefined;
+        motionGeometry?.computeBoundingBox();
+        motionGeometry?.computeBoundingSphere();
+        batches.push({
+            slot,
+            motionGroup: motionGroup ?? undefined,
+            geometry,
+            motionGeometry,
+            ranges: entry.ranges,
+        });
     }
     const milliseconds = performance.now() - start;
     proceduralMetrics.builds++;
     proceduralMetrics.lastBuildMs = milliseconds;
     return {
         batches,
+        ...(rest && { rest }),
         evaluation,
         milliseconds,
         triangles: batches.reduce((n, b) => n + b.geometry.getAttribute('position').count / 3, 0),
@@ -75,8 +297,10 @@ export function acquireProceduralGeometry(node) {
             released = true;
             const current = cache.get(key);
             if (current && --current.users === 0) {
-                for (const batch of current.value.batches)
+                for (const batch of [...current.value.batches, ...(current.value.rest ?? [])]) {
                     batch.geometry.dispose();
+                    batch.motionGeometry?.dispose();
+                }
                 cache.delete(key);
             }
             proceduralMetrics.liveEntries = cache.size;

package/dist/procedural-item/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/procedural-item/renderer.tsx"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,kBAAkB,EAAuB,MAAM,mCAAmC,CAAA;AAahG,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,+BA8FhF"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/procedural-item/renderer.tsx"],"names":[],"mappings":"AAUA,OAAO,EAIL,KAAK,kBAAkB,EAGxB,MAAM,mCAAmC,CAAA;AA0C1C,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,+BA4VhF"}

package/dist/procedural-item/renderer.js

@@ -1,17 +1,53 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useLiveNodeOverrides, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
-import { proceduralLocalPose } from '@pascal-app/core/procedural-items';
-import { createSurfaceRoleMaterial, NodeRenderer, resolveMaterialRef, resolveSlotDefaultMaterial, useLibraryMaterialsVersion, useNodeEvents, useViewer, } from '@pascal-app/viewer';
-import { useLayoutEffect, useMemo, useRef, useState } from 'react';
-import { Mesh } from 'three';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useInteractive, useLiveNodeOverrides, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
+import { motionAxis, motionRestOffset, ProceduralMotionController, proceduralLocalPose, } from '@pascal-app/core/procedural-items';
+import { usePlacementPreview } from '@pascal-app/editor';
+import { cloneWithProceduralEmission, createSurfaceRoleMaterial, materialCastsShadow, NodeRenderer, proceduralSlotMeshes, resolveMaterialRef, resolveSlotDefaultMaterial, setProceduralEmission, useItemLightPool, useLibraryMaterialsVersion, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { useFrame, useThree } from '@react-three/fiber';
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { Mesh, Vector3 } from 'three';
+import { canRegisterItemLight } from '../shared/item-light-placement';
+import { releaseFromBatch } from '../shared/node-batch/release';
+import { setProceduralMotionPlaying } from './animation';
 import { acquireProceduralGeometry, geometrySignature } from './geometry';
+const axis = new Vector3();
+const noRaycast = () => { };
+// What a hidden mesh raycast with, which may be SceneBVH's accelerated raycast.
+const hiddenRaycasts = new WeakMap();
+// Hidden mesh sets are skipped by raycasts too (three raycasts invisible objects).
+function setDrawn(container, drawn) {
+    container.visible = drawn;
+    container.traverse((child) => {
+        if (!(child instanceof Mesh))
+            return;
+        if (drawn) {
+            child.raycast = hiddenRaycasts.get(child) ?? child.raycast;
+            hiddenRaycasts.delete(child);
+        }
+        else if (child.raycast !== noRaycast) {
+            hiddenRaycasts.set(child, child.raycast);
+            child.raycast = noRaycast;
+        }
+    });
+}
 export default function ProceduralRenderer({ node }) {
     const ref = useRef(null);
+    // Part-tree designs draw their merged rest pose while idle and their joint groups while moving.
+    const restRef = useRef(null);
+    const splitRef = useRef(null);
+    const controller = useRef(null);
+    const lastCommand = useRef(0);
+    const awake = useRef(false);
+    const invalidate = useThree((state) => state.invalidate);
     const overrides = useLiveNodeOverrides((s) => s.overrides.get(node.id));
     const live = useLiveTransforms((s) => s.get(node.id));
     const effective = { ...node, ...overrides };
-    const host = useScene((s) => (node.parentId ? s.nodes[node.parentId] : undefined));
+    // Only wall and ceiling hosts pose a design; a level host changes with every child it gains.
+    const host = useScene((s) => {
+        const parent = node.parentId ? s.nodes[node.parentId] : undefined;
+        return parent?.type === 'wall' || parent?.type === 'ceiling' ? parent : undefined;
+    });
     const hostOverride = useLiveNodeOverrides((s) => node.parentId ? s.overrides.get(node.parentId) : undefined);
     const pose = proceduralLocalPose(effective, host ? { [host.id]: { ...host, ...hostOverride } } : {});
     const sceneMaterials = useScene((s) => s.materials);
@@ -19,47 +55,260 @@ export default function ProceduralRenderer({ node }) {
     const libraryVersion = useLibraryMaterialsVersion();
     const key = geometrySignature(effective);
     const [built, setBuilt] = useState(null);
+    const lightsOn = useInteractive((state) => state.procedural[node.id]?.lightsOn ?? state.lampDefault);
     const handlers = useNodeEvents(node, 'procedural-item');
     useRegistry(node.id, 'procedural-item', ref);
+    const rotation = live?.rotation === undefined
+        ? pose.rotation
+        : [pose.rotation[0], live.rotation, pose.rotation[2]];
+    const position = live?.position ?? pose.position;
+    const poseKey = JSON.stringify([position, rotation]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: poseKey is the rendered pose
     useLayoutEffect(() => {
-        // React can restore base Y after the previous frame consumed the elevation mark.
+        // Re-rendering a changed pose restores base Y after the previous frame consumed the
+        // elevation mark; an unchanged one is not reapplied, and a mark would release the batch.
         useScene.getState().markDirty(node.id);
-    });
+    }, [poseKey, node.id]);
     useLayoutEffect(() => {
         const [recipe, parameters] = JSON.parse(key);
         const lease = acquireProceduralGeometry({ recipe, parameters });
         setBuilt(lease.value);
         return lease.release;
     }, [key]);
+    useEffect(() => () => {
+        useInteractive.getState().removeProcedural(node.id);
+        setProceduralMotionPlaying(node.id, false);
+    }, [node.id]);
+    // A recessed design's host ceiling re-cuts whenever its cut can move, live values included.
+    const cutKey = effective.recipe.cuts
+        ? JSON.stringify([
+            node.parentId,
+            effective.position,
+            effective.rotation,
+            effective.parameters,
+            effective.visible,
+            effective.recipe.cuts,
+            effective.recipe.surfaces,
+            effective.recipe.mounting?.reference,
+        ])
+        : '';
+    useEffect(() => {
+        const parentId = node.parentId;
+        if (!(cutKey && parentId))
+            return;
+        const recut = (id = parentId) => {
+            if (id && useScene.getState().nodes[id])
+                useScene.getState().markDirty(id);
+        };
+        recut();
+        // A move preview of this design re-cuts its ceiling, and the ceiling it previews on, on
+        // every step.
+        const unsubscribe = usePlacementPreview.subscribe((state, previous) => {
+            if (state.node?.id !== node.id && previous.node?.id !== node.id)
+                return;
+            recut();
+            for (const id of new Set([state.node?.parentId, previous.node?.parentId]))
+                if (id !== parentId && useScene.getState().nodes[id]?.type === 'ceiling')
+                    recut(id);
+        });
+        return () => {
+            unsubscribe();
+            recut();
+            const preview = usePlacementPreview.getState().node;
+            if (preview?.id === node.id && preview.parentId !== parentId)
+                recut(preview.parentId);
+        };
+    }, [cutKey, node.parentId, node.id]);
+    useLayoutEffect(() => {
+        // Continuous joints start running, as in the baked viewer; flat spins keep #930's default.
+        const running = new Set((node.recipe.joints ?? [])
+            .filter((joint) => joint.kind === 'continuous')
+            .map((joint) => joint.child));
+        controller.current = built
+            ? new ProceduralMotionController(built.evaluation.motions, Object.fromEntries([...running].map((partId) => [partId, true])))
+            : null;
+        lastCommand.current = 0;
+        if (built)
+            useInteractive
+                .getState()
+                .initProcedural(node.id, [...new Set(built.evaluation.motions.map((motion) => motion.partId))], [...running]);
+        for (const motion of built?.evaluation.motions ?? []) {
+            const group = ref.current?.getObjectByName(`${node.id}__motion__${motion.id}`);
+            if (!group)
+                continue;
+            group.position.set(...motionRestOffset(motion, built.evaluation.motions));
+            group.quaternion.identity();
+        }
+        if (restRef.current)
+            setDrawn(restRef.current, true);
+        if (splitRef.current)
+            setDrawn(splitRef.current, false);
+        if (built?.evaluation.motions.length) {
+            awake.current = true;
+            invalidate();
+        }
+    }, [built, node.id, invalidate]);
+    useEffect(() => useInteractive.subscribe((state, previous) => {
+        if (state.procedural[node.id] === previous.procedural[node.id])
+            return;
+        awake.current = true;
+        invalidate();
+    }), [node.id, invalidate]);
+    useFrame((_, delta) => {
+        if (!awake.current || !built || !ref.current)
+            return;
+        const state = useInteractive.getState().procedural[node.id];
+        if (state?.motionCommand && state.motionCommand.sequence > lastCommand.current) {
+            controller.current?.command(state.motionCommand);
+            lastCommand.current = state.motionCommand.sequence;
+        }
+        const frame = controller.current?.tick(delta);
+        if (!frame)
+            return;
+        for (const motion of built.evaluation.motions) {
+            const group = ref.current.getObjectByName(`${node.id}__motion__${motion.id}`);
+            if (!group)
+                continue;
+            const angle = motion.kind === 'spin'
+                ? (frame.spins[motion.id]?.phase ?? 0)
+                : motion.amount * (frame.fractions[motion.id] ?? 0);
+            if (motion.kind === 'slide')
+                group.position
+                    .set(...motionRestOffset(motion, built.evaluation.motions))
+                    .addScaledVector(axis.set(...motionAxis(motion)), angle);
+            else if (motion.direction)
+                group.quaternion.setFromAxisAngle(axis.set(...motion.direction), angle);
+            else
+                group.rotation[motion.axis] = angle;
+        }
+        if (restRef.current && splitRef.current) {
+            const moving = frame.pending ||
+                Object.values(frame.fractions).some((fraction) => fraction > 0) ||
+                Object.values(frame.spins).some((spin) => spin.speed > 0);
+            if (restRef.current.visible === moving) {
+                setDrawn(restRef.current, !moving);
+                setDrawn(splitRef.current, moving);
+            }
+        }
+        // A playing motion draws its own meshes; it rejoins the node batch at the settled pose.
+        if (setProceduralMotionPlaying(node.id, frame.pending))
+            releaseFromBatch(node.id);
+        if (frame.pending)
+            invalidate();
+        else
+            awake.current = false;
+    }, -1);
+    useLayoutEffect(() => {
+        if (!built || !ref.current || !canRegisterItemLight(effective.metadata))
+            return;
+        const pool = useItemLightPool.getState();
+        const keys = [];
+        for (const light of built.evaluation.lights) {
+            const key = `${node.id}:procedural:${light.id}`;
+            keys.push(key);
+            const local = new Vector3(...light.position);
+            const motion = built.evaluation.motions.find((entry) => entry.id === light.motionGroup);
+            if (motion)
+                local.sub(new Vector3(...motion.pivot));
+            pool.register({
+                key,
+                nodeId: node.id,
+                color: light.color,
+                distance: light.distance,
+                getWorldPosition: (out) => {
+                    const root = ref.current;
+                    if (!root)
+                        return false;
+                    const object = light.motionGroup
+                        ? root.getObjectByName(`${node.id}__motion__${light.motionGroup}`)
+                        : root;
+                    if (!object)
+                        return false;
+                    object.updateWorldMatrix(true, false);
+                    out.copy(local).applyMatrix4(object.matrixWorld);
+                    return true;
+                },
+                getIntensity: () => light.intensity,
+                isEligible: () => effective.visible !== false &&
+                    (useInteractive.getState().procedural[node.id]?.lightsOn ??
+                        useInteractive.getState().lampDefault),
+            });
+        }
+        return () => {
+            for (const key of keys)
+                useItemLightPool.getState().unregister(key);
+        };
+    }, [built, node.id, effective.visible, effective.metadata?.isNew]);
     const materialKey = JSON.stringify([effective.recipe.slots, effective.slots, libraryVersion]);
     const materials = useMemo(() => {
         const [slots, overrides] = JSON.parse(materialKey);
+        const emission = new Map(built?.evaluation.lights
+            .filter((light) => light.emissiveSlot)
+            .map((light) => [light.emissiveSlot, light.color]) ?? []);
         return new Map(slots.map((s) => {
             const ref = overrides[s.id];
             const material = textures
                 ? (resolveMaterialRef(ref, sceneMaterials, shading) ??
                     resolveSlotDefaultMaterial(ref?.startsWith('#') ? ref : s.color, shading, 0.75))
                 : createSurfaceRoleMaterial('furnishing', colorPreset, undefined, sceneTheme);
-            return [s.id, material];
+            return [
+                s.id,
+                emission.has(s.id)
+                    ? cloneWithProceduralEmission(material, emission.get(s.id), true)
+                    : material,
+            ];
         }));
-    }, [materialKey, sceneMaterials, shading, textures, colorPreset, sceneTheme]);
+    }, [materialKey, sceneMaterials, shading, textures, colorPreset, sceneTheme, built]);
+    useLayoutEffect(() => {
+        const slots = new Set();
+        for (const light of built?.evaluation.lights ?? []) {
+            if (light.emissiveSlot) {
+                slots.add(light.emissiveSlot);
+                const material = materials.get(light.emissiveSlot);
+                if (material)
+                    setProceduralEmission(material, lightsOn);
+            }
+        }
+        for (const mesh of ref.current ? proceduralSlotMeshes(ref.current, slots) : []) {
+            const active = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+            for (const material of active)
+                setProceduralEmission(material, lightsOn);
+        }
+    }, [built, materials, lightsOn]);
     useLayoutEffect(() => () => {
         for (const material of materials.values())
             if (!material.userData.__pascalCachedMaterial)
                 material.dispose();
     }, [materials]);
-    const meshes = useMemo(() => built?.batches.map((batch) => {
-        const mesh = new Mesh(batch.geometry, materials.get(batch.slot));
-        mesh.name = `slot_${batch.slot}`;
-        mesh.userData = { slotId: batch.slot, proceduralRanges: batch.ranges };
-        mesh.castShadow = true;
-        mesh.receiveShadow = true;
-        return mesh;
-    }) ?? [], [built, materials]);
-    const rotation = live?.rotation === undefined
-        ? pose.rotation
-        : [pose.rotation[0], live.rotation, pose.rotation[2]];
-    return (_jsxs("group", { ref: ref, position: live?.position ?? pose.position, rotation: rotation, visible: effective.visible, ...handlers, children: [meshes.map((mesh) => (_jsx("primitive", { object: mesh, dispose: null }, mesh.uuid))), effective.children.map((id) => {
+    const meshes = useMemo(() => {
+        const make = (batch, geometry = batch.geometry) => {
+            const mesh = new Mesh(geometry, materials.get(batch.slot));
+            mesh.name = `slot_${batch.slot}`;
+            mesh.userData = { slotId: batch.slot, proceduralRanges: batch.ranges };
+            mesh.castShadow = materialCastsShadow(mesh.material);
+            mesh.receiveShadow = true;
+            return { mesh, motionGroup: batch.motionGroup };
+        };
+        return {
+            split: built?.batches.map((batch) => make(batch, batch.motionGeometry ?? batch.geometry)) ?? [],
+            rest: built?.rest?.map((batch) => make(batch)) ?? [],
+        };
+    }, [built, materials]);
+    const motions = built?.evaluation.motions ?? [];
+    const motionGroup = (motion) => (_jsxs("group", { name: `${node.id}__motion__${motion.id}`, position: motionRestOffset(motion, motions), userData: {
+            proceduralMotion: {
+                nodeId: node.id,
+                partId: motion.partId,
+                groupId: motion.id,
+                kind: motion.kind,
+            },
+        }, children: [meshes.split
+                .filter((entry) => entry.motionGroup === motion.id)
+                .map(({ mesh }) => (_jsx("primitive", { object: mesh, dispose: null }, mesh.uuid))), motions.filter((child) => child.parent === motion.id).map(motionGroup)] }, motion.id));
+    const split = (_jsxs(_Fragment, { children: [meshes.split
+                .filter((entry) => !entry.motionGroup)
+                .map(({ mesh }) => (_jsx("primitive", { object: mesh, dispose: null }, mesh.uuid))), motions.filter((motion) => !motion.parent).map(motionGroup)] }));
+    return (_jsxs("group", { ref: ref, userData: { pascalId: node.id }, position: position, rotation: rotation, visible: effective.visible, ...handlers, children: [meshes.rest.length ? (_jsxs(_Fragment, { children: [_jsx("group", { ref: restRef, userData: { pascalProceduralRest: true }, children: meshes.rest.map(({ mesh }) => (_jsx("primitive", { object: mesh, dispose: null }, mesh.uuid))) }), _jsx("group", { ref: splitRef, userData: { pascalProceduralSplit: true }, visible: false, children: split })] })) : (split), effective.children.map((id) => {
                 const surface = built?.evaluation.surfaces.find((s) => s.id === effective.attachments[id]);
                 return (_jsx("group", { position: surface?.position ?? [0, 0, 0], rotation: surface?.rotation, children: _jsx(NodeRenderer, { nodeId: id }) }, id));
             })] }));

package/dist/ridge-vent/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAwIxC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,CA2DpE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAwIxC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,CA4DpE,CAAA"}

package/dist/ridge-vent/definition.js

@@ -169,6 +169,7 @@ export const ridgeVentDefinition = {
     parametrics: ridgeVentParametrics,
     handles: ridgeVentHandles,
     floorplan: buildRidgeVentFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/ridge-vent/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/panel.tsx"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,uCAiQrC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/panel.tsx"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,uCA6OrC"}