@pascal-app/nodes 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/wall/wall-batch-system.d.ts

@@ -0,0 +1,23 @@
+import { type WallMode } from '@pascal-app/viewer';
+import { type Material, Mesh } from 'three';
+export type WallBatchCandidate = {
+    nodeId: string;
+    mesh: Mesh;
+    materials: Material[];
+};
+/**
+ * Whether a level's walls may be merged at all right now.
+ *
+ * The merged mesh captures one material set when it is sewn and nothing
+ * re-reads it, so batching is only sound while every batched wall's materials
+ * hold still. That is true in one wall mode. `cutaway` re-assigns materials
+ * from the camera's facing test as the view turns, `down` makes every wall
+ * see-through and `translucent` does the same by definition — in all three the
+ * merged copy would keep drawing walls the cutaway pass has since turned to
+ * glass. Isolation is the other stand-down: it hides the level root the merged
+ * mesh hangs off, which would leave a focused batched wall drawn by nobody.
+ */
+export declare function canBatchWalls(wallMode: WallMode, isolationActive: boolean): boolean;
+export declare function collectWallBatchCandidates(levelId: string, excludedNodeIds?: ReadonlySet<string>): Map<string, WallBatchCandidate[]>;
+export declare const WallBatchSystem: () => null;
+//# sourceMappingURL=wall-batch-system.d.ts.map

package/dist/wall/wall-batch-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-batch-system.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch-system.tsx"],"names":[],"mappings":"AAGA,OAAO,EAML,KAAK,QAAQ,EACd,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EAAE,KAAK,QAAQ,EAAW,IAAI,EAAiB,MAAM,OAAO,CAAA;AA4HnE,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAA;AA8BtF;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,OAAO,GAAG,OAAO,CAEnF;AA2BD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,eAAe,GAAE,WAAW,CAAC,MAAM,CAAa,GAC/C,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAoBnC;AAqFD,eAAO,MAAM,eAAe,YAwB3B,CAAA"}

package/dist/wall/wall-batch-system.js

