@xeokit/xeokit-sdk 2.6.28 → 2.6.29

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;
     }
@@ -23519,7 +23538,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 +24404,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 +30159,8 @@ class Scene extends Component {
 
         this._aabbDirty = true;
 
+        this._readableGeometry = !!cfg.readableGeometryEnabled;
+
         /**
          * The {@link Viewer} this Scene belongs to.
          * @type {Viewer}
@@ -31019,18 +31040,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 +32038,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 +50638,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 +51104,9 @@ class SceneModelMesh {
         if (transform) {
             transform._addMesh(this);
         }
+
+        this._volume = null;
+        this._surfaceArea = null;
     }
 
     _sceneModelDirty() {
@@ -50902,7 +51285,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;
     }
 
     /**
@@ -55706,7 +56157,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 +56187,7 @@ class VBOBatchingTrianglesLayer {
      */
     constructor(cfg) {
 
-        console.info("Creating VBOBatchingTrianglesLayer");
+     //   console.info("Creating VBOBatchingTrianglesLayer");
 
         /**
          * Owner model
@@ -55826,6 +56277,11 @@ class VBOBatchingTrianglesLayer {
          * @type {boolean}
          */
         this.solid = !!cfg.solid;
+
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.primitive;
     }
 
     get aabb() {
@@ -56022,7 +56478,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 +56515,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 +56944,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 +56952,7 @@ class VBOBatchingTrianglesLayer {
     }
 
     getEachVertex(portionId, callback) {
-        if (!this.model.scene.pickSurfacePrecisionEnabled) {
+        if (!this.model.scene.readableGeometryEnabled) {
             return;
         }
         const state = this._state;
@@ -56507,18 +56963,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 +56983,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;
@@ -56813,7 +57285,7 @@ class VBOBatchingTrianglesLayer {
 
     precisionRayPickSurface(portionId, worldRayOrigin, worldRayDir, worldSurfacePos, worldNormal) {
 
-        if (!this.model.scene.pickSurfacePrecisionEnabled) {
+        if (!this.model.scene.readableGeometryEnabled) {
             return false;
         }
 
@@ -60793,7 +61265,7 @@ function getRenderers$6(scene) {
 
 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 +61293,7 @@ class VBOInstancingTrianglesLayer {
      */
     constructor(cfg) {
 
-         console.info("Creating VBOInstancingTrianglesLayer");
+      //   console.info("Creating VBOInstancingTrianglesLayer");
 
         /**
          * Owner model
@@ -60924,6 +61396,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 +61514,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 +61952,7 @@ class VBOInstancingTrianglesLayer {
     }
 
     getEachVertex(portionId, callback) {
-        if (!this.model.scene.pickSurfacePrecisionEnabled) {
+        if (!this.model.scene.readableGeometryEnabled) {
             return false;
         }
         const state = this._state;
@@ -61487,13 +61964,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 +61977,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 +61985,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";
@@ -61815,7 +62308,7 @@ class VBOInstancingTrianglesLayer {
 
     precisionRayPickSurface(portionId, worldRayOrigin, worldRayDir, worldSurfacePos, worldNormal) {
 
-        if (!this.model.scene.pickSurfacePrecisionEnabled) {
+        if (!this.model.scene.readableGeometryEnabled) {
             return false;
         }
 
@@ -62972,7 +63465,7 @@ class VBOBatchingLinesLayer {
      */
     constructor(cfg) {
 
-        console.info("Creating VBOBatchingLinesLayer");
+       // console.info("Creating VBOBatchingLinesLayer");
 
         /**
          * Index of this LinesBatchingLayer in {@link VBOSceneModel#_layerList}.
@@ -63027,6 +63520,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() {
@@ -64735,7 +65233,7 @@ class VBOInstancingLinesLayer {
      */
     constructor(cfg) {
 
-        console.info("VBOInstancingLinesLayer");
+     //   console.info("VBOInstancingLinesLayer");
 
         /**
          * Owner model
@@ -64815,6 +65313,11 @@ class VBOInstancingLinesLayer {
         }
 
         this._finalized = false;
+
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.primitive;
     }
 
     get aabb() {
@@ -66948,7 +67451,7 @@ class VBOBatchingPointsLayer {
      */
     constructor(cfg) {
 
-        console.info("Creating VBOBatchingPointsLayer");
+     //   console.info("Creating VBOBatchingPointsLayer");
 
         /**
          * Owner model
@@ -69545,7 +70048,7 @@ class VBOInstancingPointsLayer {
      */
     constructor(cfg) {
 
-        console.info("VBOInstancingPointsLayer");
+      //  console.info("VBOInstancingPointsLayer");
 
         /**
          * Owner model
@@ -69619,6 +70122,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 +71788,7 @@ class DTXLinesLayer {
 
     constructor(model, cfg) {
 
-        console.info("Creating DTXLinesLayer");
+      //  console.info("Creating DTXLinesLayer");
 
         dataTextureRamStats$1.numberOfLayers++;
 
@@ -71319,6 +71827,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 +72658,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 +72937,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);
             }
         }
@@ -78654,6 +79168,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 +79184,7 @@ class DTXTrianglesLayer {
 
     constructor(model, cfg) {
 
-        console.info("Creating DTXTrianglesLayer");
+        //console.info("Creating DTXTrianglesLayer");
 
         dataTextureRamStats.numberOfLayers++;
 
@@ -78709,6 +79224,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 +79257,11 @@ class DTXTrianglesLayer {
          */
         this._numUpdatesInFrame = 0;
 
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.primitive;
+
         this._finalized = false;
     }
 
@@ -79042,6 +79566,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 +80225,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) {
@@ -83034,7 +83624,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 +83703,7 @@ class SceneModel extends Component {
         this._numTriangles = 0;
         this._numLines = 0;
         this._numPoints = 0;
+        this._layersFinalized = false;
 
         this._edgeThreshold = cfg.edgeThreshold || 10;
 
@@ -85051,7 +85645,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 +85656,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 +85698,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 +85714,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 +85730,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 +85743,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 +85756,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 +85773,7 @@ class SceneModel extends Component {
         }
         this._vboBatchingLayers[layerId] = vboBatchingLayer;
         this.layerList.push(vboBatchingLayer);
+        this._layersToFinalize.push(vboBatchingLayer);
         return vboBatchingLayer;
     }
 
@@ -85265,6 +85866,7 @@ class SceneModel extends Component {
         }
         this._vboInstancingLayers[layerId] = vboInstancingLayer;
         this.layerList.push(vboInstancingLayer);
+        this._layersToFinalize.push(vboInstancingLayer);
         return vboInstancingLayer;
     }
 
@@ -85365,38 +85967,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 +86023,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 +86077,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 +86449,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 +88947,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 +89010,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 +89025,7 @@ class DistanceMeasurementsMouseControl extends DistanceMeasurementsControl {
     get snapping() {
         return this._snapping;
     }
-    
+
     /**
      * Activates this DistanceMeasurementsMouseControl, ready to respond to input.
      */
@@ -88456,11 +89060,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 +89114,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 +89177,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 +89192,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 +89208,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 +89909,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 +89943,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 +90558,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 +90578,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;
     }
 
     /**
@@ -109086,7 +109669,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 +109739,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),
@@ -122942,13 +123525,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 +132449,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 +132533,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 +132545,7 @@ class XKTLoaderPlugin extends Plugin {
                                     globalizeObjectIds: options.globalizeObjectIds
                                 });
                                 i++;
-                                this.scheduleTask(loadNext, 100);
+                                this.scheduleTask(loadNext, 200);
                             }, error);
                         }
                     };
@@ -131936,13 +132554,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 +132572,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 +132631,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 +132648,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 +139410,7 @@ const triangulateEarClipping = function(planeCoords) {
         next.prev = ear.prev;
     }
 
-    return [ planeCoords, baseTriangles ];
+    return [ planeCoords, baseTriangles, isCCW ];
 };
 
 const marker3D = function(scene, color) {
@@ -139307,7 +139932,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 +139956,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 +139999,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 +140035,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 +141233,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 +141278,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 +141398,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;