@pascal-app/nodes 1.0.3 → 1.0.4

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation.d.ts","sourceRoot":"","sources":["../../src/procedural-item/animation.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,kBAAkB,EACxB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,mFAAmF;AACnF,eAAO,MAAM,yBAAyB,GAAI,QAAQ,MAAM,YAA+B,CAAA;AAEvF,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAKpF;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,kBAAkB,EACxB,MAAM,EAAE,KAAK,CAAC,QAAQ,GACrB,IAAI,CAQN;AAgBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,kBAAkB,EACxB,MAAM,EAAE,KAAK,CAAC,QAAQ,GACrB,KAAK,CAAC,aAAa,EAAE,CA6EvB"}

package/dist/procedural-item/animation.js

@@ -0,0 +1,116 @@
+import { evaluateRecipe, finitePoseFraction, motionAxis, motionRestOffset, motionTimeline, } from '@pascal-app/core/procedural-items';
+import * as THREE from 'three';
+const playingMotions = new Set();
+/** Procedural items whose motion is playing draw their own meshes (node batch). */
+export const isProceduralMotionPlaying = (nodeId) => playingMotions.has(nodeId);
+export function setProceduralMotionPlaying(nodeId, playing) {
+    if (playingMotions.has(nodeId) === playing)
+        return false;
+    if (playing)
+        playingMotions.add(nodeId);
+    else
+        playingMotions.delete(nodeId);
+    return true;
+}
+export function poseProceduralMotionsAtRest(node, object) {
+    const { motions } = evaluateRecipe(node.recipe, node.parameters);
+    for (const motion of motions) {
+        const group = object.getObjectByName(`${node.id}__motion__${motion.id}`);
+        if (!group)
+            continue;
+        group.position.set(...motionRestOffset(motion, motions));
+        group.quaternion.identity();
+    }
+}
+function axisVector(motion) {
+    return new THREE.Vector3(...motionAxis(motion));
+}
+// An export animates the joint groups, so it keeps them and drops the merged rest pose.
+function keepJointGroups(object) {
+    const rest = [];
+    object.traverse((child) => {
+        if (child.userData.pascalProceduralRest)
+            rest.push(child);
+        if (child.userData.pascalProceduralSplit)
+            child.visible = true;
+    });
+    for (const child of rest)
+        child.removeFromParent();
+}
+export function bakeProceduralAnimationClips(node, object) {
+    keepJointGroups(object);
+    const evaluation = evaluateRecipe(node.recipe, node.parameters);
+    const { T, perPart } = motionTimeline(evaluation);
+    poseProceduralMotionsAtRest(node, object);
+    const clips = [];
+    const finiteByPart = new Map();
+    const spinByPartAndPeriod = new Map();
+    for (const motion of evaluation.motions) {
+        const group = object.getObjectByName(`${node.id}__motion__${motion.id}`);
+        if (!group)
+            continue;
+        if (motion.kind === 'spin') {
+            const key = `${motion.partId}:${Math.abs(motion.amount)}`;
+            spinByPartAndPeriod.set(key, [...(spinByPartAndPeriod.get(key) ?? []), motion]);
+        }
+        else
+            finiteByPart.set(motion.partId, [...(finiteByPart.get(motion.partId) ?? []), motion]);
+    }
+    for (const [partId, motions] of finiteByPart) {
+        const tracks = [];
+        const clipName = `${node.id}:${partId}: open`;
+        for (const motion of motions) {
+            const group = object.getObjectByName(`${node.id}__motion__${motion.id}`);
+            const start = motion.delay;
+            const times = [
+                ...new Set([
+                    0,
+                    ...Array.from({ length: 33 }, (_, i) => start + (motion.duration * i) / 32),
+                    T,
+                ]),
+            ].sort((a, b) => a - b);
+            const values = times.flatMap((time) => {
+                const fraction = finitePoseFraction(motion, time);
+                if (motion.kind === 'slide')
+                    return new THREE.Vector3(...motionRestOffset(motion, evaluation.motions))
+                        .addScaledVector(axisVector(motion), motion.amount * fraction)
+                        .toArray();
+                return new THREE.Quaternion()
+                    .setFromAxisAngle(axisVector(motion), motion.amount * fraction)
+                    .toArray();
+            });
+            tracks.push(motion.kind === 'slide'
+                ? new THREE.VectorKeyframeTrack(`${group.uuid}.position`, times, values)
+                : new THREE.QuaternionKeyframeTrack(`${group.uuid}.quaternion`, times, values));
+            group.userData.proceduralMotion = {
+                ...group.userData.proceduralMotion,
+                clip: clipName,
+                activeWindow: [perPart[partId].A, perPart[partId].B],
+            };
+        }
+        const clip = new THREE.AnimationClip(clipName, T, tracks);
+        clip.userData = { loop: false };
+        clips.push(clip);
+    }
+    const spinCounts = new Map();
+    for (const motions of spinByPartAndPeriod.values()) {
+        const partId = motions[0].partId;
+        const ordinal = spinCounts.get(partId) ?? 0;
+        spinCounts.set(partId, ordinal + 1);
+        const clipName = `${node.id}:${partId}${ordinal ? `:${ordinal}` : ''}: loop`;
+        const duration = (2 * Math.PI) / Math.abs(motions[0].amount);
+        const times = [0, 0.25, 0.5, 0.75, 1].map((fraction) => fraction * duration);
+        const tracks = motions.map((motion) => {
+            const group = object.getObjectByName(`${node.id}__motion__${motion.id}`);
+            group.userData.proceduralMotion = { ...group.userData.proceduralMotion, clip: clipName };
+            const values = [0, 0.25, 0.5, 0.75, 1].flatMap((fraction) => new THREE.Quaternion()
+                .setFromAxisAngle(axisVector(motion), Math.sign(motion.amount) * 2 * Math.PI * fraction)
+                .toArray());
+            return new THREE.QuaternionKeyframeTrack(`${group.uuid}.quaternion`, times, values);
+        });
+        const clip = new THREE.AnimationClip(clipName, duration, tracks);
+        clip.userData = { loop: true };
+        clips.push(clip);
+    }
+    return clips;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/procedural-item/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgD,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEpG,OAAO,EAKL,kBAAkB,EAWnB,MAAM,mCAAmC,CAAA;AA8D1C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAqO9E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/procedural-item/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgD,cAAc,EAAE,MAAM,kBAAkB,CAAA;AASpG,OAAO,EAML,kBAAkB,EAYnB,MAAM,mCAAmC,CAAA;AA6E1C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CA+R9E,CAAA"}

package/dist/procedural-item/definition.js

@@ -1,7 +1,11 @@
-import { useScene } from '@pascal-app/core';
-import { boundsOf, boxCorners, evaluateRecipe, frame, ProceduralItemNode, parameterPatch, proceduralFootprint, proceduralSlotColor, queryProceduralItem, resolveProceduralWallPlacement, setProceduralMaterial, shelfRecipe, snapParameters, transformPoint, validateProceduralRelations, } from '@pascal-app/core/procedural-items';
+import { getEffectiveNode, proceduralItemSlots, toggleMechanism, useInteractive, useScene, } from '@pascal-app/core';
+import { boundsOf, boxCorners, evaluateRecipe, frame, operableParts, ProceduralItemNode, parameterPatch, proceduralCeilingHole, proceduralFootprint, proceduralSlotColor, queryProceduralItem, resolveProceduralWallPlacement, setProceduralMaterial, shelfRecipe, snapParameters, transformPoint, validateProceduralRelations, } from '@pascal-app/core/procedural-items';
+import { usePlacementPreview } from '@pascal-app/editor';
+import { decorateProceduralEmission } from '@pascal-app/viewer';
 import { itemPaint } from '../item/paint';
+import { proceduralMechanism, toggleItemLights } from '../shared/item-interactions';
 import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan';
+import { bakeProceduralAnimationClips, isProceduralMotionPlaying } from './animation';
 import { proceduralFloorplanMoveTarget } from './move-session';
 const GIZMO_SIDE_OFFSET = 0.3;
 const GIZMO_FRONT_OFFSET = 0.3;
@@ -10,7 +14,13 @@ function handleBounds(node, part) {
     const e = evaluateRecipe(node.recipe, node.parameters);
     const shapes = part ? e.shapes.filter((shape) => shape.partId === part) : [];
     return shapes.length
-        ? boundsOf(shapes.flatMap((shape) => boxCorners(shape.size.map((v) => -v / 2), shape.size.map((v) => v / 2)).map((point) => transformPoint(frame(shape.position, shape.rotation), point))))
+        ? boundsOf(shapes.flatMap((shape) => shape.primitive === 'ellipsoid'
+            ? (() => {
+                const axes = frame(shape.position, shape.rotation).axes;
+                const extent = [0, 1, 2].map((i) => Math.hypot(...axes.map((axis, j) => (axis[i] * shape.size[j]) / 2)));
+                return boxCorners(shape.position.map((v, i) => v - extent[i]), shape.position.map((v, i) => v + extent[i]));
+            })()
+            : boxCorners(shape.size.map((v) => -v / 2), shape.size.map((v) => v / 2)).map((point) => transformPoint(frame(shape.position, shape.rotation), point))))
         : e;
 }
 function proceduralRotateHandle() {
@@ -70,9 +80,22 @@ export const proceduralItemDefinition = {
         position: [0, 0, 0],
         rotation: [0, 0, 0],
     }),
-    extensions: { 'pascal:editor/floorplan': { directDrag: true } },
+    extensions: {
+        'pascal:editor/floorplan': {
+            directDrag: true,
+            actionMenu: { actions: () => import('../shared/item-interaction-actions') },
+        },
+    },
     capabilities: {
+        batchable: {
+            scope: 'level',
+            // Part lights clone their emissive slot per node, and a playing motion
+            // moves meshes under the static copy.
+            excluded: (n) => n.recipe.parts.some((part) => part.light) ||
+                isProceduralMotionPlaying(n.id),
+        },
         selectable: { hitVolume: 'bbox' },
+        mechanism: proceduralMechanism,
         dragBounds: (n) => {
             const node = n;
             const e = evaluateRecipe(node.recipe, node.parameters);
@@ -86,6 +109,29 @@ export const proceduralItemDefinition = {
             align: 'face',
         },
         hostRefFields: ['wallId', 'side', 'supportSlabId'],
+        // A v2 ceiling design with `cuts` opens its host ceiling (CeilingSystem dispatch).
+        ceilingCut: {
+            // Follows the live gesture (R2): a move preview cuts where it sits; handle and slider
+            // overrides cut at their live values; a hidden design (the move's source) cuts nothing.
+            buildCeilingHole: (n) => {
+                const preview = usePlacementPreview.getState().node;
+                if (preview?.id === n.id && preview.type === 'procedural-item')
+                    return preview.parentId === n.parentId ? proceduralCeilingHole(preview) : null;
+                const node = getEffectiveNode(n);
+                return node.visible === false ? null : proceduralCeilingHole(node);
+            },
+            // A design being moved onto another ceiling cuts it before it becomes its child.
+            holesFor: (ceiling) => {
+                const preview = usePlacementPreview.getState().node;
+                if (preview?.type !== 'procedural-item' || preview.parentId !== ceiling.id)
+                    return [];
+                const moving = useScene.getState().nodes[preview.id];
+                if (!moving || moving.parentId === ceiling.id)
+                    return [];
+                const hole = proceduralCeilingHole(preview);
+                return hole ? [hole] : [];
+            },
+        },
         floorPlaced: {
             footprint: (n) => proceduralFootprint(n),
             applies: (n) => !n.recipe.mounting,
@@ -95,10 +141,7 @@ export const proceduralItemDefinition = {
         rotatable: { axes: ['y'], snapAngles: [0, Math.PI / 4, Math.PI / 2, Math.PI] },
         duplicable: { subtree: 'with-children' },
         deletable: true,
-        slots: (n) => {
-            const node = n;
-            return node.recipe.slots.map((s) => ({ slotId: s.id, label: s.label, default: s.color }));
-        },
+        slots: (n) => proceduralItemSlots(n),
         surfaces: {
             custom: (n) => evaluateRecipe(n.recipe, n.parameters).surfaces.map((s) => ({
                 id: s.id,
@@ -111,15 +154,38 @@ export const proceduralItemDefinition = {
         paint: {
             ...itemPaint,
             commit: ({ node, role, material, materialPreset }) => setProceduralMaterial(node.id, role, materialPreset, material),
+            applyPreview: (args) => {
+                const restore = itemPaint.applyPreview?.(args);
+                if (!restore)
+                    return restore;
+                const node = args.node;
+                if (node?.type !== 'procedural-item')
+                    return restore;
+                const lights = evaluateRecipe(node.recipe, node.parameters).lights;
+                const restoreEmission = decorateProceduralEmission(args.root, lights, useInteractive.getState().procedural[node.id]?.lightsOn ??
+                    useInteractive.getState().lampDefault);
+                return () => {
+                    restoreEmission();
+                    restore();
+                };
+            },
         },
     },
     relations: { hosts: ['item', 'procedural-item'], cascadeDelete: 'descendants' },
     renderer: { kind: 'parametric', module: () => import('./renderer') },
+    exportAnimation: ({ node, object }) => bakeProceduralAnimationClips(node, object),
     parametrics: { groups: [], customPanel: () => import('@pascal-app/editor/procedural-items') },
     affordanceTools: { move: () => import('./move-tool') },
     floorplanMoveTarget: proceduralFloorplanMoveTarget,
     floorplanAffectedIds: restingFloorplanAffectedIds,
     keyboardActions: {
+        e: {
+            appliesTo: (n) => {
+                const recipe = n.recipe;
+                return operableParts(recipe).length > 0 || recipe.parts.some((part) => part.light);
+            },
+            run: (n) => proceduralMechanism.has(n) ? toggleMechanism(proceduralMechanism, n) : toggleItemLights(n),
+        },
         r: {
             appliesTo: (n) => Boolean(n.wallId),
             run: (n) => {

package/dist/procedural-item/geometry.d.ts

@@ -1,8 +1,10 @@
 import { type Evaluation, type ProceduralItemNode } from '@pascal-app/core/procedural-items';
-import { type BufferGeometry } from 'three';
+import { BufferGeometry } from 'three';
 export type Batch = {
     slot: string;
+    motionGroup?: string;
     geometry: BufferGeometry;
+    motionGeometry?: BufferGeometry;
     ranges: {
         end: number;
         partId: string;
@@ -11,6 +13,8 @@ export type Batch = {
 };
 export type BuiltItem = {
     batches: Batch[];
+    /** Part-tree designs: the whole rest pose merged per slot, drawn while no joint moves. */
+    rest?: Batch[];
     evaluation: Evaluation;
     milliseconds: number;
     triangles: number;

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

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/procedural-item/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAEf,KAAK,kBAAkB,EACxB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAEL,KAAK,cAAc,EAMpB,MAAM,OAAO,CAAA;AAGd,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,cAAc,CAAA;IACxB,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC3D,CAAA;AACD,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,KAAK,EAAE,CAAA;IAChB,UAAU,EAAE,UAAU,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AACD,eAAO,MAAM,iBAAiB;;;;;CAA8D,CAAA;AAE5F,eAAO,MAAM,iBAAiB,GAAI,MAAM,kBAAkB,WACV,CAAA;AAChD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,CA8D3E;AACD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,kBAAkB;;;EAwBjE;AACD,wBAAgB,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,iBAE/D"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/procedural-item/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAEf,KAAK,kBAAkB,EAIxB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAEL,cAAc,EAaf,MAAM,OAAO,CAAA;AAGd,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,cAAc,CAAA;IACxB,cAAc,CAAC,EAAE,cAAc,CAAA;IAC/B,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC3D,CAAA;AACD,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,KAAK,EAAE,CAAA;IAChB,0FAA0F;IAC1F,IAAI,CAAC,EAAE,KAAK,EAAE,CAAA;IACd,UAAU,EAAE,UAAU,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAiMD,eAAO,MAAM,iBAAiB;;;;;CAA8D,CAAA;AAE5F,eAAO,MAAM,iBAAiB,GAAI,MAAM,kBAAkB,WACV,CAAA;AAChD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,CA2G3E;AACD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,kBAAkB;;;EA2BjE;AACD,wBAAgB,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,iBAE/D"}

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"}