@@ -0,0 +1,389 @@
+'use client';
+import { sceneRegistry, useScene } from '@pascal-app/core';
+import { drainRebuiltWalls, getPendingWallRebuildCount, isIsolationActive, SCENE_LAYER, useViewer, } from '@pascal-app/viewer';
+import { useFrame, useThree } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
+import { Matrix4, Mesh } from 'three';
+import { applyWallBatchGroups, buildWallBatch, hideBatchedWall, revealBatchedWall, } from './wall-batch';
+// A level's walls are merged only once they stop changing. Below this many
+// walls a merge is not worth the buffer, and the leftovers (a selected wall,
+// a lone partition) keep drawing themselves.
+const MIN_BATCH_WALLS = 8;
+// Quiet window after the last wall change before the merge runs.
+const BATCH_SETTLE_MS = 180;
+const lastAppearance = {
+    shading: undefined,
+    textures: undefined,
+    colorPreset: undefined,
+    sceneTheme: undefined,
+    materials: null,
+};
+function appearanceChanged() {
+    const viewer = useViewer.getState();
+    const materials = useScene.getState().materials;
+    if (lastAppearance.shading === viewer.shading &&
+        lastAppearance.textures === viewer.textures &&
+        lastAppearance.colorPreset === viewer.colorPreset &&
+        lastAppearance.sceneTheme === viewer.sceneTheme &&
+        lastAppearance.materials === materials) {
+        return false;
+    }
+    lastAppearance.shading = viewer.shading;
+    lastAppearance.textures = viewer.textures;
+    lastAppearance.colorPreset = viewer.colorPreset;
+    lastAppearance.sceneTheme = viewer.sceneTheme;
+    lastAppearance.materials = materials;
+    return true;
+}
+const batchesByLevel = new Map();
+const batchByNode = new Map();
+const staleLevels = new Set();
+const changedWalls = new Set();
+const EMPTY_IDS = new Set();
+let knownWallCount = -1;
+let lastWallChangeAtMs = 0;
+let batchingSuspended = false;
+/**
+ * Batched walls are drawn by the merged mesh but still picked, measured and
+ * highlighted through their own meshes, so the merged copy must stay out of
+ * every raycast.
+ */
+function skipRaycast() {
+    // intentionally empty — see the note above
+}
+function showOwnGeometry(nodeId) {
+    const mesh = sceneRegistry.nodes.get(nodeId);
+    if (mesh)
+        revealBatchedWall(mesh);
+}
+/** Hands a wall back to itself: the merged mesh stops drawing it, it resumes. */
+function releaseWall(nodeId) {
+    const record = batchByNode.get(nodeId);
+    if (record) {
+        record.hidden.add(nodeId);
+        applyWallBatchGroups(record.batch, record.hidden);
+        batchByNode.delete(nodeId);
+    }
+    showOwnGeometry(nodeId);
+}
+function disposeLevelBatches(levelId) {
+    const records = batchesByLevel.get(levelId);
+    if (!records)
+        return;
+    for (const record of records) {
+        record.mesh.removeFromParent();
+        record.batch.geometry.dispose();
+        for (const nodeId of record.nodeIds) {
+            if (batchByNode.get(nodeId) === record)
+                batchByNode.delete(nodeId);
+            showOwnGeometry(nodeId);
+        }
+    }
+    batchesByLevel.delete(levelId);
+}
+/**
+ * A wall joins a batch only if its whole material set is opaque. Translucent
+ * and cut-away walls depend on per-object blend ordering, which merging would
+ * change — they keep the per-wall path.
+ */
+function toCandidate(nodeId, node, excludedNodeIds = EMPTY_IDS) {
+    if (excludedNodeIds.has(nodeId))
+        return null;
+    if (node.visible === false)
+        return null;
+    const mesh = sceneRegistry.nodes.get(nodeId);
+    if (!mesh?.visible)
+        return null;
+    // Solo's shadow-caster-only pass and the viewer's isolation filter both
+    // hide a wall by taking it off the scene layer. Sewing it in would put it
+    // back on screen through the merged mesh, which neither asked for.
+    if (!mesh.layers.isEnabled(SCENE_LAYER))
+        return null;
+    if (!mesh.geometry?.getAttribute('position'))
+        return null;
+    const materials = mesh.material;
+    if (!Array.isArray(materials) || materials.length === 0)
+        return null;
+    if (materials.some((material) => material.transparent))
+        return null;
+    return { nodeId, mesh, materials };
+}
+/**
+ * Whether a level's walls may be merged at all right now.
+ *
+ * The merged mesh captures one material set when it is sewn and nothing
+ * re-reads it, so batching is only sound while every batched wall's materials
+ * hold still. That is true in one wall mode. `cutaway` re-assigns materials
+ * from the camera's facing test as the view turns, `down` makes every wall
+ * see-through and `translucent` does the same by definition — in all three the
+ * merged copy would keep drawing walls the cutaway pass has since turned to
+ * glass. Isolation is the other stand-down: it hides the level root the merged
+ * mesh hangs off, which would leave a focused batched wall drawn by nobody.
+ */
+export function canBatchWalls(wallMode, isolationActive) {
+    return !isolationActive && wallMode === 'up';
+}
+/**
+ * Walls the cutaway pass is currently tinting — a selection or a delete hover.
+ *
+ * It paints them by swapping the materials on the wall's own mesh, which the
+ * merged mesh does not follow, so a lit wall goes back to drawing itself. There
+ * are only ever a handful, and a handful of extra draw calls is what the tint
+ * costs.
+ */
+function collectTintedWalls(wallIds) {
+    const viewer = useViewer.getState();
+    const tinted = new Set();
+    for (const id of viewer.selection.selectedIds)
+        if (wallIds.has(id))
+            tinted.add(id);
+    for (const id of viewer.previewSelectedIds)
+        if (wallIds.has(id))
+            tinted.add(id);
+    const hovered = viewer.hoverHighlightMode === 'delete' ? viewer.hoveredId : null;
+    if (hovered && wallIds.has(hovered))
+        tinted.add(hovered);
+    return tinted;
+}
+function materialSetKey(materials) {
+    return materials.map((material) => material.uuid).join('|');
+}
+export function collectWallBatchCandidates(levelId, excludedNodeIds = EMPTY_IDS) {
+    const nodes = useScene.getState().nodes;
+    const level = nodes[levelId];
+    const grouped = new Map();
+    if (level?.type !== 'level')
+        return grouped;
+    for (const childId of level.children) {
+        const child = nodes[childId];
+        if (child?.type !== 'wall')
+            continue;
+        const candidate = toCandidate(childId, child, excludedNodeIds);
+        if (!candidate)
+            continue;
+        const key = materialSetKey(candidate.materials);
+        const bucket = grouped.get(key);
+        if (bucket)
+            bucket.push(candidate);
+        else
+            grouped.set(key, [candidate]);
+    }
+    return grouped;
+}
+/**
+ * Walls on this level that no batch currently draws.
+ *
+ * Editing a wall drops it out of its batch — a group-list rewrite that touches
+ * no buffer — and it goes back to drawing itself. Re-sewing the level only
+ * pays off once enough walls have drifted out, so a single edit leaves the
+ * floor's merged mesh exactly where it was.
+ */
+function unbatchedWallCount(levelId, excludedNodeIds = EMPTY_IDS) {
+    const nodes = useScene.getState().nodes;
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return 0;
+    let count = 0;
+    for (const childId of level.children) {
+        if (excludedNodeIds.has(childId))
+            continue;
+        if (batchByNode.has(childId))
+            continue;
+        const child = nodes[childId];
+        if (child?.type !== 'wall')
+            continue;
+        if (toCandidate(childId, child))
+            count++;
+    }
+    return count;
+}
+const localMatrix = new Matrix4();
+const rootInverse = new Matrix4();
+function mergeLevel(levelId, excludedNodeIds = EMPTY_IDS) {
+    disposeLevelBatches(levelId);
+    const root = sceneRegistry.nodes.get(levelId);
+    if (!root)
+        return;
+    root.updateWorldMatrix(true, false);
+    rootInverse.copy(root.matrixWorld).invert();
+    const records = [];
+    for (const candidates of collectWallBatchCandidates(levelId, excludedNodeIds).values()) {
+        if (candidates.length < MIN_BATCH_WALLS)
+            continue;
+        const sources = candidates.map((candidate) => {
+            candidate.mesh.updateWorldMatrix(true, false);
+            return {
+                nodeId: candidate.nodeId,
+                geometry: candidate.mesh.geometry,
+                matrix: localMatrix.multiplyMatrices(rootInverse, candidate.mesh.matrixWorld).clone(),
+            };
+        });
+        const batch = buildWallBatch(sources);
+        if (!batch)
+            continue;
+        const mesh = new Mesh(batch.geometry, candidates[0].materials);
+        mesh.name = 'wall-batch';
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+        mesh.matrixAutoUpdate = false;
+        mesh.raycast = skipRaycast;
+        root.add(mesh);
+        const record = {
+            levelId,
+            mesh,
+            batch,
+            hidden: new Set(),
+            nodeIds: candidates.map((candidate) => candidate.nodeId),
+        };
+        records.push(record);
+        for (const candidate of candidates) {
+            hideBatchedWall(candidate.mesh);
+            batchByNode.set(candidate.nodeId, record);
+        }
+    }
+    if (records.length > 0)
+        batchesByLevel.set(levelId, records);
+}
+export const WallBatchSystem = () => {
+    const invalidate = useThree((state) => state.invalidate);
+    const wakeRef = useRef(null);
+    useFrame(() => runBatchFrame(invalidate, wakeRef), 5);
+    useEffect(() => () => {
+        if (wakeRef.current)
+            clearTimeout(wakeRef.current);
+        for (const levelId of [...batchesByLevel.keys()])
+            disposeLevelBatches(levelId);
+        changedWalls.clear();
+        staleLevels.clear();
+        knownWallCount = -1;
+        batchingSuspended = false;
+        lastAppearance.shading = undefined;
+        lastAppearance.textures = undefined;
+        lastAppearance.colorPreset = undefined;
+        lastAppearance.sceneTheme = undefined;
+        lastAppearance.materials = null;
+    }, []);
+    return null;
+};
+/**
+ * Follows the scene's dirty tracking rather than watching the walls itself.
+ *
+ * A wall changes for exactly one reason the merged mesh cares about: the wall
+ * system rebuilt its geometry. That system already runs off `dirtyNodes`, so
+ * this reads the same signal from both ends — the marks still standing when
+ * this frame reaches us, and the rebuild notices the wall system left behind
+ * for the walls whose marks it has already cleared. Nothing here re-derives
+ * "did this wall move" on its own, and the per-frame cost is the size of the
+ * dirty set rather than the size of the floor.
+ */
+function runBatchFrame(invalidate, wakeRef) {
+    const wallIds = sceneRegistry.byType.wall ?? EMPTY_IDS;
+    const nodes = useScene.getState().nodes;
+    // Walls the wall system rebuilt: it clears each mark as it goes, so by the
+    // time this runs the store no longer names them.
+    drainRebuiltWalls(changedWalls);
+    // Walls still marked: the wall system deferred them to a later frame (a
+    // progressive import) or their mesh had not mounted yet.
+    for (const nodeId of useScene.getState().dirtyNodes) {
+        if (wallIds.has(nodeId))
+            changedWalls.add(nodeId);
+    }
+    let changed = changedWalls.size > 0;
+    for (const nodeId of changedWalls) {
+        const record = batchByNode.get(nodeId);
+        if (record)
+            staleLevels.add(record.levelId);
+        const node = nodes[nodeId];
+        if (node?.type === 'wall' && node.parentId)
+            staleLevels.add(node.parentId);
+        releaseWall(nodeId);
+    }
+    changedWalls.clear();
+    // A tinted wall paints itself through materials the merged mesh never reads,
+    // so it goes back to drawing its own geometry for as long as it is lit. It
+    // stays out afterwards: one wall short of a batch is not worth re-sewing a
+    // floor over, and the level's own re-merge threshold decides when it is.
+    const tintedWalls = collectTintedWalls(wallIds);
+    for (const nodeId of tintedWalls) {
+        if (!batchByNode.has(nodeId))
+            continue;
+        const record = batchByNode.get(nodeId);
+        if (record)
+            staleLevels.add(record.levelId);
+        releaseWall(nodeId);
+        changed = true;
+    }
+    // A theme, texture or material-library switch re-makes every wall's
+    // materials without marking a single node, so the merged copies have to be
+    // sewn again from the new ones. See `appearanceChanged`.
+    if (appearanceChanged()) {
+        for (const levelId of [...batchesByLevel.keys()])
+            disposeLevelBatches(levelId);
+        for (const levelId of sceneRegistry.byType.level ?? EMPTY_IDS)
+            staleLevels.add(levelId);
+        changed = true;
+    }
+    // A wall that left the scene carries no mark of its own — deleting one
+    // dirties the neighbours it re-mitres, not the node that went away. The
+    // wall count moving is the cheap tell that the batch needs reconciling.
+    if (wallIds.size !== knownWallCount) {
+        knownWallCount = wallIds.size;
+        for (const [nodeId, record] of [...batchByNode]) {
+            if (wallIds.has(nodeId))
+                continue;
+            staleLevels.add(record.levelId);
+            releaseWall(nodeId);
+            changed = true;
+        }
+    }
+    // Two things make merging unsound, and both are handled the same way: the
+    // batch stands down for as long as they hold, and sews the floors back
+    // together once they lift. Isolation hides everything outside the focused
+    // subtree, and a level's merged mesh hangs off the level root — so it goes
+    // dark with everything else, leaving a focused batched wall drawn by nobody.
+    // Every wall mode but `up` re-assigns wall materials the merged mesh does not
+    // follow. See `canBatchWalls`.
+    const suspended = !canBatchWalls(useViewer.getState().wallMode, isIsolationActive());
+    if (suspended !== batchingSuspended) {
+        batchingSuspended = suspended;
+        for (const levelId of [...batchesByLevel.keys()])
+            disposeLevelBatches(levelId);
+        staleLevels.clear();
+        if (!suspended) {
+            for (const levelId of sceneRegistry.byType.level ?? EMPTY_IDS)
+                staleLevels.add(levelId);
+        }
+        changed = true;
+    }
+    if (batchingSuspended) {
+        staleLevels.clear();
+        return;
+    }
+    const now = performance.now();
+    if (changed)
+        lastWallChangeAtMs = now;
+    if (staleLevels.size === 0)
+        return;
+    // Merging mid-edit would sew stale geometry in: a dragged wall's neighbours
+    // are deferred to the wall system's trailing-edge flush, and those rebuilds
+    // land after the drag's last dirty mark. Waiting on its queue — not just on
+    // a clock — is what keeps a re-sewn floor in step with the walls it copies.
+    const settled = !changed && getPendingWallRebuildCount() === 0 && now - lastWallChangeAtMs >= BATCH_SETTLE_MS;
+    if (!settled) {
+        // The canvas renders on demand, so nothing would bring us back once the
+        // scene goes quiet — poke one frame after the window should have closed.
+        if (wakeRef.current)
+            clearTimeout(wakeRef.current);
+        wakeRef.current = setTimeout(() => {
+            wakeRef.current = null;
+            invalidate();
+        }, BATCH_SETTLE_MS + 20);
+        return;
+    }
+    for (const levelId of staleLevels) {
+        if (unbatchedWallCount(levelId, tintedWalls) >= MIN_BATCH_WALLS) {
+            mergeLevel(levelId, tintedWalls);
+        }
+    }
+    staleLevels.clear();
+}

