@babylonjs/core 8.47.0 → 8.47.2

package/Meshes/GaussianSplatting/gaussianSplattingMesh.js

@@ -296,7 +296,7 @@ export class GaussianSplattingMesh extends Mesh {
         super(name, scene);
         this._vertexCount = 0;
         this._worker = null;
-        this._modelViewMatrix = Matrix.Identity();
+        this._modelViewProjectionMatrix = Matrix.Identity();
         this._canPostToWorker = true;
         this._readyToDisplay = false;
         this._covariancesATexture = null;
@@ -315,6 +315,10 @@ export class GaussianSplattingMesh extends Mesh {
         this._sortIsDirty = false;
         this._shDegree = 0;
         this._cameraViewInfos = new Map();
+        /**
+         * Cosine value of the angle threshold to update view dependent splat sorting. Default is 0.0001.
+         */
+        this.viewUpdateThreshold = GaussianSplattingMesh._DefaultViewUpdateThreshold;
         this._disableDepthSort = false;
         this._loadingPromise = null;
         this.subMeshes = [];
@@ -378,11 +382,14 @@ export class GaussianSplattingMesh extends Mesh {
         return true;
     }
     _getCameraDirection(camera) {
-        const cameraMatrix = camera.getViewMatrix();
-        this.getWorldMatrix().multiplyToRef(cameraMatrix, this._modelViewMatrix);
+        const cameraViewMatrix = camera.getViewMatrix();
+        const cameraProjectionMatrix = camera.getProjectionMatrix();
+        const cameraViewProjectionMatrix = TmpVectors.Matrix[0];
+        cameraViewMatrix.multiplyToRef(cameraProjectionMatrix, cameraViewProjectionMatrix);
+        this.getWorldMatrix().multiplyToRef(cameraViewProjectionMatrix, this._modelViewProjectionMatrix);
         // return vector used to compute distance to camera
         const localDirection = TmpVectors.Vector3[1];
-        localDirection.set(this._modelViewMatrix.m[2], this._modelViewMatrix.m[6], this._modelViewMatrix.m[10]);
+        localDirection.set(this._modelViewProjectionMatrix.m[8], this._modelViewProjectionMatrix.m[9], this._modelViewProjectionMatrix.m[10]);
         localDirection.normalize();
         return localDirection;
     }
@@ -439,20 +446,19 @@ export class GaussianSplattingMesh extends Mesh {
                 const cameraDirection = this._getCameraDirection(camera);
                 const previousCameraDirection = cameraViewInfos.cameraDirection;
                 const dot = Vector3.Dot(cameraDirection, previousCameraDirection);
-                if ((forced || Math.abs(dot - 1) >= 0.01) && this._canPostToWorker) {
+                if ((forced || Math.abs(dot - 1) >= this.viewUpdateThreshold) && this._canPostToWorker) {
                     cameraViewInfos.cameraDirection.copyFrom(cameraDirection);
                     cameraViewInfos.frameIdLastUpdate = frameId;
                     this._canPostToWorker = false;
                     if (this._worker) {
                         this._worker.postMessage({
-                            view: this._modelViewMatrix.m,
+                            modelViewProjection: this._modelViewProjectionMatrix.m,
                             depthMix: this._depthMix,
-                            useRightHandedSystem: this._scene.useRightHandedSystem,
                             cameraId: camera.uniqueId,
                         }, [this._depthMix.buffer]);
                     }
                     else if (_native && _native.sortSplats) {
-                        _native.sortSplats(this._modelViewMatrix, this._splatPositions, this._splatIndex, this._scene.useRightHandedSystem);
+                        _native.sortSplats(this._modelViewProjectionMatrix, this._splatPositions, this._splatIndex, this._scene.useRightHandedSystem);
                         if (cameraViewInfos.splatIndexBufferSet) {
                             cameraViewInfos.mesh.thinInstanceBufferUpdated("splatIndex");
                         }
@@ -1220,7 +1226,7 @@ export class GaussianSplattingMesh extends Mesh {
         newGS.makeGeometryUnique();
         newGS._vertexCount = this._vertexCount;
         newGS._copyTextures(this);
-        newGS._modelViewMatrix = Matrix.Identity();
+        newGS._modelViewProjectionMatrix = Matrix.Identity();
         newGS._splatPositions = this._splatPositions;
         newGS._readyToDisplay = false;
         newGS._disableDepthSort = this._disableDepthSort;
@@ -1555,6 +1561,7 @@ GaussianSplattingMesh._SplatBatchSize = 327680;
 // batch size between 2 yield calls during the PLY to splat conversion.
 GaussianSplattingMesh._PlyConversionBatchSize = 32768;
 GaussianSplattingMesh._BatchSize = 16; // 16 splats per instance
+GaussianSplattingMesh._DefaultViewUpdateThreshold = 1e-4;
 /**
  * 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.
@@ -1573,11 +1580,11 @@ GaussianSplattingMesh._CreateWorker = function (self) {
         // udpate on view changed
         else {
             const cameraId = e.data.cameraId;
-            const viewProj = e.data.view;
+            const modelViewProjection = e.data.modelViewProjection;
             const vertexCountPadded = (positions.length / 4 + 15) & ~0xf;
-            if (!positions || !viewProj) {
+            if (!positions || !modelViewProjection) {
                 // Sanity check, it shouldn't happen!
-                throw new Error("positions or view is not defined!");
+                throw new Error("positions or modelViewProjection matrix is not defined!");
             }
             depthMix = e.data.depthMix;
             indices = new Uint32Array(depthMix.buffer);
@@ -1586,12 +1593,9 @@ GaussianSplattingMesh._CreateWorker = function (self) {
             for (let j = 0; j < vertexCountPadded; j++) {
                 indices[2 * j] = j;
             }
-            let depthFactor = -1;
-            if (e.data.useRightHandedSystem) {
-                depthFactor = 1;
-            }
             for (let j = 0; j < vertexCountPadded; j++) {
-                floatMix[2 * j + 1] = 10000 + (viewProj[2] * positions[4 * j + 0] + viewProj[6] * positions[4 * j + 1] + viewProj[10] * positions[4 * j + 2]) * depthFactor;
+                floatMix[2 * j + 1] =
+                    10000 - (modelViewProjection[2] * positions[4 * j + 0] + modelViewProjection[6] * positions[4 * j + 1] + modelViewProjection[10] * positions[4 * j + 2]);
             }
             depthMix.sort();
             self.postMessage({ depthMix, cameraId }, [depthMix.buffer]);