@xeokit/xeokit-sdk 2.6.95 → 2.6.97

package/src/plugins/IFCOpenShellLoaderPlugin/index.js

@@ -0,0 +1,2 @@
+export * from "./IFCOpenShellDefaultDataSource.js";
+export * from "./IFCOpenShellLoaderPlugin.js";

package/src/plugins/index.js

@@ -18,6 +18,7 @@ export * from "./XKTLoaderPlugin/index.js";
 export * from "./XML3DLoaderPlugin/index.js";
 export * from "./WebIFCLoaderPlugin/index.js";
 export * from "./CxConverterIFCLoaderPlugin/index.js";
+export * from "./IFCOpenShellLoaderPlugin/index.js";
 export * from "./LASLoaderPlugin/index.js";
 export * from "./CityJSONLoaderPlugin/index.js";
 export * from "./DotBIMLoaderPlugin/index.js";

package/src/viewer/scene/CameraControl/CameraControl.js

@@ -867,7 +867,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) {
@@ -946,7 +946,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;

package/src/viewer/scene/math/math.js

@@ -5475,9 +5475,12 @@ math.makeSectionPlaneSlicer = (function() {
     const tempVec3d = 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() {
@@ -5492,84 +5495,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);
 
-            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 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;
+            };
 
-                if ((ccw(i0, o0, o1) !== ccw(i1, o0, o1)) && (ccw(i0, i1, o0) !== ccw(i0, i1, o1))) {
-                    return false; // segments intersect
+            const getCoord2D = (idx, dst) => { const P = indexedPositions[idx]; dst[0] = P[3]; dst[1] = P[4]; return dst; };
+
+            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;
 
-                if (((o0y > i0y) !== (o1y > i0y)) && (dx < (dy * oDx / oDy))) {
-                    inside = !inside;
+                        const dx = i0x - o0x;
+                        const dy = i0y - o0y;
+
+                        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
@@ -5580,12 +5612,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;
+                        }
                     }
                 }
             }
@@ -5631,37 +5711,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);
@@ -5683,41 +5756,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) };
         };
     };
 })();

package/src/viewer/scene/model/SceneModel.js

