@xeokit/xeokit-sdk 2.6.85-renderers-refactor-v2 → 2.6.86

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

@@ -0,0 +1,46 @@
+/**
+ * @private
+ */
+export class DTXLinesState {
+
+    constructor() {
+        this.texturePerObjectColorsAndFlags = null;
+        this.texturePerObjectOffsets = null;
+        this.texturePerObjectInstanceMatrices = null;
+        this.texturePerObjectPositionsDecodeMatrix = null;
+        this.texturePerVertexIdCoordinates = null;
+        this.texturePerLineIdPortionIds8Bits = null;
+        this.texturePerLineIdPortionIds16Bits = null;
+        this.texturePerLineIdPortionIds32Bits = null;
+        this.texturePerLineIdIndices8Bits = null;
+        this.texturePerLineIdIndices16Bits = null;
+        this.texturePerLineIdIndices32Bits = null;
+        this.textureModelMatrices = null;
+    }
+
+    finalize() {
+        this.indicesPerBitnessTextures = {
+            8: this.texturePerLineIdIndices8Bits,
+            16: this.texturePerLineIdIndices16Bits,
+            32: this.texturePerLineIdIndices32Bits,
+        };
+        this.indicesPortionIdsPerBitnessTextures = {
+            8: this.texturePerLineIdPortionIds8Bits,
+            16: this.texturePerLineIdPortionIds16Bits,
+            32: this.texturePerLineIdPortionIds32Bits,
+        };
+    }
+
+    bindCommonTextures(glProgram, objectDecodeMatricesShaderName, vertexTextureShaderName, objectAttributesTextureShaderName, objectMatricesShaderName) {
+        this.texturePerObjectPositionsDecodeMatrix.bindTexture(glProgram, objectDecodeMatricesShaderName, 1);
+        this.texturePerVertexIdCoordinates.bindTexture(glProgram, vertexTextureShaderName, 2);
+        this.texturePerObjectColorsAndFlags.bindTexture(glProgram, objectAttributesTextureShaderName, 3);
+        this.texturePerObjectInstanceMatrices.bindTexture(glProgram, objectMatricesShaderName, 4);
+    }
+
+    bindLineIndicesTextures(glProgram, portionIdsShaderName, lineIndicesShaderName, textureBitness) {
+        this.indicesPortionIdsPerBitnessTextures[textureBitness].bindTexture(glProgram, portionIdsShaderName, 5);
+        this.indicesPerBitnessTextures[textureBitness].bindTexture(glProgram, lineIndicesShaderName, 6);
+    }
+}
+

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

