@xeokit/xeokit-sdk 2.6.27 → 2.6.29

package/src/viewer/Viewer.js

@@ -46,7 +46,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.
@@ -116,7 +116,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),

package/src/viewer/scene/CameraControl/lib/handlers/MousePickHandler.js

@@ -266,7 +266,7 @@ class MousePickHandler {
 
                 this._timeout = setTimeout(() => {
 
-                    if (firstClickPickResult) {
+                    if (firstClickPickResult && firstClickPickResult.worldPos) {
 
                         cameraControl.fire("picked", firstClickPickResult, true);
 

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

@@ -0,0 +1,90 @@
+import {math} from "./math.js";
+
+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.
+ */
+export 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}
+ */
+export const meshSurfaceArea = new MeshSurfaceArea();

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

@@ -0,0 +1,102 @@
+import {math} from "./math.js";
+import {isTriangleMeshSolid} from "./isTriangleMeshSolid.js";
+
+const v1 = math.vec3();
+const v2 = math.vec3();
+const v3 = math.vec3();
+
+/**
+ * Calculates the volume of triangle meshes.
+ */
+export 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[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.cross3Vec3(v1, v2, v1);
+
+            volume += math.dotVec3(v1, v3);
+        }
+
+        return volume;
+    }
+}
+
+/**
+ * Singleton instance of {@link MeshVolume}.
+ * @type {MeshVolume}
+ */
+export const meshVolume = new MeshVolume();

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

@@ -1,3 +1,6 @@
 export * from "./math.js";
 export * from "./Frustum.js";
 export * from "./rtcCoords.js";
+export * from "./MeshVolume.js";
+export * from "./MeshSurfaceArea.js";
+export * from "./isTriangleMeshSolid.js";

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

@@ -0,0 +1,162 @@
+/**
+ * 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;
+};
+
+export {isTriangleMeshSolid};

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

@@ -3998,6 +3998,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

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

@@ -1155,7 +1155,10 @@ export 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
@@ -1231,6 +1234,7 @@ export class SceneModel extends Component {
         this._numTriangles = 0;
         this._numLines = 0;
         this._numPoints = 0;
+        this._layersFinalized = false;
 
         this._edgeThreshold = cfg.edgeThreshold || 10;
 
@@ -3172,7 +3176,7 @@ export 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 {
@@ -3183,16 +3187,17 @@ export 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;
     }
 
@@ -3224,7 +3229,8 @@ export class SceneModel extends Component {
                         origin,
                         maxGeometryBatchSize: this._maxGeometryBatchSize,
                         solid: (cfg.primitive === "solid"),
-                        autoNormals: true
+                        autoNormals: true,
+                        primitive: cfg.primitive
                     });
                     break;
                 case "solid":
@@ -3239,7 +3245,8 @@ export class SceneModel extends Component {
                         origin,
                         maxGeometryBatchSize: this._maxGeometryBatchSize,
                         solid: (cfg.primitive === "solid"),
-                        autoNormals: true
+                        autoNormals: true,
+                        primitive: cfg.primitive
                     });
                     break;
                 case "surface":
@@ -3254,7 +3261,8 @@ export class SceneModel extends Component {
                         origin,
                         maxGeometryBatchSize: this._maxGeometryBatchSize,
                         solid: (cfg.primitive === "solid"),
-                        autoNormals: true
+                        autoNormals: true,
+                        primitive: cfg.primitive
                     });
                     break;
                 case "lines":
@@ -3266,7 +3274,8 @@ export 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":
@@ -3278,7 +3287,8 @@ export 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;
             }
@@ -3294,6 +3304,7 @@ export class SceneModel extends Component {
         }
         this._vboBatchingLayers[layerId] = vboBatchingLayer;
         this.layerList.push(vboBatchingLayer);
+        this._layersToFinalize.push(vboBatchingLayer);
         return vboBatchingLayer;
     }
 
@@ -3386,6 +3397,7 @@ export class SceneModel extends Component {
         }
         this._vboInstancingLayers[layerId] = vboInstancingLayer;
         this.layerList.push(vboInstancingLayer);
+        this._layersToFinalize.push(vboInstancingLayer);
         return vboInstancingLayer;
     }
 
@@ -3486,38 +3498,47 @@ export 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) {
@@ -3533,15 +3554,23 @@ export 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 */
@@ -3579,7 +3608,7 @@ export 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,
@@ -3951,6 +3980,7 @@ export 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();
         // });

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

@@ -633,7 +633,7 @@ export 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);
@@ -650,6 +650,51 @@ export 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);
     }