@onerjs/core 8.56.4 → 9.0.1

package/Materials/GaussianSplatting/gaussianSplattingMaterial.pure.js

@@ -1,4 +1,5 @@
 /** This file must only contain pure code and pure imports */
+import { Matrix } from "../../Maths/math.vector.pure.js";
 import { SerializationHelper } from "../../Misc/decorators.serialization.js";
 import { Logger } from "../../Misc/logger.js";
 import { VertexBuffer } from "../../Buffers/buffer.pure.js";
@@ -12,6 +13,9 @@ import { Material } from "../material.pure.js";
 import { BindFogParameters, BindLogDepth, PrepareAttributesForInstances, PrepareDefinesForAttributes, PrepareDefinesForFrameBoundValues, PrepareDefinesForMisc, PrepareUniformsAndSamplersList, } from "../materialHelper.functions.js";
 import { Engine } from "../../Engines/engine.pure.js";
 import { RegisterClass } from "../../Misc/typeStore.js";
+import { PrepassDefinesMixin } from "../prepass.defines.js";
+import { MaterialHelperGeometryRendering } from "../materialHelper.geometryrendering.js";
+import { Observable } from "../../Misc/observable.pure.js";
 /**
  * Computes the maximum number of Gaussian Splatting compound parts supported by the given engine.
  * The limit is derived from the engine's maximum vertex uniform vectors capability.
@@ -33,10 +37,35 @@ export function GetGaussianSplattingMaxPartCount(engine) {
  * @deprecated Use {@link GetGaussianSplattingMaxPartCount} with an engine instance instead.
  */
 export const GaussianSplattingMaxPartCount = 128;
+/**
+ * Returns an include-guarded declaration of the `vPartIndex` varying shared by the Gaussian
+ * Splatting material plugins (debug, solid-color, GPU picking). More than one of these plugins can
+ * be attached to the same material at once; each needs `vPartIndex` to carry `splat.partIndex` from
+ * the vertex to the fragment stage. Without a guard each plugin injects its own `varying vPartIndex`,
+ * which is a duplicate declaration — fatal under WGSL ("redefinition of 'vPartIndex'"). The guard
+ * makes the declaration idempotent so exactly one survives regardless of how many plugins inject it.
+ * Inject the result at a CUSTOM_VERTEX_DEFINITIONS / CUSTOM_FRAGMENT_DEFINITIONS point.
+ * @param shaderLanguage - The shader language the host material is compiling.
+ * @returns The guarded `vPartIndex` varying declaration.
+ */
+export function GetPartIndexVaryingDeclaration(shaderLanguage) {
+    const decl = shaderLanguage === 1 /* ShaderLanguage.WGSL */ ? "varying vPartIndex: f32;" : "varying float vPartIndex;";
+    return `
+#if !defined(VPARTINDEX_VARYING_DECLARED)
+#define VPARTINDEX_VARYING_DECLARED
+${decl}
+#endif
+`;
+}
+/**
+ * @internal
+ */
+class GaussianSplattingMaterialDefinesBase extends PrepassDefinesMixin(MaterialDefines) {
+}
 /**
  * @internal
  */