@@ -0,0 +1,411 @@
+import {BindableDataTexture} from "./../BindableDataTexture.js";
+import {dataTextureRamStats} from "./dataTextureRamStats.js";
+
+/**
+ * @private
+ */
+export class DTXLinesTextureFactory {
+    /**
+     * Enables the currently binded ````WebGLTexture```` to be used as a data texture.
+     *
+     * @param {WebGL2RenderingContext} gl
+     *
+     * @private
+     */
+    disableBindedTextureFiltering(gl) {
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    }
+
+    /**
+     * This will generate an RGBA texture for:
+     * - colors
+     * - pickColors
+     * - flags
+     * - flags2
+     * - vertex bases
+     * - vertex base offsets
+     *
+     * The texture will have:
+     * - 4 RGBA columns per row: for each object (pick) color and flags(2)
+     * - N rows where N is the number of objects
+     *
+     * @param {WebGL2RenderingContext} gl
+     * @param {ArrayLike<ArrayLike<int>>} colors Array of colors for all objects in the layer
+     * @param {ArrayLike<ArrayLike<int>>} pickColors Array of pickColors for all objects in the layer
+     * @param {ArrayLike<int>} vertexBases Array of position-index-bases foteh all objects in the layer
+     * @param {ArrayLike<int>} indexBaseOffsets For lines: array of offests between the (gl_VertexID / 2) and the position where the indices start in the texture layer
+     *
+     * @returns {BindableDataTexture}
+     */
+    generateTextureForColorsAndFlags(gl, colors, pickColors, vertexBases, indexBaseOffsets) {
+        const numPortions = colors.length;
+
+        // The number of rows in the texture is the number of
+        // objects in the layer.
+
+        this.numPortions = numPortions;
+
+        const textureWidth = 512 * 8;
+        const textureHeight = Math.ceil(numPortions / (textureWidth / 8));
+
+        if (textureHeight === 0) {
+            throw "texture height===0";
+        }
+
+        // 8 columns per texture row:
+        // - col0: (RGBA) object color RGBA
+        // - col1: (packed Uint32 as RGBA) object pick color
+        // - col2: (packed 4 bytes as RGBA) object flags
+        // - col3: (packed 4 bytes as RGBA) object flags2
+        // - col4: (packed Uint32 bytes as RGBA) vertex base
+        // - col5: (packed Uint32 bytes as RGBA) index base offset
+
+
+       // // - col6: (packed Uint32 bytes as RGBA) edge index base offset
+       // // - col7: (packed 4 bytes as RGBA) is-solid flag for objects
+
+        const texArray = new Uint8Array(4 * textureWidth * textureHeight);
+
+        dataTextureRamStats.sizeDataColorsAndFlags += texArray.byteLength;
+        dataTextureRamStats.numberOfTextures++;
+
+        for (let i = 0; i < numPortions; i++) {
+            // object color
+            texArray.set(colors [i], i * 32 + 0);
+            texArray.set(pickColors [i], i * 32 + 4); // object pick color
+            texArray.set([0, 0, 0, 0], i * 32 + 8);     // object flags
+            texArray.set([0, 0, 0, 0], i * 32 + 12);        // object flags2
+
+            // vertex base
+            texArray.set([
+                    (vertexBases[i] >> 24) & 255,
+                    (vertexBases[i] >> 16) & 255,
+                    (vertexBases[i] >> 8) & 255,
+                    (vertexBases[i]) & 255,
+                ],
+                i * 32 + 16
+            );
+
+            // lines index base offset
+            texArray.set(
+                [
+                    (indexBaseOffsets[i] >> 24) & 255,
+                    (indexBaseOffsets[i] >> 16) & 255,
+                    (indexBaseOffsets[i] >> 8) & 255,
+                    (indexBaseOffsets[i]) & 255,
+                ],
+                i * 32 + 20
+            );
+
+            // // edge index base offset
+            // texArray.set(
+            //     [
+            //         (edgeIndexBaseOffsets[i] >> 24) & 255,
+            //         (edgeIndexBaseOffsets[i] >> 16) & 255,
+            //         (edgeIndexBaseOffsets[i] >> 8) & 255,
+            //         (edgeIndexBaseOffsets[i]) & 255,
+            //     ],
+            //     i * 32 + 24
+            // );
+            //
+            // // is-solid flag
+            // texArray.set([solid[i] ? 1 : 0, 0, 0, 0], i * 32 + 28);
+        }
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8UI, textureWidth, textureHeight);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, textureWidth, textureHeight, gl.RGBA_INTEGER, gl.UNSIGNED_BYTE, texArray, 0);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return new BindableDataTexture(gl, texture, textureWidth, textureHeight, texArray);
+    }
+
+    /**
+     * This will generate a texture for all object offsets.
+     *
+     * @param {WebGL2RenderingContext} gl
+     * @param {int[]} offsets Array of int[3], one XYZ offset array for each object
+     *
+     * @returns {BindableDataTexture}
+     */
+    generateTextureForObjectOffsets(gl, numOffsets) {
+        const textureWidth = 512;
+        const textureHeight = Math.ceil(numOffsets / textureWidth);
+        if (textureHeight === 0) {
+            throw "texture height===0";
+        }
+        const texArray = new Float32Array(3 * textureWidth * textureHeight).fill(0);
+        dataTextureRamStats.sizeDataTextureOffsets += texArray.byteLength;
+        dataTextureRamStats.numberOfTextures++;
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGB32F, textureWidth, textureHeight);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, textureWidth, textureHeight, gl.RGB, gl.FLOAT, texArray, 0);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return new BindableDataTexture(gl, texture, textureWidth, textureHeight, texArray);
+    }
+
+    /**
+     * This will generate a texture for all positions decode matrices in the layer.
+     *
+     * The texture will have:
+     * - 4 RGBA columns per row (each column will contain 4 packed half-float (16 bits) components).
+     *   Thus, each row will contain 16 packed half-floats corresponding to a complete positions decode matrix)
+     * - N rows where N is the number of objects
+     *
+     * @param {WebGL2RenderingContext} gl
+    * @param {ArrayLike<Matrix4x4>} instanceMatrices Array of geometry instancing matrices for all objects in the layer. Null if the objects are not instanced.
+     *
+     * @returns {BindableDataTexture}
+     */
+    generateTextureForInstancingMatrices(gl, instanceMatrices) {
+        const numMatrices = instanceMatrices.length;
+        if (numMatrices === 0) {
+            throw "num instance matrices===0";
+        }
+        // in one row we can fit 512 matrices
+        const textureWidth = 512 * 4;
+        const textureHeight = Math.ceil(numMatrices / (textureWidth / 4));
+        const texArray = new Float32Array(4 * textureWidth * textureHeight);
+       // dataTextureRamStats.sizeDataPositionDecodeMatrices += texArray.byteLength;
+        dataTextureRamStats.numberOfTextures++;
+        for (let i = 0; i < instanceMatrices.length; i++) {            // 4x4 values
+            texArray.set(instanceMatrices[i], i * 16);
+        }
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA32F, textureWidth, textureHeight);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, textureWidth, textureHeight, gl.RGBA, gl.FLOAT, texArray, 0);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return new BindableDataTexture(gl, texture, textureWidth, textureHeight, texArray);
+    }
+
+    /**
+     * This will generate a texture for all positions decode matrices in the layer.
+     *
+     * The texture will have:
+     * - 4 RGBA columns per row (each column will contain 4 packed half-float (16 bits) components).
+     *   Thus, each row will contain 16 packed half-floats corresponding to a complete positions decode matrix)
+     * - N rows where N is the number of objects
+     *
+     * @param {WebGL2RenderingContext} gl
+     * @param {ArrayLike<Matrix4x4>} positionDecodeMatrices Array of positions decode matrices for all objects in the layer
+     *
+     * @returns {BindableDataTexture}
+     */
+    generateTextureForPositionsDecodeMatrices(gl, positionDecodeMatrices) {
+        const numMatrices = positionDecodeMatrices.length;
+        if (numMatrices === 0) {
+            throw "num decode+entity matrices===0";
+        }
+        // in one row we can fit 512 matrices
+        const textureWidth = 512 * 4;
+        const textureHeight = Math.ceil(numMatrices / (textureWidth / 4));
+        const texArray = new Float32Array(4 * textureWidth * textureHeight);
+        dataTextureRamStats.sizeDataPositionDecodeMatrices += texArray.byteLength;
+        dataTextureRamStats.numberOfTextures++;
+        for (let i = 0; i < positionDecodeMatrices.length; i++) {            // 4x4 values
+            texArray.set(positionDecodeMatrices[i], i * 16);
+        }
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA32F, textureWidth, textureHeight);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, textureWidth, textureHeight, gl.RGBA, gl.FLOAT, texArray, 0);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return new BindableDataTexture(gl, texture, textureWidth, textureHeight);
+    }
+
+    /**
+     * @param {WebGL2RenderingContext} gl
+     * @param indicesArrays
+     * @param lenIndices
+     *
+     * @returns {BindableDataTexture}
+     */
+    generateTextureFor8BitIndices(gl, indicesArrays, lenIndices) {
+        if (lenIndices === 0) {
+            return {texture: null, textureHeight: 0,};
+        }
+        const textureWidth = 4096;
+        const textureHeight = Math.ceil(lenIndices / 3 / textureWidth);
+        if (textureHeight === 0) {
+            throw "texture height===0";
+        }
+        const texArraySize = textureWidth * textureHeight * 3;
+        const texArray = new Uint8Array(texArraySize);
+        dataTextureRamStats.sizeDataTextureIndices += texArray.byteLength;
+        dataTextureRamStats.numberOfTextures++;
+        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);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, textureWidth, textureHeight, gl.RGB_INTEGER, gl.UNSIGNED_BYTE, texArray, 0);
+        this.disableBindedTextureFiltering(gl);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return new BindableDataTexture(gl, texture, textureWidth, textureHeight);
+    }
+
+    /**
+     * @param {WebGL2RenderingContext} gl
+     * @param indicesArrays
+     * @param lenIndices
+     *
+     * @returns {BindableDataTexture}
+     */
+    generateTextureFor16BitIndices(gl, indicesArrays, lenIndices) {
+        if (lenIndices === 0) {
+            return {texture: null, textureHeight: 0,};
+        }
+        const textureWidth = 4096;
+        const textureHeight = Math.ceil(lenIndices / 3 / textureWidth);
+        if (textureHeight === 0) {
+            throw "texture height===0";
+        }
+        const texArraySize = textureWidth * textureHeight * 3;
+        const texArray = new Uint16Array(texArraySize);
+        dataTextureRamStats.sizeDataTextureIndices += texArray.byteLength;
+        dataTextureRamStats.numberOfTextures++;
+        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);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, textureWidth, textureHeight, gl.RGB_INTEGER, gl.UNSIGNED_SHORT, texArray, 0);
+        this.disableBindedTextureFiltering(gl);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return new BindableDataTexture(gl, texture, textureWidth, textureHeight);
+    }
+
+    /**
+     * @param {WebGL2RenderingContext} gl
+     * @param indicesArrays
+     * @param lenIndices
+     *
+     * @returns {BindableDataTexture}
+     */
+    generateTextureFor32BitIndices(gl, indicesArrays, lenIndices) {
+        if (lenIndices === 0) {
+            return {texture: null, textureHeight: 0,};
+        }
+        const textureWidth = 4096;
+        const textureHeight = Math.ceil(lenIndices / 3 / textureWidth);
+        if (textureHeight === 0) {
+            throw "texture height===0";
+        }
+        const texArraySize = textureWidth * textureHeight * 3;
+        const texArray = new Uint32Array(texArraySize);
+        dataTextureRamStats.sizeDataTextureIndices += texArray.byteLength;
+        dataTextureRamStats.numberOfTextures++;
+        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);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, textureWidth, textureHeight, gl.RGB_INTEGER, gl.UNSIGNED_INT, texArray, 0);
+        this.disableBindedTextureFiltering(gl);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return new BindableDataTexture(gl, texture, textureWidth, textureHeight);
+    }
+
+    /**
+     * @param {WebGL2RenderingContext} gl
+     * @param {ArrayLike<int>} positionsArrays Arrays of  quantized positions in the layer
+     * @param lenPositions
+     *
+     * This will generate a texture for positions in the layer.
+     *
+     * The texture will have:
+     * - 1024 columns, where each pixel will be a 16-bit-per-component RGB texture, corresponding to the XYZ of the position
+     * - a number of rows R where R*1024 is just >= than the number of vertices (positions / 3)
+     *
+     * @returns {BindableDataTexture}
+     */
+    generateTextureForPositions(gl, positionsArrays, lenPositions) {
+        const numVertices = lenPositions / 3;
+        const textureWidth = 4096;
+        const textureHeight = Math.ceil(numVertices / textureWidth);
+        if (textureHeight === 0) {
+            throw "texture height===0";
+        }
+        const texArraySize = textureWidth * textureHeight * 3;
+        const texArray = new Uint16Array(texArraySize);
+        dataTextureRamStats.sizeDataTexturePositions += texArray.byteLength;
+        dataTextureRamStats.numberOfTextures++;
+        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);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, textureWidth, textureHeight, gl.RGB_INTEGER, gl.UNSIGNED_SHORT, texArray, 0);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return new BindableDataTexture(gl, texture, textureWidth, textureHeight);
+    }
+
+    /**
+     * @param {WebGL2RenderingContext} gl
+     * @param {ArrayLike<int>} portionIdsArray
+     *
+     * @returns {BindableDataTexture}
+     */
+    generateTextureForPackedPortionIds(gl, portionIdsArray) {
+        if (portionIdsArray.length === 0) {
+            return {texture: null, textureHeight: 0};
+        }
+        const lenArray = portionIdsArray.length;
+        const textureWidth = 4096;
+        const textureHeight = Math.ceil(lenArray / textureWidth);
+        if (textureHeight === 0) {
+            throw "texture height===0";
+        }
+        const texArraySize = textureWidth * textureHeight;
+        const texArray = new Uint16Array(texArraySize);
+        texArray.set(portionIdsArray, 0);
+        dataTextureRamStats.sizeDataTexturePortionIds += texArray.byteLength;
+        dataTextureRamStats.numberOfTextures++;
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texStorage2D(gl.TEXTURE_2D, 1, gl.R16UI, textureWidth, textureHeight);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, textureWidth, textureHeight, gl.RED_INTEGER, gl.UNSIGNED_SHORT, texArray, 0);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return new BindableDataTexture(gl, texture, textureWidth, textureHeight);
+    }
+}

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

