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

package/dist/xeokit-sdk.es.js

@@ -65787,9 +65787,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) {
@@ -78671,13 +78681,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 = [];
@@ -79248,16 +79273,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";
         }
@@ -79265,8 +79291,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);
@@ -79278,16 +79307,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";
         }
@@ -79295,8 +79325,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);
@@ -79308,16 +79341,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";
         }
@@ -79325,8 +79359,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);
@@ -79338,16 +79375,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";
         }
@@ -79355,8 +79393,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);
@@ -79368,16 +79409,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";
         }
@@ -79385,8 +79427,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);
@@ -79398,16 +79443,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";
         }
@@ -79415,8 +79461,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);
@@ -79428,7 +79477,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.
      *
@@ -79438,8 +79488,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) {
@@ -79449,8 +79499,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);
@@ -79558,7 +79611,6 @@ class TrianglesDataTextureLayer {
         this._state = new RenderState({
             origin: math.vec3(cfg.origin),
             metallicRoughnessBuf: null,
-            positionsDecodeMatrix: math.mat4(),
             textureState: this._dataTextureState,
             numIndices8Bits: 0,
             numIndices16Bits: 0,
@@ -79743,12 +79795,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;
@@ -79757,15 +79808,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;
@@ -79775,15 +79829,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;
@@ -79954,7 +80011,6 @@ class TrianglesDataTextureLayer {
         const buffer = this._buffer;
 
         state.gl = gl;
-
         textureState.texturePerObjectIdColorsAndFlags = this._dataTextureGenerator.generateTextureForColorsAndFlags(
             gl,
             buffer.perObjectColors,
@@ -79972,9 +80028,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,
@@ -80000,47 +80064,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();