@xeokit/xeokit-sdk 2.6.28 → 2.6.30

package/dist/xeokit-sdk.cjs.js

@@ -5284,6 +5284,14 @@ const math = {
         return aabb[0] > p[0] || aabb[3] < p[0] || aabb[1] > p[1] || aabb[4] < p[1] || aabb[2] > p[2] || aabb[5] < p[2];
     },
 
+    point3AABB3AbsoluteIntersect(aabb, p) {
+        return (
+            aabb[0] <= p[0] && aabb[3] >= p[0] &&
+            aabb[1] <= p[1] && aabb[4] >= p[1] &&
+            aabb[2] <= p[2] && aabb[5] >= p[2]
+        );
+    },
+
     /**
      *
      * @param dir
@@ -9289,7 +9297,7 @@ class PointerCircle {
     destroy() {
         if (!this._destroyed) {
             this.stop();
-            document.body.removeChild(this._circleDiv);
+            this._circleDiv.parentElement.removeChild(this._circleDiv);
             this._destroyed = true;
         }
     }
@@ -10545,7 +10553,7 @@ class SceneModelEntity {
         for (let i = 0, len = this.meshes.length; i < len; i++) {
             this.meshes[i]._setOffset(this._offset);
         }
-        this._aabbDirty  = true;
+        this._aabbDirty = true;
         this.model._aabbDirty = true;
         this.scene._aabbDirty = true;
         this.scene._objectOffsetUpdated(this, offset);
@@ -10562,6 +10570,51 @@ class SceneModelEntity {
         }
     }
 
+    getEachIndex(callback) {
+        for (let i = 0, len = this.meshes.length; i < len; i++) {
+            this.meshes[i].getEachIndex(callback);
+        }
+    }
+
+    /**
+     * Returns the volume of this SceneModelEntity.
+     *
+     * Only works when {@link Scene.readableGeometryEnabled | Scene.readableGeometryEnabled} is `true` and the
+     * SceneModelEntity contains solid triangle meshes; returns `0` otherwise.
+     *
+     * @returns {number}
+     */
+    get volume() {
+        let volume = 0;
+        for (let i = 0, len = this.meshes.length; i < len; i++) {
+            const meshVolume = this.meshes[i].volume;
+            if (meshVolume < 0) {
+                return -1;
+            }
+            volume += meshVolume;
+        }
+        return volume;
+    }
+
+    /**
+     * Returns the surface area of this SceneModelEntity.
+     *
+     * Only works when {@link Scene.readableGeometryEnabled | Scene.readableGeometryEnabled} is `true` and the
+     * SceneModelEntity contains triangle meshes; returns `0` otherwise.
+     *
+     * @returns {number}
+     */
+    get surfaceArea() {
+        let surfaceArea = 0;
+        for (let i = 0, len = this.meshes.length; i < len; i++) {
+            const meshSurfaceArea = this.meshes[i].surfaceArea;
+            if (meshSurfaceArea >= 0) {
+                surfaceArea += meshSurfaceArea;
+            }
+        }
+        return surfaceArea > 0 ? surfaceArea : -1;
+    }
+
     _getFlag(flag) {
         return !!(this._flags & flag);
     }
@@ -10626,7 +10679,7 @@ class SceneModelEntity {
     }
 }
 
-const tempVec4a$9 = math.vec4();
+const tempVec4a$a = math.vec4();
 const tempVec4b$6 = math.vec4();
 
 
