@xeokit/xeokit-sdk 2.6.95 → 2.6.96

package/dist/xeokit-sdk.cjs.js

@@ -1,11 +1,11 @@
 /**
- * xeokit-sdk v2.6.95
- *  Commit: ff66e348fc6786a85f8ff8732f9876d63e3782d6
- *  Built: 2025-11-18T12:58:25.225Z
+ * xeokit-sdk v2.6.96
+ *  Commit: c76eb4c08555d55fdd54313f5fb25481d28d1150
+ *  Built: 2025-12-02T12:22:54.826Z
  */
 
 if (typeof window !== 'undefined') {
-    window.__XEOKIT__ = { version: '2.6.95', commit: 'ff66e348fc6786a85f8ff8732f9876d63e3782d6', built: '2025-11-18T12:58:25.225Z' };
+    window.__XEOKIT__ = { version: '2.6.96', commit: 'c76eb4c08555d55fdd54313f5fb25481d28d1150', built: '2025-12-02T12:22:54.826Z' };
 }
 
 'use strict';
@@ -7437,9 +7437,12 @@ math.makeSectionPlaneSlicer = (function() {
     math.vec3();
 
     const triangle = [ math.vec3(), math.vec3(), math.vec3() ];
+    const tmpIntersections = [ null, null, null ];
+    const tmpPositions     = [ null, null, null ];
+    const tmpReferences    = [ null, null, null ];
 
-    const worldUp      = [0, 1, 0];
     const worldRight   = [1, 0, 0];
+    const worldUp      = [0, 1, 0];
     const worldForward = [0, 0, 1];
 
     const sqDistVec3 = (function() {
@@ -7454,84 +7457,113 @@ math.makeSectionPlaneSlicer = (function() {
         return ret;
     };
 
-    const setCoord2D = (p, dst) => { dst[0] = p.coord2Dx; dst[1] = p.coord2Dy; return dst; };
-
     const ccw = (a, b, c) => ((c[1] - a[1]) * (b[0] - a[0])) > ((b[1] - a[1]) * (c[0] - a[0]));
 
-    const isLoopInside = (inner, outer) => {
-        const bbI = inner.boundingBox;
-        const bbO = outer.boundingBox;
-        if ((bbI[0] < bbO[0]) || (bbI[1] < bbO[1]) || (bbI[2] > bbO[2]) || (bbI[3] > bbO[3])) {
-            return false;
-        }
+    return function(plane) {
+        const planeU = math.vec3ApplyQuaternion(plane.quaternion, worldRight,   math.vec3());
+        const planeV = math.vec3ApplyQuaternion(plane.quaternion, worldUp,      math.vec3());
+        const planeN = math.vec3ApplyQuaternion(plane.quaternion, worldForward, math.vec3());
 
-        const innerEndpoints = inner.endPoints;
-        const outerEndpoints = outer.endPoints;
-        for (let ii = 0, ij = innerEndpoints.length - 1; ii < innerEndpoints.length; ij = ii++) {
-            const i0 = setCoord2D(innerEndpoints[ii], tempVec2a);
-            const [i0x, i0y] = i0;
-            const i1 = setCoord2D(innerEndpoints[ij], tempVec2b);
+        return function(mesh, cfg = { }) {
+            const planeToMesh = math.subVec3(mesh.origin, plane.pos, math.vec3());
+            const planeDist = math.dotVec3(planeN, planeToMesh);
+
+            const unsortedSegment = [ ];
+            const indexedPositions = [ null ]; // to never return 0 from addPosition, so its result can be used as a predicate
+            const addPosition = (p, addUV) => {
+                const idx = indexedPositions.length;
+                const P = new Float64Array(5);
+                P.set(p);
+                if (addUV) {
+                    math.addVec3(planeToMesh, p, tempVec3a);
+                    P[3] = -math.dotVec3(planeU, tempVec3a);
+                    P[4] = math.dotVec3(planeV, tempVec3a);
+                }
+                indexedPositions.push(P);
+                return idx;
+            };
 
-            let inside = false;
-            for (let i = 0, j = outerEndpoints.length - 1; i < outerEndpoints.length; j = i++) {
-                const o0 = setCoord2D(outerEndpoints[i], tempVec2c);
-                const o1 = setCoord2D(outerEndpoints[j], tempVec2d);
+            const getCoord2D = (idx, dst) => { const P = indexedPositions[idx]; dst[0] = P[3]; dst[1] = P[4]; return dst; };
 
-                if ((ccw(i0, o0, o1) !== ccw(i1, o0, o1)) && (ccw(i0, i1, o0) !== ccw(i0, i1, o1))) {
-                    return false; // segments intersect
+            const isLoopInside = (inner, outer) => {
+                const bbI = inner.boundingBox;
+                const bbO = outer.boundingBox;
+                if ((bbI[0] < bbO[0]) || (bbI[1] < bbO[1]) || (bbI[2] > bbO[2]) || (bbI[3] > bbO[3])) {
+                    return false;
                 }
 
-                const [o0x, o0y] = o0;
-                const [o1x, o1y] = o1;
+                const innerEndpoints = inner.endPoints;
+                const outerEndpoints = outer.endPoints;
+                for (let ii = 0, ij = innerEndpoints.length - 1; ii < innerEndpoints.length; ij = ii++) {
+                    const i0 = getCoord2D(innerEndpoints[ii], tempVec2a);
+                    const [i0x, i0y] = i0;
+                    const i1 = getCoord2D(innerEndpoints[ij], tempVec2b);
 
-                const dx = i0x - o0x;
-                const dy = i0y - o0y;
+                    let inside = false;
+                    for (let i = 0, j = outerEndpoints.length - 1; i < outerEndpoints.length; j = i++) {
+                        const o0 = getCoord2D(outerEndpoints[i], tempVec2c);
+                        const o1 = getCoord2D(outerEndpoints[j], tempVec2d);
 
-                const oDx = o1x - o0x;
-                const oDy = o1y - o0y;
+                        if ((ccw(i0, o0, o1) !== ccw(i1, o0, o1)) && (ccw(i0, i1, o0) !== ccw(i0, i1, o1))) {
+                            return false; // segments intersect
+                        }
 
-                const dot = (((oDx !== 0) || (oDy !== 0)) && (Math.abs(oDx * dy - oDy * dx) < 1e-10)) ? (dx * oDx + dy * oDy) : -1;
-                if ((dot >= 0) && (dot <= (Math.pow(oDx, 2) + Math.pow(oDy, 2)))) {
-                    return false; // on edge
-                }
+                        const [o0x, o0y] = o0;
+                        const [o1x, o1y] = o1;
+
+                        const dx = i0x - o0x;
+                        const dy = i0y - o0y;
 
-                if (((o0y > i0y) !== (o1y > i0y)) && (dx < (dy * oDx / oDy))) {
-                    inside = !inside;
+                        const oDx = o1x - o0x;
+                        const oDy = o1y - o0y;
+
+                        const dot = (((oDx !== 0) || (oDy !== 0)) && (Math.abs(oDx * dy - oDy * dx) < 1e-10)) ? (dx * oDx + dy * oDy) : -1;
+                        if ((dot >= 0) && (dot <= (Math.pow(oDx, 2) + Math.pow(oDy, 2)))) {
+                            return false; // on edge
+                        }
+
+                        if (((o0y > i0y) !== (o1y > i0y)) && (dx < (dy * oDx / oDy))) {
+                            inside = !inside;
+                        }
+                    }
+                    if (! inside) {
+                        return false;
+                    }
                 }
-            }
-            if (! inside) {
-                return false;
-            }
-        }
 
-        return true;
-    };
+                return true;
+            };
 
-    return function(planePos, planeRot) {
-        const planeU = math.vec3ApplyQuaternion(planeRot, worldRight,   math.vec3());
-        const planeV = math.vec3ApplyQuaternion(planeRot, worldUp,      math.vec3());
-        const planeN = math.vec3ApplyQuaternion(planeRot, worldForward, math.vec3());
+            const pos = { indices: [ ], normals: [ ] };
+            const neg = (! cfg.onlyPosSliceWithUV) && { indices: [ ], normals: [ ] };
 
-        return function(meshCenter, meshIndices, meshPositions) {
-            const planeToMesh = math.subVec3(meshCenter, planePos, math.vec3());
-            const planeDist = math.dotVec3(planeN, planeToMesh);
+            const appendOnSide = (dst, indices, normal) => {
+                if (dst) {
+                    const p0 = indexedPositions[indices[0]];
+                    normal ||= math.normalizeVec3(math.cross3Vec3(math.subVec3(indexedPositions[indices[1]], p0, tempVec3a),
+                                                                  math.subVec3(indexedPositions[indices[2]], p0, tempVec3b),
+                                                                  tempVec3a),
+                                                  tempVec3a);
 
-            const unsortedSegment = [ ];
-            const indexedPositions = [ null ]; // to never return 0 from addPosition, so its result can be used as a predicate
-            const addPosition = p => { const idx = indexedPositions.length; indexedPositions.push(math.vec3(p)); return idx; };
+                    for (let i = 0; i < 3; ++i) {
+                        dst.indices.push(indices[i]);
+                        dst.normals.push(normal[0], normal[1], normal[2]);
+                    }
+                }
+            };
 
             const setVertex = (i, dst) => {
-                const idx = meshIndices[i] * 3;
-                dst[0] = meshPositions[idx + 0];
-                dst[1] = meshPositions[idx + 1];
-                dst[2] = meshPositions[idx + 2];
+                const idx = mesh.indices[i] * 3;
+                dst[0] = mesh.positions[idx + 0];
+                dst[1] = mesh.positions[idx + 1];
+                dst[2] = mesh.positions[idx + 2];
                 return dst;
             };
 
-            for (let meshIdx = 0; meshIdx < meshIndices.length; meshIdx += 3) {
-                const p0 = setVertex(meshIdx + 0, triangle[0]);
-                const p1 = setVertex(meshIdx + 1, triangle[1]);
-                const p2 = setVertex(meshIdx + 2, triangle[2]);
+            for (let faceIdx = 0; faceIdx < mesh.indices.length; faceIdx += 3) {
+                const p0 = setVertex(faceIdx + 0, triangle[0]);
+                const p1 = setVertex(faceIdx + 1, triangle[1]);
+                const p2 = setVertex(faceIdx + 2, triangle[2]);
 
                 if (math.compareVec3(p0, p1) || math.compareVec3(p1, p2) || math.compareVec3(p2, p0)) {
                     continue; // skip degenerate triangle
@@ -7542,12 +7574,60 @@ math.makeSectionPlaneSlicer = (function() {
                 const d2 = planeDist + math.dotVec3(planeN, p2);
 
                 if ((d0 !== 0) || (d1 !== 0) || (d2 !== 0)) {
-                    const i0 = (d0 * d1 <= 0) && addPosition(math.lerpVec3(d0 / (d0 - d1), 0, 1, p0, p1, tempVec3a));
-                    const i1 = (d1 * d2 <= 0) && addPosition(math.lerpVec3(d1 / (d1 - d2), 0, 1, p1, p2, tempVec3a));
-                    const i2 = (d2 * d0 <= 0) && addPosition(math.lerpVec3(d2 / (d2 - d0), 0, 1, p2, p0, tempVec3a));
+                    const i0 = (d0 * d1 <= 0) && addPosition(math.lerpVec3(d0 / (d0 - d1), 0, 1, p0, p1, tempVec3a), true);
+                    const i1 = (d1 * d2 <= 0) && addPosition(math.lerpVec3(d1 / (d1 - d2), 0, 1, p1, p2, tempVec3a), true);
+                    const i2 = (d2 * d0 <= 0) && addPosition(math.lerpVec3(d2 / (d2 - d0), 0, 1, p2, p0, tempVec3a), true);
+
+                    const p = (! cfg.onlyPosSliceWithUV) && tmpPositions;
+                    if (p) {
+                        p[0] = addPosition(p0);
+                        p[1] = addPosition(p1);
+                        p[2] = addPosition(p2);
+                    }
 
                     if (i0 ? (i1 || i2) : (i1 && i2)) { // triangle intersected by the section plane
                         unsortedSegment.push(i0 ? [ i0, i1 || i2 ] : [ i1, i2 ]);
+
+                        if (p) {
+                            if ((d0 === 0) && (d1 === 0)) {
+                                appendOnSide((d2 > 0) ? pos : neg, p);
+                            } else if ((d0 === 0) && (d2 === 0)) {
+                                appendOnSide((d1 > 0) ? pos : neg, p);
+                            } else if ((d1 === 0) && (d2 === 0)) {
+                                appendOnSide((d0 > 0) ? pos : neg, p);
+                            } else {
+                                const isPos = (i0 ? d0 : d1) > 0;
+                                const dst0 = isPos ? pos : neg;
+                                const dst1 = isPos ? neg : pos;
+                                const i = tmpIntersections;
+                                i[0] = i0;
+                                i[1] = i1;
+                                i[2] = i2;
+                                const ref = tmpReferences;
+                                if (i0) {
+                                    ref[0] = 0; ref[1] = 1; ref[2] = 2;
+                                } else {
+                                    ref[0] = 1; ref[1] = 2; ref[2] = 0;
+                                }
+                                if (i[ref[1]]) {
+                                    appendOnSide(dst0, [ p[ref[0]], i[ref[0]], p[ref[2]] ]);
+                                    appendOnSide(dst0, [ i[ref[0]], i[ref[1]], p[ref[2]] ]);
+                                    appendOnSide(dst1, [ i[ref[0]], p[ref[1]], i[ref[1]] ]);
+                                } else {
+                                    appendOnSide(dst0, [ p[ref[0]], i[ref[0]], i[ref[2]] ]);
+                                    appendOnSide(dst1, [ i[ref[0]], p[ref[1]], p[ref[2]] ]);
+                                    appendOnSide(dst1, [ i[ref[0]], p[ref[2]], i[ref[2]] ]);
+                                }
+                            }
+                        }
+                    } else if (p) {
+                        if ((d0 >= 0) && (d1 >= 0) && (d2 >= 0)) {
+                            appendOnSide(pos, p);
+                        } else if ((d0 <= 0) && (d1 <= 0) && (d2 <= 0)) {
+                            appendOnSide(neg, p);
+                        } else {
+                            debugger;
+                        }
                     }
                 }
             }
@@ -7593,37 +7673,30 @@ math.makeSectionPlaneSlicer = (function() {
             }
 
             const loops = endpointLoops.filter(endPoints => endPoints.length > 2).map((endPoints, idx) => {
-                const planeEndpoints = endPoints.map(posIdx => {
-                    const P = math.addVec3(planeToMesh, indexedPositions[posIdx], tempVec3a);
-                    return { posIdx: posIdx, coord2Dx: math.dotVec3(planeU, P), coord2Dy: math.dotVec3(planeV, P) };
-                });
                 let doubleArea = 0;
                 const aabb = math.collapseAABB2(math.AABB2());
-                for (let i = 0; i < planeEndpoints.length; i++) {
-                    const p0 = planeEndpoints[i];
-                    tempVec2a[0] = p0.coord2Dx;
-                    tempVec2a[1] = p0.coord2Dy;
+                for (let i = 0; i < endPoints.length; i++) {
+                    getCoord2D(endPoints[i], tempVec2a);
                     math.expandAABB2Point2(aabb, tempVec2a);
-                    const p1 = planeEndpoints[(i + 1) % planeEndpoints.length];
-                    doubleArea += (p0.coord2Dx * p1.coord2Dy - p1.coord2Dx * p0.coord2Dy);
+                    getCoord2D(endPoints[(i + 1) % endPoints.length], tempVec2b);
+                    doubleArea += (tempVec2a[0] * tempVec2b[1] - tempVec2b[0] * tempVec2a[1]);
                 }
                 return {
                     boundingBox: aabb,
                     doubleArea: Math.abs(doubleArea),
-                    endPoints: planeEndpoints
+                    endPoints: endPoints
                 };
             }).sort((a, b) => b.doubleArea - a.doubleArea);
 
-            const sliceGeometries = [ ];
-
             while (loops.length > 0) {
                 const vertices2D = [ ];
                 const vertices3D = [ ];
 
                 const appendLoopVertices = loop => loop.endPoints.forEach(endpoint2D => {
-                    vertices2D.push(endpoint2D.coord2Dx, endpoint2D.coord2Dy);
-                    vertices3D.push(endpoint2D.posIdx);
-               });
+                    getCoord2D(endpoint2D, tempVec2a);
+                    vertices2D.push(tempVec2a[0], tempVec2a[1]);
+                    vertices3D.push(endpoint2D);
+                });
 
                 const outerLoop = loops.shift();
                 appendLoopVertices(outerLoop);
@@ -7645,41 +7718,33 @@ math.makeSectionPlaneSlicer = (function() {
                 // Triangulate
                 const triangles = earcut(vertices2D, innerLoops.map(loop => loop.index));
 
-                const positions = [ ];
-                const normals   = [ ];
-                const uv        = [ ];
                 for (let i = 0; i < triangles.length; i += 3) {
-                    const v0 = indexedPositions[vertices3D[triangles[i + 0]]];
-                    const v1 = indexedPositions[vertices3D[triangles[i + 1]]];
-                    const v2 = indexedPositions[vertices3D[triangles[i + 2]]];
-                    math.subVec3(v1, v0, tempVec3b);
-                    math.subVec3(v2, v0, tempVec3c);
+                    const ti = tmpIntersections;
+                    ti[0] = vertices3D[triangles[i + 0]];
+                    ti[1] = vertices3D[triangles[i + 1]];
+                    ti[2] = vertices3D[triangles[i + 2]];
+                    const v0 = indexedPositions[ti[0]];
+                    math.subVec3(indexedPositions[ti[1]], v0, tempVec3b);
+                    math.subVec3(indexedPositions[ti[2]], v0, tempVec3c);
                     math.normalizeVec3(math.cross3Vec3(tempVec3b, tempVec3c, tempVec3c), tempVec3c);
                     const facedPositively = math.dotVec3(tempVec3c, planeN) <= 0;
-                    if (! facedPositively) {
-                        math.negateVec3(tempVec3c, tempVec3c);
-                    }
-                    for (let j = 0; j < 3; ++j) {
-                        const vIdx = triangles[i + (facedPositively ? j : (2 - j))];
-                        const v = indexedPositions[vertices3D[vIdx]];
-                        positions.push(v[0], v[1], v[2]);
-                        normals.push(tempVec3c[0], tempVec3c[1], tempVec3c[2]);
-                        const uvOff = 2 * vIdx;
-                        uv.push(-vertices2D[uvOff], vertices2D[uvOff + 1]);
-                    }
-                }
-
-                if (positions.length > 0) {
-                    sliceGeometries.push({
-                        indices:   iota(positions.length / 3),
-                        positions: positions,
-                        normals:   normals,
-                        uv:        uv
-                    });
+                    appendOnSide(facedPositively ? pos : neg, ti, tempVec3c);
+                    const tmp = ti[0]; ti[0] = ti[2]; ti[2] = tmp;
+                    appendOnSide(facedPositively ? neg : pos, ti, math.negateVec3(tempVec3c, tempVec3c));
                 }
             }
 
-            return sliceGeometries;
+            const side = src => src && (src.indices.length > 0) && (function() {
+                const positions = [ ];
+                const uv = cfg.onlyPosSliceWithUV && [ ];
+                src.indices.forEach(idx => {
+                    const P = indexedPositions[idx];
+                    positions.push(P[0], P[1], P[2]);
+                    uv && uv.push(P[3], P[4]);
+                });
+                return { indices: iota(src.indices.length), positions: positions, normals: src.normals, uv: uv };
+            })();
+            return { pos: side(pos), neg: side(neg) };
         };
     };
 })();
@@ -31331,6 +31396,8 @@ class SceneModelMesh {
      */
     _destroy() {
         this.model.scene._renderer.putPickID(this.pickId);
+
+        this.layer = null;
     }
 }
 
@@ -31943,10 +32010,7 @@ const getRenderers = (function() {
                                     appendFragmentOutputs:          programSetup.appendFragmentOutputs,
                                     cleanerEdges:                   programSetup.cleanerEdges,
                                     clipPos:                        clipPos,
-                                    clippableTest:                  (function() {
-                                        const vClippable = programVariables.createVarying("float", "vClippable", () => `${attributes.clippable} ? 1.0 : 0.0`, "flat");
-                                        return () => `${vClippable} > 0.0`;
-                                    })(),
+                                    clippableTest:                  renderingAttributes.clippableTest,
                                     clippingCaps:                   programSetup.clippingCaps,
                                     crossSections:                  scene.crossSections,
                                     discardPoints:                  setupPoints && pointsMaterial.roundPoints,
@@ -33503,9 +33567,13 @@ const makeDTXRenderingAttributes = function(programVariables, isTriangle) {
     const colorsAndFlags = (offset) => perObjColsFlags(`ivec2(objectIndexCoords.x*8+${offset}, objectIndexCoords.y)`);
 
     return {
+        clippableTest: (function() {
+            const vClippable = programVariables.createVarying("uint", "vClippable", () => "flags2.r", "flat");
+            return () => `${vClippable} > 0u`;
+        })(),
+
         geometryParameters: {
             attributes: {
-                clippable:         "(flags2.r > 0u)",
                 color:             colorA,
                 flags:             iota$2(4).map(i => `int(flags[${i}])`),
                 metallicRoughness: null,
@@ -33642,9 +33710,9 @@ function quantizePositions(positions, aabb, positionsDecodeMatrix) { // http://c
     const xmin = aabb[0];
     const ymin = aabb[1];
     const zmin = aabb[2];
-    const xwid = aabb[3] - xmin;
-    const ywid = aabb[4] - ymin;
-    const zwid = aabb[5] - zmin;
+    const xwid = (aabb[3] - xmin) || 1;
+    const ywid = (aabb[4] - ymin) || 1;
+    const zwid = (aabb[5] - zmin) || 1;
     const maxInt = 65525;
     const xMultiplier = maxInt / xwid;
     const yMultiplier = maxInt / ywid;
@@ -33673,9 +33741,9 @@ function createPositionsDecodeMatrix(aabb, positionsDecodeMatrix) { // http://cg
     const xmin = aabb[0];
     const ymin = aabb[1];
     const zmin = aabb[2];
-    const xwid = aabb[3] - xmin;
-    const ywid = aabb[4] - ymin;
-    const zwid = aabb[5] - zmin;
+    const xwid = (aabb[3] - xmin) || 1;
+    const ywid = (aabb[4] - ymin) || 1;
+    const zwid = (aabb[5] - zmin) || 1;
     const maxInt = 65525;
     math.identityMat4(translate$1);
     math.translationMat4v(aabb, translate$1);
@@ -34663,8 +34731,8 @@ class VBOLayer extends Layer {
                             } else {    // triangles
                                 if (subGeometry && subGeometry.vertices) {
                                     return drawPoints;
-                                } else if (subGeometry && edgeIndicesBuf) {
-                                    return elementsDrawer(gl.LINES, edgeIndicesBuf);
+                                } else if (subGeometry) {
+                                    return edgeIndicesBuf ? elementsDrawer(gl.LINES, edgeIndicesBuf) : (() => { });
                                 } else {
                                     return elementsDrawer(gl.TRIANGLES, indicesBuf);
                                 }
@@ -34746,9 +34814,13 @@ const makeVBORenderingAttributes = function(programVariables, instancing, entity
     return {
         dontCullOnAlphaZero: true,
 
+        clippableTest: (function() {
+            const vClippable = programVariables.createVarying("float", "vClippable", () => `${`((int(${attributes.flags}) >> 16 & 0xF) == 1)`} ? 1.0 : 0.0`); // Using `flat uint` for vClippable causes an instability - see XEOK-385
+            return () => `${vClippable} != 0.0`;
+        })(),
+
         geometryParameters: {
             attributes: {
-                clippable:         `((int(${attributes.flags}) >> 16 & 0xF) == 1)`,
                 color:             attributes.color,
                 flags:             iota$1(4).map(i => ({ toString: () => `(int(${attributes.flags}) >> ${i * 4} & 0xF)` })),
                 metallicRoughness: attributes.metallicRoughness,
@@ -54014,7 +54086,7 @@ class SectionCaps {
                 const visibleSceneModels = Object.values(scene.models).filter(sceneModel => (sceneModel.id in modelCaches) && sceneModel.visible);
                 sectionPlanes.forEach((plane) => {
                     if (plane.active) {
-                        const sliceMesh = math.makeSectionPlaneSlicer(plane.pos, plane.quaternion);
+                        const sliceMesh = math.makeSectionPlaneSlicer(plane);
                         visibleSceneModels.forEach(sceneModel => {
                             const modelAABB = sceneModel.aabb;
                             if (math.planeIntersectsAABB3(plane, modelAABB)) {
@@ -54034,10 +54106,11 @@ class SectionCaps {
                                         });
 
                                         entityCache.meshCaches.filter(meshCache => math.planeIntersectsAABB3(plane, meshCache.mesh.aabb)).forEach((meshCache, meshIdx) => {
-                                            sliceMesh(modelCenter, meshCache.meshIndices, meshCache.meshVertices).forEach((geo, geoIdx) => {
+                                            const geo = sliceMesh({ origin: modelCenter, indices: meshCache.meshIndices, positions: meshCache.meshVertices }, { onlyPosSliceWithUV: true }).pos;
+                                            if (geo) {
                                                 entityCache.capMeshes.push(new Mesh(scene, {
                                                     isObject: true,
-                                                    id:       `${plane.id}-${entityId}-${meshIdx}-${geoIdx}`,
+                                                    id:       `${plane.id}-${entityId}-${meshIdx}`,
                                                     material: entity.capMaterial,
                                                     origin:   math.addVec3(modelCenter, math.mulVec3Scalar(plane.dir, 0.001, tempVec3a$a), tempVec3a$a),
                                                     geometry: new ReadableGeometry(scene, {
@@ -54048,7 +54121,7 @@ class SectionCaps {
                                                         uv:        geo.uv
                                                     })
                                                 }));
-                                            });
+                                            }
                                         });
                                     }
                                 });
@@ -60460,7 +60533,7 @@ class CameraControl extends Component {
      *
      * See class docs for usage.
      *
-     * @param {{Number:Number}|String} value Either a set of new key mappings, or a string to select a keyboard layout,
+     * @param {{Number:(Number | Number[])[]} | String} value Either a set of new key mappings, or a string to select a keyboard layout,
      * which causes ````CameraControl```` to use the default key mappings for that layout.
      */
     set keyMap(value) {
@@ -60539,7 +60612,7 @@ class CameraControl extends Component {
     /**
      * Gets custom mappings of keys to {@link CameraControl} actions.
      *
-     * @returns {{Number:Number}} Current key mappings.
+     * @returns {{Number:(Number | Number[])[]}} Current key mappings.
      */
     get keyMap() {
         return this._keyMap;
@@ -131076,6 +131149,974 @@ class CxConverterIFCLoaderPlugin extends Plugin {
     }
 }
 
+/**
+ * Default data access strategy for {@link IFCOpenShellLoaderPlugin}.
+ *
+ * This just loads assets using XMLHttpRequest.
+ */
+class IFCOpenShellDefaultDataSource {
+
+    constructor(cfg = {}) {
+        this.cacheBuster = (cfg.cacheBuster !== false);
+    }
+
+    _cacheBusterURL(url) {
+        if (!this.cacheBuster) {
+            return url;
+        }
+        const timestamp = new Date().getTime();
+        if (url.indexOf('?') > -1) {
+            return url + '&_=' + timestamp;
+        } else {
+            return url + '?_=' + timestamp;
+        }
+    }
+
+    /**
+     * Gets the contents of the given IFC file in an arraybuffer.
+     *
+     * @param {String|Number} src Path or ID of an IFC file.
+     * @param {Function} ok Callback fired on success, argument is the IFC file in an arraybuffer.
+     * @param {Function} error Callback fired on error.
+     */
+    getIFC(src, ok, error) {
+        src = this._cacheBusterURL(src);
+
+        var defaultCallback = () => {
+        };
+        ok = ok || defaultCallback;
+        error = error || defaultCallback;
+        const dataUriRegex = /^data:(.*?)(;base64)?,(.*)$/;
+        const dataUriRegexResult = src.match(dataUriRegex);
+        if (dataUriRegexResult) { // Safari can't handle data URIs through XMLHttpRequest
+            const isBase64 = !!dataUriRegexResult[2];
+            var data = dataUriRegexResult[3];
+            data = window.decodeURIComponent(data);
+            if (isBase64) {
+                data = window.atob(data);
+            }
+            try {
+                const buffer = new ArrayBuffer(data.length);
+                const view = new Uint8Array(buffer);
+                for (var i = 0; i < data.length; i++) {
+                    view[i] = data.charCodeAt(i);
+                }
+                ok(buffer);
+            } catch (errMsg) {
+                error(errMsg);
+            }
+        } else {
+            const request = new XMLHttpRequest();
+            request.open('GET', src, true);
+            request.responseType = 'text';
+            request.onreadystatechange = function () {
+                if (request.readyState === 4) {
+                    if (request.status === 200) {
+                        ok(request.response);
+                    } else {
+                        error('getIFC error : ' + request.response);
+                    }
+                }
+            };
+            request.send(null);
+        }
+    }
+}
+
+/**
+ * {@link Viewer} plugin that uses [IfcOpenShell](https://ifcopenshell.org/) to load BIM models directly from IFC files.
+ *
+ * <a href="https://xeokit.github.io/xeokit-sdk/examples/index.html#BIMOffline_IFCOpenShellLoaderPlugin_Duplex"><img src="https://xeokit.io/img/docs/IFCOpenShellLoaderPlugin/IFCOpenShellLoaderPlugin.png"></a>
+ *
+ * [[Run this example](https://xeokit.github.io/xeokit-sdk/examples/index.html#BIMOffline_IFCOpenShellLoaderPlugin_Duplex)]
+ *
+ * ## Overview
+ *
+ * * Loads small-to-medium sized BIM models directly from IFC files.
+ * * Uses [IfcOpenShell API](https://ifcopenshell.org/) to parse IFC files in the browser.
+ * * Loads IFC geometry, element structure metadata, and property sets.
+ * * Not for large models. For best performance with large models, we recommend using {@link XKTLoaderPlugin}.
+ * * Loads double-precision coordinates, enabling models to be viewed at global coordinates without accuracy loss.
+ * * Filter which IFC types don't get loaded.
+ * * Configure initial appearances of specified IFC types.
+ * * Set a custom data source for IFC files.
+ *
+ * ## Limitations
+ *
+ * Loading and parsing huge IFC STEP files can be slow, and can overwhelm the browser, however. To view your
+ * largest IFC models, we recommend instead pre-converting those to xeokit's compressed native .XKT format, then
+ * loading them with {@link XKTLoaderPlugin} instead.</p>
+ *
+ * ## Scene representation
+ *
+ * When loading a model, IFCOpenShellLoaderPlugin creates an {@link Entity} that represents the model, which
+ * will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id}
+ * in {@link Scene#models}. The IFCOpenShellLoaderPlugin also creates an {@link Entity} for each object within the
+ * model. Those Entities will have {@link Entity#isObject} set ````true```` and will be registered
+ * by {@link Entity#id} in {@link Scene#objects}.
+ *
+ * ## Metadata
+ *
+ * When loading a model, IFCOpenShellLoaderPlugin also creates a {@link MetaModel} that represents the model, which contains
+ * a {@link MetaObject} for each IFC element, plus a {@link PropertySet} for each IFC property set. Loading metadata
+ * can be very slow, so we can also optionally disable it if we don't need it.
+ *
+ * ## Usage
+ *
+ * In the example below we'll load the Duplex BIM model from
+ * an [IFC file](https://github.com/xeokit/xeokit-sdk/tree/master/assets/models/ifc). Within our {@link Viewer}, this
+ * will create a bunch of {@link Entity}s that represents the model and its objects, along with a {@link MetaModel},
+ * {@link MetaObject}s and {@link PropertySet}s that hold their metadata.
+ *
+ * ````javascript
+ * import {Viewer, IFCOpenShellLoaderPlugin, NavCubePlugin, TreeViewPlugin} from "../../dist/xeokit-sdk.es.js";
+ *
+ * //------------------------------------------------------------------------------------------------------------------
+ * // 1. Create a Viewer,
+ * // 2. Arrange the camera
+ * //------------------------------------------------------------------------------------------------------------------
+ *
+ * // 1
+ * const viewer = new Viewer({
+ *      canvasId: "myCanvas",
+ *      transparent: true
+ * });
+ *
+ * // 2
+ * viewer.camera.eye = [-3.933, 2.855, 27.018];
+ * viewer.camera.look = [4.400, 3.724, 8.899];
+ * viewer.camera.up = [-0.018, 0.999, 0.039];
+ *
+ * //------------------------------------------------------------------------------------------------------------------
+ * // 1. Create the IFCOpenShellLoaderPlugin,
+ * // 2. Load an IFC model
+ * //------------------------------------------------------------------------------------------------------------------
+ *
+ * // 1
+ *
+ * const ifcLoader = new IFCOpenShellLoaderPlugin(viewer, {
+ *     workerSrc: "./my/directory/IFCOpenShellWorker.js",
+ *     ifcOpenShellURL: "./my/directory/ifcopenshell-0.8.3+34a1bc6-cp313-cp313-emscripten_4_0_9_wasm32.whl"
+ * });
+ *
+ * // 2
+ * const model = ifcLoader.load({          // Returns an Entity that represents the model
+ *    id: "myModel",
+ *    src: "../assets/models/ifc/Duplex.ifc",
+ *    excludeTypes: ["IfcSpace"],
+ *    edges: true
+ * });
+ *
+ * model.on("loaded", () => {
+ *
+ *    //----------------------------------------------------------------------------------------------------------
+ *    // 1. Find metadata on the bottom storey
+ *    // 2. X-ray all the objects except for the bottom storey
+ *    // 3. Fit the bottom storey in view
+ *    //----------------------------------------------------------------------------------------------------------
+ *
+ *    // 1
+ *    const metaModel = viewer.metaScene.metaModels["myModel"];       // MetaModel with ID "myModel"
+ *    const metaObject
+ *            = viewer.metaScene.metaObjects["1xS3BCk291UvhgP2dvNsgp"];  // MetaObject with ID "1xS3BCk291UvhgP2dvNsgp"
+ *
+ *    const name = metaObject.name;                                   // "01 eerste verdieping"
+ *    const type = metaObject.type;                                   // "IfcBuildingStorey"
+ *    const parent = metaObject.parent;                               // MetaObject with type "IfcBuilding"
+ *    const children = metaObject.children;                           // Array of child MetaObjects
+ *    const objectId = metaObject.id;                                 // "1xS3BCk291UvhgP2dvNsgp"
+ *    const objectIds = viewer.metaScene.getObjectIDsInSubtree(objectId);   // IDs of leaf sub-objects
+ *    const aabb = viewer.scene.getAABB(objectIds);                   // Axis-aligned boundary of the leaf sub-objects
+ *
+ *    // 2
+ *    viewer.scene.setObjectsXRayed(viewer.scene.objectIds, true);
+ *    viewer.scene.setObjectsXRayed(objectIds, false);
+ *
+ *    // 3
+ *    viewer.cameraFlight.flyTo(aabb);
+ *
+ *    // Find the model Entity by ID
+ *    model = viewer.scene.models["myModel"];
+ *
+ *    // Destroy the model
+ *    model.destroy();
+ * });
+ * ````
+ *
+ * ## Configuring a custom data source
+ *
+ * By default, IFCOpenShellLoaderPlugin will load IFC files over HTTP.
+ *
+ * In the example below, we'll customize the way IFCOpenShellLoaderPlugin loads the files by configuring it with our own data source
+ * object. For simplicity, our custom data source example also uses HTTP, using a couple of xeokit utility functions.
+ *
+ * ````javascript
+ * import {utils} from "xeokit-sdk.es.js";
+ *
+ * class MyDataSource {
+ *
+ *      constructor() {
+ *      }
+ *
+ *      // Gets the contents of the given IFC file in an arraybuffer
+ *      getIFC(src, ok, error) {
+ *          console.log("MyDataSource#getIFC(" + IFCSrc + ", ... )");
+ *          utils.loadArraybuffer(src,
+ *              (arraybuffer) => {
+ *                  ok(arraybuffer);
+ *              },
+ *              function (errMsg) {
+ *                  error(errMsg);
+ *              });
+ *      }
+ * }
+ *
+ * const ifcLoader2 = new IFCOpenShellLoaderPlugin(viewer, {
+ *       dataSource: new MyDataSource()
+ * });
+ *
+ * const model5 = ifcLoader2.load({
+ *      id: "myModel5",
+ *      src: "../assets/models/ifc/Duplex.ifc"
+ * });
+ * ````
+ *
+ * ## Loading multiple copies of a model, without object ID clashes
+ *
+ * Sometimes we need to load two or more instances of the same model, without having clashes
+ * between the IDs of the equivalent objects in the model instances.
+ *
+ * As shown in the example below, we do this by setting {@link IFCOpenShellLoaderPlugin#globalizeObjectIds} ````true```` before we load our models.
+ *
+ * ````javascript
+ * ifcLoader.globalizeObjectIds = true;
+ *
+ * const model = ifcLoader.load({
+ *      id: "model1",
+ *      src: "../assets/models/ifc/Duplex.ifc"
+ * });
+ *
+ * const model2 = ifcLoader.load({
+ *    id: "model2",
+ *    src: "../assets/models/ifc/Duplex.ifc"
+ * });
+ * ````
+ *
+ * For each {@link Entity} loaded by these two calls, {@link Entity#id} and {@link MetaObject#id} will get prefixed by
+ * the ID of their model, in order to avoid ID clashes between the two models.
+ *
+ * An Entity belonging to the first model will get an ID like this:
+ *
+ * ````
+ * myModel1#0BTBFw6f90Nfh9rP1dlXrb
+ * ````
+ *
+ * The equivalent Entity in the second model will get an ID like this:
+ *
+ * ````
+ * myModel2#0BTBFw6f90Nfh9rP1dlXrb
+ * ````
+ *
+ * Now, to update the visibility of both of those Entities collectively, using {@link Scene#setObjectsVisible}, we can
+ * supply just the IFC product ID part to that method:
+ *
+ * ````javascript
+ * myViewer.scene.setObjectVisibilities("0BTBFw6f90Nfh9rP1dlXrb", true);
+ * ````
+ *
+ * The method, along with {@link Scene#setObjectsXRayed}, {@link Scene#setObjectsHighlighted} etc, will internally expand
+ * the given ID to refer to the instances of that Entity in both models.
+ *
+ * We can also, of course, reference each Entity directly, using its globalized ID:
+ *
+ * ````javascript
+ * myViewer.scene.setObjectVisibilities("myModel1#0BTBFw6f90Nfh9rP1dlXrb", true);
+ *````
+ *
+ * @class IFCOpenShellLoaderPlugin
+ * @since 2.6.90
+ */
+class IFCOpenShellLoaderPlugin extends Plugin {
+
+    /**
+     * @param {Viewer} viewer The {@link Viewer} that will own this plugin.
+     * @param {Object} cfg Plugin configuration.
+     * @param {String} [cfg.id="IFCOpenShellLoader"] Optional ID for this plugin instance.
+     * @param {Object} [cfg.dataSource] Custom data source (defaults to {@link IFCOpenShellDefaultDataSource}).
+     * @param {Object} cfg.ifcopenshell IfcOpenShell API object.
+     * @param {Object} cfg.ifcopenshell_geom IfcOpenShell geometry API object.
+     */
+    constructor(viewer, cfg) {
+
+        super("IFCOpenShellLoader", viewer, cfg);
+
+        if (!cfg) {
+            throw new Error("IFCOpenShellLoaderPlugin: No configuration given");
+        }
+
+        if (!cfg.ifcopenshell) {
+            throw new Error("IFCOpenShellLoaderPlugin: No ifcopenshell given");
+        }
+
+        if (!cfg.ifcopenshell_geom) {
+            throw new Error("IFCOpenShellLoaderPlugin: No ifcopenshell_geom given");
+        }
+
+        this.ifcopenshell = cfg.ifcopenshell;
+        this.ifcopenshell_geom = cfg.ifcopenshell_geom;
+
+        this.dataSource = cfg.dataSource;
+    }
+
+    /**
+     * Sets a custom data source for IFC files.
+     * @param value
+     */
+    set dataSource(value) {
+        this._dataSource = value || new IFCOpenShellDefaultDataSource();
+    }
+
+    /**
+     * Gets the data source for IFC files.
+     * @returns {*|IFCOpenShellDefaultDataSource}
+     */
+    get dataSource() {
+        return this._dataSource;
+    }
+
+    /**
+     * Gets whether IFCOpenShellLoaderPlugin globalizes each {@link Entity#id} and {@link MetaObject#id} as it loads a model.
+     *
+     * Default value is ````false````.
+     *
+     * @type {Boolean}
+     */
+    get globalizeObjectIds() {
+        return this._globalizeObjectIds;
+    }
+
+    /**
+     * Sets whether IFCOpenShellLoaderPlugin globalizes each {@link Entity#id} and {@link MetaObject#id} as it loads a model.
+     *
+     * Set  this ````true```` when you need to load multiple instances of the same model, to avoid ID clashes
+     * between the objects in the different instances.
+     *
+     * When we load a model with this set ````true````, then each {@link Entity#id} and {@link MetaObject#id} will be
+     * prefixed by the ID of the model, ie. ````<modelId>#<objectId>````.
+     *
+     * {@link Entity#originalSystemId} and {@link MetaObject#originalSystemId} will always hold the original, un-prefixed, ID values.
+     *
+     * Default value is ````false````.
+     *
+     * See the main {@link IFCOpenShellLoaderPlugin} class documentation for usage info.
+     *
+     * @type {Boolean}
+     */
+    set globalizeObjectIds(value) {
+        this._globalizeObjectIds = !!value;
+    }
+
+    /**
+     * Loads an IFC model from a file or text into the {@link Viewer}.
+     *
+     * @param {Object} params
+     * @param {String} [params.id] Optional root Entity ID.
+     * @param {String} [params.src] IFC file path (alternative to `text`).
+     * @param {String} [params.text] IFC text (alternative to `src`).
+     * @param {{String:Object}} [params.objectDefaults]
+     * @param {String[]} [params.excludeTypes] Array of IFC types to exclude.
+     * @param {Number[]} [params.origin=[0,0,0]] Optional World-coordinate origin to apply to the model.
+     * @param {Number[]} [params.position=[0,0,0]] Optional position offset to apply to the model.
+     * @param {Number[]} [params.rotation=[0,0,0]] Optional XYZ Euler rotation (degrees) to apply to the model.
+     * @param {Boolean} [params.backfaces=true] Whether to render backfaces.
+     * @param {Boolean} [params.dtxEnabled=true] Whether to enable data texture storage for geometry buffers.
+     * @param {Boolean} [params.loadMetadata=true] Whether to load metadata.
+     * @param {Boolean} [params.loadMetadataPropertySets=true] Whether to load property sets within the metadata. Only works when `loadMetadata` is true.
+     * @param {Boolean} [params.edges=false] Whether to generate edge lines for the model.
+     * @param {Boolean} [params.saoEnabled=false] Whether to enable SAO for the model.
+     * @param {Boolean} [params.globalizeObjectIds=false] Whether to globalize each {@link Entity#id} and {@link MetaObject#id} as it loads the model.
+     * @returns {Entity}
+     */
+    async load(params = {}) {
+
+        let {
+            id,
+            backfaces = true,
+            dtxEnabled = true,
+            position,
+            rotation,
+            origin,
+            loadMetadata,
+            loadMetadataPropertySets,
+            edges,
+            saoEnabled,
+            globalizeObjectIds,
+            excludeTypes
+        } = params;
+
+        if (id && this.viewer.scene.components[id]) {
+            this.error(`Component with this ID already exists: ${id} - autogenerating SceneModel ID`);
+            id = null;
+        }
+
+        const sceneModel = new SceneModel(this.viewer.scene, {
+            id,
+            isModel: true,
+            globalizeObjectIds,
+            backfaces,
+            dtxEnabled,
+            position,
+            rotation,
+            origin,
+            edges,
+            saoEnabled
+        });
+
+        const modelId = sceneModel.id;
+
+        if (!params.src && !params.text) {
+            this.error("load() expected 'src' or 'text'");
+            return sceneModel; // Return empty model
+        }
+
+        const spinner = this.viewer.scene.canvas.spinner;
+        spinner.processes++;
+
+        const loadIFC = (fileData) => {
+            const ifc = this.ifcopenshell.file.from_string(fileData);
+            const ctx = {
+                loadMetadataPropertySets: (loadMetadataPropertySets !== false),
+                globalizeObjectIds: globalizeObjectIds || this._globalizeObjectIds,
+                geometryCache: new Map(),
+                ifc,
+                sceneModel
+            };
+            if (excludeTypes) {
+                ctx.excludeTypes = excludeTypes;
+            }
+            this._loadIFCGeometry(ctx);
+            if (loadMetadata !== false) {
+                const metaModelData = this._loadIFCMetaModel(ctx, ifc);
+                this.viewer.metaScene.createMetaModel(modelId, metaModelData);
+            }
+            this.viewer.scene.canvas.spinner.processes--;
+        };
+
+        if (params.src) {
+            this.viewer.scene.canvas.spinner.processes++;
+            this._dataSource.getIFC(
+                params.src,
+                (fileData) => {
+                    loadIFC(fileData);
+                    this.viewer.scene.canvas.spinner.processes--;
+                },
+                (err) => {
+                    this.viewer.scene.canvas.spinner.processes--;
+                    this.error(err);
+                }
+            );
+        } else {
+            loadIFC(params.text);
+        }
+
+        sceneModel.once("destroyed", () => {
+            this.viewer.metaScene.destroyMetaModel(modelId);
+        });
+
+        return sceneModel;
+    }
+
+    _loadIFCGeometry(ctx) {
+        const {ifc, sceneModel} = ctx;
+        const {ifcopenshell_geom} = this;
+
+        const settings = ifcopenshell_geom.settings();
+        settings.set(settings.WELD_VERTICES, false);
+
+        const iterator = ifcopenshell_geom.iterator.callKwargs({
+            settings,
+            file_or_filename: ifc,
+            exclude: ctx.excludeTypes,
+            geometry_library: "hybrid-cgal-simple-opencascade"
+        });
+
+        if (iterator.initialize()) {
+            do {
+                const obj = iterator.get();
+                if (obj) {
+                    const entity = ifc.by_id(obj.id);
+                    this._parseIFCEntity(ctx, obj, entity);
+                }
+            } while (iterator.next());
+        }
+
+        sceneModel.finalize();
+
+        sceneModel.scene.once("tick", () => {
+            if (!sceneModel.destroyed) {
+                sceneModel.scene.fire("modelLoaded", sceneModel.id);
+                sceneModel.fire("loaded", true, false);
+            }
+        });
+    }
+
+    _parseIFCEntity(ctx, obj, ifcEntity) {
+        const {sceneModel, geometryCache} = ctx;
+        const geometry_id = obj.geometry.id;
+
+        const M = obj.transformation.data().components.toJs();
+        const {origin, matrix} = extractRTCTransform(M);
+
+        if (!geometryCache.get(geometry_id)) {
+
+            const srcMaterials = obj.geometry.materials.toJs();
+            const materials = srcMaterials.map((m) => ({
+                diffuse: m.diffuse.components.toJs(),
+                transparency: (m.transparency
+                    && !isNaN(m.transparency)) ? m.transparency : 0.0,
+            }));
+
+            const materialIds = new Int32Array(obj.geometry.material_ids.toJs());
+
+            // Build mapping: materialIndex -> [faceIdx...]
+            const mapping = buildMaterialMapping(materialIds);
+
+            // Create sub-geometry per materialIndex, once
+            const subGeoms = new Map();
+
+            for (const [matIndexStr, faceList] of Object.entries(mapping)) {
+
+                if (!faceList || faceList.length === 0) {
+                    continue;
+                }
+
+                // xeokit auto-generates normals on the GPU side
+
+                const positions = new Float32Array(obj.geometry.verts.toJs());
+                const edgeIndices = new Uint32Array(obj.geometry.edges.toJs());
+                const faces = new Uint32Array(obj.geometry.faces.toJs());
+                const matIndex = Number(matIndexStr);
+                const indices = buildIndicesForFaces(faceList, faces);
+                const sceneGeometryId = makeSubGeometryId(geometry_id, matIndex); // deterministic
+
+                sceneModel.createGeometry({
+                    id: sceneGeometryId,
+                    primitive: "triangles",
+                    positions,
+                    indices,
+                    edgeIndices
+                });
+
+                subGeoms.set(matIndex, sceneGeometryId);
+            }
+
+            geometryCache.set(geometry_id, {
+                subGeoms,
+                materials,
+                // store mapping as Map<number, Uint32Array> to avoid recomputing
+                mapping: new Map(Object.entries(mapping).map(
+                    ([k, v]) => [Number(k), new Uint32Array(v)]
+                ))
+            });
+        }
+
+        // Reuse cached sub-geometries to create per-object meshes
+
+        const cached = geometryCache.get(geometry_id);
+        const meshIds = [];
+
+        for (const [matIndex, sceneGeometryId] of cached.subGeoms.entries()) {
+            const material = cached.materials[matIndex] || {diffuse: [0.6, 0.6, 0.6], transparency: 0.0};
+            const meshId = generateUUID();
+            const diffuse = material.diffuse;
+            sceneModel.createMesh({
+                id: meshId,
+                geometryId: sceneGeometryId,
+                origin,
+                matrix,
+                color: [diffuse[0], diffuse[1], diffuse[2]],
+                opacity: 1.0 - material.transparency
+            });
+            meshIds.push(meshId);
+        }
+
+        sceneModel.createEntity({
+            id: ctx.globalizeObjectIds ? math.globalizeObjectId(ctx.sceneModel.id, ifcEntity.GlobalId) : ifcEntity.GlobalId,
+            isObject: true,
+            meshIds
+        });
+    }
+
+    _loadIFCMetaModel(ctx, ifc) {
+
+        const visited = new Set();
+        const metaObjects = [];
+        const propertySets = [];
+
+        // ---- helpers -----------------------------------------------------------
+        const toStr = (v) => (v === undefined || v === null) ? "" : String(v);
+
+        function getGlobalId(entity) {
+            try {
+                return String(entity.GlobalId);
+            } catch {
+                return null;
+            }
+        }
+
+        function addNode(entity, parent) {
+            const id = getGlobalId(entity);
+            if (!id || visited.has(id)) return false;
+            visited.add(id);
+            const globalizeObjectIds = ctx.globalizeObjectIds;
+            const modelId = ctx.sceneModel.id;
+            const propertySetIds = [];
+            if (ctx.loadMetadataPropertySets) {
+                // Try all possible association fields
+                const associationFields = ["HasAssociations", "IsDefinedBy", "IsDecomposedBy", "ContainsElements"];
+                for (const field of associationFields) {
+                    const associations = entity[field];
+                    if (associations && associations.length > 0) {
+                        for (let j = 0; j < associations.length; j++) {
+                            const rel = associations.get(j);
+                            if (rel.is_a && rel.is_a() === "IfcRelDefinesByProperties") {
+                                const propSet = rel.RelatingPropertyDefinition;
+                                if (propSet && propSet.is_a) {
+                                    // Accept both IfcPropertySet and IfcElementQuantity
+                                    if (["IfcPropertySet", "IfcElementQuantity"].includes(propSet.is_a())) {
+                                        const propSetId = propSet.GlobalId ? String(propSet.GlobalId) : null;
+                                        const propSetName = propSet.Name ? String(propSet.Name) : "";
+                                        const propSetType = propSet.is_a ? String(propSet.is_a()) : "";
+                                        const properties = [];
+                                        const props = propSet.HasProperties || propSet.Quantities;
+                                        if (props && props.length > 0) {
+                                            for (let k = 0; k < props.length; k++) {
+                                                const p = props.get(k);
+                                                const propName = p.Name ? String(p.Name) : "";
+                                                let propValue = "";
+                                                let propType = p.is_a ? String(p.is_a()) : "";
+                                                if (p.is_a && p.is_a() === "IfcPropertySingleValue") {
+                                                    try {
+                                                        propValue = p.NominalValue ? String(p.NominalValue.wrappedValue) : "";
+                                                    } catch {
+                                                        propValue = "";
+                                                    }
+                                                } else if (p.is_a && p.is_a() === "IfcPropertyEnumeratedValue") {
+                                                    try {
+                                                        const values = p.EnumerationValues;
+                                                        if (values && values.length > 0) {
+                                                            const arr = [];
+                                                            for (let vi = 0; vi < values.length; vi++) {
+                                                                arr.push(String(values.get(vi).wrappedValue));
+                                                            }
+                                                            propValue = arr.join(", ");
+                                                        }
+                                                    } catch {
+                                                        propValue = "";
+                                                    }
+                                                } else if (p.is_a && p.is_a() === "IfcQuantityArea") {
+                                                    propValue = p.AreaValue ? String(p.AreaValue) : "";
+                                                } else if (p.is_a && p.is_a() === "IfcQuantityLength") {
+                                                    propValue = p.LengthValue ? String(p.LengthValue) : "";
+                                                } else if (p.is_a && p.is_a() === "IfcQuantityVolume") {
+                                                    propValue = p.VolumeValue ? String(p.VolumeValue) : "";
+                                                } else {
+                                                    try {
+                                                        propValue = p.NominalValue ? String(p.NominalValue) : "";
+                                                    } catch {
+                                                        propValue = "";
+                                                    }
+                                                }
+                                                properties.push({
+                                                    name: propName,
+                                                    value: propValue,
+                                                    type: propType
+                                                });
+                                                p.destroy?.();
+                                            }
+                                            props.destroy?.();
+                                        }
+                                        propertySets.push({
+                                            id: propSetId,
+                                            //    objectId: ctx.globalizeObjectIds ? math.globalizeObjectId(ctx.sceneModel.id, objectId) : objectId,
+                                            name: propSetName,
+                                            type: propSetType,
+                                            properties
+                                        });
+                                        propertySetIds.push(propSetId);
+                                        propSet.destroy?.();
+                                    }
+                                }
+                                rel.destroy?.();
+                            }
+                        }
+                        associations.destroy?.();
+                    }
+                }
+            }
+            metaObjects.push({
+                id: globalizeObjectIds ? math.globalizeObjectId(modelId, id) : id,
+                type: String(entity.is_a()),
+                parent: parent
+                    ? (globalizeObjectIds
+                        ? math.globalizeObjectId(modelId, getGlobalId(parent))
+                        : getGlobalId(parent))
+                    : null,
+                propertySetIds
+            });
+            return true;
+        }
+
+        function walk(entity, parent = null) {
+            if (!entity) return;
+
+            // add current node (skip children if already visited)
+            if (!addNode(entity, parent)) {
+                entity.destroy?.();
+                return;
+            }
+
+            // 1) Decomposition (IfcRelAggregates / IfcRelNests)
+            const decos = entity.IsDecomposedBy;
+            if (decos) {
+                for (let i = 0; i < decos.length; i++) {
+                    const rel = decos.get(i);
+                    const children = rel.RelatedObjects;
+                    if (children) {
+                        for (let j = 0; j < children.length; j++) {
+                            const child = children.get(j);
+                            walk(child, entity);
+                            child.destroy?.();
+                        }
+                        children.destroy?.();
+                    }
+                    rel.destroy?.();
+                }
+            }
+
+            // 2) Spatial containment (IfcRelContainedInSpatialStructure)
+            const contains = entity.ContainsElements;
+            if (contains) {
+                for (let i = 0; i < contains.length; i++) {
+                    const rel = contains.get(i);
+                    const elems = rel.RelatedElements;
+                    if (elems) {
+                        for (let j = 0; j < elems.length; j++) {
+                            const elem = elems.get(j);
+                            walk(elem, entity);
+                            elem.destroy?.();
+                        }
+                        elems.destroy?.();
+                    }
+                    rel.destroy?.();
+                }
+            }
+
+            entity.destroy?.();
+        }
+
+        // ---- metadata extraction ----------------------------------------------
+        let projectId = "";
+        let author = "";
+        let createdAt = ""; // ISO string
+        let schema = "";
+        let creatingApplication = "";
+
+        // Schema (primary)
+        try {
+            // ifcopenshell.file usually exposes a `schema` string property
+            schema = toStr(ifc.schema);
+        } catch {
+        }
+        if (!schema) {
+            // Fallback to STEP header
+            try {
+                const ids = ifc.wrapped_data.header.file_schema.schema_identifiers;
+                if (ids && ids.length > 0) schema = toStr(ids.get(0));
+            } catch {
+            }
+        }
+
+        // Project (also gives us OwnerHistory on many files)
+        const projects = ifc.by_type("IfcProject");
+        if (projects && projects.length > 0) {
+            const project = projects.get(0);
+            projectId = toStr(project.GlobalId);
+
+            // OwnerHistory path (preferred when present)
+            try {
+                const oh = project.OwnerHistory; // deprecated in newer IFC4.x, but present in many files
+                if (oh) {
+                    // Author: IfcPersonAndOrganization → ThePerson (GivenName/FamilyName) and TheOrganization.Name
+                    try {
+                        const user = oh.OwningUser;
+                        const person = user?.ThePerson;
+                        const org = user?.TheOrganization;
+                        const gn = person?.GivenName ? toStr(person.GivenName) : "";
+                        const fn = person?.FamilyName ? toStr(person.FamilyName) : "";
+                        const personName = (gn || fn) ? [gn, fn].filter(Boolean).join(" ") : "";
+                        const orgName = org?.Name ? toStr(org.Name) : "";
+                        author = [personName, orgName].filter(Boolean).join(" / ");
+                    } catch {
+                    }
+
+                    // Creation time (UNIX seconds)
+                    try {
+                        const ts = oh?.CreationDate;
+                        if (typeof ts === "number" && isFinite(ts) && ts > 0) {
+                            createdAt = new Date(ts * 1000).toISOString();
+                        }
+                    } catch {
+                    }
+
+                    // Creating application
+                    try {
+                        const app = oh?.OwningApplication;
+                        const appName =
+                            app?.ApplicationFullName ? toStr(app.ApplicationFullName) :
+                                app?.ApplicationIdentifier ? toStr(app.ApplicationIdentifier) : "";
+                        const appVer = app?.Version ? toStr(app.Version) : "";
+                        creatingApplication = [appName, appVer].filter(Boolean).join(" ");
+                    } catch {
+                    }
+                }
+            } catch {
+            }
+
+            // Clean first project (we’ll traverse below with a fresh pointer anyway)
+            project.destroy?.();
+        }
+
+        // Fallbacks via STEP header if OwnerHistory wasn’t there / incomplete
+        try {
+            const fileName = ifc.wrapped_data.header.file_name;
+            if (!author) {
+                try {
+                    const authors = fileName.author;
+                    if (authors && authors.length > 0) {
+                        // `author` is a LIST in the STEP header; join if multiple
+                        const parts = [];
+                        for (let i = 0; i < authors.length; i++) parts.push(toStr(authors.get(i)));
+                        author = parts.filter(Boolean).join(", ");
+                    }
+                } catch {
+                }
+            }
+            if (!createdAt) {
+                const ts = toStr(fileName.time_stamp); // already a string like "2023-08-10T12:34:56"
+                if (ts) {
+                    // normalize to ISO if possible
+                    const maybe = new Date(ts);
+                    if (!isNaN(maybe.getTime())) createdAt = maybe.toISOString();
+                }
+            }
+            if (!creatingApplication) {
+                // STEP header carries "originating_system" and "preprocessor_version"
+                const orig = toStr(fileName.originating_system);
+                const prep = toStr(fileName.preprocessor_version);
+                creatingApplication = [orig, prep].filter(Boolean).join(" / ");
+            }
+        } catch {
+        }
+
+        // If createdAt still missing, sweep for earliest OwnerHistory timestamp across roots
+        if (!createdAt) {
+            try {
+                let minTs = Infinity;
+                const roots = ifc.by_type("IfcRoot");
+                for (let i = 0; i < roots.length; i++) {
+                    const r = roots.get(i);
+                    const oh = r?.OwnerHistory;
+                    const ts = oh?.CreationDate;
+                    if (typeof ts === "number" && isFinite(ts) && ts > 0 && ts < minTs) {
+                        minTs = ts;
+                    }
+                    r.destroy?.();
+                }
+                roots.destroy?.();
+                if (isFinite(minTs)) createdAt = new Date(minTs * 1000).toISOString();
+            } catch {
+            }
+        }
+
+        // ---- hierarchy walk ----------------------------------------------------
+        // Re-query projects since we destroyed the first pointer above
+        const projects2 = ifc.by_type("IfcProject");
+        for (let i = 0; i < projects2.length; i++) {
+            const project = projects2.get(i);
+            walk(project, null);
+            project.destroy?.();
+        }
+        projects2.destroy?.();
+
+        return {
+            id: "",
+            projectId,
+            author,
+            createdAt,
+            schema,
+            creatingApplication,
+            metaObjects,
+            propertySets
+        };
+    }
+
+    /**
+     * Destroys this IFCOpenShellLoaderPlugin instance.
+     */
+    destroy() {
+        super.destroy();
+    }
+}
+
+function makeSubGeometryId(geometry_id, matIndex) {
+    return `${geometry_id}:${matIndex}#geom`;
+}
+
+function buildMaterialMapping(materialIds) {
+    const mapping = {};
+    for (let faceIdx = 0; faceIdx < materialIds.length; faceIdx++) {
+        const materialId = materialIds[faceIdx];
+        if (materialId == null || materialId < 0) continue; // skip invalid / missing
+        (mapping[materialId] ||= []).push(faceIdx);
+    }
+    return mapping;
+}
+
+function buildIndicesForFaces(faceList, faceIndices) {
+    const indices = new Uint32Array(faceList.length * 3);
+    let k = 0;
+    for (const faceIdx of faceList) {
+        const base = faceIdx * 3;
+        indices[k++] = faceIndices[base + 0];
+        indices[k++] = faceIndices[base + 1];
+        indices[k++] = faceIndices[base + 2];
+    }
+    return indices;
+}
+
+function generateUUID() {
+    return Math.random().toString(36).substr(2, 9);
+}
+
+function extractRTCTransform(transform) {
+    const matrix = flattenMatrixArray(transform);
+    const origin = [];
+    const worldOrigin = matrix.slice(12, 15); // translation xyz
+    worldToRTCPositions(worldOrigin, worldOrigin, origin);
+    matrix.set(worldOrigin, 12);
+    return {origin, matrix};
+}
+
+function flattenMatrixArray(m) {
+    return new Float64Array([
+        m[0][0], m[2][0], -m[1][0], m[3][0],
+        m[0][1], m[2][1], -m[1][1], m[3][1],
+        m[0][2], m[2][2], -m[1][2], m[3][2],
+        m[0][3], m[2][3], -m[1][3], m[3][3]
+    ]);
+}
+
 /**
  * Default data access strategy for {@link LASLoaderPlugin}.
  */
@@ -135166,6 +136207,8 @@ exports.GIFMediaType = GIFMediaType;
 exports.GLTFDefaultDataSource = GLTFDefaultDataSource;
 exports.GLTFLoaderPlugin = GLTFLoaderPlugin;
 exports.HalfFloatType = HalfFloatType;
+exports.IFCOpenShellDefaultDataSource = IFCOpenShellDefaultDataSource;
+exports.IFCOpenShellLoaderPlugin = IFCOpenShellLoaderPlugin;
 exports.ImagePlane = ImagePlane;
 exports.IntType = IntType;
 exports.JPEGMediaType = JPEGMediaType;