@ifc-lite/renderer 1.38.1 → 1.40.0

package/dist/scene.js

@@ -30,6 +30,10 @@ export class Scene {
     meshDataMap = new Map(); // Map expressId -> MeshData[] (for lazy buffer creation, accumulates multiple pieces)
     boundingBoxes = new Map(); // Map expressId -> bounding box (computed lazily)
     texturedMeshes = []; // #961: IFC surface-textured meshes (own buffers/texture/bindGroup)
+    /** #1781: GPU textures shared across meshes, keyed by `MeshTextureRef.textureId`
+     *  (one `IfcImageTexture` → one upload, sampled by every face set mapping it).
+     *  Refcounted: entries die when the last referencing mesh is removed / on clear(). */
+    sharedTextures = new Map();
     texturedDevice; // #961: cached for textured-mesh re-upload on translate
     instancedTemplates = []; // GPU-instancing: unique templates + per-occurrence buffers (fed by addInstancedShard)
     instancedVisible = true; // GPU-instancing: hidden in Types view mode (instanced geometry is class-0 occurrences)
@@ -964,10 +968,10 @@ export class Scene {
         // otherwise a flat-colour copy would be drawn over the texture. Still
         // register them in meshDataMap (addMeshData) so CPU picking/bbox/frame work.
         let renderable = meshDataArray;
-        if (meshDataArray.some((m) => m.texture && m.uvs)) {
+        if (meshDataArray.some((m) => Scene.hasRenderableTexture(m))) {
             renderable = [];
             for (const meshData of meshDataArray) {
-                if (meshData.texture && meshData.uvs) {
+                if (Scene.hasRenderableTexture(meshData)) {
                     this.createTexturedMesh(meshData, device, pipeline);
                     this.addMeshData(meshData);
                 }
@@ -1135,7 +1139,7 @@ export class Scene {
             tm.vertexBuffer.destroy();
             tm.indexBuffer.destroy();
             tm.uniformBuffer.destroy();
-            tm.texture.destroy();
+            this.releaseTexturedMeshTexture(tm);
             this.texturedMeshes.splice(i, 1);
             removedDedicated = true;
         }
@@ -1321,7 +1325,7 @@ export class Scene {
         // re-interleave + re-upload the moved textured parts (paired by expressId,
         // in creation order). Without this a moved textured entity renders stale.
         if (this.texturedDevice && this.texturedMeshes.length > 0) {
-            const texturedData = meshDataList.filter((md) => md.texture && md.uvs);
+            const texturedData = meshDataList.filter((md) => Scene.hasRenderableTexture(md));
             if (texturedData.length > 0) {
                 const entries = this.texturedMeshes.filter((tm) => tm.expressId === expressId);
                 for (let i = 0; i < entries.length && i < texturedData.length; i++) {
@@ -1519,7 +1523,7 @@ export class Scene {
         // #961: textured meshes render from their own GPU vertex buffer — re-upload
         // the rotated parts so they don't render stale (mirrors the translate path).
         if (this.texturedDevice && this.texturedMeshes.length > 0) {
-            const texturedData = meshDataList.filter((md) => md.texture && md.uvs);
+            const texturedData = meshDataList.filter((md) => Scene.hasRenderableTexture(md));
             if (texturedData.length > 0) {
                 const entries = this.texturedMeshes.filter((tm) => tm.expressId === expressId);
                 for (let i = 0; i < entries.length && i < texturedData.length; i++) {
@@ -1757,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);
@@ -3098,6 +3136,15 @@ export class Scene {
      * The per-frame uniform (viewProj/section/flags + colour tint) is written by
      * the renderer each frame, mirroring how colour batches are driven.
      */
+    /** True when the mesh can render through the textured pipeline: UVs plus
+     *  either a Rust-decoded image (#961) or a viewer-resolved ImageBitmap for
+     *  an external `IfcImageTexture` reference (#1781). A `textureRef` whose
+     *  image was NOT resolved (missing zip sibling) renders as ordinary
+     *  flat-colour geometry instead. */
+    static hasRenderableTexture(meshData) {
+        return Boolean(meshData.uvs) &&
+            Boolean(meshData.texture || (meshData.textureRef && meshData.textureBitmap));
+    }
     /**
      * Interleave a textured mesh's vertices into the stride-36 layout
      * `[px,py,pz, nx,ny,nz, entityId(u32), u,v]`. Shared by initial upload and
@@ -3106,7 +3153,7 @@ export class Scene {
      */
     interleaveTexturedVertices(meshData) {
         const uvs = meshData.uvs;
-        if (!meshData.texture || !uvs)
+        if (!Scene.hasRenderableTexture(meshData) || !uvs)
             return null;
         const positions = meshData.positions;
         const normals = meshData.normals;
@@ -3137,8 +3184,10 @@ export class Scene {
     }
     createTexturedMesh(meshData, device, pipeline) {
         const tex = meshData.texture;
+        const ref = meshData.textureRef;
+        const bitmap = meshData.textureBitmap;
         const interleaved = this.interleaveTexturedVertices(meshData);
-        if (!tex || !interleaved)
+        if (!interleaved || !(tex || (ref && bitmap)))
             return;
         this.texturedDevice = device; // reused by translateMeshesForEntity re-upload
         const vertexBuffer = device.createBuffer({
@@ -3151,17 +3200,48 @@ export class Scene {
             usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
         });
         device.queue.writeBuffer(indexBuffer, 0, meshData.indices);
-        // Upload the Rust-decoded RGBA8 verbatim — no image decoding in JS.
-        const texture = device.createTexture({
-            size: { width: tex.width, height: tex.height },
-            format: 'rgba8unorm',
-            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
-        });
-        device.queue.writeTexture({ texture }, tex.rgba, { bytesPerRow: tex.width * 4, rowsPerImage: tex.height }, { width: tex.width, height: tex.height });
+        let texture;
+        let sharedTextureKey;
+        if (tex) {
+            // #961: upload the Rust-decoded RGBA8 verbatim — no image decoding in JS.
+            texture = device.createTexture({
+                size: { width: tex.width, height: tex.height },
+                format: 'rgba8unorm',
+                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+            });
+            device.queue.writeTexture({ texture }, tex.rgba, { bytesPerRow: tex.width * 4, rowsPerImage: tex.height }, { width: tex.width, height: tex.height });
+        }
+        else {
+            // #1781: external image texture — the viewer decoded the `.ifcZIP`
+            // sibling to an ImageBitmap once per textureId; upload it ONCE and share
+            // the GPU texture across every mesh sampling it (real files map one
+            // 4096² image from dozens of face sets — per-mesh copies would be GBs).
+            const refKey = ref.textureId;
+            const bmp = bitmap;
+            let entry = this.sharedTextures.get(refKey);
+            if (!entry) {
+                const gpuTex = device.createTexture({
+                    size: { width: bmp.width, height: bmp.height },
+                    format: 'rgba8unorm',
+                    // RENDER_ATTACHMENT is required by copyExternalImageToTexture.
+                    usage: GPUTextureUsage.TEXTURE_BINDING |
+                        GPUTextureUsage.COPY_DST |
+                        GPUTextureUsage.RENDER_ATTACHMENT,
+                });
+                device.queue.copyExternalImageToTexture({ source: bmp }, { texture: gpuTex }, { width: bmp.width, height: bmp.height });
+                entry = { texture: gpuTex, refs: 0 };
+                this.sharedTextures.set(refKey, entry);
+            }
+            entry.refs++;
+            texture = entry.texture;
+            sharedTextureKey = refKey;
+        }
+        const repeatS = tex ? tex.repeatS : ref.repeatS;
+        const repeatT = tex ? tex.repeatT : ref.repeatT;
         const wrap = (repeat) => (repeat ? 'repeat' : 'clamp-to-edge');
         const sampler = device.createSampler({
-            addressModeU: wrap(tex.repeatS),
-            addressModeV: wrap(tex.repeatT),
+            addressModeU: wrap(repeatS),
+            addressModeV: wrap(repeatT),
             magFilter: 'linear',
             minFilter: 'linear',
             mipmapFilter: 'linear',
@@ -3181,8 +3261,26 @@ export class Scene {
             sampler,
             bindGroup,
             color: meshData.color,
+            ...(sharedTextureKey !== undefined ? { sharedTextureKey } : {}),
         });
     }
+    /** Release a textured mesh's GPU texture: shared (#1781) entries decrement
+     *  the registry refcount and die with their LAST reference; per-mesh (#961)
+     *  uploads are destroyed outright. */
+    releaseTexturedMeshTexture(tm) {
+        if (tm.sharedTextureKey === undefined) {
+            tm.texture.destroy();
+            return;
+        }
+        const entry = this.sharedTextures.get(tm.sharedTextureKey);
+        if (!entry)
+            return;
+        entry.refs--;
+        if (entry.refs <= 0) {
+            entry.texture.destroy();
+            this.sharedTextures.delete(tm.sharedTextureKey);
+        }
+    }
     clear() {
         for (const mesh of this.meshes)
             destroyGpuResources(mesh);
@@ -3192,9 +3290,14 @@ export class Scene {
             tm.vertexBuffer.destroy();
             tm.indexBuffer.destroy();
             tm.uniformBuffer.destroy();
-            tm.texture.destroy();
+            this.releaseTexturedMeshTexture(tm);
         }
         this.texturedMeshes = [];
+        // Belt-and-braces: refcounting above should have emptied the registry;
+        // destroy any straggler so clear() can never leak a shared GPU texture.
+        for (const entry of this.sharedTextures.values())
+            entry.texture.destroy();
+        this.sharedTextures.clear();
         // GPU-instancing templates own their vertex/index/instance buffers.
         for (const it of this.instancedTemplates) {
             it.vertexBuffer.destroy();