@pascal-app/viewer 1.0.6 → 1.0.7

package/dist/lib/drone-flight.d.ts

@@ -0,0 +1,44 @@
+import { type Object3D, type Quaternion, Vector3 } from 'three';
+/** Cruise speed, metres per second. */
+export declare const DRONE_SPEED = 7;
+export declare const DRONE_RUN_MULTIPLIER = 3;
+/** Alt: a slower flight and a finer look, for framing. */
+export declare const DRONE_SLOW_MULTIPLIER = 0.2;
+/** Exponential approach rate toward the wanted velocity (1/s), not a linear acceleration. */
+export declare const DRONE_SMOOTHING = 12;
+/** Radians of turn per pixel of pointer-locked mouse movement. */
+export declare const FIRST_PERSON_LOOK_SENSITIVITY = 0.002;
+export type DroneLook = {
+    yaw: number;
+    pitch: number;
+};
+export type DroneInput = {
+    forward: boolean;
+    backward: boolean;
+    leftward: boolean;
+    rightward: boolean;
+    up: boolean;
+    down: boolean;
+    boost: boolean;
+    slow: boolean;
+};
+/** The drone control a `KeyboardEvent.code` drives, if any. */
+export declare function droneInputForKey(code: string): keyof DroneInput | null;
+export declare function createDroneInput(): DroneInput;
+/**
+ * Writes the controls the held keys drive into `out`. Reading from the set of
+ * held codes (rather than toggling a flag per key) keeps a control held while
+ * either of its keys is — releasing E does not cancel a held Space.
+ */
+export declare function readDroneInput(heldCodes: ReadonlySet<string>, out: DroneInput): DroneInput;
+/** Picks up the look angles from wherever the camera currently points. */
+export declare function seedDroneLook(look: DroneLook, quaternion: Quaternion): void;
+/** Turns a first-person look by a pointer-locked mouse movement; pitch stops short of straight up/down. */
+export declare function turnFirstPersonLook(look: DroneLook, movementX: number, movementY: number, sensitivityScale?: number): void;
+/**
+ * Advances the drone one frame: orients the camera from the look angles, eases
+ * `velocity` toward the wanted one (WASD along the view axes, pitch included;
+ * up/down along world Y) and moves the camera by it.
+ */
+export declare function stepDroneFlight(camera: Object3D, look: DroneLook, input: DroneInput, velocity: Vector3, delta: number): void;
+//# sourceMappingURL=drone-flight.d.ts.map

package/dist/lib/drone-flight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drone-flight.d.ts","sourceRoot":"","sources":["../../src/lib/drone-flight.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAKtE,uCAAuC;AACvC,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,eAAO,MAAM,oBAAoB,IAAI,CAAA;AACrC,0DAA0D;AAC1D,eAAO,MAAM,qBAAqB,MAAM,CAAA;AACxC,6FAA6F;AAC7F,eAAO,MAAM,eAAe,KAAK,CAAA;AACjC,kEAAkE;AAClE,eAAO,MAAM,6BAA6B,QAAQ,CAAA;AAMlD,MAAM,MAAM,SAAS,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtD,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,OAAO,CAAA;IAClB,EAAE,EAAE,OAAO,CAAA;IACX,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE,OAAO,CAAA;CACd,CAAA;AAsBD,+DAA+D;AAC/D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,UAAU,GAAG,IAAI,CAEtE;AAED,wBAAgB,gBAAgB,IAAI,UAAU,CAW7C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,UAAU,GAAG,UAAU,CAc1F;AAID,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,QAIpE;AAED,2GAA2G;AAC3G,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,gBAAgB,SAAI,QAKrB;AAOD;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,QAAQ,EAChB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,MAAM,QA2Bd"}

package/dist/lib/drone-flight.js

