@xeokit/xeokit-sdk 2.4.0-alpha-4 → 2.4.0-alpha-6

package/dist/xeokit-sdk.es.js

@@ -15101,7 +15101,9 @@ class SAOOcclusionRenderer {
 
         const uv = new Float32Array([1, 1, 0, 1, 0, 0, 1, 0]);
         const positions = new Float32Array([1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0]);
-        const indices = new Uint8Array([0, 1, 2, 0, 2, 3]);
+        
+        // Mitigation: if Uint8Array is used, the geometry is corrupted on OSX when using Chrome with data-textures
+        const indices = new Uint32Array([0, 1, 2, 0, 2, 3]);
 
         this._positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, positions, positions.length, 3, gl.STATIC_DRAW);
         this._uvBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, uv, uv.length, 2, gl.STATIC_DRAW);
@@ -15337,7 +15339,9 @@ class SAODepthLimitedBlurRenderer {
 
         const uv = new Float32Array([1, 1, 0, 1, 0, 0, 1, 0]);
         const positions = new Float32Array([1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0]);
-        const indices = new Uint8Array([0, 1, 2, 0, 2, 3]);
+
+        // Mitigation: if Uint8Array is used, the geometry is corrupted on OSX when using Chrome with data-textures
+        const indices = new Uint32Array([0, 1, 2, 0, 2, 3]);
 
         this._positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, positions, positions.length, 3, gl.STATIC_DRAW);
         this._uvBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, uv, uv.length, 2, gl.STATIC_DRAW);
@@ -19887,7 +19891,7 @@ class TrianglesDataTextureColorRenderer {
                 tempVec4$9[2] = sao.blendCutoff;
                 tempVec4$9[3] = sao.blendFactor;
                 gl.uniform4fv(this._uSAOParams, tempVec4$9);
-                this._program.bindTexture(this._uOcclusionTexture, frameCtx.occlusionTexture, 0);
+                this._program.bindTexture(this._uOcclusionTexture, frameCtx.occlusionTexture, 10);
             }
         }
 
@@ -20218,7 +20222,7 @@ class TrianglesDataTextureColorRenderer {
             src.push("   float blendCutoff       = uSAOParams[2];");
             src.push("   float blendFactor       = uSAOParams[3];");
             src.push("   vec2 uv                 = vec2(gl_FragCoord.x / viewportWidth, gl_FragCoord.y / viewportHeight);");
-            src.push("   float ambient           = smoothstep(blendCutoff, 1.0, unpackRGBToFloat(texture2D(uOcclusionTexture, uv))) * blendFactor;");
+            src.push("   float ambient           = smoothstep(blendCutoff, 1.0, unpackRGBToFloat(texture(uOcclusionTexture, uv))) * blendFactor;");
             src.push("   outColor            = vec4(vColor.rgb * ambient, 1.0);");
         } else {
             src.push("   outColor            = vColor;");
@@ -23076,6 +23080,7 @@ class TrianglesDataTextureOcclusionRenderer {
     }
 }
 