@@ -3337,34 +3337,37 @@ export class SceneModel extends Component {
     /**
      * @private
      */
-    _withEachVisibleLayer(testNumVisibleLayerPortions, cb) {
+    _withEachVisibleLayer(frameCtx, testNumVisibleLayerPortions, cb) {
         if (testNumVisibleLayerPortions && (this.numVisibleLayerPortions === 0)) {
             return;
         }
+        const testLayerCull = frameCtx.testAABB;
         const renderFlags = this.renderFlags;
         for (let i = 0, len = renderFlags.visibleLayers.length; i < len; i++) {
-            const layerIndex = renderFlags.visibleLayers[i];
-            cb(this.layerList[layerIndex]);
-        }
-    }
-
-    drawColorOpaque          (frameCtx) { this._withEachVisibleLayer(false, layer => layer.drawColorOpaque          (this.renderFlags, frameCtx)); }
-    drawColorTransparent     (frameCtx) { this._withEachVisibleLayer(false, layer => layer.drawColorTransparent     (this.renderFlags, frameCtx)); }
-    drawDepth                (frameCtx) { this._withEachVisibleLayer(false, layer => layer.drawDepth                (this.renderFlags, frameCtx)); } // Dedicated to SAO because it skips transparent objects
-    drawSilhouetteXRayed     (frameCtx) { this._withEachVisibleLayer(false, layer => layer.drawSilhouetteXRayed     (this.renderFlags, frameCtx)); }
-    drawSilhouetteHighlighted(frameCtx) { this._withEachVisibleLayer(false, layer => layer.drawSilhouetteHighlighted(this.renderFlags, frameCtx)); }
-    drawSilhouetteSelected   (frameCtx) { this._withEachVisibleLayer(false, layer => layer.drawSilhouetteSelected   (this.renderFlags, frameCtx)); }
-    drawEdgesColorOpaque     (frameCtx) { this._withEachVisibleLayer(false, layer => layer.drawEdgesColorOpaque     (this.renderFlags, frameCtx)); }
-    drawEdgesColorTransparent(frameCtx) { this._withEachVisibleLayer(false, layer => layer.drawEdgesColorTransparent(this.renderFlags, frameCtx)); }
-    drawEdgesXRayed          (frameCtx) { this._withEachVisibleLayer(false, layer => layer.drawEdgesXRayed          (this.renderFlags, frameCtx)); }
-    drawEdgesHighlighted     (frameCtx) { this._withEachVisibleLayer(false, layer => layer.drawEdgesHighlighted     (this.renderFlags, frameCtx)); }
-    drawEdgesSelected        (frameCtx) { this._withEachVisibleLayer(false, layer => layer.drawEdgesSelected        (this.renderFlags, frameCtx)); }
-    drawOcclusion            (frameCtx) { this._withEachVisibleLayer(true,  layer => layer.drawOcclusion            (this.renderFlags, frameCtx)); }
-    drawShadow               (frameCtx) { this._withEachVisibleLayer(true,  layer => layer.drawShadow               (this.renderFlags, frameCtx)); }
-    drawPickMesh             (frameCtx) { this._withEachVisibleLayer(true,  layer => layer.drawPickMesh             (this.renderFlags, frameCtx)); }
-    drawPickDepths           (frameCtx) { this._withEachVisibleLayer(true,  layer => layer.drawPickDepths           (this.renderFlags, frameCtx)); }
-    drawPickNormals          (frameCtx) { this._withEachVisibleLayer(true,  layer => layer.drawPickNormals          (this.renderFlags, frameCtx)); }
-    _drawSnap    (frameCtx, isSnapInit) { this._withEachVisibleLayer(true,  layer => layer.drawSnap                 (this.renderFlags, frameCtx, isSnapInit)); }
+            const layer = this.layerList[renderFlags.visibleLayers[i]];
+            if ((! testLayerCull) || testLayerCull(layer.getAABB())) {
+                cb(layer);
+            }
+        }
+    }
+
+    drawColorOpaque          (frameCtx) { this._withEachVisibleLayer(frameCtx, false, layer => layer.drawColorOpaque          (this.renderFlags, frameCtx)); }
+    drawColorTransparent     (frameCtx) { this._withEachVisibleLayer(frameCtx, false, layer => layer.drawColorTransparent     (this.renderFlags, frameCtx)); }
+    drawDepth                (frameCtx) { this._withEachVisibleLayer(frameCtx, false, layer => layer.drawDepth                (this.renderFlags, frameCtx)); } // Dedicated to SAO because it skips transparent objects
+    drawSilhouetteXRayed     (frameCtx) { this._withEachVisibleLayer(frameCtx, false, layer => layer.drawSilhouetteXRayed     (this.renderFlags, frameCtx)); }
+    drawSilhouetteHighlighted(frameCtx) { this._withEachVisibleLayer(frameCtx, false, layer => layer.drawSilhouetteHighlighted(this.renderFlags, frameCtx)); }
+    drawSilhouetteSelected   (frameCtx) { this._withEachVisibleLayer(frameCtx, false, layer => layer.drawSilhouetteSelected   (this.renderFlags, frameCtx)); }
+    drawEdgesColorOpaque     (frameCtx) { this._withEachVisibleLayer(frameCtx, false, layer => layer.drawEdgesColorOpaque     (this.renderFlags, frameCtx)); }
+    drawEdgesColorTransparent(frameCtx) { this._withEachVisibleLayer(frameCtx, false, layer => layer.drawEdgesColorTransparent(this.renderFlags, frameCtx)); }
+    drawEdgesXRayed          (frameCtx) { this._withEachVisibleLayer(frameCtx, false, layer => layer.drawEdgesXRayed          (this.renderFlags, frameCtx)); }
+    drawEdgesHighlighted     (frameCtx) { this._withEachVisibleLayer(frameCtx, false, layer => layer.drawEdgesHighlighted     (this.renderFlags, frameCtx)); }
+    drawEdgesSelected        (frameCtx) { this._withEachVisibleLayer(frameCtx, false, layer => layer.drawEdgesSelected        (this.renderFlags, frameCtx)); }
+    drawOcclusion            (frameCtx) { this._withEachVisibleLayer(frameCtx, true,  layer => layer.drawOcclusion            (this.renderFlags, frameCtx)); }
+    drawShadow               (frameCtx) { this._withEachVisibleLayer(frameCtx, true,  layer => layer.drawShadow               (this.renderFlags, frameCtx)); }
+    drawPickMesh             (frameCtx) { this._withEachVisibleLayer(frameCtx, true,  layer => layer.drawPickMesh             (this.renderFlags, frameCtx)); }
+    drawPickDepths           (frameCtx) { this._withEachVisibleLayer(frameCtx, true,  layer => layer.drawPickDepths           (this.renderFlags, frameCtx)); }
+    drawPickNormals          (frameCtx) { this._withEachVisibleLayer(frameCtx, true,  layer => layer.drawPickNormals          (this.renderFlags, frameCtx)); }
+    _drawSnap    (frameCtx, isSnapInit) { this._withEachVisibleLayer(frameCtx, true,  layer => layer.drawSnap                 (this.renderFlags, frameCtx, isSnapInit)); }
 
     drawSnapInit(frameCtx) { this._drawSnap(frameCtx, true ); }
     drawSnap    (frameCtx) { this._drawSnap(frameCtx, false); }

