@onerjs/core 8.42.9 → 8.43.2

package/Meshes/GaussianSplatting/gaussianSplattingMesh.js

@@ -4,7 +4,7 @@ import { VertexData } from "../mesh.vertexData.js";
 import { Matrix, TmpVectors, Vector2, Vector3 } from "../../Maths/math.vector.js";
 import { Quaternion } from "../../Maths/math.vector.js";
 import { Logger } from "../../Misc/logger.js";
-import { GaussianSplattingMaterial, GaussianSplattingMaxPartCount } from "../../Materials/GaussianSplatting/gaussianSplattingMaterial.js";
+import { GaussianSplattingMaterial, GetGaussianSplattingMaxPartCount } from "../../Materials/GaussianSplatting/gaussianSplattingMaterial.js";
 import { RawTexture } from "../../Materials/Textures/rawTexture.js";
 
 import "../thinInstanceMesh.js";
@@ -12,7 +12,6 @@ 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";
-import { Camera } from "../../Cameras/camera.js";
 import { ImportMeshAsync } from "../../Loading/sceneLoader.js";
 import { GaussianSplattingPartProxyMesh } from "./gaussianSplattingPartProxyMesh.js";
 const IsNative = typeof _native !== "undefined";
@@ -332,7 +331,6 @@ export class GaussianSplattingMesh extends Mesh {
         this._vertexCount = 0;
         this._worker = null;
         this._modelViewProjectionMatrix = Matrix.Identity();
-        this._viewProjectionMatrix = Matrix.Identity();
         this._canPostToWorker = true;
         this._readyToDisplay = false;
         this._covariancesATexture = null;
@@ -429,10 +427,10 @@ export class GaussianSplattingMesh extends Mesh {
         const cameraProjectionMatrix = camera.getProjectionMatrix();
         const cameraViewProjectionMatrix = TmpVectors.Matrix[0];
         cameraViewMatrix.multiplyToRef(cameraProjectionMatrix, cameraViewProjectionMatrix);
-        this._viewProjectionMatrix.copyFrom(cameraViewProjectionMatrix);
+        const modelMatrix = this.getWorldMatrix();
         const modelViewMatrix = TmpVectors.Matrix[1];
-        this.getWorldMatrix().multiplyToRef(cameraViewMatrix, modelViewMatrix);
-        modelViewMatrix.multiplyToRef(cameraProjectionMatrix, this._modelViewProjectionMatrix);
+        modelMatrix.multiplyToRef(cameraViewMatrix, modelViewMatrix);
+        modelMatrix.multiplyToRef(cameraViewProjectionMatrix, this._modelViewProjectionMatrix);
         // return vector used to compute distance to camera
         const localDirection = TmpVectors.Vector3[1];
         localDirection.set(modelViewMatrix.m[2], modelViewMatrix.m[6], modelViewMatrix.m[10]);
@@ -470,6 +468,15 @@ export class GaussianSplattingMesh extends Mesh {
                 cameraMesh.reservedDataStore = { hidden: true };
                 cameraMesh.setEnabled(false);
                 cameraMesh.material = this.material;
+                if (cameraMesh.material && cameraMesh.material instanceof GaussianSplattingMaterial) {
+                    const gsMaterial = cameraMesh.material;
+                    // GaussianSplattingMaterial source mesh may not have been set yet.
+                    // This happens for cloned resources from asset containers for instance,
+                    // where material is cloned before mesh.
+                    if (!gsMaterial.getSourceMesh()) {
+                        gsMaterial.setSourceMesh(this);
+                    }
+                }
                 GaussianSplattingMesh._MakeSplatGeometryForMesh(cameraMesh);
                 const newViewInfos = {
                     camera: camera,
@@ -497,12 +504,13 @@ export class GaussianSplattingMesh extends Mesh {
                     cameraViewInfos.frameIdLastUpdate = frameId;
                     this._canPostToWorker = false;
                     if (this._worker) {
+                        const cameraViewMatrix = camera.getViewMatrix();
                         this._worker.postMessage({
-                            modelViewProjection: this._modelViewProjectionMatrix.m,
-                            viewProjection: this._viewProjectionMatrix.m,
+                            worldMatrix: this.getWorldMatrix().m,
+                            cameraForward: [cameraViewMatrix.m[2], cameraViewMatrix.m[6], cameraViewMatrix.m[10]],
+                            cameraPosition: [camera.globalPosition.x, camera.globalPosition.y, camera.globalPosition.z],
                             depthMix: this._depthMix,
                             cameraId: camera.uniqueId,
-                            depthScale: camera.mode === Camera.ORTHOGRAPHIC_CAMERA ? (camera.maxZ - camera.minZ) / 2.0 : 1.0,
                         }, [this._depthMix.buffer]);
                     }
                     else if (Native?.sortSplats) {
@@ -1306,7 +1314,6 @@ export class GaussianSplattingMesh extends Mesh {
         newGS._vertexCount = this._vertexCount;
         newGS._copyTextures(this);
         newGS._modelViewProjectionMatrix = Matrix.Identity();
-        newGS._viewProjectionMatrix = Matrix.Identity();
         newGS._splatPositions = this._splatPositions;
         newGS._readyToDisplay = false;
         newGS._disableDepthSort = this._disableDepthSort;
@@ -1798,8 +1805,9 @@ export class GaussianSplattingMesh extends Mesh {
      * @returns a placeholder mesh that can be used to manipulate the part transform
      */
     addPart(other, disposeOther = true) {
-        if (this.partCount >= GaussianSplattingMaxPartCount) {
-            throw new Error(`Cannot add part, as the maximum part count (${GaussianSplattingMaxPartCount}) has been reached`);
+        const maxPartCount = GetGaussianSplattingMaxPartCount(this._scene.getEngine());
+        if (this.partCount >= maxPartCount) {
+            throw new Error(`Cannot add part, as the maximum part count (${maxPartCount}) has been reached`);
         }
         const splatCountA = this._vertexCount;
         const splatsDataA = splatCountA == 0 ? new ArrayBuffer(0) : this.splatsData;
@@ -2060,17 +2068,6 @@ GaussianSplattingMesh._CreateWorker = function (self) {
     let floatMix;
     let partIndices;
     let partMatrices;
-    function multiplyMatrices(matrix1, matrix2) {
-        const result = new Float32Array(16);
-        for (let i = 0; i < 4; i++) {
-            for (let j = 0; j < 4; j++) {
-                for (let k = 0; k < 4; k++) {
-                    result[j * 4 + i] += matrix1[k * 4 + i] * matrix2[j * 4 + k];
-                }
-            }
-        }
-        return result;
-    }
     self.onmessage = (e) => {
         // updated on init
         if (e.data.positions) {
@@ -2087,12 +2084,13 @@ GaussianSplattingMesh._CreateWorker = function (self) {
         // update on view changed
         else {
             const cameraId = e.data.cameraId;
-            const globalModelViewProjection = e.data.modelViewProjection;
-            const viewProjection = e.data.viewProjection;
+            const globalWorldMatrix = e.data.worldMatrix;
+            const cameraForward = e.data.cameraForward;
+            const cameraPosition = e.data.cameraPosition;
             const vertexCountPadded = (positions.length / 4 + 15) & ~0xf;
-            if (!positions || !globalModelViewProjection) {
+            if (!positions || !cameraForward) {
                 // Sanity check, it shouldn't happen!
-                throw new Error("positions or modelViewProjection matrix is not defined!");
+                throw new Error("positions or camera info is not defined!");
             }
             depthMix = e.data.depthMix;
             indices = new Uint32Array(depthMix.buffer);
@@ -2101,25 +2099,37 @@ GaussianSplattingMesh._CreateWorker = function (self) {
             for (let j = 0; j < vertexCountPadded; j++) {
                 indices[2 * j] = j;
             }
-            const depthScale = e.data.depthScale;
+            // depth = dot(cameraForward, worldPos - cameraPos)
+            const camDot = cameraForward[0] * cameraPosition[0] + cameraForward[1] * cameraPosition[1] + cameraForward[2] * cameraPosition[2];
+            const computeDepthCoeffs = (m) => {
+                return [
+                    cameraForward[0] * m[0] + cameraForward[1] * m[1] + cameraForward[2] * m[2],
+                    cameraForward[0] * m[4] + cameraForward[1] * m[5] + cameraForward[2] * m[6],
+                    cameraForward[0] * m[8] + cameraForward[1] * m[9] + cameraForward[2] * m[10],
+                    cameraForward[0] * m[12] + cameraForward[1] * m[13] + cameraForward[2] * m[14] - camDot,
+                ];
+            };
             if (partMatrices && partIndices) {
-                // If there are rig node matrices, we use them instead of the global model view proj
-                // Precompute modelViewProj for each rig node
-                const modelViewProjs = partMatrices.map((model) => multiplyMatrices(viewProjection, model));
+                // Precompute depth coefficients for each rig node
+                const depthCoeffs = partMatrices.map((m) => computeDepthCoeffs(m));
                 // NB: For performance reasons, we assume that part indices are valid
                 const length = partIndices.length;
                 for (let j = 0; j < vertexCountPadded; j++) {
                     // NB: We need this 'min' because vertex array is padded, not partIndices
                     const partIndex = partIndices[Math.min(j, length - 1)];
-                    const mvp = modelViewProjs[partIndex];
-                    floatMix[2 * j + 1] = 10000 - (mvp[2] * positions[4 * j + 0] + mvp[6] * positions[4 * j + 1] + mvp[10] * positions[4 * j + 2] + mvp[14]) * depthScale;
+                    const coeff = depthCoeffs[partIndex];
+                    floatMix[2 * j + 1] = coeff[0] * positions[4 * j + 0] + coeff[1] * positions[4 * j + 1] + coeff[2] * positions[4 * j + 2] + coeff[3];
+                    // instead of using minus to sort back to front, we use bitwise not operator to invert the order of indices
+                    // might not be faster but a minus sign implies a reference value that may not be enough and will decrease floatting precision
+                    indices[2 * j + 1] = ~indices[2 * j + 1];
                 }
             }
             else {
-                // If there are no rig node matrices, we use the global model view proj
-                const mvp = globalModelViewProjection;
+                // Compute depth coefficients from global world matrix
+                const [a, b, c, d] = computeDepthCoeffs(globalWorldMatrix);
                 for (let j = 0; j < vertexCountPadded; j++) {
-                    floatMix[2 * j + 1] = 10000 - (mvp[2] * positions[4 * j + 0] + mvp[6] * positions[4 * j + 1] + mvp[10] * positions[4 * j + 2] + mvp[14]) * depthScale;
+                    floatMix[2 * j + 1] = a * positions[4 * j + 0] + b * positions[4 * j + 1] + c * positions[4 * j + 2] + d;
+                    indices[2 * j + 1] = ~indices[2 * j + 1];
                 }
             }
             depthMix.sort();