package/dist/wall/wall-batch.d.ts

@@ -0,0 +1,66 @@
+import * as THREE from 'three';
+/** A contiguous vertex range one wall contributes to one material run. */
+export type WallBatchSlice = {
+    nodeId: string;
+    start: number;
+    count: number;
+};
+/** Every triangle drawn with one material index, in wall order. */
+export type WallBatchRun = {
+    materialIndex: number;
+    start: number;
+    count: number;
+    slices: WallBatchSlice[];
+};
+export type WallBatchSource = {
+    nodeId: string;
+    geometry: THREE.BufferGeometry;
+    /** Source-local to batch-root transform, baked into the merged vertices. */
+    matrix: THREE.Matrix4;
+};
+export type WallBatch = {
+    geometry: THREE.BufferGeometry;
+    runs: WallBatchRun[];
+};
+/**
+ * Concatenates wall geometries into one buffer laid out material-major,
+ * wall-minor: every triangle sharing a material index ends up in a single
+ * contiguous run, so the merged mesh costs one draw call per material
+ * instead of one per wall per material.
+ *
+ * Vertices are baked into the batch root's frame, so the merged mesh needs
+ * no transform of its own. Each wall's slice of every run is recorded, which
+ * is what lets a single wall be pulled back out later without touching the
+ * buffers — see `applyWallBatchGroups`.
+ *
+ * Sources must be non-indexed (the wall pipeline's `applyWorldPlanarWallUVs`
+ * already de-indexes) and are skipped if they carry no positions.
+ */
+export declare function buildWallBatch(sources: readonly WallBatchSource[]): WallBatch | null;
+/**
+ * Rewrites the merged geometry's draw groups so the listed walls are skipped.
+ *
+ * Pulling a wall out of the batch is what happens while it is being dragged:
+ * it goes back to drawing itself, and the merged mesh has to stop drawing it
+ * or the two would overlap. Because each wall owns a contiguous slice of each
+ * run, skipping it is a matter of splitting that run around the hole — no
+ * vertex data moves and nothing is re-uploaded to the GPU, so a drag costs a
+ * handful of group objects rather than a rebuild of the floor.
+ *
+ * Each hidden wall adds at most one extra group (one extra draw call) per run,
+ * so callers should re-merge once the holes stop being temporary.
+ */
+export declare function applyWallBatchGroups(batch: WallBatch, hidden: ReadonlySet<string>): void;
+/**
+ * Silences a wall the batch now draws.
+ *
+ * Emptying the draw range is not enough — three.js still submits a zero-count
+ * group, so 1000 muted walls cost 1000 draw calls. `visible = false` would
+ * cost nothing but takes the wall's children (cutters, treatments) down with
+ * it. Moving the mesh alone off the scene layer skips it in every pass while
+ * its subtree keeps rendering and picking.
+ */
+export declare function hideBatchedWall(mesh: THREE.Object3D): void;
+/** Hands a wall back its own draw call — unless solo or isolation still hide it. */
+export declare function revealBatchedWall(mesh: THREE.Object3D): void;
+//# sourceMappingURL=wall-batch.d.ts.map

