@onerjs/core 8.50.1 → 8.50.3

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.d.ts

@@ -114,7 +114,34 @@ declare enum PLYValue {
     SH_42 = 82,
     SH_43 = 83,
     SH_44 = 84,
-    UNDEFINED = 85
+    SH_45 = 85,
+    SH_46 = 86,
+    SH_47 = 87,
+    SH_48 = 88,
+    SH_49 = 89,
+    SH_50 = 90,
+    SH_51 = 91,
+    SH_52 = 92,
+    SH_53 = 93,
+    SH_54 = 94,
+    SH_55 = 95,
+    SH_56 = 96,
+    SH_57 = 97,
+    SH_58 = 98,
+    SH_59 = 99,
+    SH_60 = 100,
+    SH_61 = 101,
+    SH_62 = 102,
+    SH_63 = 103,
+    SH_64 = 104,
+    SH_65 = 105,
+    SH_66 = 106,
+    SH_67 = 107,
+    SH_68 = 108,
+    SH_69 = 109,
+    SH_70 = 110,
+    SH_71 = 111,
+    UNDEFINED = 112
 }
 /**
  * Property field found in PLY header
@@ -198,6 +225,13 @@ export declare class GaussianSplattingMeshBase extends Mesh {
     protected _covariancesBTexture: Nullable<BaseTexture>;
     protected _centersTexture: Nullable<BaseTexture>;
     protected _colorsTexture: Nullable<BaseTexture>;
+    protected _rotationsATexture: Nullable<BaseTexture>;
+    protected _rotationsBTexture: Nullable<BaseTexture>;
+    protected _rotationScaleTexture: Nullable<BaseTexture>;
+    private _rotationDataA;
+    private _rotationDataB;
+    private _rotationScaleData;
+    protected _needsRotationScaleTextures: boolean;
     protected _splatPositions: Nullable<Float32Array>;
     private _splatIndex;
     protected _shTextures: Nullable<BaseTexture[]>;
@@ -222,6 +256,7 @@ export declare class GaussianSplattingMeshBase extends Mesh {
     private static _PlyConversionBatchSize;
     /** @internal */
     _shDegree: number;
+    private _maxShDegree;
     private static readonly _BatchSize;
     private _cameraViewInfos;
     protected static readonly _DefaultViewUpdateThreshold = 0.0001;
@@ -285,6 +320,23 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * Gets the colors texture
      */
     get colorsTexture(): Nullable<BaseTexture>;
+    /**
+     * Gets the rotation matrix A texture (rotation elements m[0],m[1],m[2],m[4])
+     */
+    get rotationsATexture(): Nullable<BaseTexture>;
+    /**
+     * Gets the rotation matrix B texture (rotation elements m[5],m[6],m[8],m[9])
+     */
+    get rotationsBTexture(): Nullable<BaseTexture>;
+    /**
+     * Gets the rotation scale texture (rotation element m[10] followed by scale diagonal sx,sy,sz)
+     */
+    get rotationScaleTexture(): Nullable<BaseTexture>;
+    /**
+     * Enables or disables generation of rotation and scale matrix textures, required for voxel-based IBL shadows.
+     */
+    get needsRotationScaleTextures(): boolean;
+    set needsRotationScaleTextures(value: boolean);
     /**
      * Gets the SH textures
      */
