@babylonjs/core 7.31.1 → 7.32.0

package/Meshes/GaussianSplatting/gaussianSplattingMesh.js

@@ -1,7 +1,7 @@
 import { SubMesh } from "../subMesh.js";
 import { Mesh } from "../mesh.js";
 import { VertexData } from "../mesh.vertexData.js";
-import { Matrix, Quaternion, TmpVectors, Vector2, Vector3 } from "../../Maths/math.vector.js";
+import { Matrix, TmpVectors, Vector2, Vector3 } from "../../Maths/math.vector.js";
 import { Logger } from "../../Misc/logger.js";
 import { GaussianSplattingMaterial } from "../../Materials/GaussianSplatting/gaussianSplattingMaterial.js";
 import { RawTexture } from "../../Materials/Textures/rawTexture.js";
@@ -10,6 +10,101 @@ import { Tools } from "../../Misc/tools.js";
 import "../thinInstanceMesh.js";
 import { ToHalfFloat } from "../../Misc/textureTools.js";
 import { Scalar } from "../../Maths/math.scalar.js";
+import { runCoroutineSync, runCoroutineAsync, createYieldingScheduler } from "../../Misc/coroutine.js";
+// @internal
+const unpackUnorm = (value, bits) => {
+    const t = (1 << bits) - 1;
+    return (value & t) / t;
+};
+// @internal
+const unpack111011 = (value, result) => {
+    result.x = unpackUnorm(value >>> 21, 11);
+    result.y = unpackUnorm(value >>> 11, 10);
+    result.z = unpackUnorm(value, 11);
+};
+// @internal
+const unpack8888 = (value, result) => {
+    result[0] = unpackUnorm(value >>> 24, 8) * 255;
+    result[1] = unpackUnorm(value >>> 16, 8) * 255;
+    result[2] = unpackUnorm(value >>> 8, 8) * 255;
+    result[3] = unpackUnorm(value, 8) * 255;
+};
+// @internal
+// unpack quaternion with 2,10,10,10 format (largest element, 3x10bit element)
+const unpackRot = (value, result) => {
+    const norm = 1.0 / (Math.sqrt(2) * 0.5);
+    const a = (unpackUnorm(value >>> 20, 10) - 0.5) * norm;
+    const b = (unpackUnorm(value >>> 10, 10) - 0.5) * norm;
+    const c = (unpackUnorm(value, 10) - 0.5) * norm;
+    const m = Math.sqrt(1.0 - (a * a + b * b + c * c));
+    switch (value >>> 30) {
+        case 0:
+            result.set(m, a, b, c);
+            break;
+        case 1:
+            result.set(a, m, b, c);
+            break;
+        case 2:
+            result.set(a, b, m, c);
+            break;
+        case 3:
+            result.set(a, b, c, m);
+            break;
+    }
+};
+/**
+ * Representation of the types
+ */
+var PLYType;
+(function (PLYType) {
+    PLYType[PLYType["FLOAT"] = 0] = "FLOAT";
+    PLYType[PLYType["INT"] = 1] = "INT";
+    PLYType[PLYType["UINT"] = 2] = "UINT";
+    PLYType[PLYType["DOUBLE"] = 3] = "DOUBLE";
+    PLYType[PLYType["UCHAR"] = 4] = "UCHAR";
+    PLYType[PLYType["UNDEFINED"] = 5] = "UNDEFINED";
+})(PLYType || (PLYType = {}));
+/**
+ * Usage types of the PLY values
+ */
+var PLYValue;
+(function (PLYValue) {
+    PLYValue[PLYValue["MIN_X"] = 0] = "MIN_X";
+    PLYValue[PLYValue["MIN_Y"] = 1] = "MIN_Y";
+    PLYValue[PLYValue["MIN_Z"] = 2] = "MIN_Z";
+    PLYValue[PLYValue["MAX_X"] = 3] = "MAX_X";
+    PLYValue[PLYValue["MAX_Y"] = 4] = "MAX_Y";
+    PLYValue[PLYValue["MAX_Z"] = 5] = "MAX_Z";
+    PLYValue[PLYValue["MIN_SCALE_X"] = 6] = "MIN_SCALE_X";
+    PLYValue[PLYValue["MIN_SCALE_Y"] = 7] = "MIN_SCALE_Y";
+    PLYValue[PLYValue["MIN_SCALE_Z"] = 8] = "MIN_SCALE_Z";
+    PLYValue[PLYValue["MAX_SCALE_X"] = 9] = "MAX_SCALE_X";
+    PLYValue[PLYValue["MAX_SCALE_Y"] = 10] = "MAX_SCALE_Y";
+    PLYValue[PLYValue["MAX_SCALE_Z"] = 11] = "MAX_SCALE_Z";
+    PLYValue[PLYValue["PACKED_POSITION"] = 12] = "PACKED_POSITION";
+    PLYValue[PLYValue["PACKED_ROTATION"] = 13] = "PACKED_ROTATION";
+    PLYValue[PLYValue["PACKED_SCALE"] = 14] = "PACKED_SCALE";
+    PLYValue[PLYValue["PACKED_COLOR"] = 15] = "PACKED_COLOR";
+    PLYValue[PLYValue["X"] = 16] = "X";
+    PLYValue[PLYValue["Y"] = 17] = "Y";
+    PLYValue[PLYValue["Z"] = 18] = "Z";
+    PLYValue[PLYValue["SCALE_0"] = 19] = "SCALE_0";
+    PLYValue[PLYValue["SCALE_1"] = 20] = "SCALE_1";
+    PLYValue[PLYValue["SCALE_2"] = 21] = "SCALE_2";
+    PLYValue[PLYValue["DIFFUSE_RED"] = 22] = "DIFFUSE_RED";
+    PLYValue[PLYValue["DIFFUSE_GREEN"] = 23] = "DIFFUSE_GREEN";
+    PLYValue[PLYValue["DIFFUSE_BLUE"] = 24] = "DIFFUSE_BLUE";
+    PLYValue[PLYValue["OPACITY"] = 25] = "OPACITY";
+    PLYValue[PLYValue["F_DC_0"] = 26] = "F_DC_0";
+    PLYValue[PLYValue["F_DC_1"] = 27] = "F_DC_1";
+    PLYValue[PLYValue["F_DC_2"] = 28] = "F_DC_2";
+    PLYValue[PLYValue["F_DC_3"] = 29] = "F_DC_3";
+    PLYValue[PLYValue["ROT_0"] = 30] = "ROT_0";
+    PLYValue[PLYValue["ROT_1"] = 31] = "ROT_1";
+    PLYValue[PLYValue["ROT_2"] = 32] = "ROT_2";
+    PLYValue[PLYValue["ROT_3"] = 33] = "ROT_3";
+    PLYValue[PLYValue["UNDEFINED"] = 34] = "UNDEFINED";
+})(PLYValue || (PLYValue = {}));
 /**
  * Class used to render a gaussian splatting mesh
  */
