@babylonjs/core 9.2.2 → 9.3.1

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.js

@@ -282,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
      */
@@ -358,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;
@@ -1355,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;
@@ -1384,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.
@@ -1452,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];
@@ -1544,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);
         }
@@ -1563,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();
@@ -1800,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;