@babylonjs/core 7.42.0 → 7.44.0

package/Meshes/GaussianSplatting/gaussianSplattingMesh.js

@@ -11,6 +11,7 @@ import "../thinInstanceMesh.js";
 import { ToHalfFloat } from "../../Misc/textureTools.js";
 import { Scalar } from "../../Maths/math.scalar.js";
 import { runCoroutineSync, runCoroutineAsync, createYieldingScheduler } from "../../Misc/coroutine.js";
+import { EngineStore } from "../../Engines/engineStore.js";
 // @internal
 const unpackUnorm = (value, bits) => {
     const t = (1 << bits) - 1;
@@ -103,7 +104,58 @@ var PLYValue;
     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["MIN_COLOR_R"] = 34] = "MIN_COLOR_R";
+    PLYValue[PLYValue["MIN_COLOR_G"] = 35] = "MIN_COLOR_G";
+    PLYValue[PLYValue["MIN_COLOR_B"] = 36] = "MIN_COLOR_B";
+    PLYValue[PLYValue["MAX_COLOR_R"] = 37] = "MAX_COLOR_R";
+    PLYValue[PLYValue["MAX_COLOR_G"] = 38] = "MAX_COLOR_G";
+    PLYValue[PLYValue["MAX_COLOR_B"] = 39] = "MAX_COLOR_B";
+    PLYValue[PLYValue["SH_0"] = 40] = "SH_0";
+    PLYValue[PLYValue["SH_1"] = 41] = "SH_1";
+    PLYValue[PLYValue["SH_2"] = 42] = "SH_2";
+    PLYValue[PLYValue["SH_3"] = 43] = "SH_3";
+    PLYValue[PLYValue["SH_4"] = 44] = "SH_4";
+    PLYValue[PLYValue["SH_5"] = 45] = "SH_5";
+    PLYValue[PLYValue["SH_6"] = 46] = "SH_6";
+    PLYValue[PLYValue["SH_7"] = 47] = "SH_7";
+    PLYValue[PLYValue["SH_8"] = 48] = "SH_8";
+    PLYValue[PLYValue["SH_9"] = 49] = "SH_9";
+    PLYValue[PLYValue["SH_10"] = 50] = "SH_10";
+    PLYValue[PLYValue["SH_11"] = 51] = "SH_11";
+    PLYValue[PLYValue["SH_12"] = 52] = "SH_12";
+    PLYValue[PLYValue["SH_13"] = 53] = "SH_13";
+    PLYValue[PLYValue["SH_14"] = 54] = "SH_14";
+    PLYValue[PLYValue["SH_15"] = 55] = "SH_15";
+    PLYValue[PLYValue["SH_16"] = 56] = "SH_16";
+    PLYValue[PLYValue["SH_17"] = 57] = "SH_17";
+    PLYValue[PLYValue["SH_18"] = 58] = "SH_18";
+    PLYValue[PLYValue["SH_19"] = 59] = "SH_19";
+    PLYValue[PLYValue["SH_20"] = 60] = "SH_20";
+    PLYValue[PLYValue["SH_21"] = 61] = "SH_21";
+    PLYValue[PLYValue["SH_22"] = 62] = "SH_22";
+    PLYValue[PLYValue["SH_23"] = 63] = "SH_23";
+    PLYValue[PLYValue["SH_24"] = 64] = "SH_24";
+    PLYValue[PLYValue["SH_25"] = 65] = "SH_25";
+    PLYValue[PLYValue["SH_26"] = 66] = "SH_26";
+    PLYValue[PLYValue["SH_27"] = 67] = "SH_27";
+    PLYValue[PLYValue["SH_28"] = 68] = "SH_28";
+    PLYValue[PLYValue["SH_29"] = 69] = "SH_29";
+    PLYValue[PLYValue["SH_30"] = 70] = "SH_30";
+    PLYValue[PLYValue["SH_31"] = 71] = "SH_31";
+    PLYValue[PLYValue["SH_32"] = 72] = "SH_32";
+    PLYValue[PLYValue["SH_33"] = 73] = "SH_33";
+    PLYValue[PLYValue["SH_34"] = 74] = "SH_34";
+    PLYValue[PLYValue["SH_35"] = 75] = "SH_35";
+    PLYValue[PLYValue["SH_36"] = 76] = "SH_36";
+    PLYValue[PLYValue["SH_37"] = 77] = "SH_37";
+    PLYValue[PLYValue["SH_38"] = 78] = "SH_38";
+    PLYValue[PLYValue["SH_39"] = 79] = "SH_39";
+    PLYValue[PLYValue["SH_40"] = 80] = "SH_40";
+    PLYValue[PLYValue["SH_41"] = 81] = "SH_41";
+    PLYValue[PLYValue["SH_42"] = 82] = "SH_42";
+    PLYValue[PLYValue["SH_43"] = 83] = "SH_43";
+    PLYValue[PLYValue["SH_44"] = 84] = "SH_44";
+    PLYValue[PLYValue["UNDEFINED"] = 85] = "UNDEFINED";
 })(PLYValue || (PLYValue = {}));
 /**
  * Class used to render a gaussian splatting mesh
@@ -371,8 +423,110 @@ export class GaussianSplattingMesh extends Mesh {
                 return 32 /* PLYValue.ROT_2 */;
             case "rot_3":
                 return 33 /* PLYValue.ROT_3 */;