+math.vec4();
 const tempVec3a$17 = math.vec3();
 
 /**
@@ -23098,12 +23103,12 @@ class TrianglesDataTextureDepthRenderer {
     }
 
     drawLayer(frameCtx, dataTextureLayer, renderPass) {
-
-        const model = dataTextureLayer.model;
-        const scene = model.scene;
+        const scene = this._scene;
         const camera = scene.camera;
+        const model = dataTextureLayer.model;
         const gl = scene.canvas.gl;
         const state = dataTextureLayer._state;
+        const textureState = state.textureState;
         const origin = dataTextureLayer._state.origin;
 
         if (!this._program) {
@@ -23115,13 +23120,38 @@ class TrianglesDataTextureDepthRenderer {
 
         if (frameCtx.lastProgramId !== this._program.id) {
             frameCtx.lastProgramId = this._program.id;
-            this._bindProgram();
+            this._bindProgram(frameCtx, state);
         }
+        
+        textureState.bindCommonTextures (
+            this._program,
+            this._uTexturePerObjectIdPositionsDecodeMatrix, 
+            this._uTexturePerVertexIdCoordinates, 
+            this._uTexturePerObjectIdColorsAndFlags, 
+            this._uTextureCameraMatrices, 
+            this._uTextureModelMatrices,
+            this._uTexturePerObjectIdOffsets
+        );
 
-        gl.uniform1i(this._uRenderPass, renderPass);
+        let cameraEye = camera.eye;
 
-        gl.uniformMatrix4fv(this._uWorldMatrix, false, model.worldMatrix);
-        gl.uniformMatrix4fv(this._uViewMatrix, false, (origin) ? createRTCViewMat(camera.viewMatrix, origin) : camera.viewMatrix);
+        if (frameCtx.pickViewMatrix) {
+            textureState.bindPickCameraTexture (
+                this._program,
+                this._uTextureCameraMatrices
+            );
+            cameraEye = frameCtx.pickOrigin || cameraEye;
+        }
+
+        const originCameraEye = [
+            cameraEye[0] - origin[0],
+            cameraEye[1] - origin[1],
+            cameraEye[2] - origin[2],
+        ];
+
+        gl.uniform3fv(this._uCameraEyeRtc, originCameraEye);
+
+        gl.uniform1i(this._uRenderPass, renderPass);
 
         const numSectionPlanes = scene._sectionPlanesState.sectionPlanes.length;
         if (numSectionPlanes > 0) {
@@ -23147,23 +23177,43 @@ class TrianglesDataTextureDepthRenderer {
             }
         }
 
-        gl.uniformMatrix4fv(this._uPositionsDecodeMatrix, false, dataTextureLayer._state.positionsDecodeMatrix);
-
-        this._aPosition.bindArrayBuffer(state.positionsBuf);
+        if (state.numIndices8Bits > 0)
+        {
+            textureState.bindTriangleIndicesTextures(
+                this._program,
+                this._uTexturePerPolygonIdPortionIds, 
+                this._uTexturePerPolygonIdIndices, 
+                8 // 8 bits indices
+            );
 
-        if (this._aOffset) {
-            this._aOffset.bindArrayBuffer(state.offsetsBuf);
+            gl.drawArrays(gl.TRIANGLES, 0, state.numIndices8Bits);
         }
 
-        this._aFlags.bindArrayBuffer(state.flagsBuf);
+        if (state.numIndices16Bits > 0)
+        {
+            textureState.bindTriangleIndicesTextures(
+                this._program,
+                this._uTexturePerPolygonIdPortionIds, 
+                this._uTexturePerPolygonIdIndices, 
+                16 // 16 bits indices
+            );
 
-        if (this._aFlags2) {
-            this._aFlags2.bindArrayBuffer(state.flags2Buf);
+            gl.drawArrays(gl.TRIANGLES, 0, state.numIndices16Bits);
         }
+        
+        if (state.numIndices32Bits > 0)
+        {
+            textureState.bindTriangleIndicesTextures(
+                this._program,
+                this._uTexturePerPolygonIdPortionIds, 
+                this._uTexturePerPolygonIdIndices, 
+                32 // 32 bits indices
+            );
 
-        state.indicesBuf.bind();
+            gl.drawArrays(gl.TRIANGLES, 0, state.numIndices32Bits);
+        }
 
-        gl.drawElements(gl.TRIANGLES, state.indicesBuf.numItems, state.indicesBuf.itemType, 0);
+        frameCtx.drawElements++;
     }
 
     _allocate() {
@@ -23195,23 +23245,30 @@ class TrianglesDataTextureDepthRenderer {
             });
         }
 
-        this._aPosition = program.getAttribute("position");
-        this._aOffset = program.getAttribute("offset");
-        this._aFlags = program.getAttribute("flags");
-        this._aFlags2 = program.getAttribute("flags2");
-
         if (scene.logarithmicDepthBufferEnabled) {
             this._uLogDepthBufFC = program.getLocation("logDepthBufFC");
         }
+
+        this._uTexturePerObjectIdPositionsDecodeMatrix = "uTexturePerObjectIdPositionsDecodeMatrix"; // chipmunk
+        this._uTexturePerObjectIdColorsAndFlags = "uTexturePerObjectIdColorsAndFlags"; // chipmunk
+        this._uTexturePerVertexIdCoordinates = "uTexturePerVertexIdCoordinates"; // chipmunk
+        this._uTexturePerPolygonIdNormals = "uTexturePerPolygonIdNormals"; // chipmunk
+        this._uTexturePerPolygonIdIndices = "uTexturePerPolygonIdIndices"; // chipmunk
+        this._uTexturePerPolygonIdPortionIds = "uTexturePerPolygonIdPortionIds"; // chipmunk
+        this._uTextureCameraMatrices = "uTextureCameraMatrices"; // chipmunk
+        this._uTextureModelMatrices = "uTextureModelMatrices"; // chipmunk
+        this._uTexturePerObjectIdOffsets = "uTexturePerObjectIdOffsets"; // chipmunk
+        this._uCameraEyeRtc = program.getLocation("uCameraEyeRtc"); // chipmunk
     }
 
-    _bindProgram() {
+    _bindProgram(frameCtx) {
 
         const scene = this._scene;
         const gl = scene.canvas.gl;
+        const program = this._program;
         const project = scene.camera.project;
 
-        this._program.bind();
+        program.bind();
 
         gl.uniformMatrix4fv(this._uProjMatrix, false, project.matrix);
 
@@ -23230,131 +23287,241 @@ class TrianglesDataTextureDepthRenderer {
 
     _buildVertexShader() {
         const scene = this._scene;
-        const clipping = scene._sectionPlanesState.sectionPlanes.length > 0;
+        const sectionPlanesState = scene._sectionPlanesState;
+        scene._lightsState;
+        const clipping = sectionPlanesState.sectionPlanes.length > 0;
         const src = [];
-        src.push("// Triangles dataTexture depth vertex shader");
-        if (scene.logarithmicDepthBufferEnabled && WEBGL_INFO.SUPPORTED_EXTENSIONS["EXT_frag_depth"]) {
-            src.push("#extension GL_EXT_frag_depth : enable");
-        }
+        src.push("#version 300 es");
+        src.push("// Triangles dataTexture draw vertex shader");
+
+        src.push("#ifdef GL_FRAGMENT_PRECISION_HIGH");
+        src.push("precision highp float;");
+        src.push("precision highp int;");
+        src.push("precision highp usampler2D;");
+        src.push("precision highp isampler2D;");
+        src.push("precision highp sampler2D;");
+        src.push("#else");
+        src.push("precision mediump float;");
+        src.push("precision mediump int;");
+        src.push("precision mediump usampler2D;");
+        src.push("precision mediump isampler2D;");
+        src.push("precision mediump sampler2D;");
+        src.push("#endif");
+
         src.push("uniform int renderPass;");
-        src.push("attribute vec3 position;");
+
         if (scene.entityOffsetsEnabled) {
-            src.push("attribute vec3 offset;");
+            src.push("in vec3 offset;");
         }
-        src.push("attribute vec4 flags;");
-        src.push("attribute vec4 flags2;");
-        src.push("uniform mat4 worldMatrix;");
-        src.push("uniform mat4 viewMatrix;");
-        src.push("uniform mat4 projMatrix;");
-        src.push("uniform mat4 positionsDecodeMatrix;");
+
+        // src.push("uniform sampler2D uOcclusionTexture;"); // chipmunk
+
+        src.push("uniform highp sampler2D uTexturePerObjectIdPositionsDecodeMatrix;"); // chipmunk
+        src.push("uniform lowp usampler2D uTexturePerObjectIdColorsAndFlags;"); // chipmunk
+        src.push("uniform highp sampler2D uTexturePerObjectIdOffsets;"); // chipmunk
+        src.push("uniform mediump usampler2D uTexturePerVertexIdCoordinates;"); // chipmunk
+        src.push("uniform highp usampler2D uTexturePerPolygonIdIndices;"); // chipmunk
+        src.push("uniform mediump usampler2D uTexturePerPolygonIdPortionIds;"); // chipmunk
+        src.push("uniform highp sampler2D uTextureCameraMatrices;"); // chipmunk
+        src.push("uniform highp sampler2D uTextureModelMatrices;"); // chipmunk
+        src.push("uniform vec3 uCameraEyeRtc;"); // chipmunk
+
+        src.push("vec3 positions[3];");
+
         if (scene.logarithmicDepthBufferEnabled) {
             src.push("uniform float logDepthBufFC;");
-            if (WEBGL_INFO.SUPPORTED_EXTENSIONS["EXT_frag_depth"]) {
-                src.push("varying float vFragDepth;");
-            }
-            src.push("bool isPerspectiveMatrix(mat4 m) {");
-            src.push("    return (m[2][3] == - 1.0);");
-            src.push("}");
-            src.push("varying float isPerspective;");
+            src.push("out float vFragDepth;");
+            src.push("out float isPerspective;");
         }
+
+        src.push("bool isPerspectiveMatrix(mat4 m) {");
+        src.push("    return (m[2][3] == - 1.0);");
+        src.push("}");
+
+        src.push("out highp vec2 vHighPrecisionZW;");
+
         if (clipping) {
-            src.push("varying vec4 vWorldPosition;");
-            src.push("varying vec4 vFlags2;");
+            src.push("out vec4 vWorldPosition;");
+            src.push("flat out uint vFlags2;");
         }
-        src.push("varying vec2 vHighPrecisionZW;");
+        
         src.push("void main(void) {");
 
+        // camera matrices
+        src.push ("mat4 viewMatrix = mat4 (texelFetch (uTextureCameraMatrices, ivec2(0, 0), 0), texelFetch (uTextureCameraMatrices, ivec2(1, 0), 0), texelFetch (uTextureCameraMatrices, ivec2(2, 0), 0), texelFetch (uTextureCameraMatrices, ivec2(3, 0), 0));");
+        src.push ("mat4 viewNormalMatrix = mat4 (texelFetch (uTextureCameraMatrices, ivec2(0, 1), 0), texelFetch (uTextureCameraMatrices, ivec2(1, 1), 0), texelFetch (uTextureCameraMatrices, ivec2(2, 1), 0), texelFetch (uTextureCameraMatrices, ivec2(3, 1), 0));");
+        src.push ("mat4 projMatrix = mat4 (texelFetch (uTextureCameraMatrices, ivec2(0, 2), 0), texelFetch (uTextureCameraMatrices, ivec2(1, 2), 0), texelFetch (uTextureCameraMatrices, ivec2(2, 2), 0), texelFetch (uTextureCameraMatrices, ivec2(3, 2), 0));");
+
+        // model matrices
+        src.push ("mat4 worldMatrix = mat4 (texelFetch (uTextureModelMatrices, ivec2(0, 0), 0), texelFetch (uTextureModelMatrices, ivec2(1, 0), 0), texelFetch (uTextureModelMatrices, ivec2(2, 0), 0), texelFetch (uTextureModelMatrices, ivec2(3, 0), 0));");
+        src.push ("mat4 worldNormalMatrix = mat4 (texelFetch (uTextureModelMatrices, ivec2(0, 1), 0), texelFetch (uTextureModelMatrices, ivec2(1, 1), 0), texelFetch (uTextureModelMatrices, ivec2(2, 1), 0), texelFetch (uTextureModelMatrices, ivec2(3, 1), 0));");
+        
+        // constants
+        src.push("int polygonIndex = gl_VertexID / 3;");
+
+        // get packed object-id
+        src.push("int h_packed_object_id_index = (polygonIndex >> 3) & 4095;");
+        src.push("int v_packed_object_id_index = (polygonIndex >> 3) >> 12;");
+
+        src.push("int objectIndex = int(texelFetch(uTexturePerPolygonIdPortionIds, ivec2(h_packed_object_id_index, v_packed_object_id_index), 0).r);");
+        src.push("ivec2 objectIndexCoords = ivec2(objectIndex % 512, objectIndex / 512);");
+
+        // get flags & flags2
+        src.push("uvec4 flags = texelFetch (uTexturePerObjectIdColorsAndFlags, ivec2(objectIndexCoords.x*8+2, objectIndexCoords.y), 0);"); // chipmunk
+        src.push("uvec4 flags2 = texelFetch (uTexturePerObjectIdColorsAndFlags, ivec2(objectIndexCoords.x*8+3, objectIndexCoords.y), 0);"); // chipmunk
+        
         // flags.x = NOT_RENDERED | COLOR_OPAQUE | COLOR_TRANSPARENT
         // renderPass = COLOR_OPAQUE
 
-        src.push(`if (int(flags.x) != renderPass) {`);
-        src.push("      gl_Position = vec4(0.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) {
-            src.push("      worldPosition.xyz = worldPosition.xyz + offset;");
-        }
-        src.push("      vec4 viewPosition  = viewMatrix * worldPosition; ");
-        if (clipping) {
-            src.push("      vWorldPosition = worldPosition;");
-            src.push("      vFlags2 = flags2;");
-        }
+        // src.push(`if (int(flags.x) != renderPass) {`);
+        // src.push("   gl_Position = vec4(3.0, 3.0, 3.0, 1.0);"); // Cull vertex
+        // src.push("   return;"); // Cull vertex
+        // src.push("} else {");
+        src.push("{");
+
+        // get vertex base
+        src.push("ivec4 packedVertexBase = ivec4(texelFetch (uTexturePerObjectIdColorsAndFlags, ivec2(objectIndexCoords.x*8+4, objectIndexCoords.y), 0));"); // chipmunk
+
+        src.push("ivec4 packedIndexBaseOffset = ivec4(texelFetch (uTexturePerObjectIdColorsAndFlags, ivec2(objectIndexCoords.x*8+5, objectIndexCoords.y), 0));"); // chipmunk
+
+        src.push("int indexBaseOffset = (packedIndexBaseOffset.r << 24) + (packedIndexBaseOffset.g << 16) + (packedIndexBaseOffset.b << 8) + packedIndexBaseOffset.a;");
+
+        src.push("int h_index = (polygonIndex - indexBaseOffset) & 4095;");
+        src.push("int v_index = (polygonIndex - indexBaseOffset) >> 12;");
+
+        src.push("ivec3 vertexIndices = ivec3(texelFetch(uTexturePerPolygonIdIndices, ivec2(h_index, v_index), 0));");
+        src.push("ivec3 uniqueVertexIndexes = vertexIndices + (packedVertexBase.r << 24) + (packedVertexBase.g << 16) + (packedVertexBase.b << 8) + packedVertexBase.a;");
+        
+        src.push("ivec3 indexPositionH = uniqueVertexIndexes & 4095;");
+        src.push("ivec3 indexPositionV = uniqueVertexIndexes >> 12;");
+
+        src.push("mat4 positionsDecodeMatrix = mat4 (texelFetch (uTexturePerObjectIdPositionsDecodeMatrix, ivec2(objectIndexCoords.x*8+0, objectIndexCoords.y), 0), texelFetch (uTexturePerObjectIdPositionsDecodeMatrix, ivec2(objectIndexCoords.x*8+1, objectIndexCoords.y), 0), texelFetch (uTexturePerObjectIdPositionsDecodeMatrix, ivec2(objectIndexCoords.x*8+2, objectIndexCoords.y), 0), texelFetch (uTexturePerObjectIdPositionsDecodeMatrix, ivec2(objectIndexCoords.x*8+3, objectIndexCoords.y), 0));");
+        src.push("mat4 entityMatrix = mat4 (texelFetch (uTexturePerObjectIdPositionsDecodeMatrix, ivec2(objectIndexCoords.x*8+4, objectIndexCoords.y), 0), texelFetch (uTexturePerObjectIdPositionsDecodeMatrix, ivec2(objectIndexCoords.x*8+5, objectIndexCoords.y), 0), texelFetch (uTexturePerObjectIdPositionsDecodeMatrix, ivec2(objectIndexCoords.x*8+6, objectIndexCoords.y), 0), texelFetch (uTexturePerObjectIdPositionsDecodeMatrix, ivec2(objectIndexCoords.x*8+7, objectIndexCoords.y), 0));");
+
+        src.push("positionsDecodeMatrix = entityMatrix * positionsDecodeMatrix;");
+        
+        src.push("uint solid = texelFetch (uTexturePerObjectIdColorsAndFlags, ivec2(objectIndexCoords.x*8+7, objectIndexCoords.y), 0).r;"); // chipmunk
+
+        // get position
+        src.push("positions[0] = vec3(texelFetch(uTexturePerVertexIdCoordinates, ivec2(indexPositionH.r, indexPositionV.r), 0));");
+        src.push("positions[1] = vec3(texelFetch(uTexturePerVertexIdCoordinates, ivec2(indexPositionH.g, indexPositionV.g), 0));");
+        src.push("positions[2] = vec3(texelFetch(uTexturePerVertexIdCoordinates, ivec2(indexPositionH.b, indexPositionV.b), 0));");
+
+        // get color
+        src.push("uvec4 color = texelFetch (uTexturePerObjectIdColorsAndFlags, ivec2(objectIndexCoords.x*8+0, objectIndexCoords.y), 0);"); // chipmunk
+        
+        src.push(`if (color.a == 0u) {`);
+        src.push("   gl_Position = vec4(3.0, 3.0, 3.0, 1.0);"); // Cull vertex
+        src.push("   return;");
+        src.push("};");
+
+        // get normal
+        src.push("vec3 normal = normalize(cross(positions[2] - positions[0], positions[1] - positions[0]));");
+
+        src.push("vec3 position;");
+        src.push("position = positions[gl_VertexID % 3];");
+
+        src.push("vec3 viewNormal = -normalize((transpose(inverse(viewMatrix*positionsDecodeMatrix)) * vec4(normal,1)).xyz);");
+
+        // when the geometry is not solid, if needed, flip the triangle winding
+        src.push("if (solid != 1u) {");
+            src.push("if (isPerspectiveMatrix(projMatrix)) {");
+                src.push("vec3 uCameraEyeRtcInQuantizedSpace = (inverse(worldMatrix * positionsDecodeMatrix) * vec4(uCameraEyeRtc, 1)).xyz;");
+                src.push("if (dot(position.xyz - uCameraEyeRtcInQuantizedSpace, normal) < 0.0) {");
+                        src.push("position = positions[2 - (gl_VertexID % 3)];");
+                        src.push("viewNormal = -viewNormal;");
+                    src.push("}");
+            src.push("} else {");
+                src.push("if (viewNormal.z < 0.0) {");
+                        src.push("position = positions[2 - (gl_VertexID % 3)];");
+                        src.push("viewNormal = -viewNormal;");
+                    src.push("}");
+            src.push("}");
+        src.push("}");
+
+        src.push("vec4 worldPosition = worldMatrix * (positionsDecodeMatrix * vec4(position, 1.0)); ");
+
+        // get XYZ offset
+        src.push("vec4 offset = vec4(texelFetch (uTexturePerObjectIdOffsets, objectIndexCoords, 0).rgb, 0.0);");
+
+        src.push("worldPosition.xyz = worldPosition.xyz + offset.xyz;");
+
+        src.push("vec4 viewPosition = viewMatrix * worldPosition; ");
+
         src.push("vec4 clipPos = projMatrix * viewPosition;");
         if (scene.logarithmicDepthBufferEnabled) {
-            if (WEBGL_INFO.SUPPORTED_EXTENSIONS["EXT_frag_depth"]) {
-                src.push("vFragDepth = 1.0 + clipPos.w;");
-            } else {
-                src.push("clipPos.z = log2( max( 1e-6, clipPos.w + 1.0 ) ) * logDepthBufFC - 1.0;");
-                src.push("clipPos.z *= clipPos.w;");
-            }
+            src.push("vFragDepth = 1.0 + clipPos.w;");
             src.push("isPerspective = float (isPerspectiveMatrix(projMatrix));");
         }
+        if (clipping) {
+            src.push("vWorldPosition = worldPosition;");
+            src.push("vFlags2 = flags2.r;");
+        }
         src.push("gl_Position = clipPos;");
         src.push("vHighPrecisionZW = gl_Position.zw;");
-        src.push("  }");
         src.push("}");
+
+        src.push("}");
+
         return src;
     }
 
     _buildFragmentShader() {
         const scene = this._scene;
         const sectionPlanesState = scene._sectionPlanesState;
-        const clipping = (sectionPlanesState.sectionPlanes.length > 0);
+        const clipping = sectionPlanesState.sectionPlanes.length > 0;
         const src = [];
-        src.push("// Triangles dataTexture depth fragment shader");
-        if (scene.logarithmicDepthBufferEnabled && WEBGL_INFO.SUPPORTED_EXTENSIONS["EXT_frag_depth"]) {
-            src.push("#extension GL_EXT_frag_depth : enable");
-        }
+        src.push ('#version 300 es');
+        src.push("// Triangles dataTexture draw fragment shader");
+        src.push("#ifdef GL_FRAGMENT_PRECISION_HIGH");
         src.push("precision highp float;");
         src.push("precision highp int;");
-        if (scene.logarithmicDepthBufferEnabled && WEBGL_INFO.SUPPORTED_EXTENSIONS["EXT_frag_depth"]) {
-            src.push("varying float isPerspective;");
+        src.push("#else");
+        src.push("precision mediump float;");
+        src.push("precision mediump int;");
+        src.push("#endif");
+
+        src.push("in highp vec2 vHighPrecisionZW;");
+        src.push("out vec4 outColor;");
+
+        if (scene.logarithmicDepthBufferEnabled) {
+            src.push("in float isPerspective;");
             src.push("uniform float logDepthBufFC;");
-            src.push("varying float vFragDepth;");
+            src.push("in float vFragDepth;");
         }
         if (clipping) {
-            src.push("varying vec4 vWorldPosition;");
-            src.push("varying vec4 vFlags2;");
-            for (let i = 0; i < sectionPlanesState.sectionPlanes.length; i++) {
+            src.push("in vec4 vWorldPosition;");
+            src.push("flat in uint vFlags2;");
+            for (let i = 0, len = sectionPlanesState.sectionPlanes.length; i < len; i++) {
                 src.push("uniform bool sectionPlaneActive" + i + ";");
                 src.push("uniform vec3 sectionPlanePos" + i + ";");
                 src.push("uniform vec3 sectionPlaneDir" + i + ";");
             }
         }
-        src.push("const float   packUpScale = 256. / 255.;");
-        src.push("const float   unpackDownscale = 255. / 256.;");
-        src.push("const vec3    packFactors = vec3( 256. * 256. * 256., 256. * 256.,  256. );");
-        src.push("const vec4    unpackFactors = unpackDownscale / vec4( packFactors, 1. );");
-        src.push("const float   shiftRight8 = 1.0 / 256.;");
-
-        src.push("vec4 packDepthToRGBA( const in float v ) {");
-        src.push("    vec4 r = vec4( fract( v * packFactors ), v );");
-        src.push("    r.yzw -= r.xyz * shiftRight8;");
-        src.push("    return r * packUpScale;");
-        src.push("}");
-        src.push("varying vec2 vHighPrecisionZW;");
         src.push("void main(void) {");
+
         if (clipping) {
-            src.push("  bool clippable = (float(vFlags2.x) > 0.0);");
+            src.push("  bool clippable = vFlags2 > 0u;");
             src.push("  if (clippable) {");
-            src.push("      float dist = 0.0;");
-            for (var i = 0; i < sectionPlanesState.sectionPlanes.length; i++) {
-                src.push("      if (sectionPlaneActive" + i + ") {");
-                src.push("          dist += clamp(dot(-sectionPlaneDir" + i + ".xyz, vWorldPosition.xyz - sectionPlanePos" + i + ".xyz), 0.0, 1000.0);");
-                src.push("      }");
+            src.push("  float dist = 0.0;");
+            for (let i = 0, len = sectionPlanesState.sectionPlanes.length; i < len; i++) {
+                src.push("if (sectionPlaneActive" + i + ") {");
+                src.push("   dist += clamp(dot(-sectionPlaneDir" + i + ".xyz, vWorldPosition.xyz - sectionPlanePos" + i + ".xyz), 0.0, 1000.0);");
+                src.push("}");
             }
-            src.push("      if (dist > 0.0) { discard; }");
-            src.push("  }");
+                src.push("  if (dist > 0.0) { ");
+                src.push("      discard;");
+                src.push("  }");
+            src.push("}");
         }
-        if (scene.logarithmicDepthBufferEnabled && WEBGL_INFO.SUPPORTED_EXTENSIONS["EXT_frag_depth"]) {
-            src.push("    gl_FragDepthEXT = isPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;");
+
+        if (scene.logarithmicDepthBufferEnabled) {
+            // src.push("    gl_FragDepth = isPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;");
+            src.push("    gl_FragDepth = log2( vFragDepth ) * logDepthBufFC * 0.5;");
         }
         src.push("float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;");
-        if (WEBGL_INFO.SUPPORTED_EXTENSIONS["WEBGL_depth_texture"]) {
-            src.push("    gl_FragColor = vec4(vec3(1.0 - fragCoordZ), 1.0); ");
-        } else {
-            src.push("    gl_FragColor = packDepthToRGBA(fragCoordZ); "); // Must be linear depth
-        }
+        src.push("    outColor = vec4(vec3(1.0 - fragCoordZ), 1.0); ");
+        // src.push("    outColor = vec4(1.0, 1.0, 1.0, 1.0); ");
         src.push("}");
         return src;
     }
@@ -23368,7 +23535,6 @@ class TrianglesDataTextureDepthRenderer {
             this._program.destroy();
         }
         this._program = null;
-        stats.memory.programs--;
     }
 }
 
@@ -29214,40 +29380,49 @@ class TrianglesDataTextureLayer {
  * 
  * @returns {object} The mesh information enrichened with `.preparedBuckets` key.
  */