@@ -0,0 +1,49 @@
+export const dataTextureRamStats = {
+    sizeDataColorsAndFlags: 0,
+    sizeDataPositionDecodeMatrices: 0,
+    sizeDataTextureOffsets: 0,
+    sizeDataTexturePositions: 0,
+    sizeDataTextureIndices: 0,
+    sizeDataTexturePortionIds: 0,
+    numberOfGeometries: 0,
+    numberOfPortions: 0,
+    numberOfLayers: 0,
+    numberOfTextures: 0,
+    totalLines: 0,
+    totalLines8Bits: 0,
+    totalLines16Bits: 0,
+    totalLines32Bits: 0,
+    cannotCreatePortion: {
+        because10BitsObjectId: 0,
+        becauseTextureSize: 0,
+    },
+    overheadSizeAlignementIndices: 0,
+    overheadSizeAlignementEdgeIndices: 0,
+};
+
+window.printDataTextureRamStats = function () {
+
+    console.log(JSON.stringify(dataTextureRamStats, null, 4));
+
+    let totalRamSize = 0;
+
+    Object.keys(dataTextureRamStats).forEach(key => {
+        if (key.startsWith("size")) {
+            totalRamSize += dataTextureRamStats[key];
+        }
+    });
+
+    console.log(`Total size ${totalRamSize} bytes (${(totalRamSize / 1000 / 1000).toFixed(2)} MB)`);
+    console.log(`Avg bytes / triangle: ${(totalRamSize / dataTextureRamStats.totalLines).toFixed(2)}`);
+
+    let percentualRamStats = {};
+
+    Object.keys(dataTextureRamStats).forEach(key => {
+        if (key.startsWith("size")) {
+            percentualRamStats[key] =
+                `${(dataTextureRamStats[key] / totalRamSize * 100).toFixed(2)} % of total`;
+        }
+    });
+
+    console.log(JSON.stringify({percentualRamUsage: percentualRamStats}, null, 4));
+};