@xeokit/xeokit-sdk 2.6.28 → 2.6.30

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);
     }

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

@@ -1,9 +1,11 @@
 import {math} from "../math/math.js";
+import {meshSurfaceArea, meshVolume} from "../math/index.js";
 
 const tempOBB3 = math.OBB3();
 const tempOBB3b = math.OBB3();
 const tempOBB3c = math.OBB3();
 
+
 /**
  * A mesh within a {@link SceneModel}.
  *
@@ -116,6 +118,9 @@ export class SceneModelMesh {
         if (transform) {
             transform._addMesh(this);
         }
+
+        this._volume = null;
+        this._surfaceArea = null;
     }
 
     _sceneModelDirty() {
@@ -294,7 +299,75 @@ export 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;
     }
 
     /**

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

@@ -26,6 +26,11 @@ export class SceneModelTextureSet {
          */
         this.colorTexture = cfg.colorTexture;
 
+        /**
+         * The alpha cutoff [float]
+         */
+        this.alphaCutoff = cfg.alphaCutoff;
+
         /**
          * The metallic-roughness texture.
          * @type {SceneModelTexture|*}

package/src/viewer/scene/model/dtx/lines/DTXLinesLayer.js

@@ -31,7 +31,7 @@ export class DTXLinesLayer {
 
     constructor(model, cfg) {
 
-        console.info("Creating DTXLinesLayer");
+      //  console.info("Creating DTXLinesLayer");
 
         dataTextureRamStats.numberOfLayers++;
 
@@ -70,6 +70,12 @@ export 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;
     }
 

package/src/viewer/scene/model/dtx/triangles/DTXTrianglesLayer.js

@@ -38,6 +38,7 @@ const INDICES_EDGE_INDICES_ALIGNEMENT_SIZE = 8;
  */
 const MAX_OBJECT_UPDATES_IN_FRAME_WITHOUT_BATCHED_UPDATE = 10;
 
+const tempVec4a = math.vec4();
 const tempMat4a = new Float32Array(16);
 const tempUint8Array4 = new Uint8Array(4);
 const tempFloat32Array3 = new Float32Array(3);
