@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/chimney/definition.js

@@ -1,390 +1,4 @@
-import { ChimneyNode as ChimneyNodeSchema, getActiveRoofHeight, } from '@pascal-app/core';
-import { buildChimneyFloorplan } from './floorplan.js';
-import { chimneyPaint } from './paint.js';
-import { chimneyParametrics } from './parametrics.js';
-import { ChimneyNode } from './schema.js';
-// Side handle offsets in metres. Match the roof-segment values so a
-// segment + chimney selected back-to-back use the same visual rhythm.
-const SIDE_HANDLE_OFFSET = 0.25;
-const HEIGHT_HANDLE_OFFSET = 0.25;
-const ROTATE_CORNER_OFFSET = 0.35;
-const MIN_BODY_DIM = 0.3;
-const MIN_HEIGHT_ABOVE_RIDGE = 0.05;
-const MIN_FLUE_HEIGHT = 0.05;
-const MAX_FLUE_HEIGHT = 1.5;
-const MIN_CAP_THICKNESS = 0.02;
-const MAX_CAP_THICKNESS = 0.5;
-const MIN_CAP_OVERHANG = 0;
-const MAX_CAP_OVERHANG = 0.3;
-// Cap-reveal gap between body top and cap base — mirrors the
-// `CAP_REVEAL` constant in `geometry.ts`. Local copy because handle
-// placements need to know the cap's Y range and the geometry's
-// constant isn't exported. If you change it here, change it there.
-const CAP_REVEAL = 0.003;
-// Fallback Y when the host segment can't be resolved (shouldn't happen
-// for a placed chimney, but `placement.position` runs synchronously and
-// must always return a vector).
-const FALLBACK_BODY_MID_Y = 1.5;
-// Resolve the segment that hosts this chimney. Returns undefined if the
-// chimney is unparented or the parent isn't in the scene yet.
-function resolveHostSegment(node, sceneApi) {
-    if (!node.roofSegmentId)
-        return undefined;
-    return sceneApi.get(node.roofSegmentId);
-}
-// Mid-Y of the visible chimney body in the host segment's local frame.
-// Matches the geometry builder: body runs from `baseY = max(0, wallHeight
-// - 0.2)` up to `peakY + heightAboveRidge`. The handle Y picks the
-// midpoint of the *visible* portion (deck plane → top) so chevrons sit
-// next to the body, not buried inside the roof deck or floating over
-// the eave.
-function getBodyMidY(node, segment) {
-    const peakY = segment.wallHeight + getActiveRoofHeight(segment);
-    const topY = peakY + node.heightAboveRidge;
-    return (segment.wallHeight + topY) / 2;
-}
-// Top of the chimney body (where the cap reveal gap begins). Tracker
-// handle and cap-thickness handle both reference this Y.
-function getBodyTopY(node, segment) {
-    return segment.wallHeight + getActiveRoofHeight(segment) + node.heightAboveRidge;
-}
-// Cap base Y — the bottom of the cap slab. Sits just above the body
-// top with a small reveal gap so a shadow line separates them.
-function getCapBaseY(node, segment) {
-    return getBodyTopY(node, segment) + CAP_REVEAL;
-}
-// Cap top Y — the top of the cap slab. Falls back to body top when no
-// cap is rendered (flues mount on whichever is the upper surface).
-function getCapTopY(node, segment) {
-    if (!node.cap || node.capShape === 'none')
-        return getBodyTopY(node, segment);
-    return getCapBaseY(node, segment) + node.capThickness;
-}
-// Width arrow on the +X (right) or -X (left) side. Asymmetric resize:
-// dragging one arrow grows the chimney outward from its own edge while
-// the opposite edge stays world-fixed. Handles live in the chimney's
-// registered ref frame (the nested inner group in the renderer that
-// applies `node.position` / `node.rotation`), so placements are in
-// chimney-local coordinates — no per-arrow rotation/translation
-// compensation. `apply` keeps the world-fixed edge anchored even when
-// the chimney is rotated by recentering `position` along the chimney's
-// own +X arm in segment frame.
-function chimneyWidthHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: side === 'right' ? 'min' : 'max',
-        // Portal into the roof (grandparent), not the segment (parent). Unpainted
-        // roof segments live inside a `visible={false}` wrapper, which would
-        // hide the handles. The roof itself is always visible. Skylight does
-        // the same.
-        portal: 'grandparent',
-        min: MIN_BODY_DIM,
-        currentValue: (n) => n.width,
-        apply: (initial, newWidth) => {
-            const rotY = initial.rotation ?? 0;
-            const armX = Math.cos(rotY);
-            const armZ = -Math.sin(rotY);
-            const anchorX = initial.position[0] - sign * (initial.width / 2) * armX;
-            const anchorZ = initial.position[2] - sign * (initial.width / 2) * armZ;
-            const newCenterX = anchorX + sign * (newWidth / 2) * armX;
-            const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
-            return {
-                width: newWidth,
-                position: [newCenterX, initial.position[1], newCenterZ],
-            };
-        },
-        placement: {
-            position: (n, sceneApi) => {
-                const segment = resolveHostSegment(n, sceneApi);
-                const y = segment ? getBodyMidY(n, segment) : FALLBACK_BODY_MID_Y;
-                return [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), y, 0];
-            },
-            // Chevron faces along the chimney's own ±X; the left arrow flips
-            // 180°. No node.rotation here — the registered inner group is
-            // already rotated by `node.rotation`, so chimney-local +X is the
-            // chevron's natural direction.
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-    };
-}
-// Depth arrow — symmetric on the +Z side. Only meaningful for square
-// bodies; round chimneys are circular (depth field is ignored by the
-// geometry builder, so a depth handle would just resize an invisible
-// field). The chimneys factory below omits this descriptor for round
-// bodies.
-function chimneyDepthHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'z',
-        anchor: 'center',
-        min: MIN_BODY_DIM,
-        currentValue: (n) => n.depth,
-        apply: (_n, newValue) => ({ depth: newValue }),
-        placement: {
-            position: (n, sceneApi) => {
-                const segment = resolveHostSegment(n, sceneApi);
-                const y = segment ? getBodyMidY(n, segment) : FALLBACK_BODY_MID_Y;
-                return [0, y, n.depth / 2 + SIDE_HANDLE_OFFSET];
-            },
-        },
-    };
-}
-// Height-above-ridge tracker. Dashed leader spans the chimney body's
-// visible extent — from the roof deck plane up to the body top — and
-// terminates in a draggable cube at the body top. Cap, flues, cricket
-// and bands sit ABOVE the body and are explicitly excluded from the
-// leader so the height affordance reads as "this is the body height",
-// not "this is the whole stack height". Dragging the cube vertically
-// adjusts `heightAboveRidge` 1:1.
-function chimneyHeightAboveRidgeHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        shape: 'tracker',
-        min: MIN_HEIGHT_ABOVE_RIDGE,
-        currentValue: (n) => n.heightAboveRidge,
-        apply: (initial, newValue) => ({
-            heightAboveRidge: Math.max(MIN_HEIGHT_ABOVE_RIDGE, newValue),
-        }),
-        placement: {
-            // Cube sits AT the body top (no offset) so the leader terminates
-            // exactly at the body's top edge — visually the "ceiling" of the
-            // body, before the cap reveal gap.
-            position: (n, sceneApi) => {
-                const segment = resolveHostSegment(n, sceneApi);
-                const y = segment ? getBodyTopY(n, segment) : FALLBACK_BODY_MID_Y;
-                return [0, y, 0];
-            },
-        },
-        // Leader bottom = deck plane (segment.wallHeight). The chimney body
-        // geometry actually extends a touch below the deck so the bottom
-        // doesn't show above the eave on low-slope roofs (`baseY = max(0,
-        // wallHeight - 0.2)`), but the visible portion starts at the deck —
-        // and starting the leader there is what reads as "body height" to
-        // the user.
-        trackerBaseY: (n, sceneApi) => {
-            const segment = resolveHostSegment(n, sceneApi);
-            return segment?.wallHeight ?? 0;
-        },
-    };
-}
-// Whole-chimney rotation gizmo at the +X/+Z corner of the body
-// footprint. The registered inner group already centers on the chimney
-// and applies its yaw, so the default rotation pivot (rideObject origin)
-// is correct — no `rotationCenter` override needed.
-function chimneyRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
-        placement: {
-            position: (n, sceneApi) => {
-                const segment = resolveHostSegment(n, sceneApi);
-                const y = segment ? getBodyMidY(n, segment) : FALLBACK_BODY_MID_Y;
-                const isRound = n.bodyShape === 'round';
-                const halfX = n.width / 2 + ROTATE_CORNER_OFFSET;
-                const halfZ = (isRound ? n.width : n.depth) / 2 + ROTATE_CORNER_OFFSET;
-                return [halfX, y, halfZ];
-            },
-            // The two-headed icon's natural bias points along +X; aim it
-            // toward the corner (45° outward from the chimney's local frame).
-            rotationY: () => -Math.PI / 4,
-        },
-    };
-}
-// Flue-height chevron at the center of the cap top, pointing upward.
-// Drag adjusts `flueHeight` for ALL flues uniformly — the schema only
-// carries a single scalar. Placed at chimney center (X=Z=0) so the
-// handle stays valid regardless of `flueCount` / `flueSpacing`. Anchor
-// is 'min' so the flue base stays pinned to the cap and the top edge
-// follows the pointer.
-function chimneyFlueHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        portal: 'grandparent',
-        min: MIN_FLUE_HEIGHT,
-        max: MAX_FLUE_HEIGHT,
-        currentValue: (n) => n.flueHeight,
-        apply: (_n, newValue) => ({ flueHeight: newValue }),
-        placement: {
-            position: (n, sceneApi) => {
-                const segment = resolveHostSegment(n, sceneApi);
-                // Sit the chevron at the flue top so it visually attaches to
-                // the thing being dragged. Fallback Y mirrors the body-top
-                // fallback above.
-                const baseY = segment ? getCapTopY(n, segment) : FALLBACK_BODY_MID_Y;
-                return [0, baseY + n.flueHeight, 0];
-            },
-        },
-    };
-}
-// Cap-thickness chevron above the cap top, pointing upward. Anchor is
-// 'min' so the cap base stays at body-top + reveal and the top edge
-// follows the pointer.
-function chimneyCapThicknessHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        portal: 'grandparent',
-        min: MIN_CAP_THICKNESS,
-        max: MAX_CAP_THICKNESS,
-        currentValue: (n) => n.capThickness,
-        apply: (_n, newValue) => ({ capThickness: newValue }),
-        placement: {
-            position: (n, sceneApi) => {
-                const segment = resolveHostSegment(n, sceneApi);
-                // Offset toward +Z (away from chimney center on the depth axis)
-                // so the cap-thickness chevron doesn't overlap the flue-height
-                // chevron at X=0,Z=0. Pick the cap edge minus a small margin so
-                // it sits on top of the cap, not floating off to the side.
-                const isRound = n.bodyShape === 'round';
-                const halfZ = (isRound ? n.width : n.depth) / 2;
-                const z = halfZ * 0.35;
-                const y = segment ? getCapTopY(n, segment) : FALLBACK_BODY_MID_Y;
-                return [0, y, z];
-            },
-        },
-    };
-}
-// Cap-overhang radial chevron on the +X edge of the cap. Outward 1:1
-// drag grows the overhang; the cap's half-extent is `width/2 + overhang`.
-function chimneyCapOverhangHandle() {
-    return {
-        kind: 'radial-resize',
-        axis: 'x',
-        portal: 'grandparent',
-        min: MIN_CAP_OVERHANG,
-        max: MAX_CAP_OVERHANG,
-        currentValue: (n) => n.capOverhang,
-        apply: (_n, newValue) => ({ capOverhang: newValue }),
-        placement: {
-            position: (n, sceneApi) => {
-                const segment = resolveHostSegment(n, sceneApi);
-                // Cap mid-height in the chimney-local frame so the chevron sits
-                // on the cap edge, not above or below it.
-                const capBaseY = segment ? getCapBaseY(n, segment) : FALLBACK_BODY_MID_Y;
-                const y = capBaseY + n.capThickness / 2;
-                return [n.width / 2 + n.capOverhang + SIDE_HANDLE_OFFSET, y, 0];
-            },
-        },
-    };
-}
-const chimneyHandles = (node) => {
-    const descriptors = [
-        chimneyWidthHandle('right'),
-        chimneyWidthHandle('left'),
-    ];
-    if (node.bodyShape !== 'round')
-        descriptors.push(chimneyDepthHandle());
-    descriptors.push(chimneyHeightAboveRidgeHandle(), chimneyRotateHandle());
-    // Conditional flue/cap handles are temporarily disabled — they fired
-    // a "Color target has no corresponding fragment stage output" WebGPU
-    // validation error that the original four handles don't trigger. The
-    // descriptor shapes (linear-resize y / radial-resize x) match other
-    // working handles in the codebase, so the cause is likely a TSL/MRT
-    // pipeline interaction we haven't pinned down. Re-enable one at a
-    // time after isolating the trigger; the factory + helpers are kept so
-    // we can flip them back on without re-deriving the placement math.
-    // if (node.cap && node.capShape !== 'none') {
-    //   descriptors.push(chimneyCapThicknessHandle(), chimneyCapOverhangHandle())
-    // }
-    // if (node.flueCount > 0) descriptors.push(chimneyFlueHeightHandle())
-    return descriptors;
-};
-// Every fresh chimney starts as plain white (body + top). The paint
-// flow / material picker writes preset refs or full `MaterialSchema`
-// objects on top of this; until then both roles render `#ffffff`.
-const WHITE_MATERIAL = {
-    properties: {
-        color: '#ffffff',
-        roughness: 0.85,
-        metalness: 0,
-        opacity: 1,
-        transparent: false,
-        side: 'front',
-    },
-};
-/**
- * Chimney — a vertical masonry stack hosted on a roof segment.
- *
- * Three-checkbox model: `def.renderer` (custom — segment-aware
- * geometry from `useScene`, body height derived from
- * `segment.wallHeight + roofHeight + heightAboveRidge`), no `geometry`,
- * no `system`.
- *
- * **Option C scope**: chimney ships in the registry shape with solid
- * geometry. CSG-driven decoration (cap flue holes, body cavity,
- * panels, bands) is preserved in the schema but not rendered yet —
- * those re-light when roof-segment migrates to Stage B and introduces
- * a `roofCutout` capability the parent segment can read.
- */
-export const chimneyDefinition = {
-    kind: 'chimney',
-    schemaVersion: 1,
-    schema: ChimneyNode,
-    category: 'structure',
-    surfaceRole: 'wall',
-    defaults: () => {
-        const stub = ChimneyNodeSchema.parse({
-            id: 'chimney_default',
-            type: 'chimney',
-            material: WHITE_MATERIAL,
-            topMaterial: WHITE_MATERIAL,
-        });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        // Mounts on a roof segment via `roofSegmentId`. Dirty marks
-        // cascade to the host segment's parent roof so its merged shell
-        // re-renders. No `buildCut` — the chimney does its own self-trim
-        // via `trimChimneyBodyAgainstRoof`; the host roof shell stays solid
-        // underneath.
-        roofAccessory: {},
-        // Paint dispatch for the body / top surface split. The editor's
-        // selection-manager routes paint hover / click / preview through
-        // this entry rather than carrying a kind-name arm.
-        paint: chimneyPaint,
-    },
-    affordanceTools: {
-        // Drag-to-place tool for duplicate + move. Reuses the placement
-        // ghost preview but seeds it from the moving (cloned) node so the
-        // duplicate keeps the source's body shape, materials, panels, etc.
-        move: () => import('./move-tool.js'),
-    },
-    parametrics: chimneyParametrics,
-    handles: chimneyHandles,
-    floorplan: buildChimneyFloorplan,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./preview.js'),
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Left click', label: 'Place chimney on roof' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Chimney',
-        description: 'Vertical masonry stack on a roof segment.',
-        icon: { kind: 'url', src: '/icons/chimney.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 122,
-    },
-    mcp: {
-        description: 'A chimney on a roof segment. Square or round body; optional shoulder taper; sloped/flat/stepped cap; up to 4 protruding flues; optional cricket on the up-slope face.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { chimneyEditContribution } from './definition.edit.js';
+import { chimneyRenderDefinition } from './definition.render.js';
+export const chimneyDefinition = composeNodeDefinition(chimneyRenderDefinition, chimneyEditContribution);

package/dist/chimney/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { ChimneyNode } from './schema.js';
+export declare const chimneyRenderDefinition: NodeRenderDefinition<typeof ChimneyNode> & {
+    kind: 'chimney';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/chimney/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/chimney/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAgBtC,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,OAAO,WAAW,CAAC,GAAG;IAC/E,IAAI,EAAE,SAAS,CAAA;CA6ChB,CAAA"}

package/dist/chimney/definition.render.js

@@ -0,0 +1,59 @@
+import { ChimneyNode as ChimneyNodeSchema } from '@pascal-app/core';
+import { ChimneyNode } from './schema.js';
+// Every fresh chimney starts as plain white (body + top). The paint
+// flow / material picker writes preset refs or full `MaterialSchema`
+// objects on top of this; until then both roles render `#ffffff`.
+const WHITE_MATERIAL = {
+    properties: {
+        color: '#ffffff',
+        roughness: 0.85,
+        metalness: 0,
+        opacity: 1,
+        transparent: false,
+        side: 'front',
+    },
+};
+export const chimneyRenderDefinition = {
+    kind: 'chimney',
+    schemaVersion: 1,
+    schema: ChimneyNode,
+    category: 'structure',
+    surfaceRole: 'wall',
+    defaults: () => {
+        const stub = ChimneyNodeSchema.parse({
+            id: 'chimney_default',
+            type: 'chimney',
+            material: WHITE_MATERIAL,
+            topMaterial: WHITE_MATERIAL,
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Dirty marks
+        // cascade to the host segment's parent roof so its merged shell
+        // re-renders. No `buildCut` — the chimney does its own self-trim
+        // via `trimChimneyBodyAgainstRoof`; the host roof shell stays solid
+        // underneath.
+        roofAccessory: {},
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Chimney',
+        description: 'Vertical masonry stack on a roof segment.',
+        icon: { kind: 'url', src: '/icons/chimney.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 122,
+    },
+    mcp: {
+        description: 'A chimney on a roof segment. Square or round body; optional shoulder taper; sloped/flat/stepped cap; up to 4 protruding flues; optional cricket on the up-slope face.',
+    },
+};

package/dist/chimney/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/chimney/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAA;AAkCzB;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,eAAe,aAAc;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,uCA0RvD,CAAA;eAEc,eAAe"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/chimney/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAA;AAoCzB;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,eAAe,aAAc;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,uCA8RvD,CAAA;eAEc,eAAe"}

package/dist/chimney/move-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { ChimneyNode as ChimneyNodeSchema, emitter, sceneRegistry, useScene, } from '@pascal-app/core';
-import { consumePlacementDragRelease, copyCollectionIds, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { consumePlacementDragRelease, copyCollectionIds, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import * as THREE from 'three';
@@ -89,9 +89,9 @@ const MoveChimneyTool = ({ node }) => {
             if (!rawTarget)
                 return null;
             return snapRoofSurfaceNodeTarget({
-                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true),
+                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.altKey === true),
                 node,
-                bypass: event.nativeEvent?.shiftKey === true,
+                bypass: !isMagneticSnapActive() || event.nativeEvent?.altKey === true,
             });
         };
         const clearTarget = () => {
@@ -108,7 +108,9 @@ const MoveChimneyTool = ({ node }) => {
             const sx = Math.round(target.localX * 20) / 20;
             const sz = Math.round(target.localZ * 20) / 20;
             const prev = lastSnapRef.current;
-            if (event.nativeEvent?.shiftKey !== true && (!prev || prev[0] !== sx || prev[1] !== sz)) {
+            if (isGridSnapActive() &&
+                event.nativeEvent?.altKey !== true &&
+                (!prev || prev[0] !== sx || prev[1] !== sz)) {
                 triggerSFX('sfx:grid-snap');
                 lastSnapRef.current = [sx, sz];
             }

package/dist/column/__bench__/geometry.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=geometry.d.ts.map

package/dist/column/__bench__/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../../src/column/__bench__/geometry.ts"],"names":[],"mappings":""}

package/dist/column/__bench__/geometry.js

@@ -0,0 +1,36 @@
+import { ColumnNode } from '@pascal-app/core';
+import { createColumnShaftGeometry, createColumnSpiralGeometry } from '../geometry.js';
+import { columnShaftLayout } from '../shape.js';
+// Run with bun packages/nodes/src/column/__bench__/geometry.ts. CPU construction only; not viewer FPS.
+for (const scenario of ['round spiral', 'rectangular spiral', 'bulged fluted']) {
+    const crossSection = scenario === 'rectangular spiral' ? 'rectangular' : 'round';
+    const node = ColumnNode.parse({
+        crossSection,
+        shaftProfile: scenario === 'bulged fluted' ? 'bulged' : 'tapered',
+        shaftBulge: 0.12,
+        shaftSegmentCount: 32,
+        shaftDetail: scenario === 'bulged fluted' ? 'fluted' : 'spiral',
+        fluteCount: scenario === 'bulged fluted' ? 16 : 0,
+        spiralRibCount: scenario === 'bulged fluted' ? 0 : 24,
+        spiralTwist: 1,
+    });
+    const { shaftHeight } = columnShaftLayout(node);
+    const start = performance.now();
+    let triangles = 0;
+    for (let i = 0; i < 30; i++) {
+        const geometries = [
+            createColumnShaftGeometry(node, shaftHeight),
+            createColumnSpiralGeometry(node, shaftHeight),
+        ];
+        triangles = geometries.reduce((sum, geometry) => sum +
+            (geometry ? (geometry.index?.count ?? geometry.getAttribute('position').count) / 3 : 0), 0);
+        for (const geometry of geometries)
+            geometry?.dispose();
+    }
+    console.log({
+        scenario,
+        meshes: scenario === 'bulged fluted' ? 1 : 2,
+        triangles,
+        millisecondsPerBuild: (performance.now() - start) / 30,
+    });
+}

package/dist/column/bounds.d.ts

@@ -0,0 +1,7 @@
+import type { ColumnNode } from '@pascal-app/core';
+/** Conservative, origin-centred XZ envelope shared by plan, collision and handles. */
+export declare function columnFootprintHalf(n: ColumnNode): {
+    halfX: number;
+    halfZ: number;
+};
+//# sourceMappingURL=bounds.d.ts.map

package/dist/column/bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounds.d.ts","sourceRoot":"","sources":["../../src/column/bounds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AASlD,sFAAsF;AACtF,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAkJnF"}