@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/shared/node-batch/store.js

@@ -0,0 +1,319 @@
+import { BatchedMesh } from 'three';
+import { NODE_BATCH_SETTLE_MS, } from './types';
+function skipRaycast() { }
+function positionVersion(geometry) {
+    const attribute = geometry.attributes.position;
+    return attribute?.version ?? attribute?.data?.version ?? -1;
+}
+function attributeSignature(geometry) {
+    return `${Object.entries(geometry.attributes)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, attribute]) => `${name}:${attribute.itemSize}:${attribute.normalized}:${attribute.array.constructor.name}`)
+        .join(',')}|${geometry.index ? 'i' : 'n'}`;
+}
+const batchKey = (entry) => `${entry.levelId}|${entry.material.uuid}|${attributeSignature(entry.geometry)}|${entry.castShadow}|${entry.receiveShadow}`;
+const geometryKey = (entry) => entry.allocationKey ?? entry.geometry.uuid;
+const vertexCount = (geometry) => geometry.attributes.position?.count ?? 0;
+const indexCount = (geometry) => geometry.index?.count ?? vertexCount(geometry);
+function reservation(entry) {
+    const reserve = (count) => entry.allocationKey ? Math.max(count + 12, Math.ceil(count * 1.25)) : count;
+    return {
+        vertices: reserve(vertexCount(entry.geometry)),
+        indices: reserve(indexCount(entry.geometry)),
+    };
+}
+function matches(packed, geometry) {
+    return (packed.uuid === geometry.uuid &&
+        packed.version === positionVersion(geometry) &&
+        packed.vertices === vertexCount(geometry) &&
+        packed.indices === indexCount(geometry));
+}
+export class NodeBatchStore {
+    getLevelRoot;
+    batches = new Map();
+    keysByNode = new Map();
+    instancesByNode = new Map();
+    pending = new Map();
+    instanceCount = 0;
+    counters = {
+        releases: 0,
+        joins: 0,
+        geometryReplacements: 0,
+        overflowRebuilds: 0,
+        geometryBytesCopied: 0,
+    };
+    constructor(getLevelRoot) {
+        this.getLevelRoot = getLevelRoot;
+    }
+    join(candidates, minEntriesForNewBatch) {
+        this.flushReleases();
+        const joined = [];
+        const byBatch = new Map();
+        for (const candidate of candidates) {
+            for (const entry of candidate.entries) {
+                if (vertexCount(entry.geometry) === 0)
+                    continue;
+                const key = batchKey(entry);
+                const bucket = byBatch.get(key);
+                if (bucket)
+                    bucket.push(entry);
+                else
+                    byBatch.set(key, [entry]);
+            }
+        }
+        for (const [key, entries] of byBatch) {
+            let record = this.batches.get(key);
+            if (!record && entries.length < minEntriesForNewBatch)
+                continue;
+            const root = this.getLevelRoot(entries[0].levelId);
+            if (!root)
+                continue;
+            const needed = this.requiredSpace(entries, record);
+            if (!record) {
+                record = this.createBatch(entries[0].levelId, entries[0].material, entries[0], root, entries.length, needed.vertices, needed.indices);
+                this.batches.set(key, record);
+            }
+            else if (needed.overflow ||
+                record.instances.length + entries.length > record.capacity.instances ||
+                record.used.vertices + needed.vertices > record.capacity.vertices ||
+                record.used.indices + needed.indices > record.capacity.indices) {
+                // Only resident geometry and this join wave survive compaction. Released
+                // allocations must never contribute to the replacement container's size.
+                const live = [...record.instances.map(({ entry }) => entry), ...entries];
+                const size = this.requiredSpace(live);
+                const survivors = record.instances;
+                const oldRecord = record;
+                this.disposeBatch(key, record);
+                record = this.createBatch(entries[0].levelId, entries[0].material, entries[0], root, live.length, size.vertices, size.indices);
+                this.batches.set(key, record);
+                for (const { entry } of survivors) {
+                    const other = this.instancesByNode.get(entry.nodeId)?.filter(({ record }) => record !== oldRecord) ??
+                        [];
+                    this.instancesByNode.set(entry.nodeId, other);
+                }
+                for (const { entry } of survivors)
+                    this.addEntry(key, record, entry);
+                this.counters.overflowRebuilds++;
+            }
+            for (const entry of entries) {
+                this.addEntry(key, record, entry);
+                this.instanceCount++;
+                this.counters.joins++;
+                joined.push(entry);
+            }
+            record.emptySince = null;
+        }
+        return joined;
+    }
+    requiredSpace(entries, record) {
+        let vertices = 0;
+        let indices = 0;
+        let overflow = false;
+        const seen = new Set();
+        for (const entry of entries) {
+            const key = geometryKey(entry);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const packed = record?.geometryIds.get(key);
+            if (packed) {
+                if (vertexCount(entry.geometry) > packed.reservedVertices ||
+                    indexCount(entry.geometry) > packed.reservedIndices)
+                    overflow = true;
+            }
+            else {
+                const size = reservation(entry);
+                vertices += size.vertices;
+                indices += size.indices;
+            }
+        }
+        return { vertices, indices, overflow };
+    }
+    addEntry(key, record, entry) {
+        const allocation = geometryKey(entry);
+        let packed = record.geometryIds.get(allocation);
+        if (!packed || !matches(packed, entry.geometry)) {
+            const size = packed
+                ? { vertices: packed.reservedVertices, indices: packed.reservedIndices }
+                : reservation(entry);
+            let id;
+            if (packed) {
+                id = packed.id;
+                record.batched.setGeometryAt(id, entry.geometry);
+                this.counters.geometryReplacements++;
+            }
+            else {
+                id = record.batched.addGeometry(entry.geometry, size.vertices, size.indices);
+                record.used.vertices += size.vertices;
+                record.used.indices += size.indices;
+            }
+            for (const attribute of Object.values(entry.geometry.attributes)) {
+                this.counters.geometryBytesCopied +=
+                    size.vertices * attribute.itemSize * attribute.array.BYTES_PER_ELEMENT;
+            }
+            if (entry.geometry.index)
+                this.counters.geometryBytesCopied +=
+                    size.indices * record.batched.geometry.index.array.BYTES_PER_ELEMENT;
+            packed = {
+                id,
+                uuid: entry.geometry.uuid,
+                version: positionVersion(entry.geometry),
+                vertices: vertexCount(entry.geometry),
+                indices: indexCount(entry.geometry),
+                reservedVertices: size.vertices,
+                reservedIndices: size.indices,
+            };
+            record.geometryIds.set(allocation, packed);
+        }
+        const instanceId = record.batched.addInstance(packed.id);
+        record.batched.setMatrixAt(instanceId, entry.matrixInLevel);
+        record.instances.push({ entry, instanceId });
+        let keys = this.keysByNode.get(entry.nodeId);
+        if (!keys) {
+            keys = new Set();
+            this.keysByNode.set(entry.nodeId, keys);
+        }
+        keys.add(key);
+        let instances = this.instancesByNode.get(entry.nodeId);
+        if (!instances) {
+            instances = [];
+            this.instancesByNode.set(entry.nodeId, instances);
+        }
+        instances.push({ record, instanceId });
+    }
+    release(nodeId) {
+        const instances = this.instancesByNode.get(nodeId);
+        if (!instances)
+            return false;
+        for (const { record, instanceId } of instances) {
+            // Interactions reveal sources synchronously; hide their packed draws now,
+            // then compact bookkeeping once for all releases in the frame.
+            record.batched.setVisibleAt(instanceId, false);
+            let doomed = this.pending.get(record);
+            if (!doomed) {
+                doomed = new Set();
+                this.pending.set(record, doomed);
+            }
+            doomed.add(instanceId);
+            this.instanceCount--;
+        }
+        this.instancesByNode.delete(nodeId);
+        this.keysByNode.delete(nodeId);
+        this.counters.releases++;
+        return true;
+    }
+    flushReleases(now = performance.now()) {
+        for (const [record, doomed] of this.pending) {
+            for (const id of doomed)
+                record.batched.deleteInstance(id);
+            record.instances = record.instances.filter(({ instanceId }) => !doomed.has(instanceId));
+            if (record.instances.length === 0)
+                record.emptySince = now;
+        }
+        this.pending.clear();
+    }
+    pruneEmpty(now = performance.now(), retainedLevels = new Set(), earliestDisposalAt = 0) {
+        let pending = false;
+        for (const [key, record] of this.batches) {
+            if (record.emptySince !== null &&
+                now - record.emptySince >= NODE_BATCH_SETTLE_MS &&
+                now >= earliestDisposalAt &&
+                !retainedLevels.has(record.levelId))
+                this.disposeBatch(key, record);
+            else if (record.emptySince !== null)
+                pending = true;
+        }
+        return pending;
+    }
+    pruneDetached() {
+        const orphaned = new Set();
+        const detached = [];
+        for (const [key, record] of this.batches) {
+            const root = this.getLevelRoot(record.levelId);
+            if (root && record.batched.parent === root)
+                continue;
+            for (const { entry } of record.instances)
+                orphaned.add(entry.nodeId);
+            detached.push([key, record]);
+        }
+        for (const id of orphaned)
+            this.release(id);
+        for (const [key, record] of detached)
+            this.disposeBatch(key, record);
+        return orphaned;
+    }
+    has(nodeId) {
+        return this.keysByNode.has(nodeId);
+    }
+    nodeIds() {
+        return new Set(this.keysByNode.keys());
+    }
+    disposeLevel(levelId) {
+        for (const [key, record] of this.batches) {
+            if (record.levelId !== levelId)
+                continue;
+            for (const { entry } of record.instances)
+                this.release(entry.nodeId);
+            this.flushReleases();
+            this.disposeBatch(key, record);
+        }
+    }
+    disposeAll() {
+        for (const [key, record] of this.batches)
+            this.disposeBatch(key, record);
+        this.keysByNode.clear();
+        this.instancesByNode.clear();
+        this.pending.clear();
+        this.instanceCount = 0;
+    }
+    stats() {
+        return {
+            batches: this.batches.size,
+            instances: this.instanceCount,
+            nodes: this.keysByNode.size,
+            ...this.counters,
+        };
+    }
+    createBatch(levelId, material, shadows, root, instanceCount, vertices, indices) {
+        // 2× headroom so steady-state joins (an item placed, an item released and
+        // re-joined) never pay a rebuild; overflow re-sizes to 2× the new need.
+        const batched = new BatchedMesh(Math.max(8, instanceCount * 2), Math.max(1024, vertices * 2), Math.max(1024, indices * 2), material);
+        batched.name = 'item-batch';
+        // GLTFExporter would serialize the packed multi-draw buffers as one
+        // garbage mesh; exports must never carry a batch. The batch system also
+        // releases everything on 'thumbnail:before-capture' so the real item
+        // meshes are back on the scene layer for the export clone — this marker
+        // is the backstop for any capture path that skips the emit.
+        batched.userData.pascalExport = 'strip';
+        batched.castShadow = shadows.castShadow;
+        batched.receiveShadow = shadows.receiveShadow;
+        batched.perObjectFrustumCulled = true;
+        // Whole-container culling would use a bounding sphere computed at first
+        // cull — instances joining farther out later could vanish with the whole
+        // batch. Per-instance culling above already handles visibility.
+        batched.frustumCulled = false;
+        batched.matrixAutoUpdate = false;
+        batched.matrix.identity();
+        batched.raycast = skipRaycast;
+        root.add(batched);
+        return {
+            levelId,
+            batched,
+            geometryIds: new Map(),
+            instances: [],
+            emptySince: null,
+            capacity: {
+                instances: Math.max(8, instanceCount * 2),
+                vertices: Math.max(1024, vertices * 2),
+                indices: Math.max(1024, indices * 2),
+            },
+            used: { vertices: 0, indices: 0 },
+        };
+    }
+    disposeBatch(key, record) {
+        this.pending.delete(record);
+        record.batched.removeFromParent();
+        record.batched.dispose();
+        this.batches.delete(key);
+    }
+}

package/dist/shared/node-batch/system.d.ts

@@ -0,0 +1,8 @@
+export declare function resetNodeBatchState(): void;
+export declare function subscribeBatchInteractions(invalidate: () => void): () => void;
+export declare function captureChangedNodes(): void;
+export declare function runBatchFrame(invalidate: () => void, wakeRef: {
+    current: ReturnType<typeof setTimeout> | null;
+}): void;
+export declare const NodeBatchSystem: () => import("react").JSX.Element | null;
+//# sourceMappingURL=system.d.ts.map

package/dist/shared/node-batch/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../../src/shared/node-batch/system.tsx"],"names":[],"mappings":"AAwHA,wBAAgB,mBAAmB,SAiBlC;AAkCD,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CA2B7E;AAED,wBAAgB,mBAAmB,SAmBlC;AAED,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,IAAI,EACtB,OAAO,EAAE;IAAE,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAA;CAAE,QAmB3D;AAgPD,eAAO,MAAM,eAAe,0CAG3B,CAAA"}