-function prepareMeshGeometry (geometryCfg) {
+function prepareMeshGeometry (geometryCfg, enableVertexWelding, enableIndexRebucketing) {
     let uniquePositions, uniqueIndices, uniqueEdgeIndices;
 
-    [
-        uniquePositions,
-        uniqueIndices,
-        uniqueEdgeIndices,
-    ] = uniquifyPositions ({
-        positions: geometryCfg.positions,
-        indices: geometryCfg.indices,
-        edgeIndices: geometryCfg.edgeIndices
-    });
+    if (enableVertexWelding) {
+        [
+            uniquePositions,
+            uniqueIndices,
+            uniqueEdgeIndices,
+        ] = uniquifyPositions ({
+            positions: geometryCfg.positions,
+            indices: geometryCfg.indices,
+            edgeIndices: geometryCfg.edgeIndices
+        });
+    } else {
+        uniquePositions = geometryCfg.positions;
+        uniqueIndices = geometryCfg.indices;
+        uniqueEdgeIndices = geometryCfg.edgeIndices;
+    }
 
-    let numUniquePositions = uniquePositions.length / 3;
+    let buckets;
 
-    let buckets = rebucketPositions (
-        {
+    if (enableIndexRebucketing) {
+        let numUniquePositions = uniquePositions.length / 3;
+
+        buckets = rebucketPositions (
+            {
+                positions: uniquePositions,
+                indices: uniqueIndices,
+                edgeIndices: uniqueEdgeIndices,
+            },
+            (numUniquePositions > (1<< 16)) ? 16 : 8,
+            // true
+        );    
+    } else {
+        buckets = [{
             positions: uniquePositions,
             indices: uniqueIndices,
             edgeIndices: uniqueEdgeIndices,
-        },
-        (numUniquePositions > (1<< 16)) ? 16 : 8,
-        // true
-    );
+        }];
+    }
 
     geometryCfg.preparedBuckets = buckets;
 
-    // chipmunk
-    // geometryCfg.preparedBuckets = [{
-    //     positions: uniquePositions,
-    //     indices: uniqueIndices,
-    //     edgeIndices: uniqueEdgeIndices,
-    // }];
-
     return geometryCfg;
 }
 
@@ -31475,7 +31650,7 @@ const VISIBILITY_CHECK_ENVOLVES_V = (1 << 14);
             this._camera = model.scene.camera;
         }
 