@@ -370,9 +422,11 @@ export declare class GaussianSplattingMeshBase extends Mesh {
     static ConvertPLYWithSHToSplat(data: ArrayBuffer, useCoroutine?: boolean): Generator<undefined, {
         buffer: ArrayBuffer;
         sh?: undefined;
+        shDegree?: undefined;
     } | {
         buffer: ArrayBuffer;
         sh: Uint8Array<ArrayBuffer>[] | null;
+        shDegree: number;
     }, unknown>;
     /**
      * Converts a .ply data array buffer to splat
@@ -398,9 +452,11 @@ export declare class GaussianSplattingMeshBase extends Mesh {
     static ConvertPLYWithSHToSplatAsync(data: ArrayBuffer): Promise<{
         buffer: ArrayBuffer;
         sh?: undefined;
+        shDegree?: undefined;
     } | {
         buffer: ArrayBuffer;
         sh: Uint8Array<ArrayBuffer>[] | null;
+        shDegree: number;
     }>;
     /**
      * Loads a .splat Gaussian Splatting array buffer asynchronously
@@ -493,9 +549,10 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * @param data array buffer containing center, color, orientation and scale of splats
      * @param sh optional array of uint8 array for SH data
      * @param partIndices optional array of uint8 for rig node indices
+     * @param shDegree optional SH degree of the data
      * @returns a promise
      */
-    updateDataAsync(data: ArrayBuffer, sh?: Uint8Array[], partIndices?: Uint8Array): Promise<void>;
+    updateDataAsync(data: ArrayBuffer, sh?: Uint8Array[], partIndices?: Uint8Array, shDegree?: number): Promise<void>;
     /**
      * @experimental
      * Update data from GS (position, orientation, color, scaling)
@@ -503,8 +560,9 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * @param sh optional array of uint8 array for SH data
      * @param options optional informations on how to treat data (needs to be 3rd for backward compatibility)
      * @param partIndices optional array of uint8 for rig node indices
+     * @param shDegree optional SH degree of the data
      */
-    updateData(data: ArrayBuffer, sh?: Uint8Array[], options?: IUpdateOptions, partIndices?: Uint8Array): void;
+    updateData(data: ArrayBuffer, sh?: Uint8Array[], options?: IUpdateOptions, partIndices?: Uint8Array, shDegree?: number): void;
     /**
      * Refreshes the bounding info, taking into account all the thin instances defined
      * @returns the current Gaussian Splatting

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.js

@@ -157,7 +157,34 @@ var PLYValue;
     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["SH_45"] = 85] = "SH_45";
+    PLYValue[PLYValue["SH_46"] = 86] = "SH_46";
+    PLYValue[PLYValue["SH_47"] = 87] = "SH_47";
+    PLYValue[PLYValue["SH_48"] = 88] = "SH_48";
+    PLYValue[PLYValue["SH_49"] = 89] = "SH_49";
+    PLYValue[PLYValue["SH_50"] = 90] = "SH_50";
+    PLYValue[PLYValue["SH_51"] = 91] = "SH_51";
+    PLYValue[PLYValue["SH_52"] = 92] = "SH_52";
+    PLYValue[PLYValue["SH_53"] = 93] = "SH_53";
+    PLYValue[PLYValue["SH_54"] = 94] = "SH_54";
+    PLYValue[PLYValue["SH_55"] = 95] = "SH_55";
+    PLYValue[PLYValue["SH_56"] = 96] = "SH_56";
+    PLYValue[PLYValue["SH_57"] = 97] = "SH_57";
+    PLYValue[PLYValue["SH_58"] = 98] = "SH_58";
+    PLYValue[PLYValue["SH_59"] = 99] = "SH_59";
+    PLYValue[PLYValue["SH_60"] = 100] = "SH_60";
+    PLYValue[PLYValue["SH_61"] = 101] = "SH_61";
+    PLYValue[PLYValue["SH_62"] = 102] = "SH_62";
+    PLYValue[PLYValue["SH_63"] = 103] = "SH_63";
+    PLYValue[PLYValue["SH_64"] = 104] = "SH_64";
+    PLYValue[PLYValue["SH_65"] = 105] = "SH_65";
+    PLYValue[PLYValue["SH_66"] = 106] = "SH_66";
+    PLYValue[PLYValue["SH_67"] = 107] = "SH_67";
+    PLYValue[PLYValue["SH_68"] = 108] = "SH_68";
+    PLYValue[PLYValue["SH_69"] = 109] = "SH_69";
+    PLYValue[PLYValue["SH_70"] = 110] = "SH_70";
+    PLYValue[PLYValue["SH_71"] = 111] = "SH_71";
+    PLYValue[PLYValue["UNDEFINED"] = 112] = "UNDEFINED";
 })(PLYValue || (PLYValue = {}));
 /**
  * Base class for Gaussian Splatting meshes. Contains all single-cloud rendering logic.
@@ -197,7 +224,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         return this._shDegree;
     }
     set shDegree(value) {
-        const maxDegree = this._shTextures?.length ?? 0;
+        const maxDegree = this._maxShDegree;
         const clamped = Math.max(0, Math.min(Math.round(value), maxDegree));
         if (this._shDegree === clamped) {
             return;
@@ -209,7 +236,7 @@ export class GaussianSplattingMeshBase extends Mesh {
      * Maximum SH degree available from the loaded data.
      */
     get maxShDegree() {
-        return this._shTextures?.length ?? 0;
+        return this._maxShDegree;
     }
     /**
      * Number of splats in the mesh
@@ -255,6 +282,45 @@ export class GaussianSplattingMeshBase extends Mesh {
     get colorsTexture() {
         return this._colorsTexture;
     }
+    /**
+     * Gets the rotation matrix A texture (rotation elements m[0],m[1],m[2],m[4])
+     */
+    get rotationsATexture() {
+        return this._rotationsATexture;
+    }
+    /**
+     * Gets the rotation matrix B texture (rotation elements m[5],m[6],m[8],m[9])
+     */
+    get rotationsBTexture() {
+        return this._rotationsBTexture;
+    }
+    /**
+     * Gets the rotation scale texture (rotation element m[10] followed by scale diagonal sx,sy,sz)
+     */
+    get rotationScaleTexture() {
+        return this._rotationScaleTexture;
+    }
+    /**
+     * Enables or disables generation of rotation and scale matrix textures, required for voxel-based IBL shadows.
+     */
+    get needsRotationScaleTextures() {
+        return this._needsRotationScaleTextures;
+    }
+    set needsRotationScaleTextures(value) {
+        if (this._needsRotationScaleTextures === value) {
+            return;
+        }
+        this._needsRotationScaleTextures = value;
+        if (value && this._covariancesATexture) {
+            if (this._splatsData) {
+                this.updateData(this._splatsData, this._shData ?? undefined, { flipY: false });
+            }
+            else {
+                Logger.Error("GaussianSplattingMeshBase: needsRotationScaleTextures was enabled after the mesh was already loaded, but the splat data is not kept in RAM. " +
+                    "The rotation and scale matrix textures cannot be initialized. Please reload the mesh data via updateData() or construct with keepInRam=true.");
+            }
+        }
+    }
     /**
      * Gets the SH textures
      */
@@ -331,6 +397,13 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._covariancesBTexture = null;
         this._centersTexture = null;
         this._colorsTexture = null;
+        this._rotationsATexture = null;
+        this._rotationsBTexture = null;
+        this._rotationScaleTexture = null;
+        this._rotationDataA = null;
+        this._rotationDataB = null;
+        this._rotationScaleData = null;
+        this._needsRotationScaleTextures = false;
         this._splatPositions = null;
         this._splatIndex = null;
         this._shTextures = null;
@@ -352,6 +425,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._cachedBoundingMax = null;
         /** @internal */
         this._shDegree = 0;
+        this._maxShDegree = 0;
         this._cameraViewInfos = new Map();
         /**
          * Cosine value of the angle threshold to update view dependent splat sorting. Default is 0.0001.
@@ -775,8 +849,62 @@ export class GaussianSplattingMeshBase extends Mesh {
                 return 83 /* PLYValue.SH_43 */;
             case "f_rest_44":
                 return 84 /* PLYValue.SH_44 */;
-        }
-        return 85 /* PLYValue.UNDEFINED */;
+            case "f_rest_45":
+                return 85 /* PLYValue.SH_45 */;
+            case "f_rest_46":
+                return 86 /* PLYValue.SH_46 */;
+            case "f_rest_47":
+                return 87 /* PLYValue.SH_47 */;
+            case "f_rest_48":
+                return 88 /* PLYValue.SH_48 */;
+            case "f_rest_49":
+                return 89 /* PLYValue.SH_49 */;
+            case "f_rest_50":
+                return 90 /* PLYValue.SH_50 */;
+            case "f_rest_51":
+                return 91 /* PLYValue.SH_51 */;
+            case "f_rest_52":
+                return 92 /* PLYValue.SH_52 */;
+            case "f_rest_53":
+                return 93 /* PLYValue.SH_53 */;
+            case "f_rest_54":
+                return 94 /* PLYValue.SH_54 */;
+            case "f_rest_55":
+                return 95 /* PLYValue.SH_55 */;
+            case "f_rest_56":
+                return 96 /* PLYValue.SH_56 */;
+            case "f_rest_57":
+                return 97 /* PLYValue.SH_57 */;
+            case "f_rest_58":
+                return 98 /* PLYValue.SH_58 */;
+            case "f_rest_59":
+                return 99 /* PLYValue.SH_59 */;
+            case "f_rest_60":
+                return 100 /* PLYValue.SH_60 */;
+            case "f_rest_61":
+                return 101 /* PLYValue.SH_61 */;
+            case "f_rest_62":
+                return 102 /* PLYValue.SH_62 */;
+            case "f_rest_63":
+                return 103 /* PLYValue.SH_63 */;
+            case "f_rest_64":
+                return 104 /* PLYValue.SH_64 */;
+            case "f_rest_65":
+                return 105 /* PLYValue.SH_65 */;
+            case "f_rest_66":
+                return 106 /* PLYValue.SH_66 */;
+            case "f_rest_67":
+                return 107 /* PLYValue.SH_67 */;
+            case "f_rest_68":
+                return 108 /* PLYValue.SH_68 */;
+            case "f_rest_69":
+                return 109 /* PLYValue.SH_69 */;
+            case "f_rest_70":
+                return 110 /* PLYValue.SH_70 */;
+            case "f_rest_71":
+                return 111 /* PLYValue.SH_71 */;
+        }
+        return 112 /* PLYValue.UNDEFINED */;
     }
     /**
      * Parse a PLY file header and returns metas infos on splats and chunks
@@ -826,12 +954,15 @@ export class GaussianSplattingMeshBase extends Mesh {
             if (prop.startsWith("property ")) {
                 const [, typeName, name] = prop.split(" ");
                 const value = GaussianSplattingMeshBase._ValueNameToEnum(name);
-                if (value != 85 /* PLYValue.UNDEFINED */) {
-                    // SH degree 1,2 or 3 for 9, 24 or 45 values
-                    if (value >= 84 /* PLYValue.SH_44 */) {
-                        shDegree = 3;
+                if (value != 112 /* PLYValue.UNDEFINED */) {
+                    // SH degree 1,2,3 or 4 for 9, 24, 45 or 72 values
+                    if (value >= 111 /* PLYValue.SH_71 */) {
+                        shDegree = 4;
+                    }
+                    else if (value >= 84 /* PLYValue.SH_44 */) {
+                        shDegree = Math.max(shDegree, 3);
                     }
-                    else if (value >= 64 /* PLYValue.SH_24 */) {
+                    else if (value >= 63 /* PLYValue.SH_23 */) {
                         shDegree = Math.max(shDegree, 2);
                     }
                     else if (value >= 48 /* PLYValue.SH_8 */) {
@@ -1115,7 +1246,7 @@ export class GaussianSplattingMeshBase extends Mesh {
                     r3 = value;
                     break;
             }
-            if (sh && property.value >= 40 /* PLYValue.SH_0 */ && property.value <= 84 /* PLYValue.SH_44 */) {
+            if (sh && property.value >= 40 /* PLYValue.SH_0 */ && property.value <= 111 /* PLYValue.SH_71 */) {
                 const shIndex = property.value - 40 /* PLYValue.SH_0 */;
                 if (property.type == 4 /* PLYType.UCHAR */ && header.chunkCount) {
                     // compressed ply. dataView points to beginning of vertex
@@ -1131,7 +1262,7 @@ export class GaussianSplattingMeshBase extends Mesh {
             }
         }
         if (sh) {
-            const shDim = header.shDegree == 1 ? 3 : header.shDegree == 2 ? 8 : 15;
+            const shDim = header.shDegree == 1 ? 3 : header.shDegree == 2 ? 8 : header.shDegree == 3 ? 15 : 24;
             for (let j = 0; j < shDim; j++) {
                 sh[j * 3 + 0] = plySH[j];
                 sh[j * 3 + 1] = plySH[j + shDim];
@@ -1196,7 +1327,7 @@ export class GaussianSplattingMeshBase extends Mesh {
                 }
             }
         }
-        return { buffer: header.buffer, sh: sh };
+        return { buffer: header.buffer, sh: sh, shDegree: header.shDegree };
     }
     /**
      * Converts a .ply data array buffer to splat
@@ -1270,6 +1401,15 @@ export class GaussianSplattingMeshBase extends Mesh {
                 shTexture.dispose();
             }
         }
+        this._rotationsATexture?.dispose();
+        this._rotationsBTexture?.dispose();
+        this._rotationScaleTexture?.dispose();
+        this._rotationsATexture = null;
+        this._rotationsBTexture = null;
+        this._rotationScaleTexture = null;
+        this._rotationDataA = null;
+        this._rotationDataB = null;
+        this._rotationScaleData = null;
         this._covariancesATexture = null;
         this._covariancesBTexture = null;
         this._centersTexture = null;
@@ -1299,6 +1439,11 @@ export class GaussianSplattingMeshBase extends Mesh {
                 this._shTextures?.push(shTexture.clone());
             }
         }
+        if (source._rotationsATexture) {
+            this._rotationsATexture = source._rotationsATexture.clone();
+            this._rotationsBTexture = source._rotationsBTexture?.clone();
+            this._rotationScaleTexture = source._rotationScaleTexture?.clone();
+        }
     }
     /**
      * Returns a new Mesh object generated from the current mesh properties.
@@ -1367,6 +1512,30 @@ export class GaussianSplattingMeshBase extends Mesh {
         quaternion.normalize();
         quaternion.toRotationMatrix(matrixRotation);
         Matrix.ScalingToRef(fBuffer[8 * srcIndex + 3 + 0] * 2, fBuffer[8 * srcIndex + 3 + 1] * 2, fBuffer[8 * srcIndex + 3 + 2] * 2, matrixScale);
+        if (this._needsRotationScaleTextures) {
+            if (!this._rotationDataA || this._rotationDataA.length < covA.length) {
+                this._rotationDataA = new Uint16Array(covA.length);
+                this._rotationDataB = new Uint16Array(covA.length);
+                this._rotationScaleData = new Uint16Array(covA.length);
+            }
+            const rotDataA = this._rotationDataA;
+            const rotDataB = this._rotationDataB;
+            const rotScaleData = this._rotationScaleData;
+            const rm = matrixRotation.m;
+            const sm = matrixScale.m;
+            rotDataA[dstIndex * 4 + 0] = ToHalfFloat(rm[0]);
+            rotDataA[dstIndex * 4 + 1] = ToHalfFloat(rm[1]);
+            rotDataA[dstIndex * 4 + 2] = ToHalfFloat(rm[2]);
+            rotDataA[dstIndex * 4 + 3] = ToHalfFloat(rm[4]);
+            rotDataB[dstIndex * 4 + 0] = ToHalfFloat(rm[5]);
+            rotDataB[dstIndex * 4 + 1] = ToHalfFloat(rm[6]);
+            rotDataB[dstIndex * 4 + 2] = ToHalfFloat(rm[8]);
+            rotDataB[dstIndex * 4 + 3] = ToHalfFloat(rm[9]);
+            rotScaleData[dstIndex * 4 + 0] = ToHalfFloat(rm[10]);
+            rotScaleData[dstIndex * 4 + 1] = ToHalfFloat(sm[0]);
+            rotScaleData[dstIndex * 4 + 2] = ToHalfFloat(sm[5]);
+            rotScaleData[dstIndex * 4 + 3] = ToHalfFloat(sm[10]);
+        }
         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];
@@ -1459,6 +1628,25 @@ export class GaussianSplattingMeshBase extends Mesh {
                     this._shTextures.push(shTexture);
                 }
             }
+            if (this._needsRotationScaleTextures && this._rotationDataA) {
+                if (this._rotationsATexture) {
+                    this._updateTextureFromData(this._rotationsATexture, this._rotationDataA, textureSize.x, 0, textureSize.y);
+                    this._updateTextureFromData(this._rotationsBTexture, this._rotationDataB, textureSize.x, 0, textureSize.y);
+                    this._updateTextureFromData(this._rotationScaleTexture, this._rotationScaleData, textureSize.x, 0, textureSize.y);
+                }
+                else {
+                    // Rotation textures not yet created (needsRotationScaleTextures was enabled after initial load).
+                    this._rotationsATexture = createTextureFromDataF16(this._rotationDataA, textureSize.x, textureSize.y, 5);
+                    this._rotationsBTexture = createTextureFromDataF16(this._rotationDataB, textureSize.x, textureSize.y, 5);
+                    this._rotationScaleTexture = createTextureFromDataF16(this._rotationScaleData, textureSize.x, textureSize.y, 5);
+                    this._rotationsATexture.wrapU = 0;
+                    this._rotationsATexture.wrapV = 0;
+                    this._rotationsBTexture.wrapU = 0;
+                    this._rotationsBTexture.wrapV = 0;
+                    this._rotationScaleTexture.wrapU = 0;
+                    this._rotationScaleTexture.wrapV = 0;
+                }
+            }
             this._onUpdateTextures(textureSize);
             this._postToWorker(true);
         }
@@ -1478,6 +1666,23 @@ export class GaussianSplattingMeshBase extends Mesh {
                     this._shTextures.push(shTexture);
                 }
             }
+            if (this._needsRotationScaleTextures) {
+                const rotDataA = this._rotationDataA ?? new Uint16Array(covA.length);
+                const rotDataB = this._rotationDataB ?? new Uint16Array(covA.length);
+                const rotScaleData = this._rotationScaleData ?? new Uint16Array(covA.length);
+                this._rotationsATexture?.dispose();
+                this._rotationsBTexture?.dispose();
+                this._rotationScaleTexture?.dispose();
+                this._rotationsATexture = createTextureFromDataF16(rotDataA, textureSize.x, textureSize.y, 5);
+                this._rotationsBTexture = createTextureFromDataF16(rotDataB, textureSize.x, textureSize.y, 5);
+                this._rotationScaleTexture = createTextureFromDataF16(rotScaleData, textureSize.x, textureSize.y, 5);
+                this._rotationsATexture.wrapU = 0;
+                this._rotationsATexture.wrapV = 0;
+                this._rotationsBTexture.wrapU = 0;
+                this._rotationsBTexture.wrapV = 0;
+                this._rotationScaleTexture.wrapU = 0;
+                this._rotationScaleTexture.wrapV = 0;
+            }
             this._onUpdateTextures(textureSize);
             if (firstTime) {
                 this._instantiateWorker();
@@ -1527,7 +1732,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         }
         this._sortIsDirty = true;
     }
-    *_updateData(data, isAsync, sh, partIndices, { flipY = false, previousVertexCount = 0 } = {}) {
+    *_updateData(data, isAsync, sh, partIndices, { flipY = false, previousVertexCount = 0 } = {}, shDegree) {
         if (!this._covariancesATexture) {
             this._readyToDisplay = false;
         }
@@ -1551,8 +1756,8 @@ export class GaussianSplattingMeshBase extends Mesh {
             this._updateSplatIndexBuffer(vertexCount);
         }
         this._vertexCount = vertexCount;
-        // degree == 1 for 1 texture (3 terms), 2 for 2 textures (8 terms) and 3 for 3 textures (15 terms)
-        this._shDegree = sh ? sh.length : 0;
+        this._maxShDegree = sh ? (shDegree ?? 0) : 0;
+        this._shDegree = this._maxShDegree;
         const textureSize = this._getTextureSize(vertexCount);
         const textureLength = textureSize.x * textureSize.y;
         const lineCountUpdate = GaussianSplattingMeshBase.ProgressiveUpdateAmount ?? textureSize.y;
@@ -1657,10 +1862,11 @@ export class GaussianSplattingMeshBase extends Mesh {
      * @param data array buffer containing center, color, orientation and scale of splats
      * @param sh optional array of uint8 array for SH data
      * @param partIndices optional array of uint8 for rig node indices
+     * @param shDegree optional SH degree of the data
      * @returns a promise
      */
-    async updateDataAsync(data, sh, partIndices) {
-        return await runCoroutineAsync(this._updateData(data, true, sh, partIndices), createYieldingScheduler());
+    async updateDataAsync(data, sh, partIndices, shDegree) {
+        return await runCoroutineAsync(this._updateData(data, true, sh, partIndices, undefined, shDegree), createYieldingScheduler());
     }
     /**
      * @experimental
@@ -1669,9 +1875,10 @@ export class GaussianSplattingMeshBase extends Mesh {
      * @param sh optional array of uint8 array for SH data
      * @param options optional informations on how to treat data (needs to be 3rd for backward compatibility)
      * @param partIndices optional array of uint8 for rig node indices
+     * @param shDegree optional SH degree of the data
      */
-    updateData(data, sh, options = { flipY: true }, partIndices) {
-        runCoroutineSync(this._updateData(data, false, sh, partIndices, options));
+    updateData(data, sh, options = { flipY: true }, partIndices, shDegree) {
+        runCoroutineSync(this._updateData(data, false, sh, partIndices, options, shDegree));
     }
     /**
      * Refreshes the bounding info, taking into account all the thin instances defined
@@ -1713,6 +1920,14 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._updateTextureFromData(this._covariancesBTexture, covBView, textureSize.x, lineStart, lineCount);
         this._updateTextureFromData(this._centersTexture, centersView, textureSize.x, lineStart, lineCount);
         this._updateTextureFromData(this._colorsTexture, colorsView, textureSize.x, lineStart, lineCount);
+        if (this._rotationsATexture && this._rotationDataA) {
+            const rotAView = new Uint16Array(this._rotationDataA.buffer, texelStart * 4 * Uint16Array.BYTES_PER_ELEMENT, texelCount * 4);
+            const rotBView = new Uint16Array(this._rotationDataB.buffer, texelStart * 4 * Uint16Array.BYTES_PER_ELEMENT, texelCount * 4);
+            const rotScaleView = new Uint16Array(this._rotationScaleData.buffer, texelStart * 4 * Uint16Array.BYTES_PER_ELEMENT, texelCount * 4);
+            this._updateTextureFromData(this._rotationsATexture, rotAView, textureSize.x, lineStart, lineCount);
+            this._updateTextureFromData(this._rotationsBTexture, rotBView, textureSize.x, lineStart, lineCount);
+            this._updateTextureFromData(this._rotationScaleTexture, rotScaleView, textureSize.x, lineStart, lineCount);
+        }
         if (sh) {
             for (let i = 0; i < sh.length; i++) {
                 const componentCount = 4;