@xeokit/xeokit-sdk 2.4.1 → 2.4.2-beta-1

package/dist/xeokit-sdk.cjs.js

@@ -65791,9 +65791,19 @@ class TrianglesInstancingLayer {
             return;
         }
         this._updateBackfaceCull(renderFlags, frameCtx);
-        if (this._instancingRenderers.pickNormalsRenderer) {
-            this._instancingRenderers.pickNormalsRenderer.drawLayer(frameCtx, this, RENDER_PASSES.PICK);
-        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////////
+        // TODO
+        // if (this._state.normalsBuf) {
+        //     if (this._instancingRenderers.pickNormalsRenderer) {
+        //         this._instancingRenderers.pickNormalsRenderer.drawLayer(frameCtx, this, RENDER_PASSES.PICK);
+        //     }
+        ////////////////////////////////////////////////////////////////////////////////////////////////////
+        // } else {
+            if (this._instancingRenderers.pickNormalsFlatRenderer) {
+                this._instancingRenderers.pickNormalsFlatRenderer.drawLayer(frameCtx, this, RENDER_PASSES.PICK);
+            }
+        // }
     }
 
     drawSnapInitDepthBuf(renderFlags, frameCtx) {
@@ -78675,13 +78685,28 @@ class TrianglesDataTextureBuffer {
 
     constructor() {
         this.positionsCompressed = [];
+        this.lenPositionsCompressed = 0;
+
         this.metallicRoughness = [];
+
         this.indices8Bits = [];
+        this.lenIndices8Bits = 0;
+
         this.indices16Bits = [];
+        this.lenIndices16Bits = 0;
+
         this.indices32Bits = [];
+        this.lenIndices32Bits = 0;
+
         this.edgeIndices8Bits = [];
+        this.lenEdgeIndices8Bits = 0;
+
         this.edgeIndices16Bits = [];
+        this.lenEdgeIndices16Bits = 0;
+
         this.edgeIndices32Bits = [];
+        this.lenEdgeIndices32Bits = 0;
+
         this.perObjectColors = [];
         this.perObjectPickColors = [];
         this.perObjectSolid = [];
@@ -79252,16 +79277,17 @@ class DataTextureGenerator {
 
     /**
      * @param {WebGL2RenderingContext} gl
-     * @param {ArrayLike<int>} indices
+     * @param indicesArrays
+     * @param lenIndices
      *
      * @returns {BindableDataTexture}
      */
-    generateTextureFor8BitIndices(gl, indices) {
-        if (indices.length === 0) {
+    generateTextureFor8BitIndices(gl, indicesArrays, lenIndices) {
+        if (lenIndices === 0) {
             return {texture: null, textureHeight: 0,};
         }
         const textureWidth = 4096;
-        const textureHeight = Math.ceil(indices.length / 3 / textureWidth);
+        const textureHeight = Math.ceil(lenIndices / 3 / textureWidth);
         if (textureHeight === 0) {
             throw "texture height===0";
         }
@@ -79269,8 +79295,11 @@ class DataTextureGenerator {
         const texArray = new Uint8Array(texArraySize);
         dataTextureRamStats.sizeDataTextureIndices += texArray.byteLength;
         dataTextureRamStats.numberOfTextures++;
-        texArray.fill(0);
-        texArray.set(indices, 0);
+        for (let i = 0, j = 0, len = indicesArrays.length; i < len; i++) {
+            const pc = indicesArrays[i];
+            texArray.set(pc, j);
+            j += pc.length;
+        }
         const texture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGB8UI, textureWidth, textureHeight);
@@ -79282,16 +79311,17 @@ class DataTextureGenerator {
 
     /**
      * @param {WebGL2RenderingContext} gl
-     * @param {ArrayLike<int>} indices
+     * @param indicesArrays
+     * @param lenIndices
      *
      * @returns {BindableDataTexture}
      */
-    generateTextureFor16BitIndices(gl, indices) {
-        if (indices.length === 0) {
+    generateTextureFor16BitIndices(gl, indicesArrays, lenIndices) {
+        if (lenIndices === 0) {
             return {texture: null, textureHeight: 0,};
         }
         const textureWidth = 4096;
-        const textureHeight = Math.ceil(indices.length / 3 / textureWidth);
+        const textureHeight = Math.ceil(lenIndices / 3 / textureWidth);
         if (textureHeight === 0) {
             throw "texture height===0";
         }
@@ -79299,8 +79329,11 @@ class DataTextureGenerator {
         const texArray = new Uint16Array(texArraySize);
         dataTextureRamStats.sizeDataTextureIndices += texArray.byteLength;
         dataTextureRamStats.numberOfTextures++;
-        texArray.fill(0);
-        texArray.set(indices, 0);
+        for (let i = 0, j = 0, len = indicesArrays.length; i < len; i++) {
+            const pc = indicesArrays[i];
+            texArray.set(pc, j);
+            j += pc.length;
+        }
         const texture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGB16UI, textureWidth, textureHeight);
@@ -79312,16 +79345,17 @@ class DataTextureGenerator {
 
     /**
      * @param {WebGL2RenderingContext} gl
-     * @param {ArrayLike<int>} indices
+     * @param indicesArrays
+     * @param lenIndices
      *
      * @returns {BindableDataTexture}
      */
-    generateTextureFor32BitIndices(gl, indices) {
-        if (indices.length === 0) {
-            return {texture: null, textureHeight: 0};
+    generateTextureFor32BitIndices(gl, indicesArrays, lenIndices) {
+        if (lenIndices === 0) {
+            return {texture: null, textureHeight: 0,};
         }
         const textureWidth = 4096;
-        const textureHeight = Math.ceil(indices.length / 3 / textureWidth);
+        const textureHeight = Math.ceil(lenIndices / 3 / textureWidth);
         if (textureHeight === 0) {
             throw "texture height===0";
         }
@@ -79329,8 +79363,11 @@ class DataTextureGenerator {
         const texArray = new Uint32Array(texArraySize);
         dataTextureRamStats.sizeDataTextureIndices += texArray.byteLength;
         dataTextureRamStats.numberOfTextures++;
-        texArray.fill(0);
-        texArray.set(indices, 0);
+        for (let i = 0, j = 0, len = indicesArrays.length; i < len; i++) {
+            const pc = indicesArrays[i];
+            texArray.set(pc, j);
+            j += pc.length;
+        }
         const texture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGB32UI, textureWidth, textureHeight);
@@ -79342,16 +79379,17 @@ class DataTextureGenerator {
 
     /**
      * @param {WebGL2RenderingContext} gl
-     * @param {ArrayLike<int>} edgeIndices
+     * @param indicesArrays
+     * @param lenIndices
      *
      * @returns {BindableDataTexture}
      */
-    generateTextureFor8BitsEdgeIndices(gl, edgeIndices) {
-        if (edgeIndices.length === 0) {
-            return {texture: null, textureHeight: 0};
+    generateTextureFor8BitsEdgeIndices(gl, indicesArrays, lenIndices) {
+        if (lenIndices === 0) {
+            return {texture: null, textureHeight: 0,};
         }
         const textureWidth = 4096;
-        const textureHeight = Math.ceil(edgeIndices.length / 2 / textureWidth);
+        const textureHeight = Math.ceil(lenIndices / 2 / textureWidth);
         if (textureHeight === 0) {
             throw "texture height===0";
         }
@@ -79359,8 +79397,11 @@ class DataTextureGenerator {
         const texArray = new Uint8Array(texArraySize);
         dataTextureRamStats.sizeDataTextureEdgeIndices += texArray.byteLength;
         dataTextureRamStats.numberOfTextures++;
-        texArray.fill(0);
-        texArray.set(edgeIndices, 0);
+        for (let i = 0, j = 0, len = indicesArrays.length; i < len; i++) {
+            const pc = indicesArrays[i];
+            texArray.set(pc, j);
+            j += pc.length;
+        }
         const texture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RG8UI, textureWidth, textureHeight);
@@ -79372,16 +79413,17 @@ class DataTextureGenerator {
 
     /**
      * @param {WebGL2RenderingContext} gl
-     * @param {ArrayLike<int>} edgeIndices
+     * @param indicesArrays
+     * @param lenIndices
      *
      * @returns {BindableDataTexture}
      */
-    generateTextureFor16BitsEdgeIndices(gl, edgeIndices) {
-        if (edgeIndices.length === 0) {
-            return {texture: null, textureHeight: 0};
+    generateTextureFor16BitsEdgeIndices(gl, indicesArrays, lenIndices) {
+        if (lenIndices === 0) {
+            return {texture: null, textureHeight: 0,};
         }
         const textureWidth = 4096;
-        const textureHeight = Math.ceil(edgeIndices.length / 2 / textureWidth);
+        const textureHeight = Math.ceil(lenIndices / 2 / textureWidth);
         if (textureHeight === 0) {
             throw "texture height===0";
         }
@@ -79389,8 +79431,11 @@ class DataTextureGenerator {
         const texArray = new Uint16Array(texArraySize);
         dataTextureRamStats.sizeDataTextureEdgeIndices += texArray.byteLength;
         dataTextureRamStats.numberOfTextures++;
-        texArray.fill(0);
-        texArray.set(edgeIndices, 0);
+        for (let i = 0, j = 0, len = indicesArrays.length; i < len; i++) {
+            const pc = indicesArrays[i];
+            texArray.set(pc, j);
+            j += pc.length;
+        }
         const texture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RG16UI, textureWidth, textureHeight);
@@ -79402,16 +79447,17 @@ class DataTextureGenerator {
 
     /**
      * @param {WebGL2RenderingContext} gl
-     * @param {ArrayLike<int>} edgeIndices
+     * @param indicesArrays
+     * @param lenIndices
      *
      * @returns {BindableDataTexture}
      */
-    generateTextureFor32BitsEdgeIndices(gl, edgeIndices) {
-        if (edgeIndices.length === 0) {
+    generateTextureFor32BitsEdgeIndices(gl, indicesArrays, lenIndices) {
+        if (lenIndices === 0) {
             return {texture: null, textureHeight: 0,};
         }
         const textureWidth = 4096;
-        const textureHeight = Math.ceil(edgeIndices.length / 2 / textureWidth);
+        const textureHeight = Math.ceil(lenIndices / 2 / textureWidth);
         if (textureHeight === 0) {
             throw "texture height===0";
         }
@@ -79419,8 +79465,11 @@ class DataTextureGenerator {
         const texArray = new Uint32Array(texArraySize);
         dataTextureRamStats.sizeDataTextureEdgeIndices += texArray.byteLength;
         dataTextureRamStats.numberOfTextures++;
-        texArray.fill(0);
-        texArray.set(edgeIndices, 0);
+        for (let i = 0, j = 0, len = indicesArrays.length; i < len; i++) {
+            const pc = indicesArrays[i];
+            texArray.set(pc, j);
+            j += pc.length;
+        }
         const texture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RG32UI, textureWidth, textureHeight);
@@ -79432,7 +79481,8 @@ class DataTextureGenerator {
 
     /**
      * @param {WebGL2RenderingContext} gl
-     * @param {ArrayLike<int>} positions Array of (uniquified) quantized positions in the layer
+     * @param {ArrayLike<int>} positionsArrays Arrays of  quantized positions in the layer
+     * @param lenPositions
      *
      * This will generate a texture for positions in the layer.
      *
@@ -79442,8 +79492,8 @@ class DataTextureGenerator {
      *
      * @returns {BindableDataTexture}
      */
-    generateTextureForPositions(gl, positions) {
-        const numVertices = positions.length / 3;
+    generateTextureForPositions(gl, positionsArrays, lenPositions) {
+        const numVertices = lenPositions / 3;
         const textureWidth = 4096;
         const textureHeight = Math.ceil(numVertices / textureWidth);
         if (textureHeight === 0) {
@@ -79453,8 +79503,11 @@ class DataTextureGenerator {
         const texArray = new Uint16Array(texArraySize);
         dataTextureRamStats.sizeDataTexturePositions += texArray.byteLength;
         dataTextureRamStats.numberOfTextures++;
-        texArray.fill(0);
-        texArray.set(positions, 0);
+        for (let i = 0, j = 0, len = positionsArrays.length; i < len; i++) {
+            const pc = positionsArrays[i];
+            texArray.set(pc, j);
+            j += pc.length;
+        }
         const texture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGB16UI, textureWidth, textureHeight);
@@ -79562,7 +79615,6 @@ class TrianglesDataTextureLayer {
         this._state = new RenderState({
             origin: math.vec3(cfg.origin),
             metallicRoughnessBuf: null,
-            positionsDecodeMatrix: math.mat4(),
             textureState: this._dataTextureState,
             numIndices8Bits: 0,
             numIndices16Bits: 0,
@@ -79747,12 +79799,11 @@ class TrianglesDataTextureLayer {
         const indices = bucket.indices;
         const edgeIndices = bucket.edgeIndices;
         const buffer = this._buffer;
-        const vertexBase = buffer.positionsCompressed.length / 3;
-        const numVertices = positionsCompressed.length / 3;
 
-        for (let i = 0, len = positionsCompressed.length; i < len; i++) {
-            buffer.positionsCompressed.push(positionsCompressed[i]);
-        }
+        buffer.positionsCompressed.push(positionsCompressed);
+        const vertexBase = buffer.lenPositionsCompressed / 3;
+        const numVertices = positionsCompressed.length / 3;
+        buffer.lenPositionsCompressed += positionsCompressed.length;
 
         let indicesBase;
         let numTriangles = 0;
@@ -79761,15 +79812,18 @@ class TrianglesDataTextureLayer {
             let indicesBuffer;
             if (numVertices <= (1 << 8)) {
                 indicesBuffer = buffer.indices8Bits;
+                indicesBase = buffer.lenIndices8Bits / 3;
+                buffer.lenIndices8Bits += indices.length;
             } else if (numVertices <= (1 << 16)) {
                 indicesBuffer = buffer.indices16Bits;
+                indicesBase = buffer.lenIndices16Bits / 3;
+                buffer.lenIndices16Bits += indices.length;
             } else {
                 indicesBuffer = buffer.indices32Bits;
+                indicesBase = buffer.lenIndices32Bits / 3;
+                buffer.lenIndices32Bits += indices.length;
             }
-            indicesBase = indicesBuffer.length / 3;
-            for (let i = 0, len = indices.length; i < len; i++) {
-                indicesBuffer.push(indices[i]);
-            }
+            indicesBuffer.push(indices);
         }
 
         let edgeIndicesBase;
@@ -79779,15 +79833,18 @@ class TrianglesDataTextureLayer {
             let edgeIndicesBuffer;
             if (numVertices <= (1 << 8)) {
                 edgeIndicesBuffer = buffer.edgeIndices8Bits;
+                edgeIndicesBase = buffer.lenEdgeIndices8Bits / 2;
+                buffer.lenEdgeIndices8Bits += edgeIndices.length;
             } else if (numVertices <= (1 << 16)) {
                 edgeIndicesBuffer = buffer.edgeIndices16Bits;
+                edgeIndicesBase = buffer.lenEdgeIndices16Bits / 2;
+                buffer.lenEdgeIndices16Bits += edgeIndices.length;
             } else {
                 edgeIndicesBuffer = buffer.edgeIndices32Bits;
+                edgeIndicesBase = buffer.lenEdgeIndices32Bits / 2;
+                buffer.lenEdgeIndices32Bits += edgeIndices.length;
             }
-            edgeIndicesBase = edgeIndicesBuffer.length / 2;
-            for (let i = 0, len = edgeIndices.length; i < len; i++) {
-                edgeIndicesBuffer.push(edgeIndices[i]);
-            }
+            edgeIndicesBuffer.push(edgeIndices);
         }
 
         this._state.numVertices += numVertices;
@@ -79958,7 +80015,6 @@ class TrianglesDataTextureLayer {
         const buffer = this._buffer;
 
         state.gl = gl;
-
         textureState.texturePerObjectIdColorsAndFlags = this._dataTextureGenerator.generateTextureForColorsAndFlags(
             gl,
             buffer.perObjectColors,
@@ -79976,9 +80032,17 @@ class TrianglesDataTextureLayer {
             buffer.perObjectPositionsDecodeMatrices,
             buffer.perObjectInstancePositioningMatrices);
 
+        // const positionsCompressed = new Uint16Array(buffer.lenPositionsCompressed);
+        // for (let i = 0, j = 0, len = buffer.positionsCompressed.length; i < len; i++) {
+        //     const pc = buffer.positionsCompressed[i];
+        //     positionsCompressed.set(pc, j);
+        //     j += pc.length;
+        // }
+
         textureState.texturePerVertexIdCoordinates = this._dataTextureGenerator.generateTextureForPositions(
             gl,
-            buffer.positionsCompressed);
+            buffer.positionsCompressed,
+            buffer.lenPositionsCompressed );
 
         textureState.texturePerPolygonIdPortionIds8Bits = this._dataTextureGenerator.generateTextureForPackedPortionIds(
             gl,
@@ -80004,47 +80068,46 @@ class TrianglesDataTextureLayer {
                 buffer.perEdgeNumberPortionId16Bits);
         }
 
-
         if (buffer.perEdgeNumberPortionId32Bits.length > 0) {
             textureState.texturePerEdgeIdPortionIds32Bits = this._dataTextureGenerator.generateTextureForPackedPortionIds(
                 gl,
                 buffer.perEdgeNumberPortionId32Bits);
         }
 
-        if (buffer.indices8Bits.length > 0) {
+        if (buffer.lenIndices8Bits > 0) {
             textureState.texturePerPolygonIdIndices8Bits = this._dataTextureGenerator.generateTextureFor8BitIndices(
                 gl,
-                buffer.indices8Bits);
+                buffer.indices8Bits, buffer.lenIndices8Bits);
         }
 
-        if (buffer.indices16Bits.length > 0) {
+        if (buffer.lenIndices16Bits > 0) {
             textureState.texturePerPolygonIdIndices16Bits = this._dataTextureGenerator.generateTextureFor16BitIndices(
                 gl,
-                buffer.indices16Bits);
+                buffer.indices16Bits, buffer.lenIndices16Bits);
         }
 
-        if (buffer.indices32Bits.length > 0) {
+        if (buffer.lenIndices32Bits > 0) {
             textureState.texturePerPolygonIdIndices32Bits = this._dataTextureGenerator.generateTextureFor32BitIndices(
                 gl,
-                buffer.indices32Bits);
+                buffer.indices32Bits, buffer.lenIndices32Bits);
         }
 
-        if (buffer.edgeIndices8Bits.length > 0) {
+        if (buffer.lenEdgeIndices8Bits > 0) {
             textureState.texturePerPolygonIdEdgeIndices8Bits = this._dataTextureGenerator.generateTextureFor8BitsEdgeIndices(
                 gl,
-                buffer.edgeIndices8Bits);
+                buffer.edgeIndices8Bits, buffer.lenEdgeIndices8Bits);
         }
 
-        if (buffer.edgeIndices16Bits.length > 0) {
+        if (buffer.lenEdgeIndices16Bits > 0) {
             textureState.texturePerPolygonIdEdgeIndices16Bits = this._dataTextureGenerator.generateTextureFor16BitsEdgeIndices(
                 gl,
-                buffer.edgeIndices16Bits);
+                buffer.edgeIndices16Bits, buffer.lenEdgeIndices16Bits);
         }
 
-        if (buffer.edgeIndices32Bits.length > 0) {
+        if (buffer.lenEdgeIndices32Bits > 0) {
             textureState.texturePerPolygonIdEdgeIndices32Bits = this._dataTextureGenerator.generateTextureFor32BitsEdgeIndices(
                 gl,
-                buffer.edgeIndices32Bits);
+                buffer.edgeIndices32Bits, buffer.lenEdgeIndices32Bits);
         }
 
         textureState.finalize();