+            case "min_r":
+                return 34 /* PLYValue.MIN_COLOR_R */;
+            case "min_g":
+                return 35 /* PLYValue.MIN_COLOR_G */;
+            case "min_b":
+                return 36 /* PLYValue.MIN_COLOR_B */;
+            case "max_r":
+                return 37 /* PLYValue.MAX_COLOR_R */;
+            case "max_g":
+                return 38 /* PLYValue.MAX_COLOR_G */;
+            case "max_b":
+                return 39 /* PLYValue.MAX_COLOR_B */;
+            case "f_rest_0":
+                return 40 /* PLYValue.SH_0 */;
+            case "f_rest_1":
+                return 41 /* PLYValue.SH_1 */;
+            case "f_rest_2":
+                return 42 /* PLYValue.SH_2 */;
+            case "f_rest_3":
+                return 43 /* PLYValue.SH_3 */;
+            case "f_rest_4":
+                return 44 /* PLYValue.SH_4 */;
+            case "f_rest_5":
+                return 45 /* PLYValue.SH_5 */;
+            case "f_rest_6":
+                return 46 /* PLYValue.SH_6 */;
+            case "f_rest_7":
+                return 47 /* PLYValue.SH_7 */;
+            case "f_rest_8":
+                return 48 /* PLYValue.SH_8 */;
+            case "f_rest_9":
+                return 49 /* PLYValue.SH_9 */;
+            case "f_rest_10":
+                return 50 /* PLYValue.SH_10 */;
+            case "f_rest_11":
+                return 51 /* PLYValue.SH_11 */;
+            case "f_rest_12":
+                return 52 /* PLYValue.SH_12 */;
+            case "f_rest_13":
+                return 53 /* PLYValue.SH_13 */;
+            case "f_rest_14":
+                return 54 /* PLYValue.SH_14 */;
+            case "f_rest_15":
+                return 55 /* PLYValue.SH_15 */;
+            case "f_rest_16":
+                return 56 /* PLYValue.SH_16 */;
+            case "f_rest_17":
+                return 57 /* PLYValue.SH_17 */;
+            case "f_rest_18":
+                return 58 /* PLYValue.SH_18 */;
+            case "f_rest_19":
+                return 59 /* PLYValue.SH_19 */;
+            case "f_rest_20":
+                return 60 /* PLYValue.SH_20 */;
+            case "f_rest_21":
+                return 61 /* PLYValue.SH_21 */;
+            case "f_rest_22":
+                return 62 /* PLYValue.SH_22 */;
+            case "f_rest_23":
+                return 63 /* PLYValue.SH_23 */;
+            case "f_rest_24":
+                return 64 /* PLYValue.SH_24 */;
+            case "f_rest_25":
+                return 65 /* PLYValue.SH_25 */;
+            case "f_rest_26":
+                return 66 /* PLYValue.SH_26 */;
+            case "f_rest_27":
+                return 67 /* PLYValue.SH_27 */;
+            case "f_rest_28":
+                return 68 /* PLYValue.SH_28 */;
+            case "f_rest_29":
+                return 69 /* PLYValue.SH_29 */;
+            case "f_rest_30":
+                return 70 /* PLYValue.SH_30 */;
+            case "f_rest_31":
+                return 71 /* PLYValue.SH_31 */;
+            case "f_rest_32":
+                return 72 /* PLYValue.SH_32 */;
+            case "f_rest_33":
+                return 73 /* PLYValue.SH_33 */;
+            case "f_rest_34":
+                return 74 /* PLYValue.SH_34 */;
+            case "f_rest_35":
+                return 75 /* PLYValue.SH_35 */;
+            case "f_rest_36":
+                return 76 /* PLYValue.SH_36 */;
+            case "f_rest_37":
+                return 77 /* PLYValue.SH_37 */;
+            case "f_rest_38":
+                return 78 /* PLYValue.SH_38 */;
+            case "f_rest_39":
+                return 79 /* PLYValue.SH_39 */;
+            case "f_rest_40":
+                return 80 /* PLYValue.SH_40 */;
+            case "f_rest_41":
+                return 81 /* PLYValue.SH_41 */;
+            case "f_rest_42":
+                return 82 /* PLYValue.SH_42 */;
+            case "f_rest_43":
+                return 83 /* PLYValue.SH_43 */;
+            case "f_rest_44":
+                return 84 /* PLYValue.SH_44 */;
         }
