@onerjs/core 8.56.4 → 9.0.0

package/Particles/gpuParticleSystem.pure.js

@@ -24,6 +24,7 @@ import { _IsSideEffectImplemented } from "../Misc/devTools.js";
 import { AddClipPlaneUniforms, BindClipPlane, PrepareStringDefinesForClipPlanes } from "../Materials/clipPlaneMaterialHelper.js";
 import { BindFogParameters, BindLogDepth } from "../Materials/materialHelper.functions.js";
 import { MeshParticleEmitter } from "./EmitterTypes/meshParticleEmitter.js";
+import { MaterialHelperGeometryRendering } from "../Materials/materialHelper.geometryrendering.js";
 /**
  * This represents a GPU particle system in Babylon
  * This is the fastest particle system in Babylon as it uses the GPU to update the individual particle data
@@ -438,9 +439,13 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * Resets the draw wrappers cache
      */
     resetDrawCache() {
-        for (const blendMode in this._drawWrappers) {
-            const drawWrapper = this._drawWrappers[blendMode];
-            drawWrapper.drawContext?.reset();
+        for (const drawWrappers of this._drawWrappers) {
+            if (!drawWrappers) {
+                continue;
+            }
+            for (const drawWrapper of drawWrappers) {
+                drawWrapper?.drawContext?.reset();
+            }
         }
     }
     /**
@@ -771,6 +776,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
         /** Indicates that the update of particles is done in the animate function (and not in render). Default: false */
         this.updateInAnimate = false;
         this._actualFrame = 0;
+        this._renderPassObserver = null;
         this._renderShadersLoaded = false;
         this._rawTextureWidth = 256;
         this._rebuildingAfterContextLost = false;
@@ -875,10 +881,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
         }
         this._customWrappers = { 0: new DrawWrapper(this._engine) };
         this._customWrappers[0].effect = customEffect;
-        this._drawWrappers = { 0: new DrawWrapper(this._engine) };
-        if (this._drawWrappers[0].drawContext) {
-            this._drawWrappers[0].drawContext.useInstancing = true;
-        }
+        this._drawWrappers = [];
         this._createIndexBuffer();
         // Setup the default processing configuration to the scene.
         this._attachImageProcessingConfiguration(null);