@@ -45,6 +140,7 @@ export class GaussianSplattingMesh extends Mesh {
         this._material = value;
         this._material.backFaceCulling = true;
         this._material.cullBackFaces = false;
+        value.resetDrawCache();
     }
     /**
      * get rendering material
@@ -84,12 +180,21 @@ export class GaussianSplattingMesh extends Mesh {
         this._oldDirection = new Vector3();
         this._useRGBACovariants = false;
         this._material = null;
+        this._tmpCovariances = [0, 0, 0, 0, 0, 0];
+        this._sortIsDirty = false;
         const vertexData = new VertexData();
-        vertexData.positions = [-2, -2, 0, 2, -2, 0, 2, 2, 0, -2, 2, 0];
-        vertexData.indices = [0, 1, 2, 0, 2, 3];
+        // Use an intanced quad or triangle. Triangle might be a bit faster because of less shader invocation but I didn't see any difference.
+        // Keeping both and use triangle for now.
+        // for quad, use following lines
+        //vertexData.positions = [-2, -2, 0, 2, -2, 0, 2, 2, 0, -2, 2, 0];
+        //vertexData.indices = [0, 1, 2, 0, 2, 3];
+        vertexData.positions = [-3, -2, 0, 3, -2, 0, 0, 4, 0];
+        vertexData.indices = [0, 1, 2];
         vertexData.applyToMesh(this);
         this.subMeshes = [];
-        new SubMesh(0, 0, 4, 0, 6, this);
+        // for quad, use following line
+        //new SubMesh(0, 0, 4, 0, 6, this);
+        new SubMesh(0, 0, 3, 0, 3, this);
         this.setEnabled(false);
         // webGL2 and webGPU support for RG texture with float16 is fine. not webGL1
         this._useRGBACovariants = !this.getEngine().isWebGPU && this.getEngine().version === 1.0;
@@ -131,7 +236,7 @@ export class GaussianSplattingMesh extends Mesh {
     }
     _postToWorker(forced = false) {
         const frameId = this.getScene().getFrameId();
-        if (frameId !== this._frameIdLastUpdate && this._worker && this._scene.activeCamera && this._canPostToWorker) {
+        if ((forced || frameId !== this._frameIdLastUpdate) && this._worker && this._scene.activeCamera && this._canPostToWorker) {
             const cameraMatrix = this._scene.activeCamera.getViewMatrix();
             this.getWorldMatrix().multiplyToRef(cameraMatrix, this._modelViewMatrix);
             cameraMatrix.invertToRef(TmpVectors.Matrix[0]);
@@ -160,22 +265,111 @@ export class GaussianSplattingMesh extends Mesh {
         this._postToWorker();
         return super.render(subMesh, enableAlphaMode, effectiveMeshReplacement);
     }
+    static _TypeNameToEnum(name) {
+        switch (name) {
+            case "float":
+                return 0 /* PLYType.FLOAT */;
+            case "int":
+                return 1 /* PLYType.INT */;
+                break;
+            case "uint":
+                return 2 /* PLYType.UINT */;
+            case "double":
+                return 3 /* PLYType.DOUBLE */;
+            case "uchar":
+                return 4 /* PLYType.UCHAR */;
+        }
+        return 5 /* PLYType.UNDEFINED */;
+    }
+    static _ValueNameToEnum(name) {
+        switch (name) {
+            case "min_x":
+                return 0 /* PLYValue.MIN_X */;
+            case "min_y":
+                return 1 /* PLYValue.MIN_Y */;
+            case "min_z":
+                return 2 /* PLYValue.MIN_Z */;
+            case "max_x":
+                return 3 /* PLYValue.MAX_X */;
+            case "max_y":
+                return 4 /* PLYValue.MAX_Y */;
+            case "max_z":
+                return 5 /* PLYValue.MAX_Z */;
+            case "min_scale_x":
+                return 6 /* PLYValue.MIN_SCALE_X */;
+            case "min_scale_y":
+                return 7 /* PLYValue.MIN_SCALE_Y */;
+            case "min_scale_z":
+                return 8 /* PLYValue.MIN_SCALE_Z */;
+            case "max_scale_x":
+                return 9 /* PLYValue.MAX_SCALE_X */;
+            case "max_scale_y":
+                return 10 /* PLYValue.MAX_SCALE_Y */;
+            case "max_scale_z":
+                return 11 /* PLYValue.MAX_SCALE_Z */;
+            case "packed_position":
+                return 12 /* PLYValue.PACKED_POSITION */;
+            case "packed_rotation":
+                return 13 /* PLYValue.PACKED_ROTATION */;
+            case "packed_scale":
+                return 14 /* PLYValue.PACKED_SCALE */;
+            case "packed_color":
+                return 15 /* PLYValue.PACKED_COLOR */;
+            case "x":
+                return 16 /* PLYValue.X */;
+            case "y":
+                return 17 /* PLYValue.Y */;
+            case "z":
+                return 18 /* PLYValue.Z */;
+            case "scale_0":
+                return 19 /* PLYValue.SCALE_0 */;
+            case "scale_1":
+                return 20 /* PLYValue.SCALE_1 */;
+            case "scale_2":
+                return 21 /* PLYValue.SCALE_2 */;
+            case "diffuse_red":
+            case "red":
+                return 22 /* PLYValue.DIFFUSE_RED */;
+            case "diffuse_green":
+            case "green":
+                return 23 /* PLYValue.DIFFUSE_GREEN */;
+            case "diffuse_blue":
+            case "blue":
+                return 24 /* PLYValue.DIFFUSE_BLUE */;
+            case "f_dc_0":
+                return 26 /* PLYValue.F_DC_0 */;
+            case "f_dc_1":
+                return 27 /* PLYValue.F_DC_1 */;
+            case "f_dc_2":
+                return 28 /* PLYValue.F_DC_2 */;
+            case "f_dc_3":
+                return 29 /* PLYValue.F_DC_3 */;
+            case "opacity":
+                return 25 /* PLYValue.OPACITY */;
+            case "rot_0":
+                return 30 /* PLYValue.ROT_0 */;
+            case "rot_1":
+                return 31 /* PLYValue.ROT_1 */;
+            case "rot_2":
+                return 32 /* PLYValue.ROT_2 */;
+            case "rot_3":
+                return 33 /* PLYValue.ROT_3 */;
+        }
+        return 34 /* PLYValue.UNDEFINED */;
+    }
     /**
-     * Code from https://github.com/dylanebert/gsplat.js/blob/main/src/loaders/PLYLoader.ts Under MIT license
-     * Converts a .ply data array buffer to splat
-     * if data array buffer is not ply, returns the original buffer
-     * @param data the .ply data to load
-     * @returns the loaded splat buffer
-     * @deprecated Please use SceneLoader.ImportMeshAsync instead
+     * Parse a PLY file header and returns metas infos on splats and chunks
+     * @param data the loaded buffer
+     * @returns a PLYHeader
      */