-        return 34 /* PLYValue.UNDEFINED */;
+        return 85 /* PLYValue.UNDEFINED */;
     }
     /**
      * Parse a PLY file header and returns metas infos on splats and chunks
@@ -415,10 +569,21 @@ export class GaussianSplattingMesh extends Mesh {
         const vertexProperties = [];
         const chunkProperties = [];
         const filtered = header.slice(0, headerEndIndex).split("\n");
+        let shDegree = 0;
         for (const prop of filtered) {
             if (prop.startsWith("property ")) {
                 const [, typeName, name] = prop.split(" ");
                 const value = GaussianSplattingMesh._ValueNameToEnum(name);
+                // SH degree 1,2 or 3 for 9, 24 or 45 values
+                if (value >= 84 /* PLYValue.SH_44 */) {
+                    shDegree = 3;
+                }
+                else if (value >= 64 /* PLYValue.SH_24 */) {
+                    shDegree = 2;
+                }
+                else if (value >= 48 /* PLYValue.SH_8 */) {
+                    shDegree = 1;
+                }
                 const type = GaussianSplattingMesh._TypeNameToEnum(typeName);
                 if (chunkMode == 1 /* ElementMode.Chunk */) {
                     chunkProperties.push({ value, type, offset: rowChunkOffset });
@@ -444,6 +609,13 @@ export class GaussianSplattingMesh extends Mesh {
         }
         const dataView = new DataView(data, headerEndIndex + headerEnd.length);
         const buffer = new ArrayBuffer(GaussianSplattingMesh._RowOutputLength * vertexCount);
+        let shBuffer = null;
+        let shCoefficientCount = 0;
+        if (shDegree) {
+            const shVectorCount = (shDegree + 1) * (shDegree + 1) - 1;
+            shCoefficientCount = shVectorCount * 3;
+            shBuffer = new ArrayBuffer(shCoefficientCount * vertexCount);
+        }
         return {
             vertexCount: vertexCount,
             chunkCount: chunkCount,
@@ -453,6 +625,9 @@ export class GaussianSplattingMesh extends Mesh {
             chunkProperties: chunkProperties,
             dataView: dataView,
             buffer: buffer,
+            shDegree: shDegree,
+            shCoefficientCount: shCoefficientCount,
+            shBuffer: shBuffer,
         };
     }
     static _GetCompressedChunks(header, offset) {
@@ -462,7 +637,14 @@ export class GaussianSplattingMesh extends Mesh {
         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() };
+            const currentChunk = {
+                min: new Vector3(),
+                max: new Vector3(),
+                minScale: new Vector3(),
+                maxScale: new Vector3(),
+                minColor: new Vector3(0, 0, 0),
+                maxColor: new Vector3(1, 1, 1),
+            };
             compressedChunks[i] = currentChunk;
             for (let propertyIndex = 0; propertyIndex < header.chunkProperties.length; propertyIndex++) {
                 const property = header.chunkProperties[propertyIndex];
@@ -511,6 +693,24 @@ export class GaussianSplattingMesh extends Mesh {
                     case 11 /* PLYValue.MAX_SCALE_Z */:
                         currentChunk.maxScale.z = value;
                         break;
+                    case 34 /* PLYValue.MIN_COLOR_R */:
+                        currentChunk.minColor.x = value;
+                        break;
+                    case 35 /* PLYValue.MIN_COLOR_G */:
+                        currentChunk.minColor.y = value;
+                        break;
+                    case 36 /* PLYValue.MIN_COLOR_B */:
+                        currentChunk.minColor.z = value;
+                        break;
+                    case 37 /* PLYValue.MAX_COLOR_R */:
+                        currentChunk.maxColor.x = value;
+                        break;
+                    case 38 /* PLYValue.MAX_COLOR_G */:
+                        currentChunk.maxColor.y = value;
+                        break;
+                    case 39 /* PLYValue.MAX_COLOR_B */:
+                        currentChunk.maxColor.z = value;
+                        break;
                 }
             }
             offset.value += header.rowChunkLength;
@@ -527,6 +727,10 @@ export class GaussianSplattingMesh extends Mesh {
         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);
+        let sh = null;
+        if (header.shBuffer) {
+            sh = new Uint8ClampedArray(header.shBuffer, index * header.shCoefficientCount, header.shCoefficientCount);
+        }
         const chunkIndex = index >> 8;
         let r0 = 255;
         let r1 = 0;
@@ -560,7 +764,7 @@ export class GaussianSplattingMesh extends Mesh {
                         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[1] = Scalar.Lerp(compressedChunk.min.y, compressedChunk.max.y, temp3.y);
                         position[2] = Scalar.Lerp(compressedChunk.min.z, compressedChunk.max.z, temp3.z);
                     }
                     break;
@@ -568,9 +772,9 @@ export class GaussianSplattingMesh extends Mesh {
                     {
                         unpackRot(value, q);
                         r0 = q.w;
-                        r1 = q.z;
+                        r1 = -q.z;
                         r2 = q.y;
-                        r3 = q.x;
+                        r3 = -q.x;
                     }
                     break;
                 case 14 /* PLYValue.PACKED_SCALE */:
@@ -583,7 +787,13 @@ export class GaussianSplattingMesh extends Mesh {
                     }
                     break;
                 case 15 /* PLYValue.PACKED_COLOR */:
-                    unpack8888(value, rgba);
+                    {
+                        const compressedChunk = compressedChunks[chunkIndex];
+                        unpack8888(value, rgba);
+                        rgba[0] = Scalar.Lerp(compressedChunk.minColor.x, compressedChunk.maxColor.x, rgba[0] / 255) * 255;
+                        rgba[1] = Scalar.Lerp(compressedChunk.minColor.y, compressedChunk.maxColor.y, rgba[1] / 255) * 255;
+                        rgba[2] = Scalar.Lerp(compressedChunk.minColor.z, compressedChunk.maxColor.z, rgba[2] / 255) * 255;
+                    }
                     break;
                 case 16 /* PLYValue.X */:
                     position[0] = value;
@@ -640,6 +850,11 @@ export class GaussianSplattingMesh extends Mesh {
                     r3 = value;
                     break;
             }
+            if (sh && property.value >= 40 /* PLYValue.SH_0 */ && property.value <= 84 /* PLYValue.SH_44 */) {
+                const clampedValue = Scalar.Clamp(value * 127.5 + 127.5, 0, 255);
+                const shIndex = property.value - 40 /* PLYValue.SH_0 */;
+                sh[shIndex] = clampedValue;
+            }
         }
         q.set(r1, r2, r3, r0);
         q.normalize();
@@ -649,12 +864,64 @@ export class GaussianSplattingMesh extends Mesh {
         rot[3] = q.z * 128 + 128;
         offset.value += header.rowVertexLength;
     }
+    /**
+     * Converts a .ply data with SH coefficients 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 and optional array of sh coefficients
+     */
+    static *ConvertPLYWithSHToSplat(data, useCoroutine = false) {
+        const header = GaussianSplattingMesh.ParseHeader(data);
+        if (!header) {
+            return { buffer: 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 % GaussianSplattingMesh._PlyConversionBatchSize === 0 && useCoroutine) {
+                yield;
+            }
+        }
+        let sh = null;
+        // make SH texture buffers
+        if (header.shDegree && header.shBuffer) {
+            const textureCount = Math.ceil(header.shCoefficientCount / 16); // 4 components can be stored per texture, 4 sh per component
+            let shIndexRead = 0;
+            const ubuf = new Uint8Array(header.shBuffer);
+            // sh is an array of uint8array that will be used to create sh textures
+            sh = [];
+            const splatCount = header.vertexCount;
+            const engine = EngineStore.LastCreatedEngine;
+            if (engine) {
+                const width = engine.getCaps().maxTextureSize;
+                const height = Math.ceil(splatCount / width);
+                // create array for the number of textures needed.
+                for (let textureIndex = 0; textureIndex < textureCount; textureIndex++) {
+                    const texture = new Uint8Array(height * width * 4 * 4); // 4 components per texture, 4 sh per component
+                    sh.push(texture);
+                }
+                for (let i = 0; i < splatCount; i++) {
+                    for (let shIndexWrite = 0; shIndexWrite < header.shCoefficientCount; shIndexWrite++) {
+                        const shValue = ubuf[shIndexRead++];
+                        const textureIndex = Math.floor(shIndexWrite / 16);
+                        const shArray = sh[textureIndex];
+                        const byteIndexInTexture = shIndexWrite % 16; // [0..15]
+                        const offsetPerSplat = i * 16; // 16 sh values per texture per splat.
+                        shArray[byteIndexInTexture + offsetPerSplat] = shValue;
+                    }
+                }
+            }
+        }
+        return { buffer: header.buffer, sh: sh };
+    }
     /**
      * 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
+     * @returns the loaded splat buffer without SH coefficient, whether ply contains or not SH.
      */
     static *ConvertPLYToSplat(data, useCoroutine = false) {
         const header = GaussianSplattingMesh.ParseHeader(data);
@@ -680,6 +947,15 @@ export class GaussianSplattingMesh extends Mesh {
     static async ConvertPLYToSplatAsync(data) {
         return runCoroutineAsync(GaussianSplattingMesh.ConvertPLYToSplat(data, true), createYieldingScheduler());
     }
+    /**
+     * Converts a .ply with SH 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 with SH
+     */
+    static async ConvertPLYWithSHToSplatAsync(data) {
+        return runCoroutineAsync(GaussianSplattingMesh.ConvertPLYWithSHToSplat(data, true), createYieldingScheduler());
+    }
     /**
      * Loads a .splat Gaussian Splatting array buffer asynchronously
      * @param data arraybuffer containing splat file
@@ -696,8 +972,8 @@ export class GaussianSplattingMesh extends Mesh {
      */
     loadFileAsync(url) {
         return Tools.LoadFileAsync(url, true).then(async (plyBuffer) => {
-            GaussianSplattingMesh.ConvertPLYToSplatAsync(plyBuffer).then((splatsData) => {
-                this.updateDataAsync(splatsData);
+            GaussianSplattingMesh.ConvertPLYWithSHToSplatAsync(plyBuffer).then((splatsData) => {
+                this.updateDataAsync(splatsData.buffer, splatsData.sh);
             });
         });
     }
@@ -757,22 +1033,22 @@ export class GaussianSplattingMesh extends Mesh {
         newGS.setEnabled(true);
         return newGS;
     }
-    _makeSplat(sourceIndex, destinationIndex, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum) {
+    _makeSplat(index, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum) {
         const matrixRotation = TmpVectors.Matrix[0];
         const matrixScale = TmpVectors.Matrix[1];
         const quaternion = TmpVectors.Quaternion[0];
         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;
+        const x = fBuffer[8 * index + 0];
+        const y = -fBuffer[8 * index + 1];
+        const z = fBuffer[8 * index + 2];
+        this._splatPositions[4 * index + 0] = x;
+        this._splatPositions[4 * index + 1] = y;
+        this._splatPositions[4 * index + 2] = z;
         minimum.minimizeInPlaceFromFloats(x, y, z);
         maximum.maximizeInPlaceFromFloats(x, y, z);
-        quaternion.set((uBuffer[32 * sourceIndex + 28 + 1] - 127.5) / 127.5, (uBuffer[32 * sourceIndex + 28 + 2] - 127.5) / 127.5, (uBuffer[32 * sourceIndex + 28 + 3] - 127.5) / 127.5, -(uBuffer[32 * sourceIndex + 28 + 0] - 127.5) / 127.5);
+        quaternion.set((uBuffer[32 * index + 28 + 1] - 127.5) / 127.5, (uBuffer[32 * index + 28 + 2] - 127.5) / 127.5, (uBuffer[32 * index + 28 + 3] - 127.5) / 127.5, -(uBuffer[32 * index + 28 + 0] - 127.5) / 127.5);
         quaternion.toRotationMatrix(matrixRotation);
-        Matrix.ScalingToRef(fBuffer[8 * sourceIndex + 3 + 0] * 2, fBuffer[8 * sourceIndex + 3 + 1] * 2, fBuffer[8 * sourceIndex + 3 + 2] * 2, matrixScale);
+        Matrix.ScalingToRef(fBuffer[8 * index + 3 + 0] * 2, fBuffer[8 * index + 3 + 1] * 2, fBuffer[8 * index + 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];
@@ -786,19 +1062,19 @@ export class GaussianSplattingMesh extends Mesh {
         for (let covIndex = 0; covIndex < 6; covIndex++) {
             factor = Math.max(factor, Math.abs(covariances[covIndex]));
         }
-        this._splatPositions[4 * sourceIndex + 3] = factor;
+        this._splatPositions[4 * index + 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);
+        covA[index * 4 + 0] = ToHalfFloat(covariances[0] / transform);
+        covA[index * 4 + 1] = ToHalfFloat(covariances[1] / transform);
+        covA[index * 4 + 2] = ToHalfFloat(covariances[2] / transform);
+        covA[index * 4 + 3] = ToHalfFloat(covariances[3] / transform);
+        covB[index * covBSItemSize + 0] = ToHalfFloat(covariances[4] / transform);
+        covB[index * 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];
+        colorArray[index * 4 + 0] = uBuffer[32 * index + 24 + 0];
+        colorArray[index * 4 + 1] = uBuffer[32 * index + 24 + 1];
+        colorArray[index * 4 + 2] = uBuffer[32 * index + 24 + 2];
+        colorArray[index * 4 + 3] = uBuffer[32 * index + 24 + 3];
     }
     _updateTextures(covA, covB, colorArray, sh) {
         const textureSize = this._getTextureSize(this._vertexCount);
@@ -880,7 +1156,7 @@ export class GaussianSplattingMesh extends Mesh {
                 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._makeSplat(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
@@ -897,7 +1173,7 @@ export class GaussianSplattingMesh extends Mesh {
         }
         else {
             for (let i = 0; i < vertexCount; i++) {
-                this._makeSplat(i, i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum);
+                this._makeSplat(i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum);
                 if (isAsync && i % GaussianSplattingMesh._SplatBatchSize === 0) {
                     yield;
                 }