@@ -0,0 +1,121 @@
+import { Euler, Vector3 } from 'three';
+// The drone camera: a free flight with no gravity, floor or collision, shared by
+// the viewer's `DroneController` and the editor's first-person capture camera.
+/** Cruise speed, metres per second. */
+export const DRONE_SPEED = 7;
+export const DRONE_RUN_MULTIPLIER = 3;
+/** Alt: a slower flight and a finer look, for framing. */
+export const DRONE_SLOW_MULTIPLIER = 0.2;
+/** Exponential approach rate toward the wanted velocity (1/s), not a linear acceleration. */
+export const DRONE_SMOOTHING = 12;
+/** Radians of turn per pixel of pointer-locked mouse movement. */
+export const FIRST_PERSON_LOOK_SENSITIVITY = 0.002;
+const PITCH_LIMIT = Math.PI / 2 - 0.05;
+// A long frame (tab switch, GC pause) must not teleport the camera.
+const MAX_STEP = 0.1;
+const DRONE_KEY_BINDINGS = {
+    KeyW: 'forward',
+    ArrowUp: 'forward',
+    KeyS: 'backward',
+    ArrowDown: 'backward',
+    KeyA: 'leftward',
+    ArrowLeft: 'leftward',
+    KeyD: 'rightward',
+    ArrowRight: 'rightward',
+    Space: 'up',
+    KeyE: 'up',
+    KeyQ: 'down',
+    ControlLeft: 'down',
+    ControlRight: 'down',
+    ShiftLeft: 'boost',
+    ShiftRight: 'boost',
+    AltLeft: 'slow',
+    AltRight: 'slow',
+};
+/** The drone control a `KeyboardEvent.code` drives, if any. */
+export function droneInputForKey(code) {
+    return DRONE_KEY_BINDINGS[code] ?? null;
+}
+export function createDroneInput() {
+    return {
+        forward: false,
+        backward: false,
+        leftward: false,
+        rightward: false,
+        up: false,
+        down: false,
+        boost: false,
+        slow: false,
+    };
+}
+/**
+ * Writes the controls the held keys drive into `out`. Reading from the set of
+ * held codes (rather than toggling a flag per key) keeps a control held while
+ * either of its keys is — releasing E does not cancel a held Space.
+ */
+export function readDroneInput(heldCodes, out) {
+    out.forward = false;
+    out.backward = false;
+    out.leftward = false;
+    out.rightward = false;
+    out.up = false;
+    out.down = false;
+    out.boost = false;
+    out.slow = false;
+    for (const code of heldCodes) {
+        const control = DRONE_KEY_BINDINGS[code];
+        if (control)
+            out[control] = true;
+    }
+    return out;
+}
+const lookEuler = new Euler(0, 0, 0, 'YXZ');
+/** Picks up the look angles from wherever the camera currently points. */
+export function seedDroneLook(look, quaternion) {
+    lookEuler.setFromQuaternion(quaternion, 'YXZ');
+    look.yaw = lookEuler.y;
+    look.pitch = lookEuler.x;
+}
+/** Turns a first-person look by a pointer-locked mouse movement; pitch stops short of straight up/down. */
+export function turnFirstPersonLook(look, movementX, movementY, sensitivityScale = 1) {
+    const sensitivity = FIRST_PERSON_LOOK_SENSITIVITY * sensitivityScale;
+    look.yaw -= movementX * sensitivity;
+    look.pitch = Math.max(-PITCH_LIMIT, Math.min(PITCH_LIMIT, look.pitch - movementY * sensitivity));
+}
+const flightEuler = new Euler(0, 0, 0, 'YXZ');
+const flightForward = new Vector3();
+const flightRight = new Vector3();
+const flightDesired = new Vector3();
+/**
+ * Advances the drone one frame: orients the camera from the look angles, eases
+ * `velocity` toward the wanted one (WASD along the view axes, pitch included;
+ * up/down along world Y) and moves the camera by it.
+ */
+export function stepDroneFlight(camera, look, input, velocity, delta) {
+    const step = Math.min(delta, MAX_STEP);
+    flightEuler.set(look.pitch, look.yaw, 0, 'YXZ');
+    camera.quaternion.setFromEuler(flightEuler);
+    flightForward.set(0, 0, -1).applyEuler(flightEuler);
+    flightRight.set(1, 0, 0).applyEuler(flightEuler);
+    flightDesired.set(0, 0, 0);
+    if (input.forward)
+        flightDesired.add(flightForward);
+    if (input.backward)
+        flightDesired.sub(flightForward);
+    if (input.rightward)
+        flightDesired.add(flightRight);
+    if (input.leftward)
+        flightDesired.sub(flightRight);
+    if (input.up)
+        flightDesired.y += 1;
+    if (input.down)
+        flightDesired.y -= 1;
+    if (flightDesired.lengthSq() > 0) {
+        flightDesired
+            .normalize()
+            .multiplyScalar(DRONE_SPEED * (input.slow ? DRONE_SLOW_MULTIPLIER : input.boost ? DRONE_RUN_MULTIPLIER : 1));
+    }
+    velocity.lerp(flightDesired, 1 - Math.exp(-step * DRONE_SMOOTHING));
+    camera.position.addScaledVector(velocity, step);
+    camera.updateMatrixWorld(true);
+}