@@ -53,7 +54,7 @@ export class DTXTrianglesLayer {
 
     constructor(model, cfg) {
 
-        console.info("Creating DTXTrianglesLayer");
+        //console.info("Creating DTXTrianglesLayer");
 
         dataTextureRamStats.numberOfLayers++;
 
@@ -93,6 +94,10 @@ export 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.
@@ -122,6 +127,11 @@ export class DTXTrianglesLayer {
          */
         this._numUpdatesInFrame = 0;
 
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.primitive;
+
         this._finalized = false;
     }
 
@@ -426,6 +436,15 @@ export 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++;
@@ -1076,6 +1095,63 @@ export 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;
+            const meshMatrix = subPortionReadableGeometry.meshMatrix;
+            const origin = state.origin;
+            const offsetX = origin[0] ;
+            const offsetY = origin[1] ;
+            const offsetZ = origin[2] ;
+            const worldPos = tempVec4a;
+            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) {

package/src/viewer/scene/model/dtx/triangles/renderers/DTXTrianglesSnapInitRenderer.js

@@ -304,6 +304,14 @@ export class DTXTrianglesSnapInitRenderer {
         src.push("uvec4 flags = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+2, objectIndexCoords.y), 0);");
         src.push("uvec4 flags2 = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+3, objectIndexCoords.y), 0);");
 
+        // flags.w = NOT_RENDERED | PICK
+        // renderPass = PICK
+
+        src.push(`if (int(flags.w) != renderPass) {`);
+        src.push("   gl_Position = vec4(3.0, 3.0, 3.0, 1.0);"); // Cull vertex
+        src.push("   return;"); // Cull vertex
+        src.push("}");
+
         src.push("{");
 
         // get color

package/src/viewer/scene/model/dtx/triangles/renderers/DTXTrianglesSnapRenderer.js

@@ -311,6 +311,14 @@ export class DTXTrianglesSnapRenderer {
         src.push("uvec4 flags = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+2, objectIndexCoords.y), 0);");
         src.push("uvec4 flags2 = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+3, objectIndexCoords.y), 0);");
 
+        // flags.w = NOT_RENDERED | PICK
+        // renderPass = PICK
+
+        src.push(`if (int(flags.w) != renderPass) {`);
+        src.push("   gl_Position = vec4(3.0, 3.0, 3.0, 1.0);"); // Cull vertex
+        src.push("   return;"); // Cull vertex
+        src.push("}");
+
         src.push("{");
 
         // get vertex base

package/src/viewer/scene/model/vbo/VBORenderer.js

@@ -17,11 +17,12 @@ const tempMat4a = math.mat4();
  * @private
  */
 export class VBORenderer {
-    constructor(scene, withSAO = false, {instancing = false, edges = false} = {}) {
+    constructor(scene, withSAO = false, {instancing = false, edges = false, useAlphaCutoff = false} = {}) {
         this._scene = scene;
         this._withSAO = withSAO;
         this._instancing = instancing;
         this._edges = edges;
+        this._useAlphaCutoff = useAlphaCutoff;
         this._hash = this._getHash();
 
         /**
@@ -272,6 +273,10 @@ export class VBORenderer {
             this._uSAOParams = program.getLocation("uSAOParams");
         }
 
+        if (this._useAlphaCutoff) {
+            this._alphaCutoffLocation = program.getLocation("materialAlphaCutoff");
+        }
+
         if (scene.logarithmicDepthBufferEnabled) {
             this._uLogDepthBufFC = program.getLocation("logDepthBufFC");
         }
@@ -609,6 +614,10 @@ export class VBORenderer {
             }
         }
 
+        if (this._useAlphaCutoff) {
+            gl.uniform1f(this._alphaCutoffLocation, textureSet.alphaCutoff);
+        }
+
         if (colorUniform) {
             const colorKey = this._edges ? "edgeColor" : "fillColor";
             const alphaKey = this._edges ? "edgeAlpha" : "fillAlpha";

package/src/viewer/scene/model/vbo/batching/lines/VBOBatchingLinesLayer.js

@@ -24,7 +24,7 @@ export class VBOBatchingLinesLayer {
      */
     constructor(cfg) {
 
-        console.info("Creating VBOBatchingLinesLayer");
+       // console.info("Creating VBOBatchingLinesLayer");
 
         /**
          * Index of this LinesBatchingLayer in {@link VBOSceneModel#_layerList}.
@@ -79,6 +79,11 @@ export 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() {

package/src/viewer/scene/model/vbo/batching/lines/renderers/VBOBatchingLinesSnapRenderer.js

@@ -215,7 +215,7 @@ export class VBOBatchingLinesSnapRenderer extends VBORenderer{
 
         src.push(`int pickFlag = int(flags) >> 12 & 0xF;`);
         src.push(`if (pickFlag != renderPass) {`);
-        src.push("      gl_Position = vec4(0.0, 0.0, 0.0, 0.0);"); // Cull vertex
+        src.push("      gl_Position = vec4(2.0, 0.0, 0.0, 0.0);"); // Cull vertex
         src.push("  } else {");
         src.push("      vec4 worldPosition = worldMatrix * (positionsDecodeMatrix * vec4(position, 1.0)); ");
         if (scene.entityOffsetsEnabled) {

package/src/viewer/scene/model/vbo/batching/points/VBOBatchingPointsLayer.js

@@ -24,7 +24,7 @@ export class VBOBatchingPointsLayer {
      */
     constructor(cfg) {
 
-        console.info("Creating VBOBatchingPointsLayer");
+     //   console.info("Creating VBOBatchingPointsLayer");
 
         /**
          * Owner model
@@ -99,6 +99,11 @@ export class VBOBatchingPointsLayer {
             this.aabbDirty = false;
         }
         return this._aabb;
+
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.primitive;
     }
 
     /**

package/src/viewer/scene/model/vbo/batching/triangles/VBOBatchingTrianglesLayer.js

@@ -41,7 +41,7 @@ export class VBOBatchingTrianglesLayer {
      */
     constructor(cfg) {
 
-        console.info("Creating VBOBatchingTrianglesLayer");
+     //   console.info("Creating VBOBatchingTrianglesLayer");
 
         /**
          * Owner model
@@ -131,6 +131,11 @@ export class VBOBatchingTrianglesLayer {
          * @type {boolean}
          */
         this.solid = !!cfg.solid;
+
+        /**
+         * The type of primitives in this layer.
+         */
+        this.primitive = cfg.primitive;
     }
 
     get aabb() {
@@ -327,7 +332,7 @@ export class VBOBatchingTrianglesLayer {
             numIndices: indices.length,
         };
 
-        if (scene.pickSurfacePrecisionEnabled) {
+        if (scene.readableGeometryEnabled) {
             // Quantized in-memory positions are initialized in finalize()
 
             portion.indices = indices;
@@ -364,7 +369,7 @@ export 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;
@@ -793,7 +798,7 @@ export 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];
@@ -801,7 +806,7 @@ export class VBOBatchingTrianglesLayer {
     }
 
     getEachVertex(portionId, callback) {
-        if (!this.model.scene.pickSurfacePrecisionEnabled) {
+        if (!this.model.scene.readableGeometryEnabled) {
             return;
         }
         const state = this._state;
@@ -812,18 +817,19 @@ export 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 offsetX = origin[0] ;
+        const offsetY = origin[1] ;
+        const offsetZ = origin[2] ;
         const worldPos = tempVec4a;
+        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;
@@ -831,6 +837,21 @@ export 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;
@@ -851,14 +872,21 @@ export class VBOBatchingTrianglesLayer {
             return;
         }
         this._updateBackfaceCull(renderFlags, frameCtx);
+        const useAlphaCutoff = this._state.textureSet && (typeof(this._state.textureSet.alphaCutoff) === "number");
         if (frameCtx.withSAO && this.model.saoEnabled) {
             if (frameCtx.pbrEnabled && this.model.pbrEnabled && this._state.pbrSupported) {
                 if (this._renderers.pbrRendererWithSAO) {
                     this._renderers.pbrRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
                 }
             } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-                if (this._renderers.colorTextureRendererWithSAO) {
-                    this._renderers.colorTextureRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                if (useAlphaCutoff) {
+                    if (this._renderers.colorTextureRendererWithSAOAlphaCutoff) {
+                        this._renderers.colorTextureRendererWithSAOAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
+                } else {
+                    if (this._renderers.colorTextureRendererWithSAO) {
+                        this._renderers.colorTextureRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
                 }
             } else if (this._state.normalsBuf) {
                 if (this._renderers.colorRendererWithSAO) {
@@ -875,8 +903,14 @@ export class VBOBatchingTrianglesLayer {
                     this._renderers.pbrRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
                 }
             } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-                if (this._renderers.colorTextureRenderer) {
-                    this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                if (useAlphaCutoff) {
+                    if (this._renderers.colorTextureRendererAlphaCutoff) {
+                        this._renderers.colorTextureRendererAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
+                } else {
+                    if (this._renderers.colorTextureRenderer) {
+                        this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
                 }
             } else if (this._state.normalsBuf) {
                 if (this._renderers.colorRenderer) {
@@ -913,8 +947,15 @@ export class VBOBatchingTrianglesLayer {
                 this._renderers.pbrRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
             }
         } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-            if (this._renderers.colorTextureRenderer) {
-                this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
+            const useAlphaCutoff = this._state.textureSet && (typeof(this._state.textureSet.alphaCutoff) === "number");
+            if (useAlphaCutoff) {
+                if (this._renderers.colorTextureRendererAlphaCutoff) {
+                    this._renderers.colorTextureRendererAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
+                }
+            } else {
+                if (this._renderers.colorTextureRenderer) {
+                    this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
+                }
             }
         } else if (this._state.normalsBuf) {
             if (this._renderers.colorRenderer) {
@@ -1118,7 +1159,7 @@ export class VBOBatchingTrianglesLayer {
 
     precisionRayPickSurface(portionId, worldRayOrigin, worldRayDir, worldSurfacePos, worldNormal) {
 
-        if (!this.model.scene.pickSurfacePrecisionEnabled) {
+        if (!this.model.scene.readableGeometryEnabled) {
             return false;
         }