@onerjs/core 8.40.1 → 8.40.2

package/Meshes/GaussianSplatting/gaussianSplattingMesh.d.ts

@@ -1,5 +1,5 @@
 import type { Scene } from "../../scene.js";
-import type { Nullable } from "../../types.js";
+import type { DeepImmutable, Nullable } from "../../types.js";
 import type { BaseTexture } from "../../Materials/Textures/baseTexture.js";
 import { SubMesh } from "../subMesh.js";
 import type { AbstractMesh } from "../abstractMesh.js";
@@ -518,5 +518,11 @@ export declare class GaussianSplattingMesh extends Mesh {
      * @param index - The index of the part to remove
      */
     removePart(index: number): void;
+    /**
+     * Modifies the splats according to the passed transformation matrix.
+     * @param transform defines the transform matrix to use
+     * @returns the current mesh
+     */
+    bakeTransformIntoVertices(transform: DeepImmutable<Matrix>): Mesh;
 }
 export {};

package/Meshes/GaussianSplatting/gaussianSplattingMesh.js

@@ -547,9 +547,16 @@ export class GaussianSplattingMesh extends Mesh {
         if (!cameraViewInfos || !cameraViewInfos.splatIndexBufferSet) {
             return this;
         }
+        if (this.onBeforeRenderObservable) {
+            this.onBeforeRenderObservable.notifyObservers(this);
+        }
         const mesh = cameraViewInfos.mesh;
         mesh.getWorldMatrix().copyFrom(this.getWorldMatrix());
-        return mesh.render(subMesh, enableAlphaMode, effectiveMeshReplacement);
+        const ret = mesh.render(subMesh, enableAlphaMode, effectiveMeshReplacement);
+        if (this.onAfterRenderObservable) {
+            this.onAfterRenderObservable.notifyObservers(this);
+        }
+        return ret;
     }
     static _TypeNameToEnum(name) {
         switch (name) {
@@ -1370,7 +1377,7 @@ export class GaussianSplattingMesh extends Mesh {
             return new RawTexture(data, width, height, format, this._scene, false, false, 2, 2);
         };
         const firstTime = this._covariancesATexture === null;
-        const textureSizeChanged = this._textureSize.y < textureSize.y;
+        const textureSizeChanged = this._textureSize.y != textureSize.y;
         if (!firstTime && !textureSizeChanged) {
             this._delayedTextureUpdate = { covA, covB, colors: colorArray, centers: this._splatPositions, sh, partIndices };
             const positions = Float32Array.from(this._splatPositions);
@@ -1557,7 +1564,7 @@ export class GaussianSplattingMesh extends Mesh {
     // in case size is different
     _updateSplatIndexBuffer(vertexCount) {
         const paddedVertexCount = (vertexCount + 15) & ~0xf;
-        if (!this._splatIndex || vertexCount > this._splatIndex.length) {
+        if (!this._splatIndex || vertexCount != this._splatIndex.length) {
             this._splatIndex = new Float32Array(paddedVertexCount);
             for (let i = 0; i < paddedVertexCount; i++) {
                 this._splatIndex[i] = i;
@@ -1568,10 +1575,10 @@ export class GaussianSplattingMesh extends Mesh {
             });
         }
         // Update depthMix
-        if ((!this._depthMix || vertexCount > this._depthMix.length) && !IsNative) {
+        if ((!this._depthMix || vertexCount != this._depthMix.length) && !IsNative) {
             this._depthMix = new BigInt64Array(paddedVertexCount);
         }
-        this.forcedInstanceCount = paddedVertexCount >> 4;
+        this.forcedInstanceCount = Math.max(paddedVertexCount >> 4, 1);
     }
     _updateSubTextures(centers, covA, covB, colors, lineStart, lineCount, sh, partIndices) {
         const updateTextureFromData = (texture, data, width, lineStart, lineCount) => {
@@ -1917,8 +1924,6 @@ export class GaussianSplattingMesh extends Mesh {
             }
             writeIndex++;
         }
-        // Update the mesh with the new data
-        this.updateData(newSplatsData.buffer, newShData, { flipY: false }, newPartIndices);
         // Remove the part matrix and visibility
         this._partMatrices.splice(index, 1);
         this._partVisibility.splice(index, 1);
@@ -1926,6 +1931,8 @@ export class GaussianSplattingMesh extends Mesh {
         if (this._worker) {
             this._worker.postMessage({ partMatrices: this._partMatrices.map((matrix) => new Float32Array(matrix.m)) });
         }
+        // Update the mesh with the new data
+        this.updateData(newSplatsData.buffer, newShData, { flipY: false }, newPartIndices);
         // Dispose and remove the proxy for the removed part
         const proxyToRemove = this._partProxies.get(index);
         if (proxyToRemove) {
@@ -1946,7 +1953,72 @@ export class GaussianSplattingMesh extends Mesh {
             proxy.updatePartIndex(oldIndex - 1);
             this._partProxies.set(oldIndex - 1, proxy);
         }
-        this._postToWorker(true);
+    }
+    /**
+     * Modifies the splats according to the passed transformation matrix.
+     * @param transform defines the transform matrix to use
+     * @returns the current mesh
+     */
+    bakeTransformIntoVertices(transform) {
+        const arrayBuffer = this.splatsData;
+        if (!arrayBuffer) {
+            Logger.Error("Cannot bake transform into vertices if splatsData is not kept in RAM");
+            return this;
+        }
+        // Check for uniform scaling
+        const m = transform.m;
+        const scaleX = Math.sqrt(m[0] * m[0] + m[1] * m[1] + m[2] * m[2]);
+        const scaleY = Math.sqrt(m[4] * m[4] + m[5] * m[5] + m[6] * m[6]);
+        const scaleZ = Math.sqrt(m[8] * m[8] + m[9] * m[9] + m[10] * m[10]);
+        const epsilon = 0.001;
+        if (Math.abs(scaleX - scaleY) > epsilon || Math.abs(scaleX - scaleZ) > epsilon) {
+            Logger.Error("Gaussian Splatting bakeTransformIntoVertices does not support non-uniform scaling");
+            return this;
+        }
+        const uBuffer = new Uint8Array(arrayBuffer);
+        const fBuffer = new Float32Array(arrayBuffer);
+        const temp = TmpVectors.Vector3[0];
+        let index;
+        const quaternion = TmpVectors.Quaternion[0];
+        const transformedQuaternion = TmpVectors.Quaternion[1];
+        transform.decompose(temp, transformedQuaternion, temp);
+        for (index = 0; index < this._vertexCount; index++) {
+            const floatIndex = index * 8; // 8 floats per splat (center.x, center.y, center.z, scale.x, scale.y, scale.z, ...)
+            Vector3.TransformCoordinatesFromFloatsToRef(fBuffer[floatIndex], fBuffer[floatIndex + 1], fBuffer[floatIndex + 2], transform, temp);
+            fBuffer[floatIndex] = temp.x;
+            fBuffer[floatIndex + 1] = temp.y;
+            fBuffer[floatIndex + 2] = temp.z;
+            // Apply uniform scaling to splat scales
+            fBuffer[floatIndex + 3] *= scaleX;
+            fBuffer[floatIndex + 4] *= scaleX;
+            fBuffer[floatIndex + 5] *= scaleX;
+            // Unpack quaternion from uint8array (matching _GetSplat packing convention)
+            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.normalize();
+            // If there is a negative scaling, we need to flip the quaternion to keep the correct handedness
+            if (this.scaling.x < 0) {
+                quaternion.x = -quaternion.x;
+                quaternion.w = -quaternion.w;
+            }
+            if (this.scaling.y < 0) {
+                quaternion.y = -quaternion.y;
+                quaternion.w = -quaternion.w;
+            }
+            if (this.scaling.z < 0) {
+                quaternion.z = -quaternion.z;
+                quaternion.w = -quaternion.w;
+            }
+            // Transform the quaternion
+            transformedQuaternion.multiplyToRef(quaternion, quaternion);
+            quaternion.normalize();
+            // Pack quaternion back to uint8array (matching _GetSplat packing convention)
+            uBuffer[32 * index + 28 + 0] = Math.round(quaternion.w * 127.5 + 127.5);
+            uBuffer[32 * index + 28 + 1] = Math.round(quaternion.x * 127.5 + 127.5);
+            uBuffer[32 * index + 28 + 2] = Math.round(quaternion.y * 127.5 + 127.5);
+            uBuffer[32 * index + 28 + 3] = Math.round(quaternion.z * 127.5 + 127.5);
+        }
+        this.updateData(arrayBuffer, this.shData ?? undefined, { flipY: false });
+        return this;
     }
 }
 GaussianSplattingMesh._RowOutputLength = 3 * 4 + 3 * 4 + 4 + 4; // Vector3 position, Vector3 scale, 1 u8 quaternion, 1 color with alpha