@@ -1253,6 +1256,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * @internal
      */
     _getWrapper(blendMode) {
+        var _a;
         const customWrapper = this._getCustomDrawWrapper(blendMode);
         if (customWrapper?.effect) {
             return customWrapper;
@@ -1260,13 +1264,31 @@ export class GPUParticleSystem extends BaseParticleSystem {
         const defines = [];
         this.fillDefines(defines, blendMode);
         // Effect
-        let drawWrapper = this._drawWrappers[blendMode];
+        const currentRenderPassId = this._engine._features.supportRenderPasses ? this._engine.currentRenderPassId : 0;
+        const geometryRendering = MaterialHelperGeometryRendering._PrepareStringDefines(currentRenderPassId, defines);
+        const geometryRenderingConfiguration = geometryRendering ? MaterialHelperGeometryRendering.GetConfiguration(currentRenderPassId) : undefined;
+        let drawWrappers = this._drawWrappers[currentRenderPassId];
+        if (!drawWrappers) {
+            drawWrappers = this._drawWrappers[currentRenderPassId] = [];
+            if (currentRenderPassId !== 0 && !this._renderPassObserver) {
+                this._renderPassObserver = ((_a = this._engine)._onReleaseRenderPassObservable ?? (_a._onReleaseRenderPassObservable = new Observable())).add((id) => {
+                    const releasedWrappers = this._drawWrappers[id];
+                    if (releasedWrappers) {
+                        for (const wrapper of releasedWrappers) {
+                            wrapper?.dispose();
+                        }
+                        delete this._drawWrappers[id];
+                    }
+                });
+            }
+        }
+        let drawWrapper = drawWrappers[blendMode];
         if (!drawWrapper) {
             drawWrapper = new DrawWrapper(this._engine);
             if (drawWrapper.drawContext) {
                 drawWrapper.drawContext.useInstancing = true;
             }
-            this._drawWrappers[blendMode] = drawWrapper;
+            drawWrappers[blendMode] = drawWrapper;
         }
         const join = defines.join("\n");
         if (drawWrapper.defines !== join) {
@@ -1274,6 +1296,9 @@ export class GPUParticleSystem extends BaseParticleSystem {
             const uniforms = [];
             const samplers = [];
             this.fillUniformsAttributesAndSamplerNames(uniforms, attributes, samplers);
+            if (geometryRendering) {
+                uniforms.push("cameraInfo", "inverseEmitterWM", "objectId", "meshBlendTag", "geometryZeroAlphaDiscard");
+            }
             const shaderLanguage = this._engine.isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */;
             drawWrapper.setEffect(this._engine.createEffect("gpuRenderParticles", {
                 attributes,
@@ -1281,6 +1306,8 @@ export class GPUParticleSystem extends BaseParticleSystem {
                 samplers,
                 defines: join,
                 shaderLanguage,
+                multiTarget: geometryRendering,
+                indexParameters: geometryRendering ? { buffersCount: geometryRenderingConfiguration?._mrtCount ?? 0 } : undefined,
                 extraInitializationsAsync: this._renderShadersLoaded
                     ? undefined
                     : async () => {
@@ -1293,6 +1320,21 @@ export class GPUParticleSystem extends BaseParticleSystem {
         }
         return drawWrapper;
     }
+    _bindGeometryRendering(effect, emitterWM) {
+        const renderPassId = this._engine._features.supportRenderPasses ? this._engine.currentRenderPassId : 0;
+        const configuration = MaterialHelperGeometryRendering.GetConfiguration(renderPassId);
+        if (!configuration?._defines) {
+            return;
+        }
+        effect.setFloat("objectId", 0);
+        effect.setInt("meshBlendTag", 0);
+        const camera = this._scene?.activeCamera;
+        effect.setFloat2("cameraInfo", camera?.minZ ?? 0, camera?.maxZ ?? 1);
+        if (this.isLocal) {
+            emitterWM.invertToRef(TmpVectors.Matrix[2]);
+            effect.setMatrix("inverseEmitterWM", TmpVectors.Matrix[2]);
+        }
+    }
     /**
      * @internal
      */
@@ -1652,7 +1694,8 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._engine.enableEffect(drawWrapper);
         const viewMatrix = this._scene?.getViewMatrix() || Matrix.IdentityReadOnly;
         effect.setMatrix("view", viewMatrix);
-        effect.setMatrix("projection", this.defaultProjectionMatrix ?? this._scene.getProjectionMatrix());
+        const projectionMatrix = this.defaultProjectionMatrix ?? this._scene.getProjectionMatrix();
+        effect.setMatrix("projection", projectionMatrix);
         effect.setTexture("diffuseSampler", this.particleTexture);
         effect.setVector2("translationPivot", this.translationPivot);
         const worldOffset = this.worldOffset.subtractToRef(this._scene?.floatingOriginOffset || Vector3.ZeroReadOnly, TmpVectors.Vector3[0]);
@@ -1682,9 +1725,11 @@ export class GPUParticleSystem extends BaseParticleSystem {
             }
         }
         if (defines.indexOf("#define BILLBOARDMODE_ALL") >= 0) {
-            const invView = viewMatrix.clone();
-            invView.invert();
-            effect.setMatrix("invView", invView);
+            viewMatrix.invertToRef(TmpVectors.Matrix[1]);
+            effect.setMatrix("invView", TmpVectors.Matrix[1]);
+        }
+        if (effect._multiTarget) {
+            this._bindGeometryRendering(effect, emitterWM);
         }
         // Log. depth
         if (this.useLogarithmicDepth && this._scene) {
@@ -1696,23 +1741,33 @@ export class GPUParticleSystem extends BaseParticleSystem {
         }
         // Draw order
         this._setEngineBasedOnBlendMode(blendMode);
-        // Bind source VAO
-        this._platform.bindDrawBuffers(this._targetIndex, effect, this._scene?.forceWireframe ? this._linesIndexBufferUseInstancing : null);
-        if (this._onBeforeDrawParticlesObservable) {
-            this._onBeforeDrawParticlesObservable.notifyObservers(effect);
-        }
-        // Render
-        if (this._scene?.forceWireframe) {
-            this._engine.drawElementsType(6, 0, 10, this._currentActiveCount);
+        if (effect._multiTarget) {
+            MaterialHelperGeometryRendering._BindZeroAlphaDiscard(this._engine, effect);
+        }
+        let rendered = false;
+        try {
+            if (MaterialHelperGeometryRendering._BindAttachmentsForEffect(this._engine, effect)) {
+                this._platform.bindDrawBuffers(this._targetIndex, effect, this._scene?.forceWireframe ? this._linesIndexBufferUseInstancing : null);
+                if (this._onBeforeDrawParticlesObservable) {
+                    this._onBeforeDrawParticlesObservable.notifyObservers(effect);
+                }
+                if (this._scene?.forceWireframe) {
+                    this._engine.drawElementsType(6, 0, 10, this._currentActiveCount);
+                }
+                else {
+                    this._engine.drawArraysType(7, 0, 4, this._currentActiveCount);
+                }
+                rendered = true;
+            }
         }
-        else {
-            this._engine.drawArraysType(7, 0, 4, this._currentActiveCount);
+        finally {
+            MaterialHelperGeometryRendering._RestoreAttachments(this._engine);
         }
         this._engine.setAlphaMode(0);
         if (this._scene?.forceWireframe) {
             this._engine.unbindInstanceAttributes();
         }
-        return this._currentActiveCount;
+        return rendered ? this._currentActiveCount : 0;
     }
     /** @internal */
     _update(emitterWM) {
@@ -2029,11 +2084,17 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * @param disposeTexture defines if the particule texture must be disposed as well (true by default)
      */
     dispose(disposeTexture = true) {
-        for (const blendMode in this._drawWrappers) {
-            const drawWrapper = this._drawWrappers[blendMode];
-            drawWrapper.dispose();
+        this._engine._onReleaseRenderPassObservable?.remove(this._renderPassObserver);
+        this._renderPassObserver = null;
+        for (const drawWrappers of this._drawWrappers) {
+            if (!drawWrappers) {
+                continue;
+            }
+            for (const drawWrapper of drawWrappers) {
+                drawWrapper?.dispose();
+            }
         }
-        this._drawWrappers = {};
+        this._drawWrappers = [];
         if (this._scene) {
             const index = this._scene.particleSystems.indexOf(this);
             if (index > -1) {