package/dist/lib/editor-highlight.d.ts

@@ -0,0 +1,16 @@
+import { Color, type Material } from 'three';
+/**
+ * Marks an editor highlight material (selection, hover, delete): a clone of the object's own
+ * material with a soft emissive tint, so it reads as marked. The daylight look must not treat
+ * that tint as a glowing surface (no night boost, no exposure lift, no bloom): the object stays
+ * readable under it at any time of day.
+ */
+export declare function markHighlight<T extends Material>(material: T): T;
+export declare function isHighlight(material: Material | null | undefined): boolean;
+/**
+ * Adds a highlight tint to `material`'s emission: its own glow (a lamp's shade) as it was, plus
+ * `color` × `amount`. The intensity is folded into the colour (and set to 1): a material's default
+ * intensity is 1, so raising it to the tint's would have run the tint at full strength.
+ */
+export declare function tintEmissive(material: Material, color: Color, amount: number): void;
+//# sourceMappingURL=editor-highlight.d.ts.map

package/dist/lib/editor-highlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-highlight.d.ts","sourceRoot":"","sources":["../../src/lib/editor-highlight.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAE5C;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,QAAQ,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAOhE;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE1E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAQnF"}

package/dist/lib/editor-highlight.js

@@ -0,0 +1,33 @@
+import { Color } from 'three';
+/**
+ * Marks an editor highlight material (selection, hover, delete): a clone of the object's own
+ * material with a soft emissive tint, so it reads as marked. The daylight look must not treat
+ * that tint as a glowing surface (no night boost, no exposure lift, no bloom): the object stays
+ * readable under it at any time of day.
+ */
+export function markHighlight(material) {
+    material.userData.editorHighlight = true;
+    // three shares a compiled program between materials of the same shape (userData aside): a
+    // highlight must get its own, or it renders with its source's and the daylight hooks miss it.
+    const key = material.customProgramCacheKey.bind(material);
+    material.customProgramCacheKey = () => `${key()}|editor-highlight`;
+    return material;
+}
+export function isHighlight(material) {
+    return material?.userData.editorHighlight === true;
+}
+/**
+ * Adds a highlight tint to `material`'s emission: its own glow (a lamp's shade) as it was, plus
+ * `color` × `amount`. The intensity is folded into the colour (and set to 1): a material's default
+ * intensity is 1, so raising it to the tint's would have run the tint at full strength.
+ */
+export function tintEmissive(material, color, amount) {
+    const m = material;
+    if (!(m.emissive instanceof Color))
+        return;
+    m.emissive = m.emissive
+        .clone()
+        .multiplyScalar(m.emissiveIntensity ?? 1)
+        .add(color.clone().multiplyScalar(amount));
+    m.emissiveIntensity = 1;
+}