package/dist/wall/wall-batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-batch.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,0EAA0E;AAC1E,MAAM,MAAM,cAAc,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7E,mEAAmE;AACnE,MAAM,MAAM,YAAY,GAAG;IACzB,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,cAAc,EAAE,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,4EAA4E;IAC5E,MAAM,EAAE,KAAK,CAAC,OAAO,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,IAAI,EAAE,YAAY,EAAE,CAAA;CACrB,CAAA;AAkCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,GAAG,IAAI,CAmEpF;AAwCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAmBxF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE1D;AAED,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE5D"}

package/dist/wall/wall-batch.js

@@ -0,0 +1,169 @@
+import { hideFromScene, showInScene } from '@pascal-app/viewer';
+import * as THREE from 'three';
+const BATCH_ATTRIBUTES = ['position', 'normal', 'uv', 'uv2'];
+const ATTRIBUTE_ITEM_SIZE = {
+    position: 3,
+    normal: 3,
+    uv: 2,
+    uv2: 2,
+};
+function planSource(source) {
+    const position = source.geometry.getAttribute('position');
+    if (!position || position.count === 0)
+        return null;
+    const declared = source.geometry.groups.length > 0
+        ? source.geometry.groups
+        : [{ start: 0, count: position.count, materialIndex: 0 }];
+    const groups = [];
+    for (const group of declared) {
+        const start = Math.max(0, group.start);
+        const count = Math.min(group.count, position.count - start);
+        if (count <= 0)
+            continue;
+        groups.push({ materialIndex: group.materialIndex ?? 0, start, count });
+    }
+    return groups.length > 0 ? { source, groups } : null;
+}
+/**
+ * Concatenates wall geometries into one buffer laid out material-major,
+ * wall-minor: every triangle sharing a material index ends up in a single
+ * contiguous run, so the merged mesh costs one draw call per material
+ * instead of one per wall per material.
+ *
+ * Vertices are baked into the batch root's frame, so the merged mesh needs
+ * no transform of its own. Each wall's slice of every run is recorded, which
+ * is what lets a single wall be pulled back out later without touching the
+ * buffers — see `applyWallBatchGroups`.
+ *
+ * Sources must be non-indexed (the wall pipeline's `applyWorldPlanarWallUVs`
+ * already de-indexes) and are skipped if they carry no positions.
+ */
+export function buildWallBatch(sources) {
+    const planned = [];
+    const totals = new Map();
+    for (const source of sources) {
+        const entry = planSource(source);
+        if (!entry)
+            continue;
+        planned.push(entry);
+        for (const group of entry.groups) {
+            totals.set(group.materialIndex, (totals.get(group.materialIndex) ?? 0) + group.count);
+        }
+    }
+    if (planned.length === 0)
+        return null;
+    const names = BATCH_ATTRIBUTES.filter((name) => planned.every((entry) => entry.source.geometry.getAttribute(name)));
+    if (!names.includes('position'))
+        return null;
+    let totalVertices = 0;
+    for (const count of totals.values())
+        totalVertices += count;
+    const buffers = new Map(names.map((name) => [name, new Float32Array(totalVertices * ATTRIBUTE_ITEM_SIZE[name])]));
+    const normalMatrix = new THREE.Matrix3();
+    const vector = new THREE.Vector3();
+    const runs = [];
+    let cursor = 0;
+    for (const materialIndex of [...totals.keys()].sort((left, right) => left - right)) {
+        const runStart = cursor;
+        const slices = [];
+        for (const entry of planned) {
+            const sliceStart = cursor;
+            normalMatrix.getNormalMatrix(entry.source.matrix);
+            for (const group of entry.groups) {
+                if (group.materialIndex !== materialIndex)
+                    continue;
+                copyGroup(entry.source, group, names, buffers, cursor, normalMatrix, vector);
+                cursor += group.count;
+            }
+            if (cursor > sliceStart) {
+                slices.push({ nodeId: entry.source.nodeId, start: sliceStart, count: cursor - sliceStart });
+            }
+        }
+        runs.push({ materialIndex, start: runStart, count: cursor - runStart, slices });
+    }
+    const geometry = new THREE.BufferGeometry();
+    for (const name of names) {
+        geometry.setAttribute(name, new THREE.BufferAttribute(buffers.get(name), ATTRIBUTE_ITEM_SIZE[name]));
+    }
+    geometry.computeBoundingSphere();
+    geometry.computeBoundingBox();
+    const batch = { geometry, runs };
+    applyWallBatchGroups(batch, EMPTY_HIDDEN);
+    return batch;
+}
+const EMPTY_HIDDEN = new Set();
+function copyGroup(source, group, names, buffers, writeAt, normalMatrix, vector) {
+    for (const name of names) {
+        const attribute = source.geometry.getAttribute(name);
+        const target = buffers.get(name);
+        const itemSize = ATTRIBUTE_ITEM_SIZE[name];
+        for (let offset = 0; offset < group.count; offset += 1) {
+            const from = group.start + offset;
+            const to = (writeAt + offset) * itemSize;
+            if (name === 'position') {
+                vector.fromBufferAttribute(attribute, from).applyMatrix4(source.matrix);
+                target[to] = vector.x;
+                target[to + 1] = vector.y;
+                target[to + 2] = vector.z;
+            }
+            else if (name === 'normal') {
+                vector.fromBufferAttribute(attribute, from).applyMatrix3(normalMatrix).normalize();
+                target[to] = vector.x;
+                target[to + 1] = vector.y;
+                target[to + 2] = vector.z;
+            }
+            else {
+                target[to] = attribute.getX(from);
+                target[to + 1] = attribute.getY(from);
+            }
+        }
+    }
+}
+/**
+ * Rewrites the merged geometry's draw groups so the listed walls are skipped.
+ *
+ * Pulling a wall out of the batch is what happens while it is being dragged:
+ * it goes back to drawing itself, and the merged mesh has to stop drawing it
+ * or the two would overlap. Because each wall owns a contiguous slice of each
+ * run, skipping it is a matter of splitting that run around the hole — no
+ * vertex data moves and nothing is re-uploaded to the GPU, so a drag costs a
+ * handful of group objects rather than a rebuild of the floor.
+ *
+ * Each hidden wall adds at most one extra group (one extra draw call) per run,
+ * so callers should re-merge once the holes stop being temporary.
+ */
+export function applyWallBatchGroups(batch, hidden) {
+    batch.geometry.clearGroups();
+    for (const run of batch.runs) {
+        let cursor = run.start;
+        if (hidden.size > 0) {
+            for (const slice of run.slices) {
+                if (!hidden.has(slice.nodeId))
+                    continue;
+                if (slice.start > cursor) {
+                    batch.geometry.addGroup(cursor, slice.start - cursor, run.materialIndex);
+                }
+                cursor = slice.start + slice.count;
+            }
+        }
+        const end = run.start + run.count;
+        if (end > cursor)
+            batch.geometry.addGroup(cursor, end - cursor, run.materialIndex);
+    }
+}
+/**
+ * Silences a wall the batch now draws.
+ *
+ * Emptying the draw range is not enough — three.js still submits a zero-count
+ * group, so 1000 muted walls cost 1000 draw calls. `visible = false` would
+ * cost nothing but takes the wall's children (cutters, treatments) down with
+ * it. Moving the mesh alone off the scene layer skips it in every pass while
+ * its subtree keeps rendering and picking.
+ */
+export function hideBatchedWall(mesh) {
+    hideFromScene(mesh, 'batched');
+}
+/** Hands a wall back its own draw call — unless solo or isolation still hide it. */
+export function revealBatchedWall(mesh) {
+    showInScene(mesh, 'batched');
+}

package/dist/zone/quantities-panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quantities-panel.d.ts","sourceRoot":"","sources":["../../src/zone/quantities-panel.tsx"],"names":[],"mappings":"AA4TA,MAAM,CAAC,OAAO,UAAU,mBAAmB,uCA2F1C"}
+{"version":3,"file":"quantities-panel.d.ts","sourceRoot":"","sources":["../../src/zone/quantities-panel.tsx"],"names":[],"mappings":"AA8TA,MAAM,CAAC,OAAO,UAAU,mBAAmB,uCA6F1C"}