-        this._ensureFrustumPropsUpdated ();
+        this._ensureFrustumPropsUpdated (model);
 
         this._initializeCullingDataIfNeeded (model);
 
@@ -31654,9 +31829,11 @@ const VISIBILITY_CHECK_ENVOLVES_V = (1 << 14);
     }
 
     /**
+     * @param {DataTextureSceneModel} model
+     * 
      * @private
      */
-    _ensureFrustumPropsUpdated ()
+    _ensureFrustumPropsUpdated (model)
     {
         // Assuming "min" for fovAxis
         const min = Math.min (
@@ -31685,10 +31862,33 @@ const VISIBILITY_CHECK_ENVOLVES_V = (1 << 14);
         //     return;
         // }
 
+        // Adjust camera eye/look to take into account the `model.worldMatrix`:
+        //  - the entities' AABBs don't take it into account
+        //  - and they can't, since `model.worldMatrix` is dynamic
+        // So, instead of transformating the positions of the r*tree's AABBs,
+        // apply the inverse transform to the camera eye/look, since the culling
+        // result is equivalent.
+        const invWorldMatrix = math.inverseMat4(
+            model.worldMatrix,
+            math.mat4()
+        );
+
+        const modelCamEye = math.transformVec3(
+            this._camera.eye,
+            invWorldMatrix,
+            [ 0, 0, 0 ]
+        );
+
+        const modelCamLook = math.transformVec3(
+            this._camera.look,
+            invWorldMatrix,
+            [ 0, 0, 0 ]
+        );
+
         this._frustumProps.forward = math.normalizeVec3 (
             math.subVec3 (
-                this._camera.look,
-                this._camera.eye,
+                modelCamLook,
+                modelCamEye,
                 [ 0, 0, 0]
             ),
             [ 0, 0, 0]
@@ -31708,7 +31908,7 @@ const VISIBILITY_CHECK_ENVOLVES_V = (1 << 14);
             [ 0, 0, 0 ]
         );
 
-        this._frustumProps.eye = this._camera.eye.slice ();
+        this._frustumProps.eye = modelCamEye.slice ();
 
         this._frustumProps.CAM_FACTOR_1 = this._frustumProps.fov / 2 * this._frustumProps.wMultiply / _180_DIV_MATH_PI;
         this._frustumProps.CAM_FACTOR_2 = this._frustumProps.fov / 2 * this._frustumProps.hMultiply / _180_DIV_MATH_PI;
@@ -31979,6 +32179,8 @@ class DataTextureSceneModel extends Component {
      * @param {Boolean} [cfg.saoEnabled=true] Indicates if Scalable Ambient Obscurance (SAO) will apply to this dataTexturePerformanceModel. SAO is configured by the Scene's {@link SAO} component.
      * @param {Boolean} [cfg.pbrEnabled=false] Indicates if physically-based rendering (PBR) will apply to the dataTexturePerformanceModel. Only works when {@link Scene#pbrEnabled} is also ````true````.
      * @param {Number} [cfg.edgeThreshold=10] When xraying, highlighting, selecting or edging, this is the threshold angle between normals of adjacent triangles, below which their shared wireframe edge is not drawn.
+     * @param {Boolean} [cfg.disableVertexWelding] Disable vertex welding when loading geometry into the GPU. Default is ```false```.
+     * @param {Boolean} [cfg.disableIndexRebucketing] Disable index rebucketing when loading geometry into the GPU. Default is ```false```.
      */
     constructor(owner, cfg = {}) {
         super(owner, cfg);
@@ -31987,6 +32189,24 @@ class DataTextureSceneModel extends Component {
             throw "Using a DataTextureSceneModel requires the usage of webgl2";
         }
 
+        /**
+         * Enable welding vertices when loading geometry into the ```TrianglesDataTextureLayer```.
+         * 
+         * The welding is applied per-geometry.
+         * 
+         * @type {Boolean}
+         */
+        this._enableVertexWelding = !cfg.disableVertexWelding;
+
+        /**
+         * Enable demotion of index bitness then loading geometry into the ```TrianglesDataTextureLayer```.
+         * 
+         * The rebucketing is applied per-geometry.
+         * 
+         * @type {Boolean}
+         */
+        this._enableIndexRebucketing = !cfg.disableIndexRebucketing;
+
         this._targetLodFps = cfg.targetLodFps;
 
         if (cfg.enableViewFrustumCulling) {
@@ -33038,7 +33258,11 @@ class DataTextureSceneModel extends Component {
 
             geometryCfg.edgeIndices = edgeIndices;
 
-            preparedGeometryCfg = prepareMeshGeometry (geometryCfg);
+            preparedGeometryCfg = prepareMeshGeometry (
+                geometryCfg,
+                this._enableVertexWelding,
+                this._enableIndexRebucketing
+            );
 
             if (instancing) {
                 this._preparedInstancingGeometries[geometryId] = preparedGeometryCfg;
@@ -34136,7 +34360,7 @@ const Renderer = function (scene, options) {
 
                     const drawable = drawableList[i];
 
-                    if (drawable.culled === true || drawable.visible === false || !drawable.drawDepth) {
+                    if (drawable.culled === true || drawable.visible === false || !drawable.drawDepth || !drawable.saoEnabled) {
                         continue;
                     }
 
@@ -131487,6 +131711,8 @@ class XKTLoaderPlugin extends Plugin {
                 origin: params.origin,
                 targetLodFps: params.useDataTextures.targetLodFps || false,
                 enableViewFrustumCulling: params.useDataTextures.enableViewFrustumCulling || false,
+                disableVertexWelding: params.useDataTextures.disableVertexWelding || false,
+                disableIndexRebucketing: params.useDataTextures.disableIndexRebucketing || false,
             }));
         } else {
             sceneModel = new VBOSceneModel(this.viewer.scene, utils.apply(params, {