package/dist/lib/foundation-materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"foundation-materials.d.ts","sourceRoot":"","sources":["../../src/lib/foundation-materials.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AAkBtD,mGAAmG;AACnG,eAAO,MAAM,gBAAgB;aAC3B,GAAG;aACH,QAAQ;CACA,CAAA;AAUV,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IACvC,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,OAM3B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,EAChE,KAAK,GAAE,GAA0C,2BAkBlD;AAED,wBAAgB,gBAAgB,4BAO/B"}
+{"version":3,"file":"foundation-materials.d.ts","sourceRoot":"","sources":["../../src/lib/foundation-materials.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AAgBtD,mGAAmG;AACnG,eAAO,MAAM,gBAAgB;aAC3B,GAAG;aACH,QAAQ;CACA,CAAA;AAUV,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IACvC,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,OAM3B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,EAChE,KAAK,GAAE,GAA0C,2BAkBlD;AAED,wBAAgB,gBAAgB,4BAO/B"}

package/dist/lib/foundation-materials.js

@@ -2,10 +2,8 @@ import { FrontSide } from 'three';
 import { attribute, color, float, floor, fract, mix, mod, mx_noise_float, normalLocal, positionWorld, smoothstep, step, vec3, } from 'three/tsl';
 import { MeshLambertNodeMaterial } from 'three/webgpu';
 /**
- * How bare structure looks: courses of block, and cast concrete. The generic foundation under a
- * building draws them (nodes `generic-foundation.tsx`), and a wall whose assembly has no cladding
- * over a masonry or concrete core shows the same on its exterior face (`wall-materials.ts`), so a
- * basement's walls above grade read as the foundation under them.
+ * How bare structure looks: courses of block, and cast concrete. A wall whose assembly has no
+ * cladding over a masonry or concrete core shows it on its exterior face (`wall-materials.ts`).
  */
 const INCH = 0.0254;
 /** A nominal 8 × 8 × 16 in block: the course is 8 in with its joint, a block 16 in long. */

package/dist/lib/glb-merge.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+export type GlbMergeOptions = {
+    /** pascalIds whose meshes must stay individual (lit lamps, animated fixtures). */
+    keepIds: ReadonlySet<string>;
+    /** Nodes driven by animation tracks (their subtrees move). */
+    animated: ReadonlySet<THREE.Object3D>;
+};
+export type GlbBatch = THREE.Mesh & {
+    userData: {
+        glbBatch: true;
+        role?: string;
+        bakedMaterial: THREE.Material;
+    };
+};
+export type GlbMerge = {
+    batches: GlbBatch[];
+    merged: number;
+    /** Changes when any merged original is shown or hidden on its own (the merge is then stale). */
+    visibilitySignature(): number;
+    dispose(): void;
+};
+export declare function mergeBakedStatic(root: THREE.Object3D, roleOf: (kind: string | undefined) => string | undefined, options: GlbMergeOptions): GlbMerge;
+//# sourceMappingURL=glb-merge.d.ts.map

package/dist/lib/glb-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glb-merge.d.ts","sourceRoot":"","sources":["../../src/lib/glb-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA0B9B,MAAM,MAAM,eAAe,GAAG;IAC5B,kFAAkF;IAClF,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC5B,8DAA8D;IAC9D,QAAQ,EAAE,WAAW,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;CACtC,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,GAAG;IAClC,QAAQ,EAAE;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAA;KAAE,CAAA;CAC3E,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,EAAE,QAAQ,EAAE,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,gGAAgG;IAChG,mBAAmB,IAAI,MAAM,CAAA;IAC7B,OAAO,IAAI,IAAI,CAAA;CAChB,CAAA;AAQD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,KAAK,CAAC,QAAQ,EACpB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,KAAK,MAAM,GAAG,SAAS,EACxD,OAAO,EAAE,eAAe,GACvB,QAAQ,CA6IV"}

package/dist/lib/glb-merge.js

@@ -0,0 +1,184 @@
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js';
+import { hideFromScene, showInScene } from './scene-visibility';
+const KEPT_KINDS = new Set(['ceiling', 'roof', 'roof-segment', 'site', 'zone', 'spawn', 'level']);
+const ATTRIBUTES = ['position', 'normal', 'uv', 'uv1', 'color'];
+/** Cell size (m) batches are split by, so frustum culling still drops what's behind the eye. */
+const CELL = 24;
+const NO_RAYCAST = () => { };
+export function mergeBakedStatic(root, roleOf, options) {
+    root.updateWorldMatrix(true, true);
+    const groups = new Map();
+    const center = new THREE.Vector3();
+    root.traverse((object) => {
+        const mesh = object;
+        if (!mesh.isMesh || mesh.userData.glbBatch)
+            return;
+        if (mesh.isSkinnedMesh || mesh.isInstancedMesh)
+            return;
+        const material = (mesh.userData.__bakedMaterial ??
+            mesh.material);
+        if (Array.isArray(material) || !material)
+            return;
+        const glass = material.transparent || material.userData.isGlass || mesh.userData.slotId === 'glass';
+        if (mesh.geometry.morphAttributes.position)
+            return;
+        const geometry = mesh.geometry;
+        if (!geometry.getAttribute('position') || !geometry.getAttribute('normal'))
+            return;
+        // Walk up once: the level, the nearest moving pivot (a sash, a door leaf: its parts merge
+        // under it and swing with it), the owner's kind, and anything that disqualifies.
+        let level = null;
+        let pivot = null;
+        let ownerKind;
+        let inGlassSlot = false;
+        for (let x = mesh; x; x = x.parent) {
+            if (!x.visible)
+                return;
+            const extras = x.userData;
+            if (!pivot && x !== mesh && (options.animated.has(x) || extras.proceduralMotion))
+                pivot = x;
+            if (extras.slotId === 'glass')
+                inGlassSlot = true;
+            if (extras.pascalId) {
+                if (options.keepIds.has(extras.pascalId))
+                    return;
+                if (ownerKind === undefined && extras.kind !== 'level')
+                    ownerKind = extras.kind ?? '';
+            }
+            const kind = extras.kind;
+            if (kind === 'level') {
+                level = x;
+                break;
+            }
+            if (kind && (KEPT_KINDS.has(kind) || kind.includes(':')))
+                return;
+        }
+        if (!level || options.animated.has(mesh))
+            return;
+        // Glass sorts per mesh: merge it only within one moving part (one sash's panes together).
+        if ((glass || inGlassSlot) && !pivot)
+            return;
+        const anchor = pivot ?? level;
+        const role = roleOf(ownerKind);
+        const signature = ATTRIBUTES.filter((name) => geometry.getAttribute(name)).join(',');
+        if (!geometry.boundingBox)
+            geometry.computeBoundingBox();
+        geometry.boundingBox.getCenter(center).applyMatrix4(mesh.matrixWorld);
+        const cell = pivot ? '' : `${Math.floor(center.x / CELL)},${Math.floor(center.z / CELL)}`;
+        const key = [
+            anchor.uuid,
+            cell,
+            material.uuid,
+            role ?? '',
+            signature,
+            mesh.castShadow,
+            mesh.receiveShadow,
+        ].join('|');
+        let group = groups.get(key);
+        if (!group) {
+            group = { anchor, material, role, meshes: [] };
+            groups.set(key, group);
+        }
+        group.meshes.push(mesh);
+    });
+    const batches = [];
+    const originals = [];
+    const toAnchor = new THREE.Matrix4();
+    const local = new THREE.Matrix4();
+    for (const group of groups.values()) {
+        if (group.meshes.length < 2)
+            continue;
+        toAnchor.copy(group.anchor.matrixWorld).invert();
+        const names = ATTRIBUTES.filter((name) => group.meshes[0].geometry.getAttribute(name));
+        const parts = [];
+        for (const mesh of group.meshes) {
+            const source = mesh.geometry;
+            const part = new THREE.BufferGeometry();
+            for (const name of names)
+                part.setAttribute(name, toFloat(source.getAttribute(name)));
+            const count = part.getAttribute('position').count;
+            part.setIndex(source.index
+                ? Array.from(source.index.array)
+                : Array.from({ length: count }, (_, i) => i));
+            local.multiplyMatrices(toAnchor, mesh.matrixWorld);
+            part.applyMatrix4(local);
+            if (local.determinant() < 0)
+                flipWinding(part); // mirrored transforms flip winding
+            parts.push(part);
+        }
+        const geometry = mergeGeometries(parts, false);
+        for (const part of parts)
+            part.dispose();
+        if (!geometry)
+            continue;
+        geometry.computeBoundingBox();
+        geometry.computeBoundingSphere();
+        const batch = new THREE.Mesh(geometry, group.material);
+        batch.name = `glb-batch:${group.material.name || group.material.type}`;
+        batch.castShadow = group.meshes[0].castShadow;
+        batch.receiveShadow = group.meshes[0].receiveShadow;
+        batch.userData = { glbBatch: true, role: group.role, bakedMaterial: group.material };
+        batch.raycast = NO_RAYCAST;
+        group.anchor.add(batch);
+        batches.push(batch);
+        for (const mesh of group.meshes) {
+            hideFromScene(mesh, 'batched');
+            originals.push(mesh);
+        }
+    }
+    return {
+        batches,
+        merged: originals.length,
+        visibilitySignature() {
+            let h = 0;
+            for (let i = 0; i < originals.length; i++) {
+                const mesh = originals[i];
+                // Its own visibility up to the level: level-wide hiding is the batch's parent's job.
+                let shown = true;
+                for (let x = mesh; x && shown; x = x.parent) {
+                    if (x.userData.kind === 'level')
+                        break;
+                    shown = x.visible;
+                }
+                if (shown)
+                    h += (i % 97) + 1;
+            }
+            return h;
+        },
+        dispose() {
+            for (const batch of batches) {
+                batch.removeFromParent();
+                batch.geometry.dispose();
+            }
+            for (const mesh of originals)
+                showInScene(mesh, 'batched');
+            batches.length = 0;
+            originals.length = 0;
+        },
+    };
+}
+function toFloat(attribute) {
+    const count = attribute.count;
+    const size = attribute.itemSize;
+    const out = new Float32Array(count * size);
+    for (let i = 0; i < count; i++) {
+        out[i * size] = attribute.getX(i);
+        if (size > 1)
+            out[i * size + 1] = attribute.getY(i);
+        if (size > 2)
+            out[i * size + 2] = attribute.getZ(i);
+        if (size > 3)
+            out[i * size + 3] = attribute.getW(i);
+    }
+    return new THREE.BufferAttribute(out, size);
+}
+function flipWinding(geometry) {
+    const index = geometry.index.array;
+    for (let i = 0; i < index.length; i += 3) {
+        const t = index[i + 1];
+        index[i + 1] = index[i + 2];
+        index[i + 2] = t;
+    }
+    geometry.index.needsUpdate = true;
+}

package/dist/lib/hardware-geometry.d.ts

@@ -0,0 +1,21 @@
+import { type BufferGeometry } from 'three';
+export declare function leverOnRose(): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+export declare function leverOnRoseCurved(): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+export declare function leverOnPlate(): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+/** Origin at the mounting face; a 56 mm ball on a 20 mm neck and 56 mm rose. */
+export declare function knobOnRose(): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+/** Origin at the face; a 40 × 120 mm open cup with a 3 mm rim, recessed 12 mm. */
+export declare function flushPull(): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+/** Odd knuckles and plate on the leaf edge (+X), extending into the rebate (-Z). */
+export declare function hingeLeafPart(diameter?: number, height?: number): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+/** Even knuckles and plate on the jamb face (-X), extending into the rebate (-Z). */
+export declare function hingeJambPart(diameter?: number, height?: number): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+/** Origin on the mounting face; bar along Y, projecting along +Z. */
+export declare function pullBar(doorScale?: boolean): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+export declare function roundedBox(w: number, h: number, d: number, r?: number): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+/** A capped round bar along Y. */
+export declare function tube(radius: number, length: number): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+export declare function sphere(radius: number): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+/** A wheel with its axle along Z. */
+export declare function roller(radius: number, width: number): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+//# sourceMappingURL=hardware-geometry.d.ts.map

package/dist/lib/hardware-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hardware-geometry.d.ts","sourceRoot":"","sources":["../../src/lib/hardware-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EASpB,MAAM,OAAO,CAAA;AAgKd,wBAAgB,WAAW,mGAE1B;AAED,wBAAgB,iBAAiB,mGAEhC;AAED,wBAAgB,YAAY,mGAE3B;AAED,gFAAgF;AAChF,wBAAgB,UAAU,mGAazB;AAED,kFAAkF;AAClF,wBAAgB,SAAS,mGAiBxB;AAsCD,oFAAoF;AACpF,wBAAgB,aAAa,CAAC,QAAQ,SAAQ,EAAE,MAAM,SAAQ,kGAE7D;AAED,qFAAqF;AACrF,wBAAgB,aAAa,CAAC,QAAQ,SAAQ,EAAE,MAAM,SAAQ,kGAE7D;AAED,qEAAqE;AACrE,wBAAgB,OAAO,CAAC,SAAS,UAAQ,kGA0BxC;AAmBD,wBAAgB,UAAU,CACxB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,SAAuC,kGAOzC;AAED,kCAAkC;AAClC,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kGAElD;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,kGAMpC;AAED,qCAAqC;AACrC,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,kGAInD"}