-class GaussianSplattingMaterialDefines extends MaterialDefines {
+class GaussianSplattingMaterialDefines extends GaussianSplattingMaterialDefinesBase {
     /**
      * Constructor of the defines.
      * @param externalProperties External properties (e.g. from material plugins) to add to the defines.
@@ -108,6 +137,10 @@ export class GaussianSplattingMaterial extends PushMaterial {
         // set to true when material defines are dirty
         this._isDirty = false;
         this._sourceMesh = null;
+        this._inverseProjection = Matrix.Identity();
+        this._geometryProjectionUpdateFlag = -1;
+        this._partMotionHistory = new Map();
+        this._renderPassObserver = null;
         this._voxelMissingTextureWarned = new Set();
         this._voxelPartWorldData = new Float32Array(0);
         this._voxelPartVisibilityData = [];
@@ -118,7 +151,7 @@ export class GaussianSplattingMaterial extends PushMaterial {
      * Set compensation default value is `GaussianSplattingMaterial.Compensation`
      */
     set compensation(value) {
-        this._isDirty = this._isDirty != value;
+        this._isDirty = this._isDirty || this._compensation !== value;
         this._compensation = value;
     }
     /**
@@ -147,6 +180,16 @@ export class GaussianSplattingMaterial extends PushMaterial {
     needAlphaBlending() {
         return true;
     }
+    static _BindViewportAndFocal(effect, camera, renderWidth, renderHeight, invViewportWidth = renderWidth) {
+        effect.setFloat2("invViewport", 1 / invViewportWidth, 1 / renderHeight);
+        if (camera) {
+            const projection = camera.getProjectionMatrix();
+            effect.setFloat2("focal", (renderWidth * projection.m[0]) / 2, (renderHeight * projection.m[5]) / 2);
+        }
+        else {
+            effect.setFloat2("focal", 1000, 1000);
+        }
+    }
     /**
      * Checks whether the material is ready to be rendered for a given mesh.
      * @param mesh The mesh to render
@@ -190,6 +233,7 @@ export class GaussianSplattingMaterial extends PushMaterial {
         }
         const engine = scene.getEngine();
         const gsMesh = this._sourceMesh;
+        MaterialHelperGeometryRendering.PrepareDefines(engine.currentRenderPassId, gsMesh, defines);
         // Misc.
         PrepareDefinesForMisc(mesh, scene, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, false, defines, undefined, undefined, undefined, this._isVertexOutputInvariant);
         // Values that need to be evaluated on every frame
@@ -208,11 +252,18 @@ export class GaussianSplattingMaterial extends PushMaterial {
         }
         defines["IS_COMPOUND"] = gsMesh.isCompound;
         defines["MAX_PART_COUNT"] = GetGaussianSplattingMaxPartCount(engine);
+        if (gsMesh.isCompound && (defines.PREPASS_VELOCITY || defines.PREPASS_VELOCITY_LINEAR)) {
+            // Reserve the regular 40 vectors plus projection/history matrices and the depth range.
+            defines.MAX_PART_COUNT = Math.min(defines.MAX_PART_COUNT, Math.max(1, Math.floor((engine.getCaps().maxVertexUniformVectors - 53) / 9)));
+            if (gsMesh.partCount > defines.MAX_PART_COUNT) {
+                throw new Error(`GaussianSplattingMaterial "${this.name}": geometry velocity supports at most ${defines.MAX_PART_COUNT} compound parts on this engine`);
+            }
+        }
         defines["USE_SOG"] = gsMesh.useSog;
         defines["USE_SOG_V2"] = gsMesh.useSog && gsMesh.sogParams?.version === 2;
         // Compensation
         const splatMaterial = gsMesh.material;
-        defines["COMPENSATION"] = splatMaterial && splatMaterial.compensation ? splatMaterial.compensation : GaussianSplattingMaterial.Compensation;
+        defines["COMPENSATION"] = splatMaterial?.compensation ?? GaussianSplattingMaterial.Compensation;
         // Get correct effect
         if (defines.isDirty) {
             defines.markAsProcessed();
@@ -223,6 +274,7 @@ export class GaussianSplattingMaterial extends PushMaterial {
             const uniforms = GaussianSplattingMaterial._Uniforms.slice();
             const samplers = GaussianSplattingMaterial._Samplers.slice();
             const uniformBuffers = GaussianSplattingMaterial._UniformBuffers.slice();
+            MaterialHelperGeometryRendering.AddUniformsAndSamplers(uniforms, samplers);
             PrepareUniformsAndSamplersList({
                 uniformsNames: uniforms,
                 uniformBuffersNames: uniformBuffers,
@@ -253,8 +305,9 @@ export class GaussianSplattingMaterial extends PushMaterial {
                 defines: join,
                 onCompiled: this.onCompiled,
                 onError: this.onError,
-                indexParameters: {},
+                indexParameters: { SCENE_MRT_COUNT: defines.SCENE_MRT_COUNT },
                 processCodeAfterIncludes: this._eventInfo.customCode,
+                multiTarget: defines.PREPASS,
                 shaderLanguage: this._shaderLanguage,
                 extraInitializationsAsync: async () => {
                     if (this._shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
@@ -281,6 +334,9 @@ export class GaussianSplattingMaterial extends PushMaterial {
      * @param mesh mesh this material belongs to
      */
     setSourceMesh(mesh) {
+        if (this._sourceMesh !== mesh) {
+            this._partMotionHistory.clear();
+        }
         this._sourceMesh = mesh;
     }
     /**
@@ -299,37 +355,20 @@ export class GaussianSplattingMaterial extends PushMaterial {
     static BindEffect(mesh, effect, scene) {
         const engine = scene.getEngine();
         const camera = scene.activeCamera;
-        const renderWidth = engine.getRenderWidth() * camera.viewport.width;
-        const renderHeight = engine.getRenderHeight() * camera.viewport.height;
-        const gsMaterial = mesh.material;
-        if (!gsMaterial._sourceMesh) {
+        const renderWidth = engine.getRenderWidth() * (camera?.viewport.width ?? 1);
+        const renderHeight = engine.getRenderHeight() * (camera?.viewport.height ?? 1);
+        const material = mesh.material;
+        const gsMaterial = material instanceof GaussianSplattingMaterial ? material : null;
+        const gsMesh = gsMaterial?._sourceMesh ?? mesh.reservedDataStore?._gaussianSplattingSourceMesh;
+        if (!gsMesh) {
             return;
         }
-        const gsMesh = gsMaterial._sourceMesh;
         // check if rigcamera, get number of rigs
         const numberOfRigs = camera?.rigParent?.rigCameras.length || 1;
-        effect.setFloat2("invViewport", 1 / (renderWidth / numberOfRigs), 1 / renderHeight);
-        let focal = 1000;
-        if (camera) {
-            /*
-            more explicit version:
-            const t = camera.getProjectionMatrix().m[5];
-            const FovY = Math.atan(1.0 / t) * 2.0;
-            focal = renderHeight / 2.0 / Math.tan(FovY / 2.0);
-            Using a shorter version here to not have tan(atan) and 2.0 factor
-            */
-            const t = camera.getProjectionMatrix().m[5];
-            if (camera.fovMode == Camera.FOVMODE_VERTICAL_FIXED) {
-                focal = (renderHeight * t) / 2.0;
-            }
-            else {
-                focal = (renderWidth * t) / 2.0;
-            }
-        }
-        effect.setFloat2("focal", focal, focal);
-        effect.setFloat("kernelSize", gsMaterial && gsMaterial.kernelSize ? gsMaterial.kernelSize : GaussianSplattingMaterial.KernelSize);
+        GaussianSplattingMaterial._BindViewportAndFocal(effect, camera, renderWidth, renderHeight, renderWidth / numberOfRigs);
+        effect.setFloat("kernelSize", gsMaterial?.kernelSize || GaussianSplattingMaterial.KernelSize);
         effect.setFloat("minPixelSize", gsMaterial ? gsMaterial.minPixelSize : GaussianSplattingMaterial.MinPixelSize);
-        effect.setFloat("alpha", gsMaterial.alpha);
+        effect.setFloat("alpha", material?.alpha ?? 1);
         scene.bindEyePosition(effect, "eyePosition", true);
         if (gsMesh.covariancesATexture) {
             const textureSize = gsMesh.covariancesATexture.getSize();
@@ -350,6 +389,84 @@ export class GaussianSplattingMaterial extends PushMaterial {
             gsMesh.bindExtraEffectUniforms(effect);
         }
     }
+    _bindGeometryRendering(effect, defines, mustRebind) {
+        const sourceMesh = this._sourceMesh;
+        if (!sourceMesh || !defines.PREPASS) {
+            return;
+        }
+        const scene = this.getScene();
+        const engine = scene.getEngine();
+        const renderPassId = engine.currentRenderPassId;
+        const configuration = MaterialHelperGeometryRendering.GetConfiguration(renderPassId);
+        if (!configuration) {
+            return;
+        }
+        MaterialHelperGeometryRendering.Bind(renderPassId, effect, sourceMesh, sourceMesh.getWorldMatrix(), this);
+        MaterialHelperGeometryRendering._BindZeroAlphaDiscard(engine, effect);
+        const camera = scene.activeCamera;
+        if (camera) {
+            if (defines.PREPASS_POSITION || defines.PREPASS_LOCAL_POSITION || defines.PREPASS_VELOCITY || defines.PREPASS_VELOCITY_LINEAR) {
+                const projection = camera.getProjectionMatrix();
+                if (projection.updateFlag !== this._geometryProjectionUpdateFlag) {
+                    projection.invertToRef(this._inverseProjection);
+                    this._geometryProjectionUpdateFlag = projection.updateFlag;
+                }
+                effect.setMatrix("inverseProjection", this._inverseProjection);
+            }
+            if (defines.PREPASS_NORMALIZED_VIEW_DEPTH) {
+                effect.setFloat2("geometryDepthRange", camera.minZ, camera.maxZ);
+            }
+        }
+        if (!mustRebind) {
+            sourceMesh.bindExtraEffectUniforms(effect);
+        }
+        if (!sourceMesh.isCompound || (!defines.PREPASS_VELOCITY && !defines.PREPASS_VELOCITY_LINEAR)) {
+            return;
+        }
+        const partCount = sourceMesh.partCount;
+        let history = this._partMotionHistory.get(renderPassId);
+        if (!history || history.configuration !== configuration || history.currentPartWorldMatrices.length !== partCount) {
+            if (partCount > defines.MAX_PART_COUNT) {
+                throw new Error(`GaussianSplattingMaterial "${this.name}": geometry velocity supports at most ${defines.MAX_PART_COUNT} compound parts on this engine`);
+            }
+            const currentPartWorldMatrices = new Array(partCount);
+            for (let i = 0; i < partCount; i++) {
+                currentPartWorldMatrices[i] = sourceMesh.getWorldMatrixForPart(i).clone();
+            }
+            history = {
+                configuration,
+                currentPartWorldMatrices,
+                previousPartWorldData: new Float32Array(partCount * 16),
+                lastUpdateFrameId: -1,
+            };
+            this._partMotionHistory.set(renderPassId, history);
+            this._renderPassObserver ?? (this._renderPassObserver = (engine._onReleaseRenderPassObservable ?? (engine._onReleaseRenderPassObservable = new Observable())).add((id) => this._partMotionHistory.delete(id)));
+        }
+        if (history.lastUpdateFrameId !== engine.frameId) {
+            const consecutiveFrame = history.lastUpdateFrameId === engine.frameId - 1;
+            for (let i = 0; i < partCount; i++) {
+                const previous = consecutiveFrame ? history.currentPartWorldMatrices[i] : sourceMesh.getWorldMatrixForPart(i);
+                previous.toArray(history.previousPartWorldData, i * 16);
+            }
+            history.lastUpdateFrameId = engine.frameId;
+        }
+        effect.setMatrices("previousPartWorld", history.previousPartWorldData);
+        for (let i = 0; i < partCount; i++) {
+            history.currentPartWorldMatrices[i].copyFrom(sourceMesh.getWorldMatrixForPart(i));
+        }
+    }
+    /**
+     * Releases the material and its render-pass motion histories.
+     * @param forceDisposeEffect whether associated effects should be disposed
+     * @param forceDisposeTextures whether associated textures should be disposed
+     * @param notBoundToMesh whether mesh references can be left unchanged
+     */
+    dispose(forceDisposeEffect, forceDisposeTextures, notBoundToMesh) {
+        this.getScene().getEngine()._onReleaseRenderPassObservable?.remove(this._renderPassObserver);
+        this._renderPassObserver = null;
+        this._partMotionHistory.clear();
+        super.dispose(forceDisposeEffect, forceDisposeTextures, notBoundToMesh);
+    }
     /**
      * Bind SOG dequantization uniforms + raw textures.
      * @internal
@@ -413,6 +530,7 @@ export class GaussianSplattingMaterial extends PushMaterial {
         else if (scene.getEngine()._features.needToAlwaysBindUniformBuffers) {
             this._needToBindSceneUbo = true;
         }
+        this._bindGeometryRendering(effect, defines, mustRebind);
         // Fog
         BindFogParameters(scene, mesh, effect);
         // Log. depth
@@ -436,25 +554,7 @@ export class GaussianSplattingMaterial extends PushMaterial {
         shaderMaterial.bindViewProjection(effect);
         const renderWidth = engine.getRenderWidth() * camera.viewport.width;
         const renderHeight = engine.getRenderHeight() * camera.viewport.height;
-        effect.setFloat2("invViewport", 1 / renderWidth, 1 / renderHeight);
-        let focal = 1000;
-        if (camera) {
-            /*
-            more explicit version:
-            const t = camera.getProjectionMatrix().m[5];
-            const FovY = Math.atan(1.0 / t) * 2.0;
-            focal = renderHeight / 2.0 / Math.tan(FovY / 2.0);
-            Using a shorter version here to not have tan(atan) and 2.0 factor
-            */
-            const t = camera.getProjectionMatrix().m[5];
-            if (camera.fovMode == Camera.FOVMODE_VERTICAL_FIXED) {
-                focal = (renderHeight * t) / 2.0;
-            }
-            else {
-                focal = (renderWidth * t) / 2.0;
-            }
-        }
-        effect.setFloat2("focal", focal, focal);
+        GaussianSplattingMaterial._BindViewportAndFocal(effect, camera, renderWidth, renderHeight);
         effect.setFloat("kernelSize", gsMaterial && gsMaterial.kernelSize ? gsMaterial.kernelSize : GaussianSplattingMaterial.KernelSize);
         effect.setFloat("minPixelSize", gsMaterial ? gsMaterial.minPixelSize : GaussianSplattingMaterial.MinPixelSize);
         effect.setFloat("alpha", gsMaterial.alpha);
@@ -731,6 +831,7 @@ GaussianSplattingMaterial._Uniforms = [
     "world",
     "view",
     "projection",
+    "inverseProjection",
     "vFogInfos",
     "vFogColor",
     "logarithmicDepthConstant",
@@ -742,7 +843,10 @@ GaussianSplattingMaterial._Uniforms = [
     "minPixelSize",
     "alpha",
     "depthValues",
+    "geometryDepthRange",
+    "geometryZeroAlphaDiscard",
     "partWorld",
+    "previousPartWorld",
     "partVisibility",
     "sogMeansMin",
     "sogMeansMax",