package/src/viewer/scene/model/SceneModelMesh.js

@@ -415,5 +415,7 @@ export class SceneModelMesh {
      */
     _destroy() {
         this.model.scene._renderer.putPickID(this.pickId);
+
+        this.layer = null;
     }
 }

package/src/viewer/scene/model/compression.js

@@ -12,9 +12,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;
@@ -43,9 +43,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);
     math.translationMat4v(aabb, translate);

package/src/viewer/scene/model/layer/DTXLayer.js

@@ -812,9 +812,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(4).map(i => `int(flags[${i}])`),
                 metallicRoughness: null,

package/src/viewer/scene/model/layer/Layer.js

@@ -156,10 +156,7 @@ export 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,
@@ -505,6 +502,15 @@ export class Layer {
 
     aabbChanged() { this._aabbDirty = true; }
 
+    getAABB() {
+        if (this._aabbDirty) { // Per-layer AABB for best RTC accuracy
+            math.collapseAABB3(this._aabb);
+            this._meshes.forEach(m => math.expandAABB3(this._aabb, m.aabb));
+            this._aabbDirty = false;
+        }
+        return this._aabb;
+    }
+
     __drawLayer(renderFlags, frameCtx, renderer, pass) {
         if ((this._countsByFlag[ENTITY_FLAGS.CULLED].count < this._portions.length) && (this._countsByFlag[ENTITY_FLAGS.VISIBLE].count > 0)) {
             const backfacePasses = (this.primitive !== "points") && (this.primitive !== "lines") && [
@@ -674,13 +680,7 @@ export class Layer {
     drawSnap(renderFlags, frameCtx, isSnapInit) {
         frameCtx.snapPickOrigin = [0, 0, 0];
 
-        if (this._aabbDirty) { // Per-layer AABB for best RTC accuracy
-            math.collapseAABB3(this._aabb);
-            this._meshes.forEach(m => math.expandAABB3(this._aabb, m.aabb));
-            this._aabbDirty = false;
-        }
-
-        const aabb = this._aabb;
+        const aabb = this.getAABB();
         frameCtx.snapPickCoordinateScale = math.mulVec3Scalar(
             safeInvVec3([ aabb[3] - aabb[0], aabb[4] - aabb[1], aabb[5] - aabb[2] ]),
             math.MAX_INT);

package/src/viewer/scene/model/layer/VBOLayer.js

@@ -887,8 +887,8 @@ export 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);
                                 }
@@ -970,9 +970,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(4).map(i => ({ toString: () => `(int(${attributes.flags}) >> ${i * 4} & 0xF)` })),
                 metallicRoughness: attributes.metallicRoughness,

package/src/viewer/scene/sectionCaps/SectionCaps.js

@@ -118,7 +118,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)) {
@@ -138,10 +138,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), tempVec3a),
                                                     geometry: new ReadableGeometry(scene, {
@@ -152,7 +153,7 @@ class SectionCaps {
                                                         uv:        geo.uv
                                                     })
                                                 }));
-                                            });
+                                            }
                                         });
                                     }
                                 });