@@ -10786,9 +10839,9 @@ class Marker extends Component {
             this.fire("viewPos", this._viewPos);
         }
         if (this._canvasPosDirty) {
-            tempVec4a$9.set(this._viewPos);
-            tempVec4a$9[3] = 1.0;
-            math.transformPoint4(this.scene.camera.projMatrix, tempVec4a$9, tempVec4b$6);
+            tempVec4a$a.set(this._viewPos);
+            tempVec4a$a[3] = 1.0;
+            math.transformPoint4(this.scene.camera.projMatrix, tempVec4a$a, tempVec4b$6);
             const aabb = this.scene.canvas.boundary;
             this._canvasPos[0] = Math.floor((1 + tempVec4b$6[0] / tempVec4b$6[3]) * aabb[2] / 2);
             this._canvasPos[1] = Math.floor((1 - tempVec4b$6[1] / tempVec4b$6[3]) * aabb[3] / 2);
@@ -12618,22 +12671,13 @@ class AngleMeasurementsMouseControl extends AngleMeasurementsControl {
         this.pointerLens = cfg.pointerLens;
 
         this._active = false;
-        this._mouseState = MOUSE_FINDING_ORIGIN;
 
         this._currentAngleMeasurement = null;
 
-        // init markerDiv element (think about making its style configurable)
         this._initMarkerDiv();
 
-        this._onMouseHoverSurface = null;
-        this._onHoverNothing = null;
-        this._onPickedNothing = null;
-        this._onPickedSurface = null;
-
-        this._onInputMouseDown = null;
-        this._onInputMouseUp = null;
-
         this._snapping = cfg.snapping !== false;
+        this._mouseState = MOUSE_FINDING_ORIGIN;
 
         this._attachPlugin(angleMeasurementsPlugin, cfg);
     }
@@ -12698,20 +12742,10 @@ class AngleMeasurementsMouseControl extends AngleMeasurementsControl {
      *
      * This is `true` by default.
      *
-     * Internally, this deactivates then activates the AngleMeasurementsMouseControl when changed, which means that
-     * it will destroy any AngleMeasurements currently under construction, and incurs some overhead, since it unbinds
-     * and rebinds various input handlers.
-     *
      * @param {boolean} snapping Whether to enable snap-to-vertex and snap-edge for this AngleMeasurementsMouseControl.
      */
     set snapping(snapping) {
-        if (snapping !== this._snapping) {
-            this._snapping = snapping;
-            this.deactivate();
-            this.activate();
-        } else {
-            this._snapping = snapping;
-        }
+        this._snapping = snapping;
     }
 
     /**
@@ -12755,11 +12789,7 @@ class AngleMeasurementsMouseControl extends AngleMeasurementsControl {
 
         const pagePos = math.vec2();
 
-        this._onMouseHoverSurface = cameraControl.on(
-            this._snapping
-                ? "hoverSnapOrSurface"
-                : "hoverSurface",
-            event => {
+        const hoverOn = event => {
                 if (event.snappedToVertex || event.snappedToEdge) {
                     if (pointerLens) {
                         pointerLens.visible = true;
@@ -12821,7 +12851,10 @@ class AngleMeasurementsMouseControl extends AngleMeasurementsControl {
                         canvas.style.cursor = "pointer";
                         break;
                 }
-            });
+        };
+        this._onHoverSnapOrSurface = cameraControl.on("hoverSnapOrSurface", e => { if (this._snapping)   hoverOn(e); });
+        this._onHoverSurface       = cameraControl.on("hoverSurface",       e => { if (! this._snapping) hoverOn(e); });
+
         canvas.addEventListener('mousedown', this._onMouseDown = (e) => {
             if (e.which !== 1) {
                 return;
@@ -12909,11 +12942,8 @@ class AngleMeasurementsMouseControl extends AngleMeasurementsControl {
                     break;
             }
         });
-        this._onMouseHoverOff = cameraControl.on(
-            this._snapping
-                ? "hoverSnapOrSurfaceOff"
-                : "hoverOff",
-            event => {
+
+        const hoverOff = event => {
                 mouseHovering = false;
                 if (pointerLens) {
                     pointerLens.visible = true;
@@ -12943,7 +12973,10 @@ class AngleMeasurementsMouseControl extends AngleMeasurementsControl {
                     }
                     canvas.style.cursor = "default";
                 }
-            });
+        };
+        this._onHoverSnapOrSurfaceOff = cameraControl.on("hoverSnapOrSurfaceOff", e => { if (this._snapping)   hoverOff(e); });
+        this._onHoverOff              = cameraControl.on("hoverOff",              e => { if (! this._snapping) hoverOff(e); });
+
         this._active = true;
     }
 
@@ -12956,22 +12989,22 @@ class AngleMeasurementsMouseControl extends AngleMeasurementsControl {
         if (!this._active) {
             return;
         }
+
         if (this.pointerLens) {
             this.pointerLens.visible = false;
         }
-        if (this.markerDiv) {
-            this._destroyMarkerDiv();
-        }
+
         this.reset();
+
         const canvas = this.scene.canvas.canvas;
         canvas.removeEventListener("mousedown", this._onMouseDown);
         canvas.removeEventListener("mouseup", this._onMouseUp);
         const cameraControl = this.angleMeasurementsPlugin.viewer.cameraControl;
-        cameraControl.off(this._onMouseHoverSurface);
-        cameraControl.off(this._onPickedSurface);
-        cameraControl.off(this._onHoverNothing);
-        cameraControl.off(this._onPickedNothing);
-        this._currentAngleMeasurement = null;
+        cameraControl.off(this._onHoverSnapOrSurface);
+        cameraControl.off(this._onHoverSurface);
+        cameraControl.off(this._onHoverSnapOrSurfaceOff);
+        cameraControl.off(this._onHoverOff);
+
         this._active = false;
     }
 
@@ -12994,6 +13027,7 @@ class AngleMeasurementsMouseControl extends AngleMeasurementsControl {
             this._currentAngleMeasurement.destroy();
             this._currentAngleMeasurement = null;
         }
+
         this._mouseState = MOUSE_FINDING_ORIGIN;
     }
 
@@ -13509,8 +13543,6 @@ class AngleMeasurementsTouchControl extends AngleMeasurementsControl {
 
         this._currentAngleMeasurement = null;
 
-        this._onCanvasTouchStart = null;
-        this._onCanvasTouchEnd = null;
         this._longTouchTimeoutMs = 300;
         this._snapping = cfg.snapping !== false;
         this._touchState = WAITING_FOR_ORIGIN_TOUCH_START$1;
@@ -13546,20 +13578,10 @@ class AngleMeasurementsTouchControl extends AngleMeasurementsControl {
      *
      * This is `true` by default.
      *
-     * Internally, this deactivates then activates the AngleMeasurementsMouseControl when changed, which means that
-     * it will destroy any AngleMeasurements currently under construction, and incurs some overhead, since it unbinds
-     * and rebinds various input handlers.
-     *
      * @param {boolean} snapping Whether to enable snap-to-vertex and snap-edge for this AngleMeasurementsMouseControl.
      */
     set snapping(snapping) {
-        if (snapping !== this._snapping) {
-            this._snapping = snapping;
-            this.deactivate();
-            this.activate();
-        } else {
-            this._snapping = snapping;
-        }
+        this._snapping = snapping;
     }
 
     /**
@@ -14329,14 +14351,11 @@ class AngleMeasurementsTouchControl extends AngleMeasurementsControl {
             this.plugin.pointerLens.visible = false;
         }
         this.reset();
+
         const canvas = this.plugin.viewer.scene.canvas.canvas;
         canvas.removeEventListener("touchstart", this._onCanvasTouchStart);
         canvas.removeEventListener("touchend", this._onCanvasTouchEnd);
-        if (this._currentAngleMeasurement) {
-            this.angleMeasurementsPlugin.fire("measurementCancel", this._currentAngleMeasurement);
-            this._currentAngleMeasurement.destroy();
-            this._currentAngleMeasurement = null;
-        }
+
         this._active = false;
         this.plugin.viewer.cameraControl.active = true;
     }
@@ -17452,7 +17471,7 @@ class OcclusionLayer {
         for (let i = 0; i < this.numMarkers; i++) {
             if (this.markerList[i]) {
                 const marker = this.markerList[i];
-                const worldPos = marker.worldPos;
+                const worldPos = marker.rtcPos;
                 this.positions[j++] = worldPos[0];
                 this.positions[j++] = worldPos[1];
                 this.positions[j++] = worldPos[2];
@@ -17894,10 +17913,7 @@ class OcclusionTester {
                 continue;
             }
 
-            // The `origin` has been changed from `occlusionLayer.origin` to `[ 0, 0, 0 ]`
-            // because OcclusionLayer markers' transformation is being applied through the
-            // OcclusionLayer::positions array. See XEOK-33
-            const origin = [ 0, 0, 0 ];
+            const origin = occlusionLayer.origin;
 
             gl.uniformMatrix4fv(this._uViewMatrix, false, createRTCViewMat(camera.viewMatrix, origin));
 
@@ -23519,7 +23535,7 @@ const tempVec3c$u = math.vec3();
 const tempVec3d$d = math.vec3();
 const tempVec3e$2 = math.vec3();
 const tempVec3f$2 = math.vec3();
-const tempVec4a$8 = math.vec4();
+const tempVec4a$9 = math.vec4();
 const tempVec4b$5 = math.vec4();
 const tempVec4c$2 = math.vec4();
 const tempMat = math.mat4();
@@ -24385,7 +24401,7 @@ class Camera extends Component {
      * @returns {[number, number]} the canvas position
      */
     projectWorldPos(worldPos) {
-        const _worldPos = tempVec4a$8;
+        const _worldPos = tempVec4a$9;
         const viewPos = tempVec4b$5;
         const screenPos = tempVec4c$2;
         _worldPos[0] = worldPos[0];
@@ -30140,6 +30156,8 @@ class Scene extends Component {
 
         this._aabbDirty = true;
 
+        this._readableGeometry = !!cfg.readableGeometryEnabled;
+
         /**
          * The {@link Viewer} this Scene belongs to.
          * @type {Viewer}
@@ -31019,18 +31037,27 @@ class Scene extends Component {
     }
 
     /**
-     * Whether precision surface picking is enabled.
+     * Whether geometry is readable.
      *
      * This is set via the {@link Viewer} constructor and is ````false```` by default.
      *
-     * The ````pickSurfacePrecision```` option for ````Scene#pick```` only works if this is set ````true````.
+     * The ````readableGeometryEnabled```` option for ````Scene#pick```` only works if this is set ````true````.
      *
      * Note that when ````true````, this configuration will increase the amount of browser memory used by the Viewer.
      *
-     * @returns {Boolean} True if precision picking is enabled.
+     * @returns {Boolean} True if geometry is readable.
+     */
+    get readableGeometryEnabled() {
+        return this._readableGeometry;
+    }
+
+    /**
+     * Whether precision surface picking is enabled.
+     * @deprecated
+     * @returns {*|boolean}
      */
     get pickSurfacePrecisionEnabled() {
-        return false; // Removed
+        return this._readableGeometry;
     }
 
     /**
@@ -32008,7 +32035,7 @@ class Scene extends Component {
      *
      * @param {*} params Picking parameters.
      * @param {Boolean} [params.pickSurface=false] Whether to find the picked position on the surface of the Entity.
-     * @param {Boolean} [params.pickSurfacePrecision=false] When picking an Entity surface position, indicates whether or not we want full-precision {@link PickResult#worldPos}. Only works when {@link Scene#pickSurfacePrecisionEnabled} is ````true````. If pick succeeds, the returned {@link PickResult} will have {@link PickResult#precision} set ````true````, to indicate that it contains full-precision surface pick results.
+     * @param {Boolean} [params.pickSurfacePrecision=false] When picking an Entity surface position, indicates whether or not we want full-precision {@link PickResult#worldPos}. Only works when {@link Scene#readableGeometryEnabled} is ````true````. If pick succeeds, the returned {@link PickResult} will have {@link PickResult#precision} set ````true````, to indicate that it contains full-precision surface pick results.
      * @param {Boolean} [params.pickSurfaceNormal=false] Whether to find the picked normal on the surface of the Entity. Only works if ````pickSurface```` is given.
      * @param {Number[]} [params.canvasPos] Canvas-space coordinates. When ray-picking, this will override the **origin** and ** direction** parameters and will cause the ray to be fired through the canvas at this position, directly along the negative View-space Z-axis.
      * @param {Number[]} [params.origin] World-space ray origin when ray-picking. Ignored when canvasPos given.
@@ -50608,10 +50635,360 @@ class Bitmap extends Component {
     }
 }
 
+/**
+ * Uses edge adjacency counts to identify if the given triangle mesh can be rendered with backface culling enabled.
+ *
+ * If all edges are connected to exactly two triangles, then the mesh will likely be a closed solid, and we can safely
+ * render it with backface culling enabled.
+ *
+ * Otherwise, the mesh is a surface, and we must render it with backface culling disabled.
+ *
+ * @private
+ */
+const isTriangleMeshSolid = (indices, positions) => {
+
+    const vertexIndexMapping = [];
+    let edges = [];
+
+    function compareIndexPositions(a, b) {
+        let posA, posB;
+
+        for (let i = 0; i < 3; i++) {
+            posA = positions [a * 3 + i];
+            posB = positions [b * 3 + i];
+
+            if (posA !== posB) {
+                return posB - posA;
+            }
+        }
+
+        return 0;
+    }
+    // Group together indices corresponding to same position coordinates
+    let newIndices = indices.slice().sort(compareIndexPositions);
+
+    // Calculate the mapping:
+    // - from original index in indices array
+    // - to indices-for-unique-positions
+    let uniqueVertexIndex = null;
+
+    for (let i = 0, len = newIndices.length; i < len; i++) {
+        if (i === 0 || 0 !== compareIndexPositions(
+            newIndices[i],
+            newIndices[i - 1],
+        )) {
+            // different position
+            uniqueVertexIndex = newIndices [i];
+        }
+
+        vertexIndexMapping [
+            newIndices[i]
+            ] = uniqueVertexIndex;
+    }
+
+    // Generate the list of edges
+    for (let i = 0, len = indices.length; i < len; i += 3) {
+
+        const a = vertexIndexMapping[indices[i]];
+        const b = vertexIndexMapping[indices[i + 1]];
+        const c = vertexIndexMapping[indices[i + 2]];
+
+        let a2 = a;
+        let b2 = b;
+        let c2 = c;
+
+        if (a > b && a > c) {
+            if (b > c) {
+                a2 = a;
+                b2 = b;
+                c2 = c;
+            } else {
+                a2 = a;
+                b2 = c;
+                c2 = b;
+            }
+        } else if (b > a && b > c) {
+            if (a > c) {
+                a2 = b;
+                b2 = a;
+                c2 = c;
+            } else {
+                a2 = b;
+                b2 = c;
+                c2 = a;
+            }
+        } else if (c > a && c > b) {
+            if (a > b) {
+                a2 = c;
+                b2 = a;
+                c2 = b;
+            } else {
+                a2 = c;
+                b2 = b;
+                c2 = a;
+            }
+        }
+
+        edges[i + 0] = [
+            a2, b2
+        ];
+        edges[i + 1] = [
+            b2, c2
+        ];
+
+        if (a2 > c2) {
+            const temp = c2;
+            c2 = a2;
+            a2 = temp;
+        }
+
+        edges[i + 2] = [
+            c2, a2
+        ];
+    }
+
+    // Group semantically equivalent edgdes together
+    function compareEdges(e1, e2) {
+        let a, b;
+
+        for (let i = 0; i < 2; i++) {
+            a = e1[i];
+            b = e2[i];
+
+            if (b !== a) {
+                return b - a;
+            }
+        }
+
+        return 0;
+    }
+
+    edges = edges.slice(0, indices.length);
+
+    edges.sort(compareEdges);
+
+    // Make sure each edge is used exactly twice
+    let sameEdgeCount = 0;
+
+    for (let i = 0; i < edges.length; i++) {
+        if (i === 0 || 0 !== compareEdges(
+            edges[i], edges[i - 1]
+        )) {
+            // different edge
+            if (0 !== i && sameEdgeCount !== 2) {
+                return false;
+            }
+
+            sameEdgeCount = 1;
+        } else {
+            // same edge
+            sameEdgeCount++;
+        }
+    }
+
+    if (edges.length > 0 && sameEdgeCount !== 2) {
+        return false;
+    }
+
+    // Each edge is used exactly twice, this is a
+    // watertight surface and hence a solid geometry.
+    return true;
+};
+
+const v1$1 = math.vec3();
+const v2$1 = math.vec3();
+const v3$1 = math.vec3();
+
+/**
+ * Calculates the volume of triangle meshes.
+ */
+class MeshVolume {
+    constructor() {
+        this.vertices = [];
+        this.indices = [];
+        this.reset();
+    }
+
+    /**
+     * Resets, ready to add vertices and indices for a new mesh.
+     */
+    reset() {
+        this.lenVertices = 0;
+        this.lenIndices = 0;
+        this.primitive = null;
+    }
+
+    setPrimitive(primitive) {
+        this.primitive = primitive;
+    }
+
+    /**
+     * Adds a vertex.
+     * @param vertex
+     */
+    addVertex(vertex) {
+        this.vertices[this.lenVertices++] = vertex[0];
+        this.vertices[this.lenVertices++] = vertex[1];
+        this.vertices[this.lenVertices++] = vertex[2];
+    }
+
+    /**
+     * Adds an index.
+     * @param index
+     */
+    addIndex(index) {
+        this.indices[this.lenIndices++] = index;
+    }
+
+    /**
+     * Gets the volume of the mesh.
+     *
+     * The mesh must be a closed solid.
+     *
+     * @returns {number} The volume of the mesh, or -1 if the mesh is not solid, in which case volume cannot be determined.
+     */
+    get volume() {
+
+        const vertices = this.vertices;
+        const indices = this.indices;
+
+        if (this.primitive !== "solid" && this.primitive !== "surface" && this.primitive !== "triangles") {
+            return -1;
+        }
+
+        if (this.primitive !== "solid" && !isTriangleMeshSolid(indices, vertices)) {
+            return -1;
+        }
+
+        let volume = 0;
+
+        for (let i = 0; i < this.lenIndices; i += 3) {
+
+            const index1 = indices[i] * 3;
+            const index2 = indices[i + 1] * 3;
+            const index3 = indices[i + 2] * 3;
+
+            v1$1[0] = vertices[index1];
+            v1$1[1] = vertices[index1 + 1];
+            v1$1[2] = vertices[index1 + 2];
+
+            v2$1[0] = vertices[index2];
+            v2$1[1] = vertices[index2 + 1];
+            v2$1[2] = vertices[index2 + 2];
+
+            v3$1[0] = vertices[index3];
+            v3$1[1] = vertices[index3 + 1];
+            v3$1[2] = vertices[index3 + 2];
+
+            math.cross3Vec3(v1$1, v2$1, v1$1);
+
+            volume += math.dotVec3(v1$1, v3$1);
+        }
+
+        return volume;
+    }
+}
+
+/**
+ * Singleton instance of {@link MeshVolume}.
+ * @type {MeshVolume}
+ */
+const meshVolume = new MeshVolume();
+
+const v1 = math.vec3();
+const v2 = math.vec3();
+const v3 = math.vec3();
+const v4 = math.vec3();
+const v5 = math.vec3();
+const v6 = math.vec3();
+
+/**
+ * Calculates the surface area of triangle meshes.
+ */
+class MeshSurfaceArea {
+    constructor() {
+        this.vertices = [];
+        this.indices = [];
+        this.reset();
+    }
+
+    /**
+     * Resets, ready to add vertices and indices for a new mesh.
+     */
+    reset() {
+        this.lenVertices = 0;
+        this.lenIndices = 0;
+    }
+
+    /**
+     * Adds a vertex.
+     * @param vertex
+     */
+    addVertex(vertex) {
+        this.vertices[this.lenVertices++] = vertex[0];
+        this.vertices[this.lenVertices++] = vertex[1];
+        this.vertices[this.lenVertices++] = vertex[2];
+    }
+
+    /**
+     * Adds an index.
+     * @param index
+     */
+    addIndex(index) {
+        this.indices[this.lenIndices++] = index;
+    }
+
+    /**
+     * Gets the surface area of the mesh.
+     *
+     * @returns {number}
+     */
+    get surfaceArea() {
+
+        const vertices = this.vertices;
+        const indices = this.indices;
+
+        let surfaceArea = 0;
+
+        for (let i = 0; i < this.lenIndices; i += 3) {
+
+            const index1 = indices[i] * 3;
+            const index2 = indices[i + 1] * 3;
+            const index3 = indices[i + 2] * 3;
+
+            v1[0] = vertices[index1];
+            v1[1] = vertices[index1 + 1];
+            v1[2] = vertices[index1 + 2];
+
+            v2[0] = vertices[index2];
+            v2[1] = vertices[index2 + 1];
+            v2[2] = vertices[index2 + 2];
+
+            v3[0] = vertices[index3];
+            v3[1] = vertices[index3 + 1];
+            v3[2] = vertices[index3 + 2];
+
+            math.subVec3(v1, v2, v4);
+            math.subVec3(v3, v2, v5);
+
+            surfaceArea += math.lenVec3(math.cross3Vec3(v4, v5, v6)) * 0.5;
+        }
+
+        return surfaceArea;
+    }
+}
+
+/**
+ * Singleton instance of {@link MeshSurfaceArea}.
+ * @type {MeshSurfaceArea}
+ */
+const meshSurfaceArea = new MeshSurfaceArea();
+
 const tempOBB3$1 = math.OBB3();
 const tempOBB3b = math.OBB3();
 const tempOBB3c = math.OBB3();
 
+
 /**
  * A mesh within a {@link SceneModel}.
  *
@@ -50724,6 +51101,9 @@ class SceneModelMesh {
         if (transform) {
             transform._addMesh(this);
         }
+
+        this._volume = null;
+        this._surfaceArea = null;
     }
 
     _sceneModelDirty() {
@@ -50902,7 +51282,75 @@ class SceneModelMesh {
      * @private
      */
     getEachVertex(callback) {
-        this.layer.getEachVertex(this.portionId, callback);
+        if (this.layer.getEachVertex) {
+            this.layer.getEachVertex(this.portionId, callback);
+        }
+    }
+
+    /**
+     * @private
+     */
+    getEachIndex(callback) {
+        if (this.layer.getEachIndex ) {
+            this.layer.getEachIndex(this.portionId, callback);
+        }
+    }
+
+    /**
+     * Returns the volume of this SceneModelMesh.
+     * @returns {number}
+     */
+    get volume() {
+        if (this._volume !== null) {
+            return this._volume;
+        }
+        switch (this.layer.primitive) {
+            case "solid":
+            case "surface":
+            case "triangles":
+                meshVolume.reset();
+                meshVolume.setPrimitive(this.layer.primitive);
+                this.getEachVertex((vertex) =>{
+                    meshVolume.addVertex(vertex);
+                });
+                this.getEachIndex((index)=>{
+                   meshVolume.addIndex(index);
+                });
+                this._volume = meshVolume.volume;
+                break;
+            default:
+                this._volume = 0;
+                break;
+        }
+        return this._volume;
+    }
+
+    /**
+     * Returns the surface area of this SceneModelMesh.
+     * @returns {number}
+     */
+    get surfaceArea() {
+        if (this._surfaceArea !== null) {
+            return this._surfaceArea;
+        }
+        switch (this.layer.primitive) {
+            case "solid":
+            case "surface":
+            case "triangles":
+                meshSurfaceArea.reset();
+                this.getEachVertex((vertex) =>{
+                    meshSurfaceArea.addVertex(vertex);
+                });
+                this.getEachIndex((index)=>{
+                    meshSurfaceArea.addIndex(index);
+                });
+                this._surfaceArea = meshSurfaceArea.surfaceArea;
+                break;
+            default:
+                this._surfaceArea = 0;
+                break;
+        }
+        return this._surfaceArea;
     }
 
     /**
@@ -51055,11 +51503,12 @@ const tempMat4a$r = math.mat4();
  * @private
  */
 class VBORenderer {
-    constructor(scene, withSAO = false, {instancing = false, edges = false} = {}) {
+    constructor(scene, withSAO = false, {instancing = false, edges = false, useAlphaCutoff = false} = {}) {
         this._scene = scene;
         this._withSAO = withSAO;
         this._instancing = instancing;
         this._edges = edges;
+        this._useAlphaCutoff = useAlphaCutoff;
         this._hash = this._getHash();
 
         /**
@@ -51310,6 +51759,10 @@ class VBORenderer {
             this._uSAOParams = program.getLocation("uSAOParams");
         }
 
+        if (this._useAlphaCutoff) {
+            this._alphaCutoffLocation = program.getLocation("materialAlphaCutoff");
+        }
+
         if (scene.logarithmicDepthBufferEnabled) {
             this._uLogDepthBufFC = program.getLocation("logDepthBufFC");
         }
@@ -51647,6 +52100,10 @@ class VBORenderer {
             }
         }
 
+        if (this._useAlphaCutoff) {
+            gl.uniform1f(this._alphaCutoffLocation, textureSet.alphaCutoff);
+        }
+
         if (colorUniform) {
             const colorKey = this._edges ? "edgeColor" : "fillColor";
             const alphaKey = this._edges ? "edgeAlpha" : "fillAlpha";
@@ -51697,8 +52154,8 @@ class VBORenderer {
  */
 class TrianglesBatchingRenderer extends VBORenderer {
 
-    constructor(scene, withSAO, {edges = false} = {}) {
-        super(scene, withSAO, {instancing: false, edges});
+    constructor(scene, withSAO, {edges = false, useAlphaCutoff = false} = {}) {
+        super(scene, withSAO, {instancing: false, edges, useAlphaCutoff});
     }
 
     _draw(drawCfg) {
@@ -51715,7 +52172,6 @@ class TrianglesBatchingRenderer extends VBORenderer {
         } else {
             const count = frameCtx.pickElementsCount || state.indicesBuf.numItems;
             const offset = frameCtx.pickElementsOffset ? frameCtx.pickElementsOffset * state.indicesBuf.itemByteSize : 0;
-
             gl.drawElements(gl.TRIANGLES, count, state.indicesBuf.itemType, offset);
 
             if (incrementDrawState) {
@@ -54168,6 +54624,7 @@ class TrianglesPickNormalsFlatRenderer$1 extends TrianglesBatchingRenderer {
 /**
  * @private
  */
+
 class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
     _getHash() {
         const scene = this._scene;
@@ -54175,11 +54632,10 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
     }
 
     drawLayer(frameCtx, layer, renderPass) {
-        super.drawLayer(frameCtx, layer, renderPass, {incrementDrawState: true});
+        super.drawLayer(frameCtx, layer, renderPass, { incrementDrawState: true });
     }
 
     _buildVertexShader() {
-
         const scene = this._scene;
         const sectionPlanesState = scene._sectionPlanesState;
         const clipping = sectionPlanesState.getNumAllocatedSectionPlanes() > 0;
@@ -54234,6 +54690,7 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
         if (scene.entityOffsetsEnabled) {
             src.push("worldPosition.xyz = worldPosition.xyz + offset;");
         }
+
         src.push("vec4 viewPosition  = viewMatrix * worldPosition; ");
         src.push("vViewPosition = viewPosition;");
         src.push("vColor = vec4(float(color.r) / 255.0, float(color.g) / 255.0, float(color.b) / 255.0, float(color.a) / 255.0);");
@@ -54244,10 +54701,12 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
             src.push("vFragDepth = 1.0 + clipPos.w;");
             src.push("isPerspective = float (isPerspectiveMatrix(projMatrix));");
         }
+
         if (clipping) {
             src.push("vWorldPosition = worldPosition;");
             src.push("vFlags = flags;");
         }
+
         src.push("gl_Position = clipPos;");
         src.push("}");
         src.push("}");
@@ -54260,6 +54719,7 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
         const lightsState = scene._lightsState;
         const sectionPlanesState = scene._sectionPlanesState;
         const clipping = sectionPlanesState.getNumAllocatedSectionPlanes() > 0;
+        const useAlphaCutoff = this._useAlphaCutoff;
         const src = [];
         src.push("#version 300 es");
         src.push("// Triangles batching color texture fragment shader");
@@ -54318,6 +54778,7 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
             src.push("uniform vec4 sliceColor;");
         }
         this._addMatricesUniformBlockLines(src);
+
         src.push("uniform vec4 lightAmbient;");
         for (let i = 0, len = lightsState.lights.length; i < len; i++) {
             const light = lightsState.lights[i];
@@ -54337,6 +54798,10 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
             }
         }
 
+        if (useAlphaCutoff) {
+            src.push("uniform float materialAlphaCutoff;");
+        }
+
         src.push("in vec4 vViewPosition;");
         src.push("in vec4 vColor;");
         src.push("in vec2 vUV;");
@@ -54404,11 +54869,21 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
         }
 
         src.push("vec4 color =  vec4((lightAmbient.rgb * lightAmbient.a * newColor.rgb) + (reflectedColor * newColor.rgb), newColor.a);");
+
+        src.push("vec4 sampleColor = texture(uColorMap, vUV);");
+
+        if (useAlphaCutoff) {
+            src.push("if (sampleColor.a < materialAlphaCutoff) {");
+            src.push("   discard;");
+            src.push("}");
+        }
+
         if (gammaOutput) {
-            src.push("vec4 colorTexel = color * sRGBToLinear(texture(uColorMap, vUV));");
-        } else {
-            src.push("vec4 colorTexel = color * texture(uColorMap, vUV);");
+            src.push("sampleColor = sRGBToLinear(sampleColor);");
         }
+
+        src.push("vec4 colorTexel = color * sampleColor;");
+
         src.push("float opacity = color.a;");
 
         if (this._withSAO) {
@@ -54955,7 +55430,7 @@ class TrianglesSnapRenderer$1 extends VBORenderer{
 
         src.push(`int pickFlag = int(flags) >> 12 & 0xF;`);
         src.push(`if (pickFlag != renderPass) {`);
-        src.push("      gl_Position = vec4(0.0, 0.0, 0.0, 0.0);"); // Cull vertex
+        src.push("      gl_Position = vec4(2.0, 0.0, 0.0, 0.0);"); // Cull vertex
         src.push("  } else {");
         src.push("      vec4 worldPosition = worldMatrix * (positionsDecodeMatrix * vec4(position, 1.0)); ");
         if (scene.entityOffsetsEnabled) {
@@ -55082,6 +55557,14 @@ class Renderers$1 {
             this._colorTextureRendererWithSAO.destroy();
             this._colorTextureRendererWithSAO = null;
         }
+        if (this._colorTextureRendererAlphaCutoff && (!this._colorTextureRendererAlphaCutoff.getValid())) {
+            this._colorTextureRendererAlphaCutoff.destroy();
+            this._colorTextureRendererAlphaCutoff = null;
+        }
+        if (this._colorTextureRendererWithSAOAlphaCutoff && (!this._colorTextureRendererWithSAOAlphaCutoff.getValid())) {
+            this._colorTextureRendererWithSAOAlphaCutoff.destroy();
+            this._colorTextureRendererWithSAOAlphaCutoff = null;
+        }
         if (this._pbrRenderer && (!this._pbrRenderer.getValid())) {
             this._pbrRenderer.destroy();
             this._pbrRenderer = null;
@@ -55209,6 +55692,20 @@ class Renderers$1 {
         return this._colorTextureRendererWithSAO;
     }
 
+    get colorTextureRendererAlphaCutoff() {
+        if (!this._colorTextureRendererAlphaCutoff) {
+            this._colorTextureRendererAlphaCutoff = new TrianglesColorTextureRenderer$1(this._scene, false, { useAlphaCutoff: true });
+        }
+        return this._colorTextureRendererAlphaCutoff;
+    }
+
+    get colorTextureRendererWithSAOAlphaCutoff() {
+        if (!this._colorTextureRendererWithSAOAlphaCutoff) {
+            this._colorTextureRendererWithSAOAlphaCutoff = new TrianglesColorTextureRenderer$1(this._scene, true, { useAlphaCutoff: true });
+        }
+        return this._colorTextureRendererWithSAOAlphaCutoff;
+    }
+
     get pbrRenderer() {
         if (!this._pbrRenderer) {
             this._pbrRenderer = new TrianglesPBRRenderer$1(this._scene, false);
@@ -55333,6 +55830,12 @@ class Renderers$1 {
         if (this._colorTextureRendererWithSAO) {
             this._colorTextureRendererWithSAO.destroy();
         }
+        if (this._colorTextureRendererAlphaCutoff) {
+            this._colorTextureRendererAlphaCutoff.destroy();
+        }
+        if (this._colorTextureRendererWithSAOAlphaCutoff) {
+            this._colorTextureRendererWithSAOAlphaCutoff.destroy();
+        }
         if (this._pbrRenderer) {
             this._pbrRenderer.destroy();
         }
@@ -55381,29 +55884,29 @@ class Renderers$1 {
     }
 }
 
-const cachdRenderers$1 = {};
+const cachedRenderers$6 = {};
 
 /**
  * @private
  */
 function getRenderers$7(scene) {
     const sceneId = scene.id;
-    let batchingRenderers = cachdRenderers$1[sceneId];
-    if (!batchingRenderers) {
-        batchingRenderers = new Renderers$1(scene);
-        cachdRenderers$1[sceneId] = batchingRenderers;
-        batchingRenderers._compile();
-        batchingRenderers.eagerCreateRenders();
+    let renderers = cachedRenderers$6[sceneId];
+    if (!renderers) {
+        renderers = new Renderers$1(scene);
+        cachedRenderers$6[sceneId] = renderers;
+        renderers._compile();
+        renderers.eagerCreateRenders();
         scene.on("compile", () => {
-            batchingRenderers._compile();
-            batchingRenderers.eagerCreateRenders();
+            renderers._compile();
+            renderers.eagerCreateRenders();
         });
         scene.on("destroyed", () => {
-            delete cachdRenderers$1[sceneId];
-            batchingRenderers._destroy();
+            delete cachedRenderers$6[sceneId];
+            renderers._destroy();
         });
     }
-    return batchingRenderers;
+    return renderers;
 }
 
 let maxDataTextureHeight = 1 << 16;
@@ -55706,7 +56209,7 @@ function octDecodeVec2(oct) { // Decode an oct-encoded normal
 
 const tempMat4$1 = math.mat4();
 const tempMat4b = math.mat4();
-const tempVec4a$7 = math.vec4([0, 0, 0, 1]);
+const tempVec4a$8 = math.vec4([0, 0, 0, 1]);
 
 const tempVec3a$z = math.vec3();
 const tempVec3b$v = math.vec3();
@@ -55736,7 +56239,7 @@ class VBOBatchingTrianglesLayer {
      */
     constructor(cfg) {
 
-        console.info("Creating VBOBatchingTrianglesLayer");
+     //   console.info("Creating VBOBatchingTrianglesLayer");
 
         /**
          * Owner model
@@ -55826,6 +56329,11 @@ class VBOBatchingTrianglesLayer {
          * @type {boolean}
          */
         this.solid = !!cfg.solid;
+
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.primitive;
     }
 
     get aabb() {
@@ -56022,7 +56530,7 @@ class VBOBatchingTrianglesLayer {
             numIndices: indices.length,
         };
 
-        if (scene.pickSurfacePrecisionEnabled) {
+        if (scene.readableGeometryEnabled) {
             // Quantized in-memory positions are initialized in finalize()
 
             portion.indices = indices;
@@ -56059,7 +56567,7 @@ class VBOBatchingTrianglesLayer {
                 ? new Uint16Array(buffer.positions)
                 : quantizePositions(buffer.positions, this._modelAABB, this._state.positionsDecodeMatrix = math.mat4()); // BOTTLENECK
             state.positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, quantizedPositions, quantizedPositions.length, 3, gl.STATIC_DRAW);
-            if (this.model.scene.pickSurfacePrecisionEnabled) {
+            if (this.model.scene.readableGeometryEnabled) {
                 for (let i = 0, numPortions = this._portions.length; i < numPortions; i++) {
                     const portion = this._portions[i];
                     const start = portion.vertsBaseIndex * 3;
@@ -56488,7 +56996,7 @@ class VBOBatchingTrianglesLayer {
         if (this._state.offsetsBuf) {
             this._state.offsetsBuf.setData(tempArray, firstOffset, lenOffsets);
         }
-        if (this.model.scene.pickSurfacePrecisionEnabled) {
+        if (this.model.scene.readableGeometryEnabled) {
             portion.offset[0] = offset[0];
             portion.offset[1] = offset[1];
             portion.offset[2] = offset[2];
@@ -56496,7 +57004,7 @@ class VBOBatchingTrianglesLayer {
     }
 
     getEachVertex(portionId, callback) {
-        if (!this.model.scene.pickSurfacePrecisionEnabled) {
+        if (!this.model.scene.readableGeometryEnabled) {
             return;
         }
         const state = this._state;
@@ -56507,18 +57015,19 @@ class VBOBatchingTrianglesLayer {
         }
         const positions = portion.quantizedPositions;
         const origin = state.origin;
-        const offset = portion.offset;
-        const offsetX = origin[0] + offset[0];
-        const offsetY = origin[1] + offset[1];
-        const offsetZ = origin[2] + offset[2];
-        const worldPos = tempVec4a$7;
+        const offsetX = origin[0] ;
+        const offsetY = origin[1] ;
+        const offsetZ = origin[2] ;
+        const worldPos = tempVec4a$8;
+        const sceneModelMatrix = this.model.matrix;
+        const positionsDecodeMatrix = state.positionsDecodeMatrix;
         for (let i = 0, len = positions.length; i < len; i += 3) {
             worldPos[0] = positions[i];
             worldPos[1] = positions[i + 1];
             worldPos[2] = positions[i + 2];
             worldPos[3] = 1.0;
-            math.decompressPosition(worldPos, state.positionsDecodeMatrix);
-            math.transformPoint4(this.model.worldMatrix, worldPos);
+            math.decompressPosition(worldPos, positionsDecodeMatrix);
+            math.transformPoint4(sceneModelMatrix, worldPos);
             worldPos[0] += offsetX;
             worldPos[1] += offsetY;
             worldPos[2] += offsetZ;
@@ -56526,6 +57035,21 @@ class VBOBatchingTrianglesLayer {
         }
     }
 
+    getEachIndex(portionId, callback) {
+        if (!this.model.scene.readableGeometryEnabled) {
+            return;
+        }
+        const portion = this._portions[portionId];
+        if (!portion) {
+            this.model.error("portion not found: " + portionId);
+            return;
+        }
+        const indices = portion.indices;
+        for (let i = 0, len = indices.length; i < len; i++) {
+            callback(indices[i]);
+        }
+    }
+
     getElementsCountAndOffset(portionId) {
         let count = null;
         let offset = null;
@@ -56546,14 +57070,21 @@ class VBOBatchingTrianglesLayer {
             return;
         }
         this._updateBackfaceCull(renderFlags, frameCtx);
+        const useAlphaCutoff = this._state.textureSet && (typeof(this._state.textureSet.alphaCutoff) === "number");
         if (frameCtx.withSAO && this.model.saoEnabled) {
             if (frameCtx.pbrEnabled && this.model.pbrEnabled && this._state.pbrSupported) {
                 if (this._renderers.pbrRendererWithSAO) {
                     this._renderers.pbrRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
                 }
             } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-                if (this._renderers.colorTextureRendererWithSAO) {
-                    this._renderers.colorTextureRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                if (useAlphaCutoff) {
+                    if (this._renderers.colorTextureRendererWithSAOAlphaCutoff) {
+                        this._renderers.colorTextureRendererWithSAOAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
+                } else {
+                    if (this._renderers.colorTextureRendererWithSAO) {
+                        this._renderers.colorTextureRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
                 }
             } else if (this._state.normalsBuf) {
                 if (this._renderers.colorRendererWithSAO) {
@@ -56570,8 +57101,14 @@ class VBOBatchingTrianglesLayer {
                     this._renderers.pbrRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
                 }
             } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-                if (this._renderers.colorTextureRenderer) {
-                    this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                if (useAlphaCutoff) {
+                    if (this._renderers.colorTextureRendererAlphaCutoff) {
+                        this._renderers.colorTextureRendererAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
+                } else {
+                    if (this._renderers.colorTextureRenderer) {
+                        this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
                 }
             } else if (this._state.normalsBuf) {
                 if (this._renderers.colorRenderer) {
@@ -56608,8 +57145,15 @@ class VBOBatchingTrianglesLayer {
                 this._renderers.pbrRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
             }
         } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-            if (this._renderers.colorTextureRenderer) {
-                this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
+            const useAlphaCutoff = this._state.textureSet && (typeof(this._state.textureSet.alphaCutoff) === "number");
+            if (useAlphaCutoff) {
+                if (this._renderers.colorTextureRendererAlphaCutoff) {
+                    this._renderers.colorTextureRendererAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
+                }
+            } else {
+                if (this._renderers.colorTextureRenderer) {
+                    this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
+                }
             }
         } else if (this._state.normalsBuf) {
             if (this._renderers.colorRenderer) {
@@ -56813,7 +57357,7 @@ class VBOBatchingTrianglesLayer {
 
     precisionRayPickSurface(portionId, worldRayOrigin, worldRayDir, worldSurfacePos, worldNormal) {
 
-        if (!this.model.scene.pickSurfacePrecisionEnabled) {
+        if (!this.model.scene.readableGeometryEnabled) {
             return false;
         }
 
@@ -56953,8 +57497,8 @@ class VBOBatchingTrianglesLayer {
  * @private
  */
 class TrianglesInstancingRenderer extends VBORenderer {
-    constructor(scene, withSAO, {edges = false} = {}) {
-        super(scene, withSAO, {instancing: true, edges});
+    constructor(scene, withSAO, {edges = false, useAlphaCutoff = false} = {}) {
+        super(scene, withSAO, {instancing: true, edges, useAlphaCutoff});
     }
 
     _draw(drawCfg) {
@@ -56963,13 +57507,14 @@ class TrianglesInstancingRenderer extends VBORenderer {
         const {
             state,
             frameCtx,
-            incrementDrawState,
+            incrementDrawState
         } = drawCfg;
 
         if (this._edges) {
             gl.drawElementsInstanced(gl.LINES, state.edgeIndicesBuf.numItems, state.edgeIndicesBuf.itemType, 0, state.numInstances);
         } else {
             gl.drawElementsInstanced(gl.TRIANGLES, state.indicesBuf.numItems, state.indicesBuf.itemType, 0, state.numInstances);
+
             if (incrementDrawState) {
                 frameCtx.drawElements++;
             }
@@ -59498,7 +60043,6 @@ class TrianglesPickNormalsFlatRenderer extends TrianglesInstancingRenderer {
  * @private
  */
 
-
 class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
     _getHash() {
         const scene = this._scene;
@@ -59567,7 +60111,7 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
         src.push("vec4 worldPosition =  positionsDecodeMatrix * vec4(position, 1.0); ");
         src.push("worldPosition = worldMatrix * vec4(dot(worldPosition, modelMatrixCol0), dot(worldPosition, modelMatrixCol1), dot(worldPosition, modelMatrixCol2), 1.0);");
         if (scene.entityOffsetsEnabled) {
-            src.push("      worldPosition.xyz = worldPosition.xyz + offset;");
+            src.push("worldPosition.xyz = worldPosition.xyz + offset;");
         }
 
         src.push("vec4 viewPosition  = viewMatrix * worldPosition; ");
@@ -59595,11 +60139,10 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
     _buildFragmentShader() {
         const scene = this._scene;
         const gammaOutput = scene.gammaOutput; // If set, then it expects that all textures and colors need to be outputted in premultiplied gamma. Default is false.
-        const sectionPlanesState = scene._sectionPlanesState;
         const lightsState = scene._lightsState;
-        let i;
-        let len;
+        const sectionPlanesState = scene._sectionPlanesState;
         const clipping = sectionPlanesState.getNumAllocatedSectionPlanes() > 0;
+        const useAlphaCutoff = this._useAlphaCutoff;
         const src = [];
         src.push("#version 300 es");
         src.push("// Instancing geometry drawing fragment shader");
@@ -59611,6 +60154,7 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
         src.push("precision mediump float;");
         src.push("precision mediump int;");
         src.push("#endif");
+
         if (scene.logarithmicDepthBufferEnabled) {
             src.push("in float isPerspective;");
             src.push("uniform float logDepthBufFC;");
@@ -59659,7 +60203,7 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
         this._addMatricesUniformBlockLines(src);
 
         src.push("uniform vec4 lightAmbient;");
-        for (i = 0, len = lightsState.lights.length; i < len; i++) {
+        for (let i = 0, len = lightsState.lights.length; i < len; i++) {
             const light = lightsState.lights[i];
             if (light.type === "ambient") {
                 continue;
@@ -59677,6 +60221,10 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
             }
         }
 
+        if (useAlphaCutoff) {
+            src.push("uniform float materialAlphaCutoff;");
+        }
+
         src.push("in vec4 vViewPosition;");
         src.push("in vec4 vColor;");
         src.push("in vec2 vUV;");
@@ -59712,7 +60260,7 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
         src.push("vec3 yTangent = dFdy( vViewPosition.xyz );");
         src.push("vec3 viewNormal = normalize( cross( xTangent, yTangent ) );");
 
-        for (i = 0, len = lightsState.lights.length; i < len; i++) {
+        for (let i = 0, len = lightsState.lights.length; i < len; i++) {
             const light = lightsState.lights[i];
             if (light.type === "ambient") {
                 continue;
@@ -59738,16 +60286,27 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
             } else {
                 continue;
             }
+
             src.push("lambertian = max(dot(-viewNormal, viewLightDir), 0.0);");
             src.push("reflectedColor += lambertian * (lightColor" + i + ".rgb * lightColor" + i + ".a);");
         }
 
         src.push("vec4 color =  vec4((lightAmbient.rgb * lightAmbient.a * newColor.rgb) + (reflectedColor * newColor.rgb), newColor.a);");
+
+        src.push("vec4 sampleColor = texture(uColorMap, vUV);");
+
+        if (useAlphaCutoff) {
+            src.push("if (sampleColor.a < materialAlphaCutoff) {");
+            src.push("   discard;");
+            src.push("}");
+        }
+
         if (gammaOutput) {
-            src.push("vec4 colorTexel = color * sRGBToLinear(texture(uColorMap, vUV));");
-        } else {
-            src.push("vec4 colorTexel = color * texture(uColorMap, vUV);");
+            src.push("sampleColor = sRGBToLinear(sampleColor);");
         }
+
+        src.push("vec4 colorTexel = color * sampleColor;");
+
         src.push("float opacity = color.a;");
 
         if (this._withSAO) {
@@ -59759,9 +60318,10 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
             src.push("   float blendFactor       = uSAOParams[3];");
             src.push("   vec2 uv                 = vec2(gl_FragCoord.x / viewportWidth, gl_FragCoord.y / viewportHeight);");
             src.push("   float ambient           = smoothstep(blendCutoff, 1.0, unpackRGBToFloat(texture(uOcclusionTexture, uv))) * blendFactor;");
-            src.push("   outColor                = vec4(newColor.rgb * colorTexel.rgb * ambient, opacity);");
+
+            src.push("   outColor                = vec4(colorTexel.rgb * ambient, opacity);");
         } else {
-            src.push("   outColor                = vec4(newColor.rgb * colorTexel.rgb, opacity);");
+            src.push("   outColor                = vec4(colorTexel.rgb, opacity);");
         }
 
         if (gammaOutput) {
@@ -59769,7 +60329,7 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
         }
 
         if (scene.logarithmicDepthBufferEnabled) {
-            src.push("    gl_FragDepth = isPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;");
+            src.push("gl_FragDepth = isPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;");
         }
 
         src.push("}");
@@ -60339,7 +60899,7 @@ class TrianglesSnapRenderer extends VBORenderer {
         // renderPass = PICK
         src.push(`int pickFlag = int(flags) >> 12 & 0xF;`);
         src.push(`if (pickFlag != renderPass) {`);
-        src.push("   gl_Position = vec4(0.0, 0.0, 0.0, 0.0);"); // Cull vertex
+        src.push("   gl_Position = vec4(2.0, 0.0, 0.0, 0.0);"); // Cull vertex
         src.push("} else {");
         src.push("  vec4 worldPosition = positionsDecodeMatrix * vec4(position, 1.0); ");
         src.push("  worldPosition = worldMatrix * vec4(dot(worldPosition, modelMatrixCol0), dot(worldPosition, modelMatrixCol1), dot(worldPosition, modelMatrixCol2), 1.0);");
@@ -60459,14 +61019,6 @@ class Renderers {
             this._flatColorRendererWithSAO.destroy();
             this._flatColorRendererWithSAO = null;
         }
-        if (this._pbrRenderer && (!this._pbrRenderer.getValid())) {
-            this._pbrRenderer.destroy();
-            this._pbrRenderer = null;
-        }
-        if (this._pbrRendererWithSAO && (!this._pbrRendererWithSAO.getValid())) {
-            this._pbrRendererWithSAO.destroy();
-            this._pbrRendererWithSAO = null;
-        }
         if (this._colorTextureRenderer && (!this._colorTextureRenderer.getValid())) {
             this._colorTextureRenderer.destroy();
             this._colorTextureRenderer = null;
@@ -60475,6 +61027,22 @@ class Renderers {
             this._colorTextureRendererWithSAO.destroy();
             this._colorTextureRendererWithSAO = null;
         }
+        if (this._colorTextureRendererAlphaCutoff && (!this._colorTextureRendererAlphaCutoff.getValid())) {
+            this._colorTextureRendererAlphaCutoff.destroy();
+            this._colorTextureRendererAlphaCutoff = null;
+        }
+        if (this._colorTextureRendererWithSAOAlphaCutoff && (!this._colorTextureRendererWithSAOAlphaCutoff.getValid())) {
+            this._colorTextureRendererWithSAOAlphaCutoff.destroy();
+            this._colorTextureRendererWithSAOAlphaCutoff = null;
+        }
+        if (this._pbrRenderer && (!this._pbrRenderer.getValid())) {
+            this._pbrRenderer.destroy();
+            this._pbrRenderer = null;
+        }
+        if (this._pbrRendererWithSAO && (!this._pbrRendererWithSAO.getValid())) {
+            this._pbrRendererWithSAO.destroy();
+            this._pbrRendererWithSAO = null;
+        }
         if (this._depthRenderer && (!this._depthRenderer.getValid())) {
             this._depthRenderer.destroy();
             this._depthRenderer = null;
@@ -60507,7 +61075,7 @@ class Renderers {
             this._pickNormalsRenderer.destroy();
             this._pickNormalsRenderer = null;
         }
-        if (this._pickNormalsFlatRenderer && (!this._pickNormalsFlatRenderer.getValid())) {
+        if (this._pickNormalsFlatRenderer && this._pickNormalsFlatRenderer.getValid() === false) {
             this._pickNormalsFlatRenderer.destroy();
             this._pickNormalsFlatRenderer = null;
         }
@@ -60580,20 +61148,6 @@ class Renderers {
         return this._flatColorRendererWithSAO;
     }
 
-    get pbrRenderer() {
-        if (!this._pbrRenderer) {
-            this._pbrRenderer = new TrianglesPBRRenderer(this._scene, false);
-        }
-        return this._pbrRenderer;
-    }
-
-    get pbrRendererWithSAO() {
-        if (!this._pbrRendererWithSAO) {
-            this._pbrRendererWithSAO = new TrianglesPBRRenderer(this._scene, true);
-        }
-        return this._pbrRendererWithSAO;
-    }
-
     get colorTextureRenderer() {
         if (!this._colorTextureRenderer) {
             this._colorTextureRenderer = new TrianglesColorTextureRenderer(this._scene, false);
@@ -60608,6 +61162,34 @@ class Renderers {
         return this._colorTextureRendererWithSAO;
     }
 
+    get colorTextureRendererAlphaCutoff() {
+        if (!this._colorTextureRendererAlphaCutoff) {
+            this._colorTextureRendererAlphaCutoff = new TrianglesColorTextureRenderer(this._scene, false, { useAlphaCutoff: true });
+        }
+        return this._colorTextureRendererAlphaCutoff;
+    }
+
+    get colorTextureRendererWithSAOAlphaCutoff() {
+        if (!this._colorTextureRendererWithSAOAlphaCutoff) {
+            this._colorTextureRendererWithSAOAlphaCutoff = new TrianglesColorTextureRenderer(this._scene, true, { useAlphaCutoff: true });
+        }
+        return this._colorTextureRendererWithSAOAlphaCutoff;
+    }
+
+    get pbrRenderer() {
+        if (!this._pbrRenderer) {
+            this._pbrRenderer = new TrianglesPBRRenderer(this._scene, false);
+        }
+        return this._pbrRenderer;
+    }
+
+    get pbrRendererWithSAO() {
+        if (!this._pbrRendererWithSAO) {
+            this._pbrRendererWithSAO = new TrianglesPBRRenderer(this._scene, true);
+        }
+        return this._pbrRendererWithSAO;
+    }
+
     get silhouetteRenderer() {
         if (!this._silhouetteRenderer) {
             this._silhouetteRenderer = new TrianglesSilhouetteRenderer(this._scene);
@@ -60685,13 +61267,6 @@ class Renderers {
         return this._shadowRenderer;
     }
 
-    get snapInitRenderer() {
-        if (!this._snapInitRenderer) {
-            this._snapInitRenderer = new TrianglesSnapInitRenderer(this._scene, false);
-        }
-        return this._snapInitRenderer;
-    }
-
     get snapRenderer() {
         if (!this._snapRenderer) {
             this._snapRenderer = new TrianglesSnapRenderer(this._scene);
@@ -60699,6 +61274,13 @@ class Renderers {
         return this._snapRenderer;
     }
 
+    get snapInitRenderer() {
+        if (!this._snapInitRenderer) {
+            this._snapInitRenderer = new TrianglesSnapInitRenderer(this._scene);
+        }
+        return this._snapInitRenderer;
+    }
+
     _destroy() {
         if (this._colorRenderer) {
             this._colorRenderer.destroy();
@@ -60712,18 +61294,24 @@ class Renderers {
         if (this._flatColorRendererWithSAO) {
             this._flatColorRendererWithSAO.destroy();
         }
-        if (this._pbrRenderer) {
-            this._pbrRenderer.destroy();
-        }
-        if (this._pbrRendererWithSAO) {
-            this._pbrRendererWithSAO.destroy();
-        }
         if (this._colorTextureRenderer) {
             this._colorTextureRenderer.destroy();
         }
         if (this._colorTextureRendererWithSAO) {
             this._colorTextureRendererWithSAO.destroy();
         }
+        if (this._colorTextureRendererAlphaCutoff) {
+            this._colorTextureRendererAlphaCutoff.destroy();
+        }
+        if (this._colorTextureRendererWithSAOAlphaCutoff) {
+            this._colorTextureRendererWithSAOAlphaCutoff.destroy();
+        }
+        if (this._pbrRenderer) {
+            this._pbrRenderer.destroy();
+        }
+        if (this._pbrRendererWithSAO) {
+            this._pbrRendererWithSAO.destroy();
+        }
         if (this._depthRenderer) {
             this._depthRenderer.destroy();
         }
@@ -60773,27 +61361,27 @@ const cachedRenderers$5 = {};
  */
 function getRenderers$6(scene) {
     const sceneId = scene.id;
-    let instancingRenderers = cachedRenderers$5[sceneId];
-    if (!instancingRenderers) {
-        instancingRenderers = new Renderers(scene);
-        cachedRenderers$5[sceneId] = instancingRenderers;
-        instancingRenderers._compile();
-        instancingRenderers.eagerCreateRenders();
+    let renderers = cachedRenderers$5[sceneId];
+    if (!renderers) {
+        renderers = new Renderers(scene);
+        cachedRenderers$5[sceneId] = renderers;
+        renderers._compile();
+        renderers.eagerCreateRenders();
         scene.on("compile", () => {
-            instancingRenderers._compile();
-            instancingRenderers.eagerCreateRenders();
+            renderers._compile();
+            renderers.eagerCreateRenders();
         });
         scene.on("destroyed", () => {
             delete cachedRenderers$5[sceneId];
-            instancingRenderers._destroy();
+            renderers._destroy();
         });
     }
-    return instancingRenderers;
+    return renderers;
 }
 
 const tempUint8Vec4$2 = new Uint8Array(4);
 const tempFloat32$2 = new Float32Array(1);
-const tempVec4a$6 = math.vec4([0, 0, 0, 1]);
+const tempVec4a$7 = math.vec4([0, 0, 0, 1]);
 const tempVec3fa$2 = new Float32Array(3);
 
 const tempVec3a$w = math.vec3();
@@ -60821,7 +61409,7 @@ class VBOInstancingTrianglesLayer {
      */
     constructor(cfg) {
 
-         console.info("Creating VBOInstancingTrianglesLayer");
+      //   console.info("Creating VBOInstancingTrianglesLayer");
 
         /**
          * Owner model
@@ -60924,6 +61512,11 @@ class VBOInstancingTrianglesLayer {
          * @type {number|*}
          */
         this.numIndices = cfg.geometry.numIndices;
+
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.geometry.primitive;
     }
 
     get aabb() {
@@ -61037,7 +61630,7 @@ class VBOInstancingTrianglesLayer {
 
         const portion = {};
 
-        if (this.model.scene.pickSurfacePrecisionEnabled) {
+        if (this.model.scene.readableGeometryEnabled) {
             portion.matrix = meshMatrix.slice();
             portion.inverseMatrix = null; // Lazy-computed in precisionRayPickSurface
             portion.normalMatrix = null; // Lazy-computed in precisionRayPickSurface
@@ -61475,7 +62068,7 @@ class VBOInstancingTrianglesLayer {
     }
 
     getEachVertex(portionId, callback) {
-        if (!this.model.scene.pickSurfacePrecisionEnabled) {
+        if (!this.model.scene.readableGeometryEnabled) {
             return false;
         }
         const state = this._state;
@@ -61487,13 +62080,12 @@ class VBOInstancingTrianglesLayer {
         }
         const positions = geometry.quantizedPositions;
         const origin = state.origin;
-        const offset = portion.offset;
-        const offsetX = origin[0] + offset[0];
-        const offsetY = origin[1] + offset[1];
-        const offsetZ = origin[2] + offset[2];
-        const worldPos = tempVec4a$6;
+        const offsetX = origin[0] ;
+        const offsetY = origin[1] ;
+        const offsetZ = origin[2] ;
+        const worldPos = tempVec4a$7;
         const portionMatrix = portion.matrix;
-        const sceneModelPatrix = this.model.sceneModelMatrix;
+        const sceneModelMatrix = this.model.matrix;
         const positionsDecodeMatrix = state.positionsDecodeMatrix;
         for (let i = 0, len = positions.length; i < len; i += 3) {
             worldPos[0] = positions[i];
@@ -61501,7 +62093,7 @@ class VBOInstancingTrianglesLayer {
             worldPos[2] = positions[i + 2];
             math.decompressPosition(worldPos, positionsDecodeMatrix);
             math.transformPoint3(portionMatrix, worldPos);
-            math.transformPoint3(sceneModelPatrix, worldPos);
+            math.transformPoint3(sceneModelMatrix, worldPos);
             worldPos[0] += offsetX;
             worldPos[1] += offsetY;
             worldPos[2] += offsetZ;
@@ -61509,6 +62101,23 @@ class VBOInstancingTrianglesLayer {
         }
     }
 
+    getEachIndex(portionId, callback) {
+        if (!this.model.scene.readableGeometryEnabled) {
+            return false;
+        }
+        const state = this._state;
+        const geometry = state.geometry;
+        const portion = this._portions[portionId];
+        if (!portion) {
+            this.model.error("portion not found: " + portionId);
+            return;
+        }
+        const indices = geometry.indices;
+        for (let i = 0, len = indices.length; i < len; i++) {
+            callback(indices[i]);
+        }
+    }
+
     setMatrix(portionId, matrix) {
         if (!this._finalized) {
             throw "Not finalized";
@@ -61549,14 +62158,21 @@ class VBOInstancingTrianglesLayer {
             return;
         }
         this._updateBackfaceCull(renderFlags, frameCtx);
+        const useAlphaCutoff = this._state.textureSet && (typeof(this._state.textureSet.alphaCutoff) === "number");
         if (frameCtx.withSAO && this.model.saoEnabled) {
             if (frameCtx.pbrEnabled && this.model.pbrEnabled && this._state.pbrSupported) {
                 if (this._renderers.pbrRendererWithSAO) {
                     this._renderers.pbrRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
                 }
             } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-                if (this._renderers.colorTextureRendererWithSAO) {
-                    this._renderers.colorTextureRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                if (useAlphaCutoff) {
+                    if (this._renderers.colorTextureRendererWithSAOAlphaCutoff) {
+                        this._renderers.colorTextureRendererWithSAOAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
+                } else {
+                    if (this._renderers.colorTextureRendererWithSAO) {
+                        this._renderers.colorTextureRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
                 }
             } else if (this._state.normalsBuf) {
                 if (this._renderers.colorRendererWithSAO) {
@@ -61572,8 +62188,14 @@ class VBOInstancingTrianglesLayer {
                 this._renderers.pbrRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
             }
         } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-            if (this._renderers.colorTextureRenderer) {
-                this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+            if (useAlphaCutoff) {
+                if (this._renderers.colorTextureRendererAlphaCutoff) {
+                    this._renderers.colorTextureRendererAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                }
+            } else {
+                if (this._renderers.colorTextureRenderer) {
+                    this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                }
             }
         } else if (this._state.normalsBuf) {
             if (this._renderers.colorRenderer) {
@@ -61815,7 +62437,7 @@ class VBOInstancingTrianglesLayer {
 
     precisionRayPickSurface(portionId, worldRayOrigin, worldRayDir, worldSurfacePos, worldNormal) {
 
-        if (!this.model.scene.pickSurfacePrecisionEnabled) {
+        if (!this.model.scene.readableGeometryEnabled) {
             return false;
         }
 
@@ -62748,7 +63370,7 @@ class VBOBatchingLinesSnapRenderer extends VBORenderer{
 
         src.push(`int pickFlag = int(flags) >> 12 & 0xF;`);
         src.push(`if (pickFlag != renderPass) {`);
-        src.push("      gl_Position = vec4(0.0, 0.0, 0.0, 0.0);"); // Cull vertex
+        src.push("      gl_Position = vec4(2.0, 0.0, 0.0, 0.0);"); // Cull vertex
         src.push("  } else {");
         src.push("      vec4 worldPosition = worldMatrix * (positionsDecodeMatrix * vec4(position, 1.0)); ");
         if (scene.entityOffsetsEnabled) {
@@ -62972,7 +63594,7 @@ class VBOBatchingLinesLayer {
      */
     constructor(cfg) {
 
-        console.info("Creating VBOBatchingLinesLayer");
+       // console.info("Creating VBOBatchingLinesLayer");
 
         /**
          * Index of this LinesBatchingLayer in {@link VBOSceneModel#_layerList}.
@@ -63027,6 +63649,11 @@ class VBOBatchingLinesLayer {
         if (cfg.origin) {
             this._state.origin = math.vec3(cfg.origin);
         }
+
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.primitive;
     }
 
     get aabb() {
@@ -64485,7 +65112,7 @@ class VBOInstancingLinesSnapRenderer extends VBORenderer {
         // renderPass = PICK
         src.push(`int pickFlag = int(flags) >> 12 & 0xF;`);
         src.push(`if (pickFlag != renderPass) {`);
-        src.push("   gl_Position = vec4(0.0, 0.0, 0.0, 0.0);"); // Cull vertex
+        src.push("   gl_Position = vec4(2.0, 0.0, 0.0, 0.0);"); // Cull vertex
         src.push("} else {");
         src.push("  vec4 worldPosition = positionsDecodeMatrix * vec4(position, 1.0); ");
         src.push("  worldPosition = worldMatrix * vec4(dot(worldPosition, modelMatrixCol0), dot(worldPosition, modelMatrixCol1), dot(worldPosition, modelMatrixCol2), 1.0);");
@@ -64735,7 +65362,7 @@ class VBOInstancingLinesLayer {
      */
     constructor(cfg) {
 
-        console.info("VBOInstancingLinesLayer");
+     //   console.info("VBOInstancingLinesLayer");
 
         /**
          * Owner model
@@ -64815,6 +65442,11 @@ class VBOInstancingLinesLayer {
         }
 
         this._finalized = false;
+
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.primitive;
     }
 
     get aabb() {
@@ -66948,7 +67580,7 @@ class VBOBatchingPointsLayer {
      */
     constructor(cfg) {
 
-        console.info("Creating VBOBatchingPointsLayer");
+     //   console.info("Creating VBOBatchingPointsLayer");
 
         /**
          * Owner model
@@ -69545,7 +70177,7 @@ class VBOInstancingPointsLayer {
      */
     constructor(cfg) {
 
-        console.info("VBOInstancingPointsLayer");
+      //  console.info("VBOInstancingPointsLayer");
 
         /**
          * Owner model
@@ -69619,6 +70251,11 @@ class VBOInstancingPointsLayer {
         this.aabbDirty = true;
 
         this._finalized = false;
+
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.geometry.primitive;
     }
 
     get aabb() {
@@ -71280,7 +71917,7 @@ class DTXLinesLayer {
 
     constructor(model, cfg) {
 
-        console.info("Creating DTXLinesLayer");
+      //  console.info("Creating DTXLinesLayer");
 
         dataTextureRamStats$1.numberOfLayers++;
 
@@ -71319,6 +71956,12 @@ class DTXLinesLayer {
         this._aabb = math.collapseAABB3();
         this.aabbDirty = true;
         this._numUpdatesInFrame = 0;
+
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.primitive;
+
         this._finalized = false;
     }
 
@@ -72144,7 +72787,7 @@ const tempVec3b$i = math.vec3();
 const tempVec3c$e = math.vec3();
 math.vec3();
 
-const tempVec4a$5 = math.vec4();
+const tempVec4a$6 = math.vec4();
 
 const tempMat4a$c = math.mat4();
 
@@ -72423,11 +73066,11 @@ class DTXTrianglesColorRenderer {
             if (saoEnabled) {
                 const viewportWidth = gl.drawingBufferWidth;
                 const viewportHeight = gl.drawingBufferHeight;
-                tempVec4a$5[0] = viewportWidth;
-                tempVec4a$5[1] = viewportHeight;
-                tempVec4a$5[2] = sao.blendCutoff;
-                tempVec4a$5[3] = sao.blendFactor;
-                gl.uniform4fv(this._uSAOParams, tempVec4a$5);
+                tempVec4a$6[0] = viewportWidth;
+                tempVec4a$6[1] = viewportHeight;
+                tempVec4a$6[2] = sao.blendCutoff;
+                tempVec4a$6[3] = sao.blendFactor;
+                gl.uniform4fv(this._uSAOParams, tempVec4a$6);
                 this._program.bindTexture(this._uOcclusionTexture, frameCtx.occlusionTexture, 10);
             }
         }
@@ -75236,6 +75879,14 @@ class DTXTrianglesSnapRenderer {
         src.push("uvec4 flags = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+2, objectIndexCoords.y), 0);");
         src.push("uvec4 flags2 = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+3, objectIndexCoords.y), 0);");
 
+        // flags.w = NOT_RENDERED | PICK
+        // renderPass = PICK
+
+        src.push(`if (int(flags.w) != renderPass) {`);
+        src.push("   gl_Position = vec4(3.0, 3.0, 3.0, 1.0);"); // Cull vertex
+        src.push("   return;"); // Cull vertex
+        src.push("}");
+
         src.push("{");
 
         // get vertex base
@@ -75651,6 +76302,14 @@ class DTXTrianglesSnapInitRenderer {
         src.push("uvec4 flags = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+2, objectIndexCoords.y), 0);");
         src.push("uvec4 flags2 = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+3, objectIndexCoords.y), 0);");
 
+        // flags.w = NOT_RENDERED | PICK
+        // renderPass = PICK
+
+        src.push(`if (int(flags.w) != renderPass) {`);
+        src.push("   gl_Position = vec4(3.0, 3.0, 3.0, 1.0);"); // Cull vertex
+        src.push("   return;"); // Cull vertex
+        src.push("}");
+
         src.push("{");
 
         // get color
@@ -78654,6 +79313,7 @@ const INDICES_EDGE_INDICES_ALIGNEMENT_SIZE = 8;
  */
 const MAX_OBJECT_UPDATES_IN_FRAME_WITHOUT_BATCHED_UPDATE = 10;
 
+const tempVec4a$5 = math.vec4();
 const tempMat4a = new Float32Array(16);
 const tempUint8Array4 = new Uint8Array(4);
 const tempFloat32Array3 = new Float32Array(3);
@@ -78669,7 +79329,7 @@ class DTXTrianglesLayer {
 
     constructor(model, cfg) {
 
-        console.info("Creating DTXTrianglesLayer");
+        //console.info("Creating DTXTrianglesLayer");
 
         dataTextureRamStats.numberOfLayers++;
 
@@ -78709,6 +79369,10 @@ class DTXTrianglesLayer {
 
         this._subPortions = [];
 
+        if (this.model.scene.readableGeometryEnabled) {
+            this._subPortionReadableGeometries = {};
+        }
+
         /**
          * Due to `index rebucketting` process in ```prepareMeshGeometry``` function, it's possible that a single
          * portion is expanded to more than 1 real sub-portion.
@@ -78738,6 +79402,11 @@ class DTXTrianglesLayer {
          */
         this._numUpdatesInFrame = 0;
 
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.primitive;
+
         this._finalized = false;
     }
 
@@ -79042,6 +79711,15 @@ class DTXTrianglesLayer {
             numVertices: bucketGeometry.numTriangles
         });
 
+        if (this.model.scene.readableGeometryEnabled) {
+            this._subPortionReadableGeometries[subPortionId] = {
+                indices: bucket.indices,
+                positionsCompressed: bucket.positionsCompressed,
+                positionsDecodeMatrix: portionCfg.positionsDecodeMatrix,
+                meshMatrix: portionCfg.meshMatrix
+            };
+        }
+
         this._numPortions++;
 
         dataTextureRamStats.numberOfPortions++;
@@ -79692,6 +80370,63 @@ class DTXTrianglesLayer {
         // gl.bindTexture (gl.TEXTURE_2D, null);
     }
 
+    getEachVertex(portionId, callback) {
+        if (!this.model.scene.readableGeometryEnabled) {
+            return;
+        }
+        const state = this._state;
+        const subPortionIds = this._portionToSubPortionsMap[portionId];
+        if (!subPortionIds) {
+            this.model.error("portion not found: " + portionId);
+            return;
+        }
+        for (let i = 0, len = subPortionIds.length; i < len; i++) {
+            const subPortionId = subPortionIds[i];
+            const subPortionReadableGeometry = this._subPortionReadableGeometries[subPortionId];
+            const positions = subPortionReadableGeometry.positionsCompressed;
+            const positionsDecodeMatrix = subPortionReadableGeometry.positionsDecodeMatrix;
+            subPortionReadableGeometry.meshMatrix;
+            const origin = state.origin;
+            const offsetX = origin[0] ;
+            const offsetY = origin[1] ;
+            const offsetZ = origin[2] ;
+            const worldPos = tempVec4a$5;
+            for (let i = 0, len = positions.length; i < len; i += 3) {
+                worldPos[0] = positions[i];
+                worldPos[1] = positions[i + 1];
+                worldPos[2] = positions[i + 2];
+                worldPos[3] = 1.0;
+                math.decompressPosition(worldPos, positionsDecodeMatrix);
+                math.transformPoint4(this.model.worldMatrix, worldPos);
+                math.transformPoint4(this.model.worldMatrix, worldPos);
+                worldPos[0] += offsetX;
+                worldPos[1] += offsetY;
+                worldPos[2] += offsetZ;
+                callback(worldPos);
+            }
+        }
+    }
+
+    getEachIndex(portionId, callback) {
+        if (!this.model.scene.readableGeometryEnabled) {
+            return;
+        }
+        const subPortionIds = this._portionToSubPortionsMap[portionId];
+        if (!subPortionIds) {
+            this.model.error("portion not found: " + portionId);
+            return;
+        }
+        for (let i = 0, len = subPortionIds.length; i < len; i++) {
+            const subPortionId = subPortionIds[i];
+            const subPortionReadableGeometry = this._subPortionReadableGeometries[subPortionId];
+            const indices = subPortionReadableGeometry.indices;
+            for (let i = 0, len = indices.length; i < len; i++) {
+                callback(indices[i]);
+            }
+        }
+    }
+
+
     // ---------------------- COLOR RENDERING -----------------------------------
 
     drawColorOpaque(renderFlags, frameCtx) {
@@ -79967,6 +80702,11 @@ class SceneModelTextureSet {
          */
         this.colorTexture = cfg.colorTexture;
 
+        /**
+         * The alpha cutoff [float]
+         */
+        this.alphaCutoff = cfg.alphaCutoff;
+
         /**
          * The metallic-roughness texture.
          * @type {SceneModelTexture|*}
@@ -83034,7 +83774,10 @@ class SceneModel extends Component {
         this._meshList = [];
 
         this.layerList = []; // For GL state efficiency when drawing, InstancingLayers are in first part, BatchingLayers are in second
+        this._layersToFinalize = [];
+
         this._entityList = [];
+        this._entitiesToFinalize = [];
 
         this._geometries = {};
         this._dtxBuckets = {}; // Geometries with optimizations used for data texture representation
@@ -83110,6 +83853,7 @@ class SceneModel extends Component {
         this._numTriangles = 0;
         this._numLines = 0;
         this._numPoints = 0;
+        this._layersFinalized = false;
 
         this._edgeThreshold = cfg.edgeThreshold || 10;
 
@@ -84519,6 +85263,7 @@ class SceneModel extends Component {
             id: textureSetId,
             model: this,
             colorTexture,
+            alphaCutoff: cfg.alphaCutoff,
             metallicRoughnessTexture,
             normalsTexture,
             emissiveTexture,
@@ -84952,6 +85697,14 @@ class SceneModel extends Component {
         return this._createMesh(cfg);
     }
 
+    _createDefaultIndices(numIndices) {
+        const indices = [];
+        for (let i = 0; i < numIndices; i++) {
+            indices.push(i);
+        }
+        return indices;
+    }
+
     _createMesh(cfg) {
         const mesh = new SceneModelMesh(this, cfg.id, cfg.color, cfg.opacity, cfg.transform, cfg.textureSet);
         mesh.pickId = this.scene._renderer.getPickID(mesh);
@@ -85051,7 +85804,7 @@ class SceneModel extends Component {
         let dtxLayer = this._dtxLayers[layerId];
         if (dtxLayer) {
             if (!dtxLayer.canCreatePortion(cfg)) {
-                dtxLayer.finalize();
+                //  dtxLayer.finalize();
                 delete this._dtxLayers[layerId];
                 dtxLayer = null;
             } else {
@@ -85062,16 +85815,17 @@ class SceneModel extends Component {
             case "triangles":
             case "solid":
             case "surface":
-                dtxLayer = new DTXTrianglesLayer(this, {layerIndex: 0, origin}); // layerIndex is set in #finalize()
+                dtxLayer = new DTXTrianglesLayer(this, {layerIndex: 0, origin, primitive}); // layerIndex is set in #finalize()
                 break;
             case "lines":
-                dtxLayer = new DTXLinesLayer(this, {layerIndex: 0, origin}); // layerIndex is set in #finalize()
+                dtxLayer = new DTXLinesLayer(this, {layerIndex: 0, origin, primitive}); // layerIndex is set in #finalize()
                 break;
             default:
                 return;
         }
         this._dtxLayers[layerId] = dtxLayer;
         this.layerList.push(dtxLayer);
+        this._layersToFinalize.push(dtxLayer);
         return dtxLayer;
     }
 
@@ -85103,7 +85857,8 @@ class SceneModel extends Component {
                         origin,
                         maxGeometryBatchSize: this._maxGeometryBatchSize,
                         solid: (cfg.primitive === "solid"),
-                        autoNormals: true
+                        autoNormals: true,
+                        primitive: cfg.primitive
                     });
                     break;
                 case "solid":
@@ -85118,7 +85873,8 @@ class SceneModel extends Component {
                         origin,
                         maxGeometryBatchSize: this._maxGeometryBatchSize,
                         solid: (cfg.primitive === "solid"),
-                        autoNormals: true
+                        autoNormals: true,
+                        primitive: cfg.primitive
                     });
                     break;
                 case "surface":
@@ -85133,7 +85889,8 @@ class SceneModel extends Component {
                         origin,
                         maxGeometryBatchSize: this._maxGeometryBatchSize,
                         solid: (cfg.primitive === "solid"),
-                        autoNormals: true
+                        autoNormals: true,
+                        primitive: cfg.primitive
                     });
                     break;
                 case "lines":
@@ -85145,7 +85902,8 @@ class SceneModel extends Component {
                         positionsDecodeMatrix: cfg.positionsDecodeMatrix,  // Can be undefined
                         uvDecodeMatrix: cfg.uvDecodeMatrix, // Can be undefined
                         origin,
-                        maxGeometryBatchSize: this._maxGeometryBatchSize
+                        maxGeometryBatchSize: this._maxGeometryBatchSize,
+                        primitive: cfg.primitive
                     });
                     break;
                 case "points":
@@ -85157,7 +85915,8 @@ class SceneModel extends Component {
                         positionsDecodeMatrix: cfg.positionsDecodeMatrix,  // Can be undefined
                         uvDecodeMatrix: cfg.uvDecodeMatrix, // Can be undefined
                         origin,
-                        maxGeometryBatchSize: this._maxGeometryBatchSize
+                        maxGeometryBatchSize: this._maxGeometryBatchSize,
+                        primitive: cfg.primitive
                     });
                     break;
             }
@@ -85173,6 +85932,7 @@ class SceneModel extends Component {
         }
         this._vboBatchingLayers[layerId] = vboBatchingLayer;
         this.layerList.push(vboBatchingLayer);
+        this._layersToFinalize.push(vboBatchingLayer);
         return vboBatchingLayer;
     }
 
@@ -85265,6 +86025,7 @@ class SceneModel extends Component {
         }
         this._vboInstancingLayers[layerId] = vboInstancingLayer;
         this.layerList.push(vboInstancingLayer);
+        this._layersToFinalize.push(vboInstancingLayer);
         return vboInstancingLayer;
     }
 
@@ -85365,38 +86126,47 @@ class SceneModel extends Component {
             lodCullable); // Internally sets SceneModelEntity#parent to this SceneModel
         this._entityList.push(entity);
         this._entities[cfg.id] = entity;
+        this._entitiesToFinalize.push(entity);
         this.numEntities++;
     }
 
     /**
-     * Finalizes this SceneModel.
-     *
-     * Once finalized, you can't add anything more to this SceneModel.
+     * Pre-renders all meshes that have been added, even if the SceneModel has not bee finalized yet.
+     * This is use for progressively showing the SceneModel while it is being loaded or constructed.
+     * @returns {boolean}
      */
-    finalize() {
+    preFinalize() {
         if (this.destroyed) {
-            return;
+            return false;
+        }
+        if (this._layersToFinalize.length === 0) {
+            return false;
         }
         this._createDummyEntityForUnusedMeshes();
-        for (let i = 0, len = this.layerList.length; i < len; i++) {
-            const layer = this.layerList[i];
+        for (let i = 0, len = this._layersToFinalize.length; i < len; i++) {
+            const layer = this._layersToFinalize[i];
             layer.finalize();
         }
-        this._geometries = {};
-        this._dtxBuckets = {};
-        this._textures = {};
-        this._textureSets = {};
-        this._dtxLayers = {};
-        this._vboInstancingLayers = {};
         this._vboBatchingLayers = {};
-        for (let i = 0, len = this._entityList.length; i < len; i++) {
-            const entity = this._entityList[i];
+        this._vboInstancingLayers = {};
+        this._dtxLayers = {};
+        this._layersToFinalize = [];
+        for (let i = 0, len = this._entitiesToFinalize.length; i < len; i++) {
+            const entity = this._entitiesToFinalize[i];
             entity._finalize();
         }
-        for (let i = 0, len = this._entityList.length; i < len; i++) {
-            const entity = this._entityList[i];
+        for (let i = 0, len = this._entitiesToFinalize.length; i < len; i++) {
+            const entity = this._entitiesToFinalize[i];
             entity._finalize2();
         }
+        this._entitiesToFinalize = [];
+        this.scene._aabbDirty = true;
+        this._viewMatrixDirty = true;
+        this._matrixDirty = true;
+        this._aabbDirty = true;
+        this._setWorldMatrixDirty();
+        this._sceneModelDirty();
+        this.position = this._position;
         // Sort layers to reduce WebGL shader switching when rendering them
         this.layerList.sort((a, b) => {
             if (a.sortId < b.sortId) {
@@ -85412,15 +86182,23 @@ class SceneModel extends Component {
             layer.layerIndex = i;
         }
         this.glRedraw();
-        this.scene._aabbDirty = true;
-        this._viewMatrixDirty = true;
-        this._matrixDirty = true;
-        this._aabbDirty = true;
-
-        this._setWorldMatrixDirty();
-        this._sceneModelDirty();
+        this._layersFinalized = true;
+    }
 
-        this.position = this._position;
+    /**
+     * Finalizes this SceneModel.
+     *
+     * Once finalized, you can't add anything more to this SceneModel.
+     */
+    finalize() {
+        if (this.destroyed) {
+            return;
+        }
+        this.preFinalize();
+        this._geometries = {};
+        this._dtxBuckets = {};
+        this._textures = {};
+        this._textureSets = {};
     }
 
     /** @private */
@@ -85458,7 +86236,7 @@ class SceneModel extends Component {
     _createDummyEntityForUnusedMeshes() {
         const unusedMeshIds = Object.keys(this._unusedMeshes);
         if (unusedMeshIds.length > 0) {
-            const entityId = `${this.id}-dummyEntityForUnusedMeshes`;
+            const entityId = `${this.id}-${math.createUUID()}`;
             this.warn(`Creating dummy SceneModelEntity "${entityId}" for unused SceneMeshes: [${unusedMeshIds.join(",")}]`);
             this.createEntity({
                 id: entityId,
@@ -85830,6 +86608,7 @@ class SceneModel extends Component {
         for (let i = 0, len = this._entityList.length; i < len; i++) {
             this._entityList[i]._destroy();
         }
+        this._layersToFinalize = {};
         // Object.entries(this._geometries).forEach(([id, geometry]) => {
         //     geometry.destroy();
         // });
@@ -88327,12 +89106,6 @@ class DistanceMeasurementsMouseControl extends DistanceMeasurementsControl {
 
         this._initMarkerDiv();
 
-        this._onCameraControlHoverSnapOrSurface = null;
-        this._onCameraControlHoverSnapOrSurfaceOff = null;
-        this._onMouseDown = null;
-        this._onMouseUp = null;
-        this._onCanvasTouchStart = null;
-        this._onCanvasTouchEnd = null;
         this._snapping = cfg.snapping !== false;
         this._mouseState = MOUSE_FIRST_CLICK_EXPECTED;
 
@@ -88396,20 +89169,10 @@ class DistanceMeasurementsMouseControl extends DistanceMeasurementsControl {
      *
      * This is `true` by default.
      *
-     * Internally, this deactivates then activates the DistanceMeasurementsMouseControl when changed, which means that
-     * it will destroy any DistanceMeasurements currently under construction, and incurs some overhead, since it unbinds
-     * and rebinds various input handlers.
-     *
      * @param snapping
      */
     set snapping(snapping) {
-        if (snapping !== this._snapping) {
-            this._snapping = snapping;
-            this.deactivate();
-            this.activate();
-        } else {
-            this._snapping = snapping;
-        }
+        this._snapping = snapping;
     }
 
     /**
@@ -88421,7 +89184,7 @@ class DistanceMeasurementsMouseControl extends DistanceMeasurementsControl {
     get snapping() {
         return this._snapping;
     }
-    
+
     /**
      * Activates this DistanceMeasurementsMouseControl, ready to respond to input.
      */
@@ -88456,11 +89219,8 @@ class DistanceMeasurementsMouseControl extends DistanceMeasurementsControl {
         const getLeft = el => el.offsetLeft + (el.offsetParent && (el.offsetParent !== canvas.parentNode) && getLeft(el.offsetParent));
 
         const pagePos = math.vec2();
-        
-        this._onCameraControlHoverSnapOrSurface = cameraControl.on(
-            this._snapping
-                ? "hoverSnapOrSurface"
-                : "hoverSurface", event => {
+
+        const hoverOn = event => {
                 const canvasPos = event.snappedCanvasPos || event.canvasPos;
                 mouseHovering = true;
                 pointerWorldPos.set(event.worldPos);
@@ -88513,7 +89273,9 @@ class DistanceMeasurementsMouseControl extends DistanceMeasurementsControl {
                     this._markerDiv.style.left = `-10000px`;
                     this._markerDiv.style.top = `-10000px`;
                 }
-            });
+        };
+        this._onHoverSnapOrSurface = cameraControl.on("hoverSnapOrSurface", e => { if (this._snapping)   hoverOn(e); });
+        this._onHoverSurface       = cameraControl.on("hoverSurface",       e => { if (! this._snapping) hoverOn(e); });
 
         canvas.addEventListener('mousedown', this._onMouseDown = (e) => {
             if (e.which !== 1) {
@@ -88574,10 +89336,7 @@ class DistanceMeasurementsMouseControl extends DistanceMeasurementsControl {
             }
         });
 
-        this._onCameraControlHoverSnapOrSurfaceOff = cameraControl.on(
-            this._snapping
-                ? "hoverSnapOrSurfaceOff"
-                : "hoverOff", event => {
+        const hoverOff = event => {
                 if (this.pointerLens) {
                     this.pointerLens.visible = true;
                     this.pointerLens.canvasPos = event.canvasPos;
@@ -88592,7 +89351,9 @@ class DistanceMeasurementsMouseControl extends DistanceMeasurementsControl {
                     this._currentDistanceMeasurement.axisVisible = false;
                 }
                 canvas.style.cursor = "default";
-            });
+        };
+        this._onHoverSnapOrSurfaceOff = cameraControl.on("hoverSnapOrSurfaceOff", e => { if (this._snapping)   hoverOff(e); });
+        this._onHoverOff              = cameraControl.on("hoverOff",              e => { if (! this._snapping) hoverOff(e); });
 
         this._active = true;
     }
@@ -88606,27 +89367,24 @@ class DistanceMeasurementsMouseControl extends DistanceMeasurementsControl {
         if (!this._active) {
             return;
         }
-        
+
         this.fire("activated", false);
 
         if (this.pointerLens) {
             this.pointerLens.visible = false;
         }
-        // if (this._markerDiv) {
-        //     this._destroyMarkerDiv()
-        // }
-        // this.reset();
+
+        this.reset();
+
         const canvas = this.scene.canvas.canvas;
         canvas.removeEventListener("mousedown", this._onMouseDown);
         canvas.removeEventListener("mouseup", this._onMouseUp);
         const cameraControl = this.distanceMeasurementsPlugin.viewer.cameraControl;
-        cameraControl.off(this._onCameraControlHoverSnapOrSurface);
-        cameraControl.off(this._onCameraControlHoverSnapOrSurfaceOff);
-        // if (this._currentDistanceMeasurement) {
-        //     this.distanceMeasurementsPlugin.fire("measurementCancel", this._currentDistanceMeasurement);
-        //     this._currentDistanceMeasurement.destroy();
-        //     this._currentDistanceMeasurement = null;
-        // }
+        cameraControl.off(this._onHoverSnapOrSurface);
+        cameraControl.off(this._onHoverSurface);
+        cameraControl.off(this._onHoverSnapOrSurfaceOff);
+        cameraControl.off(this._onHoverOff);
+
         this._active = false;
     }
 
@@ -89310,11 +90068,8 @@ class DistanceMeasurementsTouchControl extends DistanceMeasurementsControl {
             targetVisible: null,
         };
 
-        this._onCanvasTouchStart = null;
-        this._onCanvasTouchEnd = null;
         this._longTouchTimeoutMs = 300;
         this._snapping = cfg.snapping !== false;
-        this._touchState = WAITING_FOR_ORIGIN_TOUCH_START;
 
         this._attachPlugin(distanceMeasurementsPlugin, cfg);
     }
@@ -89347,20 +90102,10 @@ class DistanceMeasurementsTouchControl extends DistanceMeasurementsControl {
      *
      * This is `true` by default.
      *
-     * Internally, this deactivates then activates the DistanceMeasurementsTouchControl when changed, which means that
-     * it will destroy any DistanceMeasurements currently under construction, and incurs some overhead, since it unbinds
-     * and rebinds various input handlers.
-     *
      * @param {boolean} snapping Whether to enable snap-to-vertex and snap-edge for this DistanceMeasurementsTouchControl.
      */
     set snapping(snapping) {
-        if (snapping !== this._snapping) {
-            this._snapping = snapping;
-            this.deactivate();
-            this.activate();
-        } else {
-            this._snapping = snapping;
-        }
+        this._snapping = snapping;
     }
 
     /**
@@ -89972,14 +90717,11 @@ class DistanceMeasurementsTouchControl extends DistanceMeasurementsControl {
             this.plugin.pointerLens.visible = false;
         }
         this.reset();
+
         const canvas = this.plugin.viewer.scene.canvas.canvas;
         canvas.removeEventListener("touchstart", this._onCanvasTouchStart);
         canvas.removeEventListener("touchend", this._onCanvasTouchEnd);
-        if (this._currentDistanceMeasurement) {
-            this.distanceMeasurementsPlugin.fire("measurementCancel", this._currentDistanceMeasurement);
-            this._currentDistanceMeasurement.destroy();
-            this._currentDistanceMeasurement = null;
-        }
+
         this._active = false;
         this.plugin.viewer.cameraControl.active = true;
     }
@@ -89995,12 +90737,12 @@ class DistanceMeasurementsTouchControl extends DistanceMeasurementsControl {
         if (!this._active) {
             return;
         }
+
         if (this._currentDistanceMeasurement) {
             this.distanceMeasurementsPlugin.fire("measurementCancel", this._currentDistanceMeasurement);
             this._currentDistanceMeasurement.destroy();
             this._currentDistanceMeasurement = null;
         }
-        this._mouseState = WAITING_FOR_ORIGIN_TOUCH_START;
     }
 
     /**
@@ -101012,8 +101754,6 @@ class MetaScene {
      * @param {String} modelId ID for the new {@link MetaModel}, which will have {@link MetaModel#id} set to this value.
      * @param {Object} metaModelData Data for the {@link MetaModel}.
      * @param {Object} [options] Options for creating the {@link MetaModel}.
-     * @param {Object} [options.includeTypes] When provided, only create {@link MetaObject}s with types in this list.
-     * @param {Object} [options.excludeTypes] When provided, never create {@link MetaObject}s with types in this list.
      * @param {Boolean} [options.globalizeObjectIds=false] Whether to globalize each {@link MetaObject#id}. Set this ````true```` when you need to load multiple instances of the same meta model, to avoid ID clashes between the meta objects in the different instances.
      * @returns {MetaModel} The new MetaModel.
      */
@@ -109086,7 +109826,7 @@ class Viewer {
      * @throws {String} Throws an exception when both canvasId or canvasElement are missing or they aren't pointing to a valid HTMLCanvasElement.
      * @param {Boolean} [cfg.alphaDepthMask=true] Whether writing into the depth buffer is enabled or disabled when rendering transparent objects.
      * @param {Boolean} [cfg.entityOffsetsEnabled=false] Whether to enable {@link Entity#offset}. For best performance, only set this ````true```` when you need to use {@link Entity#offset}.
-     * @param {Boolean} [cfg.pickSurfacePrecisionEnabled=false] Whether to enable full-precision accuracy when surface picking with {@link Scene#pick}. Note that when ````true````, this configuration will increase the amount of browser memory used by the Viewer. The ````pickSurfacePrecision```` option for ````Scene#pick```` only works if this is set ````true````.
+     * @param {Boolean} [cfg.readableGeometryEnabled=false] Whether to enable full-precision accuracy when surface picking with {@link Scene#pick}. Note that when ````true````, this configuration will increase the amount of browser memory used by the Viewer. The ````pickSurfacePrecision```` option for ````Scene#pick```` only works if this is set ````true````.
      * @param {Boolean} [cfg.logarithmicDepthBufferEnabled=false] Whether to enable logarithmic depth buffer. When this is true,
      * you can set huge values for {@link Perspective#far} and {@link Ortho#far}, to push the far clipping plane back so
      * that it does not clip huge models.
@@ -109156,7 +109896,7 @@ class Viewer {
             saoEnabled: cfg.saoEnabled,
             alphaDepthMask: (cfg.alphaDepthMask !== false),
             entityOffsetsEnabled: (!!cfg.entityOffsetsEnabled),
-            pickSurfacePrecisionEnabled: (!!cfg.pickSurfacePrecisionEnabled),
+            readableGeometryEnabled: (!!cfg.readableGeometryEnabled),
             logarithmicDepthBufferEnabled: (!!cfg.logarithmicDepthBufferEnabled),
             pbrEnabled: (!!cfg.pbrEnabled),
             colorTextureEnabled: (cfg.colorTextureEnabled !== false),
@@ -116999,40 +117739,6 @@ class GLTFSceneModelLoader {
     }
 }
 
-function getMetaModelCorrections(metaModelJSON) {
-    const eachRootStats = {};
-    const eachChildRoot = {};
-    const metaObjects = metaModelJSON.metaObjects || [];
-    const metaObjectsMap = {};
-    for (let i = 0, len = metaObjects.length; i < len; i++) {
-        const metaObject = metaObjects[i];
-        metaObjectsMap[metaObject.id] = metaObject;
-    }
-    for (let i = 0, len = metaObjects.length; i < len; i++) {
-        const metaObject = metaObjects[i];
-        if (metaObject.parent !== undefined && metaObject.parent !== null) {
-            const metaObjectParent = metaObjectsMap[metaObject.parent];
-            if (metaObject.type === metaObjectParent.type) {
-                let rootMetaObject = metaObjectParent;
-                while (rootMetaObject.parent && metaObjectsMap[rootMetaObject.parent].type === rootMetaObject.type) {
-                    rootMetaObject = metaObjectsMap[rootMetaObject.parent];
-                }
-                const rootStats = eachRootStats[rootMetaObject.id] || (eachRootStats[rootMetaObject.id] = {
-                    numChildren: 0,
-                    countChildren: 0
-                });
-                rootStats.numChildren++;
-                eachChildRoot[metaObject.id] = rootMetaObject;
-            }
-        }
-    }
-    return {
-        metaObjectsMap,
-        eachRootStats,
-        eachChildRoot
-    };
-}
-
 function loadGLTF(plugin, src, metaModelJSON, options, sceneModel, ok, error) {
     const spinner = plugin.viewer.scene.canvas.spinner;
     spinner.processes++;
@@ -117074,7 +117780,9 @@ function parseGLTF(plugin, src, gltf, metaModelJSON, options, sceneModel, ok) {
         const ctx = {
             src: src,
             entityId: options.entityId,
-            metaModelCorrections: metaModelJSON ? getMetaModelCorrections(metaModelJSON) : null,
+            metaModelJSON,
+            autoMetaModel: options.autoMetaModel,
+            metaObjects: [],
             loadBuffer: options.loadBuffer,
             basePath: options.basePath,
             handlenode: options.handlenode,
@@ -117093,8 +117801,20 @@ function parseGLTF(plugin, src, gltf, metaModelJSON, options, sceneModel, ok) {
         };
         loadTextures(ctx);
         loadMaterials(ctx);
+        if (options.autoMetaModel) {
+          ctx.metaObjects.push({
+              id: sceneModel.id,
+              type: "Default",
+              name: sceneModel.id
+          });
+        }
         loadDefaultScene(ctx);
         sceneModel.finalize();
+        if (options.autoMetaModel) {
+            plugin.viewer.metaScene.createMetaModel(sceneModel.id, {
+                metaObjects: ctx.metaObjects
+            });
+        }
         spinner.processes--;
         ok();
     });
@@ -117223,23 +117943,17 @@ function loadTextureSet(ctx, material) {
     if (material.emissiveTexture) {
         textureSetCfg.emissiveTextureId = material.emissiveTexture.texture._textureId;
     }
-    // const alphaMode = material.alphaMode;
-    // switch (alphaMode) {
-    //     case "NORMAL_OPAQUE":
-    //         materialCfg.alphaMode = "opaque";
-    //         break;
-    //     case "MASK":
-    //         materialCfg.alphaMode = "mask";
-    //         break;
-    //     case "BLEND":
-    //         materialCfg.alphaMode = "blend";
-    //         break;
-    //     default:
-    // }
-    // const alphaCutoff = material.alphaCutoff;
-    // if (alphaCutoff !== undefined) {
-    //     materialCfg.alphaCutoff = alphaCutoff;
-    // }
+
+    switch (material.alphaMode) {
+        case "OPAQUE":
+            break;
+        case "MASK":
+            const alphaCutoff = material.alphaCutoff;
+            // Default from the spec https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#reference-material
+            textureSetCfg.alphaCutoff = (alphaCutoff !== undefined) ? alphaCutoff : 0.5;
+            break;
+    }
+
     const metallicPBR = material.pbrMetallicRoughness;
     if (material.pbrMetallicRoughness) {
         const pbrMetallicRoughness = material.pbrMetallicRoughness;
@@ -117285,7 +117999,7 @@ function loadMaterialAttributes(ctx, material) { // Substitute RGBA for material
         opacity: 1,
         metallic: 0,
         roughness: 1,
-        doubleSided : true
+        doubleSided: true
     };
     if (extensions) {
         const specularPBR = extensions["KHR_materials_pbrSpecularGlossiness"];
@@ -117359,9 +118073,22 @@ function loadScene(ctx, scene) {
         const node = nodes[i];
         countMeshUsage(ctx, node);
     }
-    for (let i = 0, len = nodes.length; i < len; i++) {
+    for (let i = 0, len = nodes.length; i < len && !ctx.nodesHaveNames; i++) {
         const node = nodes[i];
-        loadNode(ctx, node, 0, null);
+        if (testIfNodesHaveNames(node)) {
+            ctx.nodesHaveNames = true;
+        }
+    }
+    if (!ctx.nodesHaveNames) {
+        for (let i = 0, len = nodes.length; i < len; i++) {
+            const node = nodes[i];
+            parseNodesWithoutNames(ctx, node, 0, null);
+        }
+    } else {
+        for (let i = 0, len = nodes.length; i < len; i++) {
+            const node = nodes[i];
+            parseNodesWithNames(ctx, node, 0, null);
+        }
     }
 }
 
@@ -117383,10 +118110,131 @@ function countMeshUsage(ctx, node) {
     }
 }
 
-const deferredMeshIds = [];
+function testIfNodesHaveNames(node) {
+    if (node.name) {
+        return true;
+    }
+    if (node.children) {
+        const children = node.children;
+        for (let i = 0, len = children.length; i < len; i++) {
+            const childNode = children[i];
+            if (testIfNodesHaveNames(childNode)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * Parses a glTF node hierarchy that is known to NOT contain "name" attributes on the nodes.
+ * Create a SceneMesh for each mesh primitive, and a single SceneObject.
+ */
+const parseNodesWithoutNames = (function () {
+    const meshIds = [];
+    return function (ctx, node, depth, matrix, parentNode) {
+        matrix = parseNodeMatrix(node, matrix);
+        if (node.mesh) {
+            parseNodeMesh(node, ctx, matrix, meshIds);
+        }
+        if (node.children) {
+            const children = node.children;
+            for (let i = 0, len = children.length; i < len; i++) {
+                const childNode = children[i];
+                parseNodesWithoutNames(ctx, childNode, depth + 1, matrix, node);
+            }
+        }
+        if (depth === 0) {
+            let entityId = "entity-" + ctx.nextId++;
+            if (meshIds && meshIds.length > 0) {
+                ctx.sceneModel.createEntity({
+                    id: entityId,
+                    meshIds,
+                    isObject: true
+                });
+                if (ctx.autoMetaModel) {
+                    ctx.metaObjects.push({
+                        id: entityId,
+                        type: "Default",
+                        name: entityId,
+                        parent: ctx.sceneModel.id
+                    });
+                }
+                meshIds.length = 0;
+            }
+        }
+    }
+})();
 
-function loadNode(ctx, node, depth, matrix) {
-    ctx.gltfData;
+const parseNodesWithNames = (function () {
+
+    const objectIdStack = [];
+    const meshIdsStack = [];
+    let meshIds = null;
+
+    return function (ctx, node, depth, matrix) {
+        matrix = parseNodeMatrix(node, matrix);
+        if (meshIds && node.mesh) {
+            parseNodeMesh(node, ctx, matrix, meshIds);
+        }
+
+        if (node.name) {
+            meshIds = [];
+            let entityId = node.name;
+            if (!!entityId && ctx.sceneModel.objects[entityId]) ;
+            while (!entityId || ctx.sceneModel.objects[entityId]) {
+                entityId = "entity-" + ctx.nextId++;
+            }
+            objectIdStack.push(entityId);
+            meshIdsStack.push(meshIds);
+        }
+
+        if (node.children) {
+            const children = node.children;
+            for (let i = 0, len = children.length; i < len; i++) {
+                const childNode = children[i];
+                parseNodesWithNames(ctx, childNode, depth + 1, matrix);
+            }
+        }
+
+        // Post-order visit scene node
+
+        const nodeName = node.name;
+        if ((nodeName !== undefined && nodeName !== null) || depth === 0) {
+            let entityId = objectIdStack.pop();
+            if (!entityId) { // For when there are no nodes with names
+                entityId = "entity-" + ctx.nextId++;
+            }
+            let entityMeshIds = meshIdsStack.pop();
+            if (meshIds && meshIds.length > 0) {
+                ctx.sceneModel.createEntity({
+                    id: entityId,
+                    meshIds: entityMeshIds,
+                    isObject: true
+                });
+                if (ctx.autoMetaModel) {
+                    ctx.metaObjects.push({
+                        id: entityId,
+                        type: "Default",
+                        name: entityId,
+                        parent: ctx.sceneModel.id
+                    });
+                }
+            }
+            meshIds = meshIdsStack.length > 0 ? meshIdsStack[meshIdsStack.length - 1] : null;
+        }
+    };
+})();
+
+
+/**
+ * Parses transform at the given glTF node.
+ *
+ * @param node the glTF node
+ * @param matrix Transfor matrix from parent nodes
+ * @returns {*} Transform matrix for the node
+ */
+function parseNodeMatrix(node, matrix) {
     let localMatrix;
     if (node.matrix) {
         localMatrix = node.matrix;
@@ -117420,171 +118268,92 @@ function loadNode(ctx, node, depth, matrix) {
             matrix = localMatrix;
         }
     }
+    return matrix;
+}
 
-    const sceneModel = ctx.sceneModel;
-    if (node.mesh) {
-        const mesh = node.mesh;
-        if (ctx.handlenode) {
-            const actions = {};
-            if (!ctx.handlenode(ctx.sceneModel.id, node, actions)) {
-                return;
-            }
-            if (actions.createEntity) ;
-        }
-        const worldMatrix = matrix ? matrix.slice() : math.identityMat4();
-        const numPrimitives = mesh.primitives.length;
-
-        if (numPrimitives > 0) {
-
-            for (let i = 0; i < numPrimitives; i++) {
-
-                const primitive = mesh.primitives[i];
-                if (primitive.mode < 4) {
-                    continue;
-                }
-
-                const meshCfg = {
-                    id: sceneModel.id + "." + ctx.numObjects++
-                };
-
-                const material = primitive.material;
-                if (material) {
-                    meshCfg.textureSetId = material._textureSetId;
-                    meshCfg.color = material._attributes.color;
-                    meshCfg.opacity = material._attributes.opacity;
-                    meshCfg.metallic = material._attributes.metallic;
-                    meshCfg.roughness = material._attributes.roughness;
-                } else {
-                    meshCfg.color = new Float32Array([1.0, 1.0, 1.0]);
-                    meshCfg.opacity = 1.0;
-                }
-
-                const backfaces = ((ctx.backfaces !== false) || (material && material.doubleSided !== false));
-
-                switch (primitive.mode) {
-                    case 0: // POINTS
-                        meshCfg.primitive = "points";
-                        break;
-                    case 1: // LINES
-                        meshCfg.primitive = "lines";
-                        break;
-                    case 2: // LINE_LOOP
-                        meshCfg.primitive = "lines";
-                        break;
-                    case 3: // LINE_STRIP
-                        meshCfg.primitive = "lines";
-                        break;
-                    case 4: // TRIANGLES
-                        meshCfg.primitive = backfaces ? "triangles" : "solid";
-                        break;
-                    case 5: // TRIANGLE_STRIP
-                        meshCfg.primitive = backfaces ? "triangles" : "solid";
-                        break;
-                    case 6: // TRIANGLE_FAN
-                        meshCfg.primitive = backfaces ? "triangles" : "solid";
-                        break;
-                    default:
-                        meshCfg.primitive = backfaces ? "triangles" : "solid";
-                }
-
-                const POSITION = primitive.attributes.POSITION;
-                if (!POSITION) {
-                    continue;
-                }
-                meshCfg.localPositions = POSITION.value;
-                meshCfg.positions = new Float64Array(meshCfg.localPositions.length);
-
-                if (primitive.attributes.NORMAL) {
-                    meshCfg.normals = primitive.attributes.NORMAL.value;
-                }
-
-                if (primitive.attributes.TEXCOORD_0) {
-                    meshCfg.uv = primitive.attributes.TEXCOORD_0.value;
-                }
-
-                if (primitive.indices) {
-                    meshCfg.indices = primitive.indices.value;
-                }
-
-                math.transformPositions3(worldMatrix, meshCfg.localPositions, meshCfg.positions);
-                const origin = math.vec3();
-                const rtcNeeded = worldToRTCPositions(meshCfg.positions, meshCfg.positions, origin); // Small cellsize guarantees better accuracy
-                if (rtcNeeded) {
-                    meshCfg.origin = origin;
-                }
-
-                sceneModel.createMesh(meshCfg);
-                deferredMeshIds.push(meshCfg.id);
-            }
-        }
-    }
-
-    if (node.children) {
-        const children = node.children;
-        for (let i = 0, len = children.length; i < len; i++) {
-            const childNode = children[i];
-            loadNode(ctx, childNode, depth + 1, matrix);
-        }
+/**
+ * Parses primitives referenced by the mesh belonging to the given node, creating XKTMeshes in the XKTModel.
+ *
+ * @param node glTF node
+ * @param ctx Parsing context
+ * @param matrix Matrix for the XKTMeshes
+ * @param meshIds returns IDs of the new XKTMeshes
+ */
+function parseNodeMesh(node, ctx, matrix, meshIds) {
+    const mesh = node.mesh;
+    if (!mesh) {
+        return;
     }
-
-    // Post-order visit scene node
-
-    if (ctx.entityId) {
-        if (depth ===0) {
-            sceneModel.createEntity({
-                id: ctx.entityId,
-                meshIds: deferredMeshIds,
-                isObject: true
-            });
-            deferredMeshIds.length = 0;
-        }
-    } else {
-        const nodeName = node.name;
-        if (((nodeName !== undefined && nodeName !== null) || depth === 0) && deferredMeshIds.length > 0) {
-            if (nodeName === undefined || nodeName === null) {
-                ctx.log(`Warning: 'name' properties not found on glTF scene nodes - will randomly-generate object IDs in XKT`);
+    const numPrimitives = mesh.primitives.length;
+    if (numPrimitives > 0) {
+        for (let i = 0; i < numPrimitives; i++) {
+            const primitive = mesh.primitives[i];
+            if (primitive.mode < 4) {
+                continue;
             }
-            let entityId = nodeName; // Fall back on generated ID when `name` not found on glTF scene node(s)
-            // if (!!entityId && sceneModel.entities[entityId]) {
-            //     ctx.log(`Warning: Two or more glTF nodes found with same 'name' attribute: '${nodeName} - will randomly-generating an object ID in XKT`);
-            // }
-            // while (!entityId || sceneModel.entities[entityId]) {
-            //     entityId = "entity-" + ctx.nextId++;
-            // }
-            if (ctx.metaModelCorrections) {
-                // Merging meshes into XKTObjects that map to metaobjects
-                const rootMetaObject = ctx.metaModelCorrections.eachChildRoot[entityId];
-                if (rootMetaObject) {
-                    const rootMetaObjectStats = ctx.metaModelCorrections.eachRootStats[rootMetaObject.id];
-                    rootMetaObjectStats.countChildren++;
-                    if (rootMetaObjectStats.countChildren >= rootMetaObjectStats.numChildren) {
-                        sceneModel.createEntity({
-                            id: rootMetaObject.id,
-                            meshIds: deferredMeshIds,
-                            isObject: true
-                        });
-                        deferredMeshIds.length = 0;
-                    }
-                } else {
-                    const metaObject = ctx.metaModelCorrections.metaObjectsMap[entityId];
-                    if (metaObject) {
-                        sceneModel.createEntity({
-                            id: entityId,
-                            meshIds: deferredMeshIds,
-                            isObject: true
-                        });
-                        deferredMeshIds.length = 0;
-                    }
-                }
+            const meshCfg = {
+                id: ctx.sceneModel.id + "." + ctx.numObjects++
+            };
+            const material = primitive.material;
+            if (material) {
+                meshCfg.textureSetId = material._textureSetId;
+                meshCfg.color = material._attributes.color;
+                meshCfg.opacity = material._attributes.opacity;
+                meshCfg.metallic = material._attributes.metallic;
+                meshCfg.roughness = material._attributes.roughness;
             } else {
-                // Create an XKTObject from the meshes at each named glTF node, don't care about metaobjects
-                sceneModel.createEntity({
-                    id: entityId,
-                    meshIds: deferredMeshIds,
-                    isObject: true
-                });
-                deferredMeshIds.length = 0;
+                meshCfg.color = new Float32Array([1.0, 1.0, 1.0]);
+                meshCfg.opacity = 1.0;
+            }
+            const backfaces = ((ctx.backfaces !== false) || (material && material.doubleSided !== false));
+            switch (primitive.mode) {
+                case 0: // POINTS
+                    meshCfg.primitive = "points";
+                    break;
+                case 1: // LINES
+                    meshCfg.primitive = "lines";
+                    break;
+                case 2: // LINE_LOOP
+                    meshCfg.primitive = "lines";
+                    break;
+                case 3: // LINE_STRIP
+                    meshCfg.primitive = "lines";
+                    break;
+                case 4: // TRIANGLES
+                    meshCfg.primitive = backfaces ? "triangles" : "solid";
+                    break;
+                case 5: // TRIANGLE_STRIP
+                    meshCfg.primitive = backfaces ? "triangles" : "solid";
+                    break;
+                case 6: // TRIANGLE_FAN
+                    meshCfg.primitive = backfaces ? "triangles" : "solid";
+                    break;
+                default:
+                    meshCfg.primitive = backfaces ? "triangles" : "solid";
+            }
+            const POSITION = primitive.attributes.POSITION;
+            if (!POSITION) {
+                continue;
+            }
+            meshCfg.localPositions = POSITION.value;
+            meshCfg.positions = new Float64Array(meshCfg.localPositions.length);
+            if (primitive.attributes.NORMAL) {
+                meshCfg.normals = primitive.attributes.NORMAL.value;
+            }
+            if (primitive.attributes.TEXCOORD_0) {
+                meshCfg.uv = primitive.attributes.TEXCOORD_0.value;
             }
+            if (primitive.indices) {
+                meshCfg.indices = primitive.indices.value;
+            }
+            math.transformPositions3(matrix, meshCfg.localPositions, meshCfg.positions);
+            const origin = math.vec3();
+            const rtcNeeded = worldToRTCPositions(meshCfg.positions, meshCfg.positions, origin); // Small cellsize guarantees better accuracy
+            if (rtcNeeded) {
+                meshCfg.origin = origin;
+            }
+            ctx.sceneModel.createMesh(meshCfg);
+            meshIds.push(meshCfg.id);
         }
     }
 }
@@ -117911,8 +118680,6 @@ class GLTFLoaderPlugin extends Plugin {
      * @param {String} [params.metaModelSrc] Path to an optional metadata file, as an alternative to the ````metaModelJSON```` parameter.
      * @param {*} [params.metaModelJSON] JSON model metadata, as an alternative to the ````metaModelSrc```` parameter.
      * @param {{String:Object}} [params.objectDefaults] Map of initial default states for each loaded {@link Entity} that represents an object. Default value is {@link IFCObjectDefaults}.
-     * @param {String[]} [params.includeTypes] When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
-     * @param {String[]} [params.excludeTypes] When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
      * @param {Boolean} [params.edges=false] Whether or not xeokit renders the model with edges emphasized.
      * @param {Number[]} [params.origin=[0,0,0]] The double-precision World-space origin of the model's coordinates.
      * @param {Number[]} [params.position=[0,0,0]] The single-precision position, relative to ````origin````.
@@ -117928,150 +118695,47 @@ class GLTFLoaderPlugin extends Plugin {
      * represent the returned model. Set false to always use vertex buffer objects (VBOs). Note that DTX is only applicable
      * to non-textured triangle meshes, and that VBOs are always used for meshes that have textures, line segments, or point
      * primitives. Only works while {@link DTX#enabled} is also ````true````.
-     * @param {String} [params.entityId] When supplied, causes the entire model to be loaded into a single {@link Entity} that gets this ID.
+     * @param {Boolean} [params.autoMetaModel] When supplied, creates a default MetaModel with a single MetaObject.
      * @returns {Entity} Entity representing the model, which will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id} in {@link Scene#models}
      */
     load(params = {}) {
-
         if (params.id && this.viewer.scene.components[params.id]) {
             this.error("Component with this ID already exists in viewer: " + params.id + " - will autogenerate this ID");
             delete params.id;
         }
-
         const sceneModel = new SceneModel(this.viewer.scene, utils.apply(params, {
             isModel: true,
             dtxEnabled: params.dtxEnabled
         }));
-
         const modelId = sceneModel.id;  // In case ID was auto-generated
-
         if (!params.src && !params.gltf) {
             this.error("load() param expected: src or gltf");
             return sceneModel; // Return new empty model
         }
-
         if (params.metaModelSrc || params.metaModelJSON) {
-
-            const objectDefaults = params.objectDefaults || this._objectDefaults || IFCObjectDefaults;
-
             const processMetaModelJSON = (metaModelJSON) => {
-
-                this.viewer.metaScene.createMetaModel(modelId, metaModelJSON, {
-                    includeTypes: params.includeTypes,
-                    excludeTypes: params.excludeTypes
-                });
-
+                this.viewer.metaScene.createMetaModel(modelId, metaModelJSON, {});
                 this.viewer.scene.canvas.spinner.processes--;
-
-                let includeTypes;
-                if (params.includeTypes) {
-                    includeTypes = {};
-                    for (let i = 0, len = params.includeTypes.length; i < len; i++) {
-                        includeTypes[params.includeTypes[i]] = true;
-                    }
-                }
-                if (params.excludeTypes) {
-                    if (!includeTypes) {
-                        includeTypes = {};
-                    }
-                    for (let i = 0, len = params.excludeTypes.length; i < len; i++) {
-                        includeTypes[params.excludeTypes[i]] = true;
-                    }
-                }
-
-                params.readableGeometry = false;
-
-                params.handleGLTFNode = (modelId, glTFNode, actions) => {
-
-                    const name = glTFNode.name;
-
-                    if (!name) {
-                        return true; // Continue descending this node subtree
-                    }
-
-                    const nodeId = name;
-                    const metaObject = this.viewer.metaScene.metaObjects[nodeId];
-                    const type = (metaObject ? metaObject.type : "DEFAULT") || "DEFAULT";
-
-                    actions.createEntity = {
-                        id: nodeId,
-                        isObject: true // Registers the Entity in Scene#objects
-                    };
-
-                    const props = objectDefaults[type];
-
-                    if (props) { // Set Entity's initial rendering state for recognized type
-
-                        if (props.visible === false) {
-                            actions.createEntity.visible = false;
-                        }
-
-                        if (props.colorize) {
-                            actions.createEntity.colorize = props.colorize;
-                        }
-
-                        if (props.pickable === false) {
-                            actions.createEntity.pickable = false;
-                        }
-
-                        if (props.opacity !== undefined && props.opacity !== null) {
-                            actions.createEntity.opacity = props.opacity;
-                        }
-                    }
-
-                    return true; // Continue descending this glTF node subtree
-                };
-
                 if (params.src) {
                     this._sceneModelLoader.load(this, params.src, metaModelJSON, params, sceneModel);
                 } else {
                     this._sceneModelLoader.parse(this, params.gltf, metaModelJSON, params, sceneModel);
                 }
             };
-
             if (params.metaModelSrc) {
-
                 const metaModelSrc = params.metaModelSrc;
-
                 this.viewer.scene.canvas.spinner.processes++;
-
                 this._dataSource.getMetaModel(metaModelSrc, (metaModelJSON) => {
-
                     this.viewer.scene.canvas.spinner.processes--;
-
                     processMetaModelJSON(metaModelJSON);
-
                 }, (errMsg) => {
                     this.error(`load(): Failed to load model metadata for model '${modelId} from  '${metaModelSrc}' - ${errMsg}`);
                     this.viewer.scene.canvas.spinner.processes--;
                 });
-
             } else if (params.metaModelJSON) {
-
                 processMetaModelJSON(params.metaModelJSON);
             }
-
         } else {
-
-            params.handleGLTFNode = (modelId, glTFNode, actions) => {
-
-                const name = glTFNode.name;
-
-                if (!name) {
-                    return true; // Continue descending this node subtree
-                }
-
-                const id = name;
-
-                actions.createEntity = { // Create an Entity for this glTF scene node
-                    id: id,
-                    isObject: true // Registers the Entity in Scene#objects
-                };
-
-                return true; // Continue descending this glTF node subtree
-            };
-
-
             if (params.src) {
                 this._sceneModelLoader.load(this, params.src, null, params, sceneModel);
             } else {
@@ -122942,13 +123606,43 @@ class StoreyViewsPlugin extends Plugin {
     getStoreyContainingWorldPos(worldPos) {
         for (var storeyId in this.storeys) {
             const storey = this.storeys[storeyId];
-            if (math.point3AABB3Intersect(storey.storeyAABB, worldPos)) {
+            if (math.point3AABB3AbsoluteIntersect(storey.storeyAABB, worldPos)) {
                 return storeyId;
             }
         }
         return null;
     }
 
+    /**
+     * Gets the ID of the storey which's bounding box contains the y point of the world position
+     * 
+     * @param {Number[]} worldPos 3D World-space position.
+     * @returns {String} ID of the storey containing the position, or null if the position falls outside all the storeys.
+     */
+    getStoreyInVerticalRange(worldPos) {
+        for(let storeyId in this.storeys) {
+            const storey = this.storeys[storeyId];
+            const aabb = [0,0,0,0,0,0], pos = [0,0,0];
+            aabb[1] = storey.storeyAABB[1];
+            aabb[4] = storey.storeyAABB[4];
+            pos[1] = worldPos[1];
+            if (math.point3AABB3AbsoluteIntersect(aabb, pos)) {
+                return storeyId;
+            }
+        }
+        return null;
+    }
+
+    isPositionAboveOrBelowBuilding(worldPos){
+        const keys = Object.keys(this.storeys);
+        const ids = [keys[0], keys[keys.length-1]];
+        if(worldPos[1] < this.storeys[ids[0]].storeyAABB[1])
+            return ids[0];
+        else if (worldPos[1] > this.storeys[ids[1]].storeyAABB[4])
+            return ids[1];
+        return null;
+    }
+
     /**
      * Converts a 3D World-space position to a 2D position within a StoreyMap image.
      *
@@ -131836,6 +132530,9 @@ class XKTLoaderPlugin extends Plugin {
         this.viewer.scene.canvas.spinner.processes++;
 
         const finish = () => {
+            if (sceneModel.destroyed) {
+                return;
+            }
             // this._createDefaultMetaModelIfNeeded(sceneModel, params, options);
             sceneModel.finalize();
             metaModel.finalize();
@@ -131917,7 +132614,9 @@ class XKTLoaderPlugin extends Plugin {
                 const loadJSONs = (metaDataFiles, done, error) => {
                     let i = 0;
                     const loadNext = () => {
-                        if (i >= metaDataFiles.length) {
+                        if (sceneModel.destroyed) {
+                            done();
+                        } else if (i >= metaDataFiles.length) {
                             done();
                         } else {
                             this._dataSource.getMetaModel(`${baseDir}${metaDataFiles[i]}`, (metaModelData) => {
@@ -131927,7 +132626,7 @@ class XKTLoaderPlugin extends Plugin {
                                     globalizeObjectIds: options.globalizeObjectIds
                                 });
                                 i++;
-                                this.scheduleTask(loadNext, 100);
+                                this.scheduleTask(loadNext, 200);
                             }, error);
                         }
                     };
@@ -131936,13 +132635,16 @@ class XKTLoaderPlugin extends Plugin {
                 const loadXKTs_excludeTheirMetaModels = (xktFiles, done, error) => { // Load XKTs, ignore metamodels in the XKT
                     let i = 0;
                     const loadNext = () => {
-                        if (i >= xktFiles.length) {
+                        if (sceneModel.destroyed) {
+                            done();
+                        } else if (i >= xktFiles.length) {
                             done();
                         } else {
                             this._dataSource.getXKT(`${baseDir}${xktFiles[i]}`, (arrayBuffer) => {
                                 this._parseModel(arrayBuffer, params, options, sceneModel, null /* Ignore metamodel in XKT */, manifestCtx);
+                                sceneModel.preFinalize();
                                 i++;
-                                this.scheduleTask(loadNext, 100);
+                                this.scheduleTask(loadNext, 200);
                             }, error);
                         }
                     };
@@ -131951,13 +132653,16 @@ class XKTLoaderPlugin extends Plugin {
                 const loadXKTs_includeTheirMetaModels = (xktFiles, done, error) => { // Load XKTs, parse metamodels from the XKT
                     let i = 0;
                     const loadNext = () => {
-                        if (i >= xktFiles.length) {
+                        if (sceneModel.destroyed) {
+                            done();
+                        } else if (i >= xktFiles.length) {
                             done();
                         } else {
                             this._dataSource.getXKT(`${baseDir}${xktFiles[i]}`, (arrayBuffer) => {
                                 this._parseModel(arrayBuffer, params, options, sceneModel, metaModel, manifestCtx);
+                                sceneModel.preFinalize();
                                 i++;
-                                this.scheduleTask(loadNext, 100);
+                                this.scheduleTask(loadNext, 200);
                             }, error);
                         }
                     };
@@ -132007,11 +132712,12 @@ class XKTLoaderPlugin extends Plugin {
     _loadModel(src, params, options, sceneModel, metaModel, manifestCtx, done, error) {
         this._dataSource.getXKT(params.src, (arrayBuffer) => {
             this._parseModel(arrayBuffer, params, options, sceneModel, metaModel, manifestCtx);
+            sceneModel.preFinalize();
             done();
         }, error);
     }
 
-    _parseModel(arrayBuffer, params, options, sceneModel, metaModel, manifestCtx) {
+    async _parseModel(arrayBuffer, params, options, sceneModel, metaModel, manifestCtx) {
         if (sceneModel.destroyed) {
             return;
         }
@@ -132023,7 +132729,7 @@ class XKTLoaderPlugin extends Plugin {
             this.error("Unsupported .XKT file version: " + xktVersion + " - this XKTLoaderPlugin supports versions " + Object.keys(parsers));
             return;
         }
-        this.log("Loading .xkt V" + xktVersion);
+        //   this.log("Loading .xkt V" + xktVersion);
         const numElements = dataView.getUint32(4, true);
         const elements = [];
         let byteOffset = (numElements + 2) * 4;
@@ -138785,7 +139491,7 @@ const triangulateEarClipping = function(planeCoords) {
         next.prev = ear.prev;
     }
 
-    return [ planeCoords, baseTriangles ];
+    return [ planeCoords, baseTriangles, isCCW ];
 };
 
 const marker3D = function(scene, color) {
@@ -139307,7 +140013,7 @@ class Zone extends Component {
         const altitude    = this._geometry.altitude + (downward ? this._geometry.height : 0);
         const height      = this._geometry.height * (downward ? -1 : 1);
 
-        const [ baseVertices, baseTriangles ] = triangulateEarClipping(planeCoords); // TODO: prevent crossing edges
+        const [ baseVertices, baseTriangles, isCCW ] = triangulateEarClipping(planeCoords); // TODO: prevent crossing edges
 
         const pos = [ ];
         const ind = [ ];
@@ -139331,7 +140037,7 @@ class Zone extends Component {
         // sides
         for (let i = 0; i < baseVertices.length; ++i) {
             const a = baseVertices[i];
-            const b = baseVertices[(i+1) % baseVertices.length];
+            const b = baseVertices[(baseVertices.length + i + (isCCW ? 1 : -1)) % baseVertices.length];
             const f = altitude;
             const c = altitude + height;
 
@@ -139374,6 +140080,28 @@ class Zone extends Component {
 
         this._zoneMesh.zone = this;
 
+        {
+            const u = math.vec2();
+            const v = math.vec2();
+
+            let baseArea = 0;
+
+            for (let t of baseTriangles) {
+                const p0 = baseVertices[t[0]];
+                const p1 = baseVertices[t[1]];
+                const p2 = baseVertices[t[2]];
+
+                math.subVec2(p1, p0, u);
+                math.subVec2(p2, p0, v);
+
+                baseArea += Math.abs(u[0] * v[1] - u[1] * v[0]);
+            }
+
+            this._baseArea = baseArea / 2;
+        }
+
+        this._metrics = null;
+
 
         const min = idx => Math.min(...pos.map(p => p[idx]));
         const max = idx => Math.max(...pos.map(p => p[idx]));
@@ -139388,6 +140116,48 @@ class Zone extends Component {
         this._center = math.vec3([ (xmin + xmax) / 2, (ymin + ymax) / 2, (zmin + zmax) / 2 ]);
     }
 
+    get baseArea() {
+        return this._baseArea;
+    }
+
+    get area() {
+        return this._getMetrics().area;
+    }
+
+    get volume() {
+        return this._getMetrics().volume;
+    }
+
+    _getMetrics() {
+        if (this._metrics === null) {
+            // Sum the volume of tetrahedrons formed by the origin and face triangles
+            let volume = 0;
+            let area = 0;
+            const geo = this._zoneMesh.geometry;
+            const pts = [ math.vec3(), math.vec3(), math.vec3() ];
+            const tmpVec3 = math.vec3();
+            for (let i = 0; i < geo.indices.length; i += 3) {
+                for (let off = 0; off < 3; ++off) {
+                    const p = pts[off];
+                    const pIdx = 3 * geo.indices[i + off];
+                    for (let c = 0; c < 3; ++c) {
+                        p[c] = geo.positions[pIdx + c];
+                    }
+                }
+                volume += math.dotVec3(pts[0], math.cross3Vec3(pts[1], pts[2], tmpVec3));
+                math.subVec3(pts[1], pts[0], pts[1]);
+                math.subVec3(pts[2], pts[0], pts[2]);
+                area += math.lenVec3(math.cross3Vec3(pts[1], pts[2], tmpVec3));
+            }
+
+            this._metrics = {
+                area: area / 2,
+                volume: volume / 6
+            };
+        }
+        return this._metrics;
+    }
+
     sectionedAverage(sectionPlanes) {
         const planeCoords = this._geometry.planeCoordinates.slice();
 
@@ -140544,6 +141314,7 @@ exports.DefaultLoadingManager = DefaultLoadingManager;
 exports.DepthFormat = DepthFormat;
 exports.DepthStencilFormat = DepthStencilFormat;
 exports.DirLight = DirLight;
+exports.DistanceMeasurementEditControl = DistanceMeasurementEditControl;
 exports.DistanceMeasurementEditMouseControl = DistanceMeasurementEditMouseControl;
 exports.DistanceMeasurementEditTouchControl = DistanceMeasurementEditTouchControl;
 exports.DistanceMeasurementsControl = DistanceMeasurementsControl;
@@ -140588,6 +141359,8 @@ exports.Marker = Marker;
 exports.MarqueePicker = MarqueePicker;
 exports.MarqueePickerMouseControl = MarqueePickerMouseControl;
 exports.Mesh = Mesh;
+exports.MeshSurfaceArea = MeshSurfaceArea;
+exports.MeshVolume = MeshVolume;
 exports.MetallicMaterial = MetallicMaterial;
 exports.MirroredRepeatWrapping = MirroredRepeatWrapping;
 exports.ModelMemento = ModelMemento;
@@ -140706,9 +141479,12 @@ exports.createRTCViewMat = createRTCViewMat;
 exports.frustumIntersectsAABB3 = frustumIntersectsAABB3;
 exports.getKTX2TextureTranscoder = getKTX2TextureTranscoder;
 exports.getPlaneRTCPos = getPlaneRTCPos;
+exports.isTriangleMeshSolid = isTriangleMeshSolid;
 exports.load3DSGeometry = load3DSGeometry;
 exports.loadOBJGeometry = loadOBJGeometry;
 exports.math = math;
+exports.meshSurfaceArea = meshSurfaceArea;
+exports.meshVolume = meshVolume;
 exports.rtcToWorldPos = rtcToWorldPos;
 exports.sRGBEncoding = sRGBEncoding;
 exports.setFrustum = setFrustum;