@ifc-lite/renderer 1.38.1 → 1.39.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++) {
@@ -3098,6 +3102,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 +3119,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 +3150,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 +3166,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 +3227,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 +3256,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();