-    static ConvertPLYToSplat(data) {
+    static ParseHeader(data) {
         const ubuf = new Uint8Array(data);
         const header = new TextDecoder().decode(ubuf.slice(0, 1024 * 10));
         const headerEnd = "end_header\n";
         const headerEndIndex = header.indexOf(headerEnd);
         if (headerEndIndex < 0 || !header) {
             // standard splat
-            return data;
+            return null;
         }
         const vertexCount = parseInt(/element vertex (\d+)\n/.exec(header)[1]);
         const chunkElement = /element chunk (\d+)\n/.exec(header);
@@ -206,17 +400,19 @@ export class GaussianSplattingMesh extends Mesh {
         const filtered = header.slice(0, headerEndIndex).split("\n");
         for (const prop of filtered) {
             if (prop.startsWith("property ")) {
-                const [, type, name] = prop.split(" ");
+                const [, typeName, name] = prop.split(" ");
+                const value = GaussianSplattingMesh._ValueNameToEnum(name);
+                const type = GaussianSplattingMesh._TypeNameToEnum(typeName);
                 if (chunkMode == 1 /* ElementMode.Chunk */) {
-                    chunkProperties.push({ name, type, offset: rowChunkOffset });
-                    rowChunkOffset += offsets[type];
+                    chunkProperties.push({ value, type, offset: rowChunkOffset });
+                    rowChunkOffset += offsets[typeName];
                 }
                 else if (chunkMode == 0 /* ElementMode.Vertex */) {
-                    vertexProperties.push({ name, type, offset: rowVertexOffset });
-                    rowVertexOffset += offsets[type];
+                    vertexProperties.push({ value, type, offset: rowVertexOffset });
+                    rowVertexOffset += offsets[typeName];
                 }
-                if (!offsets[type]) {
-                    Logger.Warn(`Unsupported property type: ${type}.`);
+                if (!offsets[typeName]) {
+                    Logger.Warn(`Unsupported property type: ${typeName}.`);
                 }
             }
             else if (prop.startsWith("element ")) {
@@ -229,239 +425,243 @@ export class GaussianSplattingMesh extends Mesh {
                 }
             }
         }
-        const rowVertexLength = rowVertexOffset;
-        const rowChunkLength = rowChunkOffset;
-        const rowOutputLength = 3 * 4 + 3 * 4 + 4 + 4; // Vector3 position, Vector3 scale, 1 u8 quaternion, 1 color with alpha
-        const SH_C0 = 0.28209479177387814;
-        let offset = 0;
         const dataView = new DataView(data, headerEndIndex + headerEnd.length);
-        const buffer = new ArrayBuffer(rowOutputLength * vertexCount);
-        const q = new Quaternion();
-        const temp3 = TmpVectors.Vector3[0];
-        const unpackUnorm = (value, bits) => {
-            const t = (1 << bits) - 1;
-            return (value & t) / t;
-        };
-        const unpack111011 = (value, result) => {
-            result.x = unpackUnorm(value >>> 21, 11);
-            result.y = unpackUnorm(value >>> 11, 10);
-            result.z = unpackUnorm(value, 11);
+        const buffer = new ArrayBuffer(GaussianSplattingMesh._RowOutputLength * vertexCount);
+        return {
+            vertexCount: vertexCount,
+            chunkCount: chunkCount,
+            rowVertexLength: rowVertexOffset,
+            rowChunkLength: rowChunkOffset,
+            vertexProperties: vertexProperties,
+            chunkProperties: chunkProperties,
+            dataView: dataView,
+            buffer: buffer,
         };
-        const unpack8888 = (value, result) => {
-            result[0] = unpackUnorm(value >>> 24, 8) * 255;
-            result[1] = unpackUnorm(value >>> 16, 8) * 255;
-            result[2] = unpackUnorm(value >>> 8, 8) * 255;
-            result[3] = unpackUnorm(value, 8) * 255;
-        };
-        // unpack quaternion with 2,10,10,10 format (largest element, 3x10bit element)
-        const unpackRot = (value, result) => {
-            const norm = 1.0 / (Math.sqrt(2) * 0.5);
-            const a = (unpackUnorm(value >>> 20, 10) - 0.5) * norm;
-            const b = (unpackUnorm(value >>> 10, 10) - 0.5) * norm;
-            const c = (unpackUnorm(value, 10) - 0.5) * norm;
-            const m = Math.sqrt(1.0 - (a * a + b * b + c * c));
-            switch (value >>> 30) {
-                case 0:
-                    result.set(m, a, b, c);
-                    break;
-                case 1:
-                    result.set(a, m, b, c);
-                    break;
-                case 2:
-                    result.set(a, b, m, c);
-                    break;
-                case 3:
-                    result.set(a, b, c, m);
-                    break;
-            }
-        };
-        const compressedChunks = new Array(chunkCount);
-        for (let i = 0; i < chunkCount; i++) {
+    }
+    static _GetCompressedChunks(header, offset) {
+        if (!header.chunkCount) {
+            return null;
+        }
+        const dataView = header.dataView;
+        const compressedChunks = new Array(header.chunkCount);
+        for (let i = 0; i < header.chunkCount; i++) {
             const currentChunk = { min: new Vector3(), max: new Vector3(), minScale: new Vector3(), maxScale: new Vector3() };
             compressedChunks[i] = currentChunk;
-            for (let propertyIndex = 0; propertyIndex < chunkProperties.length; propertyIndex++) {
-                const property = chunkProperties[propertyIndex];
+            for (let propertyIndex = 0; propertyIndex < header.chunkProperties.length; propertyIndex++) {
+                const property = header.chunkProperties[propertyIndex];
                 let value;
                 switch (property.type) {
-                    case "float":
-                        value = dataView.getFloat32(property.offset + offset, true);
+                    case 0 /* PLYType.FLOAT */:
+                        value = dataView.getFloat32(property.offset + offset.value, true);
                         break;
                     default:
                         continue;
                 }
-                switch (property.name) {
-                    case "min_x":
+                switch (property.value) {
+                    case 0 /* PLYValue.MIN_X */:
                         currentChunk.min.x = value;
                         break;
-                    case "min_y":
+                    case 1 /* PLYValue.MIN_Y */:
                         currentChunk.min.y = value;
                         break;
-                    case "min_z":
+                    case 2 /* PLYValue.MIN_Z */:
                         currentChunk.min.z = value;
                         break;
-                    case "max_x":
+                    case 3 /* PLYValue.MAX_X */:
                         currentChunk.max.x = value;
                         break;
-                    case "max_y":
+                    case 4 /* PLYValue.MAX_Y */:
                         currentChunk.max.y = value;
                         break;
-                    case "max_z":
+                    case 5 /* PLYValue.MAX_Z */:
                         currentChunk.max.z = value;
                         break;
-                    case "min_scale_x":
+                    case 6 /* PLYValue.MIN_SCALE_X */:
                         currentChunk.minScale.x = value;
                         break;
-                    case "min_scale_y":
+                    case 7 /* PLYValue.MIN_SCALE_Y */:
                         currentChunk.minScale.y = value;
                         break;
-                    case "min_scale_z":
+                    case 8 /* PLYValue.MIN_SCALE_Z */:
                         currentChunk.minScale.z = value;
                         break;
-                    case "max_scale_x":
+                    case 9 /* PLYValue.MAX_SCALE_X */:
                         currentChunk.maxScale.x = value;
                         break;
-                    case "max_scale_y":
+                    case 10 /* PLYValue.MAX_SCALE_Y */:
                         currentChunk.maxScale.y = value;
                         break;
-                    case "max_scale_z":
+                    case 11 /* PLYValue.MAX_SCALE_Z */:
                         currentChunk.maxScale.z = value;
                         break;
                 }
             }
-            offset += rowChunkLength;
+            offset.value += header.rowChunkLength;
         }
-        for (let i = 0; i < vertexCount; i++) {
-            const position = new Float32Array(buffer, i * rowOutputLength, 3);
-            const scale = new Float32Array(buffer, i * rowOutputLength + 12, 3);
-            const rgba = new Uint8ClampedArray(buffer, i * rowOutputLength + 24, 4);
-            const rot = new Uint8ClampedArray(buffer, i * rowOutputLength + 28, 4);
-            const chunkIndex = i >> 8;
-            let r0 = 255;
-            let r1 = 0;
-            let r2 = 0;
-            let r3 = 0;
-            for (let propertyIndex = 0; propertyIndex < vertexProperties.length; propertyIndex++) {
-                const property = vertexProperties[propertyIndex];
-                let value;
-                switch (property.type) {
-                    case "float":
-                        value = dataView.getFloat32(offset + property.offset, true);
-                        break;
-                    case "int":
-                        value = dataView.getInt32(offset + property.offset, true);
-                        break;
-                    case "uint":
-                        value = dataView.getUint32(offset + property.offset, true);
-                        break;
-                    case "double":
-                        value = dataView.getFloat64(offset + property.offset, true);
-                        break;
-                    case "uchar":
-                        value = dataView.getUint8(offset + property.offset);
-                        break;
-                    default:
-                        //throw new Error(`Unsupported property type: ${property.type}`);
-                        continue;
-                }
-                switch (property.name) {
-                    case "packed_position":
-                        {
-                            const compressedChunk = compressedChunks[chunkIndex];
-                            unpack111011(value, temp3);
-                            position[0] = Scalar.Lerp(compressedChunk.min.x, compressedChunk.max.x, temp3.x);
-                            position[1] = -Scalar.Lerp(compressedChunk.min.y, compressedChunk.max.y, temp3.y);
-                            position[2] = Scalar.Lerp(compressedChunk.min.z, compressedChunk.max.z, temp3.z);
-                        }
-                        break;
-                    case "packed_rotation":
-                        {
-                            unpackRot(value, q);
-                            r0 = q.w;
-                            r1 = q.z;
-                            r2 = q.y;
-                            r3 = q.x;
-                        }
-                        break;
-                    case "packed_scale":
-                        {
-                            const compressedChunk = compressedChunks[chunkIndex];
-                            unpack111011(value, temp3);
-                            scale[0] = Math.exp(Scalar.Lerp(compressedChunk.minScale.x, compressedChunk.maxScale.x, temp3.x));
-                            scale[1] = Math.exp(Scalar.Lerp(compressedChunk.minScale.y, compressedChunk.maxScale.y, temp3.y));
-                            scale[2] = Math.exp(Scalar.Lerp(compressedChunk.minScale.z, compressedChunk.maxScale.z, temp3.z));
-                        }
-                        break;
-                    case "packed_color":
-                        unpack8888(value, rgba);
-                        break;
-                    case "x":
-                        position[0] = value;
-                        break;
-                    case "y":
-                        position[1] = value;
-                        break;
-                    case "z":
-                        position[2] = value;
-                        break;
-                    case "scale_0":
-                        scale[0] = Math.exp(value);
-                        break;
-                    case "scale_1":
-                        scale[1] = Math.exp(value);
-                        break;
-                    case "scale_2":
-                        scale[2] = Math.exp(value);
-                        break;
-                    case "diffuse_red":
-                    case "red":
-                        rgba[0] = value;
-                        break;
-                    case "diffuse_green":
-                    case "green":
-                        rgba[1] = value;
-                        break;
-                    case "diffuse_blue":
-                    case "blue":
-                        rgba[2] = value;
-                        break;
-                    case "f_dc_0":
-                        rgba[0] = (0.5 + SH_C0 * value) * 255;
-                        break;
-                    case "f_dc_1":
-                        rgba[1] = (0.5 + SH_C0 * value) * 255;
-                        break;
-                    case "f_dc_2":
-                        rgba[2] = (0.5 + SH_C0 * value) * 255;
-                        break;
-                    case "f_dc_3":
-                        rgba[3] = (0.5 + SH_C0 * value) * 255;
-                        break;
-                    case "opacity":
-                        rgba[3] = (1 / (1 + Math.exp(-value))) * 255;
-                        break;
-                    case "rot_0":
-                        r0 = value;
-                        break;
-                    case "rot_1":
-                        r1 = value;
-                        break;
-                    case "rot_2":
-                        r2 = value;
-                        break;
-                    case "rot_3":
-                        r3 = value;
-                        break;
-                }
+        return compressedChunks;
+    }
+    static _GetSplat(header, index, compressedChunks, offset) {
+        const q = TmpVectors.Quaternion[0];
+        const temp3 = TmpVectors.Vector3[0];
+        const rowOutputLength = GaussianSplattingMesh._RowOutputLength;
+        const buffer = header.buffer;
+        const dataView = header.dataView;
+        const position = new Float32Array(buffer, index * rowOutputLength, 3);
+        const scale = new Float32Array(buffer, index * rowOutputLength + 12, 3);
+        const rgba = new Uint8ClampedArray(buffer, index * rowOutputLength + 24, 4);
+        const rot = new Uint8ClampedArray(buffer, index * rowOutputLength + 28, 4);
+        const chunkIndex = index >> 8;
+        let r0 = 255;
+        let r1 = 0;
+        let r2 = 0;
+        let r3 = 0;
+        for (let propertyIndex = 0; propertyIndex < header.vertexProperties.length; propertyIndex++) {
+            const property = header.vertexProperties[propertyIndex];
+            let value;
+            switch (property.type) {
+                case 0 /* PLYType.FLOAT */:
+                    value = dataView.getFloat32(offset.value + property.offset, true);
+                    break;
+                case 1 /* PLYType.INT */:
+                    value = dataView.getInt32(offset.value + property.offset, true);
+                    break;
+                case 2 /* PLYType.UINT */:
+                    value = dataView.getUint32(offset.value + property.offset, true);
+                    break;
+                case 3 /* PLYType.DOUBLE */:
+                    value = dataView.getFloat64(offset.value + property.offset, true);
+                    break;
+                case 4 /* PLYType.UCHAR */:
+                    value = dataView.getUint8(offset.value + property.offset);
+                    break;
+                default:
+                    continue;
+            }
+            switch (property.value) {
+                case 12 /* PLYValue.PACKED_POSITION */:
+                    {
+                        const compressedChunk = compressedChunks[chunkIndex];
+                        unpack111011(value, temp3);
+                        position[0] = Scalar.Lerp(compressedChunk.min.x, compressedChunk.max.x, temp3.x);
+                        position[1] = -Scalar.Lerp(compressedChunk.min.y, compressedChunk.max.y, temp3.y);
+                        position[2] = Scalar.Lerp(compressedChunk.min.z, compressedChunk.max.z, temp3.z);
+                    }
+                    break;
+                case 13 /* PLYValue.PACKED_ROTATION */:
+                    {
+                        unpackRot(value, q);
+                        r0 = q.w;
+                        r1 = q.z;
+                        r2 = q.y;
+                        r3 = q.x;
+                    }
+                    break;
+                case 14 /* PLYValue.PACKED_SCALE */:
+                    {
+                        const compressedChunk = compressedChunks[chunkIndex];
+                        unpack111011(value, temp3);
+                        scale[0] = Math.exp(Scalar.Lerp(compressedChunk.minScale.x, compressedChunk.maxScale.x, temp3.x));
+                        scale[1] = Math.exp(Scalar.Lerp(compressedChunk.minScale.y, compressedChunk.maxScale.y, temp3.y));
+                        scale[2] = Math.exp(Scalar.Lerp(compressedChunk.minScale.z, compressedChunk.maxScale.z, temp3.z));
+                    }
+                    break;
+                case 15 /* PLYValue.PACKED_COLOR */:
+                    unpack8888(value, rgba);
+                    break;
+                case 16 /* PLYValue.X */:
+                    position[0] = value;
+                    break;
+                case 17 /* PLYValue.Y */:
+                    position[1] = value;
+                    break;
+                case 18 /* PLYValue.Z */:
+                    position[2] = value;
+                    break;
+                case 19 /* PLYValue.SCALE_0 */:
+                    scale[0] = Math.exp(value);
+                    break;
+                case 20 /* PLYValue.SCALE_1 */:
+                    scale[1] = Math.exp(value);
+                    break;
+                case 21 /* PLYValue.SCALE_2 */:
+                    scale[2] = Math.exp(value);
+                    break;
+                case 22 /* PLYValue.DIFFUSE_RED */:
+                    rgba[0] = value;
+                    break;
+                case 23 /* PLYValue.DIFFUSE_GREEN */:
+                    rgba[1] = value;
+                    break;
+                case 24 /* PLYValue.DIFFUSE_BLUE */:
+                    rgba[2] = value;
+                    break;
+                case 26 /* PLYValue.F_DC_0 */:
+                    rgba[0] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
+                    break;
+                case 27 /* PLYValue.F_DC_1 */:
+                    rgba[1] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
+                    break;
+                case 28 /* PLYValue.F_DC_2 */:
+                    rgba[2] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
+                    break;
+                case 29 /* PLYValue.F_DC_3 */:
+                    rgba[3] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
+                    break;
+                case 25 /* PLYValue.OPACITY */:
+                    rgba[3] = (1 / (1 + Math.exp(-value))) * 255;
+                    break;
+                case 30 /* PLYValue.ROT_0 */:
+                    r0 = value;
+                    break;
+                case 31 /* PLYValue.ROT_1 */:
+                    r1 = value;
+                    break;
+                case 32 /* PLYValue.ROT_2 */:
+                    r2 = value;
+                    break;
+                case 33 /* PLYValue.ROT_3 */:
+                    r3 = value;
+                    break;
             }
-            q.set(r1, r2, r3, r0);
-            q.normalize();
-            rot[0] = q.w * 128 + 128;
-            rot[1] = q.x * 128 + 128;
-            rot[2] = q.y * 128 + 128;
-            rot[3] = q.z * 128 + 128;
-            offset += rowVertexLength;
         }
-        return buffer;
+        q.set(r1, r2, r3, r0);
+        q.normalize();
+        rot[0] = q.w * 128 + 128;
+        rot[1] = q.x * 128 + 128;
+        rot[2] = q.y * 128 + 128;
+        rot[3] = q.z * 128 + 128;
+        offset.value += header.rowVertexLength;
+    }
+    /**
+     * Converts a .ply data array buffer to splat
+     * if data array buffer is not ply, returns the original buffer
+     * @param data the .ply data to load
+     * @param useCoroutine use coroutine and yield
+     * @returns the loaded splat buffer
+     */
+    static *ConvertPLYToSplat(data, useCoroutine = false) {
+        const header = GaussianSplattingMesh.ParseHeader(data);
+        if (!header) {
+            return data;
+        }
+        const offset = { value: 0 };
+        const compressedChunks = GaussianSplattingMesh._GetCompressedChunks(header, offset);
+        for (let i = 0; i < header.vertexCount; i++) {
+            GaussianSplattingMesh._GetSplat(header, i, compressedChunks, offset);
+            if (i % 30000 === 0 && useCoroutine) {
+                yield;
+            }
+        }
+        return header.buffer;
+    }
+    /**
+     * Converts a .ply data array buffer to splat
+     * if data array buffer is not ply, returns the original buffer
+     * @param data the .ply data to load
+     * @returns the loaded splat buffer
+     */
+    static async ConvertPLYToSplatAsync(data) {
+        return runCoroutineAsync(GaussianSplattingMesh.ConvertPLYToSplat(data, true), createYieldingScheduler());
     }
     /**
      * Loads a .splat Gaussian Splatting array buffer asynchronously
@@ -469,7 +669,7 @@ export class GaussianSplattingMesh extends Mesh {
      * @returns a promise that resolves when the operation is complete
      */
     loadDataAsync(data) {
-        return Promise.resolve(this._loadData(data));
+        return this.updateDataAsync(data);
     }
     /**
      * Loads a .splat Gaussian or .ply Splatting file asynchronously
@@ -478,8 +678,10 @@ export class GaussianSplattingMesh extends Mesh {
      * @deprecated Please use SceneLoader.ImportMeshAsync instead
      */
     loadFileAsync(url) {
-        return Tools.LoadFileAsync(url, true).then((data) => {
-            this._loadData(GaussianSplattingMesh.ConvertPLYToSplat(data));
+        return Tools.LoadFileAsync(url, true).then(async (plyBuffer) => {
+            GaussianSplattingMesh.ConvertPLYToSplatAsync(plyBuffer).then((splatsData) => {
+                this.updateDataAsync(splatsData);
+            });
         });
     }
     /**
@@ -526,78 +728,52 @@ export class GaussianSplattingMesh extends Mesh {
         newGS.setEnabled(true);
         return newGS;
     }
-    /**
-     * @experimental
-     * Update data from GS (position, orientation, color, scaling)
-     * @param data array that contain all the datas
-     */
-    updateData(data) {
-        if (!data.byteLength) {
-            return;
-        }
-        // if a covariance texture is present, then it's not a creation but an update
-        if (!this._covariancesATexture) {
-            this._readyToDisplay = false;
-        }
-        // Parse the data
-        const uBuffer = new Uint8Array(data);
-        const fBuffer = new Float32Array(uBuffer.buffer);
-        const rowLength = 3 * 4 + 3 * 4 + 4 + 4;
-        const vertexCount = uBuffer.length / rowLength;
-        if (vertexCount != this._vertexCount) {
-            this._updateSplatIndexBuffer(vertexCount);
-        }
-        this._vertexCount = vertexCount;
-        const textureSize = this._getTextureSize(vertexCount);
-        const textureLength = textureSize.x * textureSize.y;
-        this._splatPositions = new Float32Array(4 * textureLength);
-        const covA = new Uint16Array(4 * textureLength);
-        const covB = new Uint16Array((this._useRGBACovariants ? 4 : 2) * textureLength);
+    _makeSplat(sourceIndex, destinationIndex, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum) {
         const matrixRotation = TmpVectors.Matrix[0];
         const matrixScale = TmpVectors.Matrix[1];
         const quaternion = TmpVectors.Quaternion[0];
-        const minimum = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-        const maximum = new Vector3(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
-        const covariances = [0, 0, 0, 0, 0, 0];
-        const covBSplatSize = this._useRGBACovariants ? 4 : 2;
-        for (let i = 0; i < vertexCount; i++) {
-            const x = fBuffer[8 * i + 0];
-            const y = -fBuffer[8 * i + 1];
-            const z = fBuffer[8 * i + 2];
-            this._splatPositions[4 * i + 0] = x;
-            this._splatPositions[4 * i + 1] = y;
-            this._splatPositions[4 * i + 2] = z;
-            minimum.minimizeInPlaceFromFloats(x, y, z);
-            maximum.maximizeInPlaceFromFloats(x, y, z);
-            quaternion.set((uBuffer[32 * i + 28 + 1] - 128) / 128, (uBuffer[32 * i + 28 + 2] - 128) / 128, (uBuffer[32 * i + 28 + 3] - 128) / 128, -(uBuffer[32 * i + 28 + 0] - 128) / 128);
-            quaternion.toRotationMatrix(matrixRotation);
-            Matrix.ScalingToRef(fBuffer[8 * i + 3 + 0] * 2, fBuffer[8 * i + 3 + 1] * 2, fBuffer[8 * i + 3 + 2] * 2, matrixScale);
-            const M = matrixRotation.multiplyToRef(matrixScale, TmpVectors.Matrix[0]).m;
-            covariances[0] = M[0] * M[0] + M[1] * M[1] + M[2] * M[2];
-            covariances[1] = M[0] * M[4] + M[1] * M[5] + M[2] * M[6];
-            covariances[2] = M[0] * M[8] + M[1] * M[9] + M[2] * M[10];
-            covariances[3] = M[4] * M[4] + M[5] * M[5] + M[6] * M[6];
-            covariances[4] = M[4] * M[8] + M[5] * M[9] + M[6] * M[10];
-            covariances[5] = M[8] * M[8] + M[9] * M[9] + M[10] * M[10];
-            // normalize covA, covB
-            let factor = -10000;
-            for (let covIndex = 0; covIndex < 6; covIndex++) {
-                factor = Math.max(factor, Math.abs(covariances[covIndex]));
-            }
-            this._splatPositions[4 * i + 3] = factor;
-            const transform = factor;
-            covA[i * 4 + 0] = ToHalfFloat(covariances[0] / transform);
-            covA[i * 4 + 1] = ToHalfFloat(covariances[1] / transform);
-            covA[i * 4 + 2] = ToHalfFloat(covariances[2] / transform);
-            covA[i * 4 + 3] = ToHalfFloat(covariances[3] / transform);
-            covB[i * covBSplatSize + 0] = ToHalfFloat(covariances[4] / transform);
-            covB[i * covBSplatSize + 1] = ToHalfFloat(covariances[5] / transform);
+        const covBSItemSize = this._useRGBACovariants ? 4 : 2;
+        const x = fBuffer[8 * sourceIndex + 0];
+        const y = -fBuffer[8 * sourceIndex + 1];
+        const z = fBuffer[8 * sourceIndex + 2];
+        this._splatPositions[4 * sourceIndex + 0] = x;
+        this._splatPositions[4 * sourceIndex + 1] = y;
+        this._splatPositions[4 * sourceIndex + 2] = z;
+        minimum.minimizeInPlaceFromFloats(x, y, z);
+        maximum.maximizeInPlaceFromFloats(x, y, z);
+        quaternion.set((uBuffer[32 * sourceIndex + 28 + 1] - 128) / 128, (uBuffer[32 * sourceIndex + 28 + 2] - 128) / 128, (uBuffer[32 * sourceIndex + 28 + 3] - 128) / 128, -(uBuffer[32 * sourceIndex + 28 + 0] - 128) / 128);
+        quaternion.toRotationMatrix(matrixRotation);
+        Matrix.ScalingToRef(fBuffer[8 * sourceIndex + 3 + 0] * 2, fBuffer[8 * sourceIndex + 3 + 1] * 2, fBuffer[8 * sourceIndex + 3 + 2] * 2, matrixScale);
+        const M = matrixRotation.multiplyToRef(matrixScale, TmpVectors.Matrix[0]).m;
+        const covariances = this._tmpCovariances;
+        covariances[0] = M[0] * M[0] + M[1] * M[1] + M[2] * M[2];
+        covariances[1] = M[0] * M[4] + M[1] * M[5] + M[2] * M[6];
+        covariances[2] = M[0] * M[8] + M[1] * M[9] + M[2] * M[10];
+        covariances[3] = M[4] * M[4] + M[5] * M[5] + M[6] * M[6];
+        covariances[4] = M[4] * M[8] + M[5] * M[9] + M[6] * M[10];
+        covariances[5] = M[8] * M[8] + M[9] * M[9] + M[10] * M[10];
+        // normalize covA, covB
+        let factor = -10000;
+        for (let covIndex = 0; covIndex < 6; covIndex++) {
+            factor = Math.max(factor, Math.abs(covariances[covIndex]));
         }
-        // Update the mesh
-        const binfo = this.getBoundingInfo();
-        binfo.reConstruct(minimum, maximum, this.getWorldMatrix());
-        this.setEnabled(true);
-        // Update the material
+        this._splatPositions[4 * sourceIndex + 3] = factor;
+        const transform = factor;
+        covA[destinationIndex * 4 + 0] = ToHalfFloat(covariances[0] / transform);
+        covA[destinationIndex * 4 + 1] = ToHalfFloat(covariances[1] / transform);
+        covA[destinationIndex * 4 + 2] = ToHalfFloat(covariances[2] / transform);
+        covA[destinationIndex * 4 + 3] = ToHalfFloat(covariances[3] / transform);
+        covB[destinationIndex * covBSItemSize + 0] = ToHalfFloat(covariances[4] / transform);
+        covB[destinationIndex * covBSItemSize + 1] = ToHalfFloat(covariances[5] / transform);
+        // colors
+        colorArray[destinationIndex * 4 + 0] = uBuffer[32 * sourceIndex + 24 + 0];
+        colorArray[destinationIndex * 4 + 1] = uBuffer[32 * sourceIndex + 24 + 1];
+        colorArray[destinationIndex * 4 + 2] = uBuffer[32 * sourceIndex + 24 + 2];
+        colorArray[destinationIndex * 4 + 3] = uBuffer[32 * sourceIndex + 24 + 3];
+    }
+    _updateTextures(covA, covB, colorArray) {
+        const textureSize = this._getTextureSize(this._vertexCount);
+        // Update the textures
         const createTextureFromData = (data, width, height, format) => {
             return new RawTexture(data, width, height, format, this._scene, false, false, 2, 1);
         };
@@ -607,13 +783,6 @@ export class GaussianSplattingMesh extends Mesh {
         const createTextureFromDataF16 = (data, width, height, format) => {
             return new RawTexture(data, width, height, format, this._scene, false, false, 2, 2);
         };
-        const colorArray = new Uint8Array(textureSize.x * textureSize.y * 4);
-        for (let i = 0; i < this._vertexCount; ++i) {
-            colorArray[i * 4 + 0] = uBuffer[32 * i + 24 + 0];
-            colorArray[i * 4 + 1] = uBuffer[32 * i + 24 + 1];
-            colorArray[i * 4 + 2] = uBuffer[32 * i + 24 + 2];
-            colorArray[i * 4 + 3] = uBuffer[32 * i + 24 + 3];
-        }
         if (this._keepInRam) {
             this._covariancesA = covA;
             this._covariancesB = covB;
@@ -634,11 +803,83 @@ export class GaussianSplattingMesh extends Mesh {
             this._instanciateWorker();
         }
     }
-    _loadData(data) {
-        if (!data.byteLength) {
-            return;
+    *_updateData(data, isAsync) {
+        // if a covariance texture is present, then it's not a creation but an update
+        if (!this._covariancesATexture) {
+            this._readyToDisplay = false;
+        }
+        // Parse the data
+        const uBuffer = new Uint8Array(data);
+        const fBuffer = new Float32Array(uBuffer.buffer);
+        const vertexCount = uBuffer.length / GaussianSplattingMesh._RowOutputLength;
+        if (vertexCount != this._vertexCount) {
+            this._updateSplatIndexBuffer(vertexCount);
+        }
+        this._vertexCount = vertexCount;
+        const textureSize = this._getTextureSize(vertexCount);
+        const textureLength = textureSize.x * textureSize.y;
+        const lineCountUpdate = GaussianSplattingMesh.ProgressiveUpdateAmount ?? textureSize.y;
+        const textureLengthPerUpdate = textureSize.x * lineCountUpdate;
+        this._splatPositions = new Float32Array(4 * textureLength);
+        const covA = new Uint16Array(textureLength * 4);
+        const covB = new Uint16Array((this._useRGBACovariants ? 4 : 2) * textureLength);
+        const colorArray = new Uint8Array(textureLength * 4);
+        const minimum = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
+        const maximum = new Vector3(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+        if (GaussianSplattingMesh.ProgressiveUpdateAmount) {
+            // create textures with not filled-yet array, then update directly portions of it
+            this._updateTextures(covA, covB, colorArray);
+            this.setEnabled(true);
+            const partCount = Math.ceil(textureSize.y / lineCountUpdate);
+            for (let partIndex = 0; partIndex < partCount; partIndex++) {
+                const updateLine = partIndex * lineCountUpdate;
+                const splatIndexBase = updateLine * textureSize.x;
+                for (let i = 0; i < textureLengthPerUpdate; i++) {
+                    this._makeSplat(splatIndexBase + i, splatIndexBase + i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum);
+                }
+                this._updateSubTextures(this._splatPositions, covA, covB, colorArray, updateLine, Math.min(lineCountUpdate, textureSize.y - updateLine));
+                // Update the binfo
+                this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
+                if (isAsync) {
+                    yield;
+                }
+            }
+            // sort will be dirty here as just finished filled positions will not be sorted
+            const positions = Float32Array.from(this._splatPositions);
+            const vertexCount = this._vertexCount;
+            this._worker.postMessage({ positions, vertexCount }, [positions.buffer]);
+            this._sortIsDirty = true;
+        }
+        else {
+            for (let i = 0; i < vertexCount; i++) {
+                this._makeSplat(i, i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum);
+                if (isAsync && i % 327680 === 0) {
+                    yield;
+                }
+            }
+            // textures
+            this._updateTextures(covA, covB, colorArray);
+            // Update the binfo
+            this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
+            this.setEnabled(true);
         }
-        this.updateData(data);
+        this._postToWorker(true);
+    }
+    /**
+     * Update asynchronously the buffer
+     * @param data array buffer containing center, color, orientation and scale of splats
+     * @returns a promise
+     */
+    async updateDataAsync(data) {
+        return runCoroutineAsync(this._updateData(data, true), createYieldingScheduler());
+    }
+    /**
+     * @experimental
+     * Update data from GS (position, orientation, color, scaling)
+     * @param data array that contain all the datas
+     */
+    updateData(data) {
+        runCoroutineSync(this._updateData(data, false));
     }
     // in case size is different
     _updateSplatIndexBuffer(vertexCount) {
@@ -648,6 +889,29 @@ export class GaussianSplattingMesh extends Mesh {
         }
         this.forcedInstanceCount = vertexCount;
     }
+    _updateSubTextures(centers, covA, covB, colors, lineStart, lineCount) {
+        const updateTextureFromData = (texture, data, width, lineStart, lineCount) => {
+            this.getEngine().updateTextureData(texture.getInternalTexture(), data, 0, lineStart, width, lineCount, 0, 0, false);
+        };
+        const updateTextureFromDataU8 = (texture, data, width, lineStart, lineCount) => {
+            this.getEngine().updateTextureData(texture.getInternalTexture(), data, 0, lineStart, width, lineCount, 0, 0, false);
+        };
+        const updateTextureFromDataF16 = (texture, data, width, lineStart, lineCount) => {
+            this.getEngine().updateTextureData(texture.getInternalTexture(), data, 0, lineStart, width, lineCount, 0, 0, false);
+        };
+        const textureSize = this._getTextureSize(this._vertexCount);
+        const covBSItemSize = this._useRGBACovariants ? 4 : 2;
+        const texelStart = lineStart * textureSize.x;
+        const texelCount = lineCount * textureSize.x;
+        const covAView = new Uint16Array(covA.buffer, texelStart * 4 * Uint16Array.BYTES_PER_ELEMENT, texelCount * 4);
+        const covBView = new Uint16Array(covB.buffer, texelStart * covBSItemSize * Uint16Array.BYTES_PER_ELEMENT, texelCount * covBSItemSize);
+        const colorsView = new Uint8Array(colors.buffer, texelStart * 4, texelCount * 4);
+        const centersView = new Float32Array(centers.buffer, texelStart * 4 * Float32Array.BYTES_PER_ELEMENT, texelCount * 4);
+        updateTextureFromDataF16(this._covariancesATexture, covAView, textureSize.x, lineStart, lineCount);
+        updateTextureFromDataF16(this._covariancesBTexture, covBView, textureSize.x, lineStart, lineCount);
+        updateTextureFromData(this._centersTexture, centersView, textureSize.x, lineStart, lineCount);
+        updateTextureFromDataU8(this._colorsTexture, colorsView, textureSize.x, lineStart, lineCount);
+    }
     _instanciateWorker() {
         if (!this._vertexCount) {
             return;
@@ -671,25 +935,19 @@ export class GaussianSplattingMesh extends Mesh {
                 }
             }
             if (this._delayedTextureUpdate) {
-                const updateTextureFromData = (texture, data, width, height) => {
-                    this.getEngine().updateTextureData(texture.getInternalTexture(), data, 0, 0, width, height, 0, 0, false);
-                };
-                const updateTextureFromDataU8 = (texture, data, width, height) => {
-                    this.getEngine().updateTextureData(texture.getInternalTexture(), data, 0, 0, width, height, 0, 0, false);
-                };
-                const updateTextureFromDataF16 = (texture, data, width, height) => {
-                    this.getEngine().updateTextureData(texture.getInternalTexture(), data, 0, 0, width, height, 0, 0, false);
-                };
                 const textureSize = this._getTextureSize(vertexCount);
-                updateTextureFromDataF16(this._covariancesATexture, this._delayedTextureUpdate.covA, textureSize.x, textureSize.y);
-                updateTextureFromDataF16(this._covariancesBTexture, this._delayedTextureUpdate.covB, textureSize.x, textureSize.y);
-                updateTextureFromData(this._centersTexture, this._delayedTextureUpdate.centers, textureSize.x, textureSize.y);
-                updateTextureFromDataU8(this._colorsTexture, this._delayedTextureUpdate.colors, textureSize.x, textureSize.y);
+                this._updateSubTextures(this._delayedTextureUpdate.centers, this._delayedTextureUpdate.covA, this._delayedTextureUpdate.covB, this._delayedTextureUpdate.colors, 0, textureSize.y);
                 this._delayedTextureUpdate = null;
             }
             this.thinInstanceBufferUpdated("splatIndex");
             this._canPostToWorker = true;
             this._readyToDisplay = true;
+            // sort is dirty when GS is visible for progressive update with a this message arriving but positions were partially filled
+            // another update needs to be kicked. The kick can't happen just when the position buffer is ready because _canPostToWorker might be false.
+            if (this._sortIsDirty) {
+                this._postToWorker(true);
+                this._sortIsDirty = false;
+            }
         };
     }
     _getTextureSize(length) {
@@ -711,6 +969,13 @@ export class GaussianSplattingMesh extends Mesh {
         return new Vector2(width, height);
     }
 }
+GaussianSplattingMesh._RowOutputLength = 3 * 4 + 3 * 4 + 4 + 4; // Vector3 position, Vector3 scale, 1 u8 quaternion, 1 color with alpha
+GaussianSplattingMesh._SH_C0 = 0.28209479177387814;
+/**
+ * Set the number of batch (a batch is 16384 splats) after which a display update is performed
+ * A value of 0 (default) means display update will not happens before splat is ready.
+ */
+GaussianSplattingMesh.ProgressiveUpdateAmount = 0;
 GaussianSplattingMesh._CreateWorker = function (self) {
     let vertexCount = 0;
     let positions;