@ifc-lite/renderer 1.39.0 → 1.40.0

package/dist/scene.js

@@ -1761,56 +1761,90 @@ export class Scene {
         const oldFragments = this.streamingFragments;
         const oldBatches = this.batchedMeshes;
         const fragmentSet = new Set(oldFragments);
-        this.streamingFragments = [];
-        // 1. Collect ALL accumulated meshData before clearing state.
-        //    Cold buckets (issue #1682 phase 3b) hold NO meshData — their
-        //    geometry lives on disk — so they are carried through the rebuild as
-        //    sealed shells instead of being re-grouped (re-grouping would
-        //    silently drop them).
-        const allMeshData = [];
-        const carriedCold = [];
-        for (const [key, bucket] of this.buckets) {
-            if (this.coldBuckets.has(key) && bucket.meshData.length === 0 && bucket.batchedMesh) {
-                carriedCold.push([key, bucket]);
-                continue;
+        const oldBatchSet = new Set(oldBatches);
+        // Steps 1-4 detach the old drawables (streamingFragments = [],
+        // batchedMeshes = []) BEFORE the replacement GPU buffers exist. If a
+        // createBuffer fails part-way through, callers that CONTAIN the throw to
+        // keep the canvas alive would otherwise be left rendering a half-built —
+        // often empty — scene, turning a crash into a silently blank model.
+        let rebuilt = false;
+        try {
+            this.streamingFragments = [];
+            // 1. Collect ALL accumulated meshData before clearing state.
+            //    Cold buckets (issue #1682 phase 3b) hold NO meshData — their
+            //    geometry lives on disk — so they are carried through the rebuild as
+            //    sealed shells instead of being re-grouped (re-grouping would
+            //    silently drop them).
+            const allMeshData = [];
+            const carriedCold = [];
+            for (const [key, bucket] of this.buckets) {
+                if (this.coldBuckets.has(key) && bucket.meshData.length === 0 && bucket.batchedMesh) {
+                    carriedCold.push([key, bucket]);
+                    continue;
+                }
+                for (const md of bucket.meshData)
+                    allMeshData.push(md);
+            }
+            // 2. Clear all bucket/batch state for a clean rebuild
+            // NOTE: batchedMeshes keeps the OLD array reference — the renderer
+            // continues to draw from it until we swap in the new array below.
+            this.buckets.clear();
+            this.meshDataBucket = new Map();
+            this.activeBucketKey.clear();
+            this.lastDrawnFrame.clear();
+            this.residencyRestoreQueue.clear();
+            this.pendingBatchKeys.clear();
+            // Re-seat the carried cold shells in the fresh bucket map (their GPU
+            // shells re-enter the flat array via rebuildPendingBatches below).
+            for (const [key, bucket] of carriedCold)
+                this.buckets.set(key, bucket);
+            // 3. Re-group ALL meshData by their CURRENT color (and grid cell).
+            //    meshData.color may have been mutated in-place since the mesh was
+            //    first bucketed, so the original bucket key is stale. Re-grouping
+            //    by current color ensures batches render with correct colors.
+            for (const meshData of allMeshData) {
+                const baseKey = this.bucketBaseKey(meshData);
+                const bucketKey = this.resolveActiveBucket(baseKey, meshData);
+                let bucket = this.buckets.get(bucketKey);
+                if (!bucket) {
+                    bucket = { key: bucketKey, meshData: [], batchedMesh: null, vertexBytes: 0 };
+                    this.buckets.set(bucketKey, bucket);
+                }
+                bucket.meshData.push(meshData);
+                this.meshDataBucket.set(meshData, bucket);
+                this.pendingBatchKeys.add(bucketKey);
             }
-            for (const md of bucket.meshData)
-                allMeshData.push(md);
+            // 4. Build new proper batches into a fresh array
+            this.batchedMeshes = [];
+            this.rebuildPendingBatches(device, pipeline);
+            rebuilt = true;
+            // Cached partial (filtered-visibility) batches are keyed by their SOURCE
+            // batch, so they only go stale once the replacement batches are live.
+            // Dropping them up in step 2 destroyed their GPU resources BEFORE the
+            // rebuild could fail, and the rollback cannot bring them back — an active
+            // hide/isolate view lost its visible subset and had to recreate it
+            // against the very device that just failed. On the failure path they now
+            // survive, still matching the restored batches.
+            this.dropAllPartialCaches();
         }
-        // 2. Clear all bucket/batch state for a clean rebuild
-        // NOTE: batchedMeshes keeps the OLD array reference — the renderer
-        // continues to draw from it until we swap in the new array below.
-        this.buckets.clear();
-        this.meshDataBucket = new Map();
-        this.activeBucketKey.clear();
-        this.lastDrawnFrame.clear();
-        this.residencyRestoreQueue.clear();
-        this.pendingBatchKeys.clear();
-        // Destroy cached partial batches — their colorKeys are now stale
-        this.dropAllPartialCaches();
-        // Re-seat the carried cold shells in the fresh bucket map (their GPU
-        // shells re-enter the flat array via rebuildPendingBatches below).
-        for (const [key, bucket] of carriedCold)
-            this.buckets.set(key, bucket);
-        // 3. Re-group ALL meshData by their CURRENT color (and grid cell).
-        //    meshData.color may have been mutated in-place since the mesh was
-        //    first bucketed, so the original bucket key is stale. Re-grouping
-        //    by current color ensures batches render with correct colors.
-        for (const meshData of allMeshData) {
-            const baseKey = this.bucketBaseKey(meshData);
-            const bucketKey = this.resolveActiveBucket(baseKey, meshData);
-            let bucket = this.buckets.get(bucketKey);
-            if (!bucket) {
-                bucket = { key: bucketKey, meshData: [], batchedMesh: null, vertexBytes: 0 };
-                this.buckets.set(bucketKey, bucket);
+        finally {
+            if (!rebuilt) {
+                // Free ONLY what this attempt created. Carried cold shells are aliased
+                // into BOTH the old and the new array, so anything that was already
+                // live before the rebuild must be left alone — destroying it would
+                // leave the restored arrays pointing at dead buffers.
+                for (const created of this.batchedMeshes) {
+                    if (!oldBatchSet.has(created) && !fragmentSet.has(created)) {
+                        destroyGpuResources(created);
+                    }
+                }
+                // Step 5 never ran, so every old fragment/batch is still a live GPU
+                // resource: putting the arrays back restores exactly what was on
+                // screen.
+                this.streamingFragments = oldFragments;
+                this.batchedMeshes = oldBatches;
             }
-            bucket.meshData.push(meshData);
-            this.meshDataBucket.set(meshData, bucket);
-            this.pendingBatchKeys.add(bucketKey);
         }
-        // 4. Build new proper batches into a fresh array
-        this.batchedMeshes = [];
-        this.rebuildPendingBatches(device, pipeline);
         // 5. NOW destroy old fragment/batch GPU resources (new batches are live)
         for (const fragment of oldFragments)
             destroyGpuResources(fragment);