@babylonjs/core 5.35.1 → 5.37.0

package/Particles/gpuParticleSystem.d.ts

@@ -1,8 +1,9 @@
-import type { Nullable } from "../types";
+import type { Immutable, Nullable } from "../types";
 import type { Color3Gradient, IValueGradient } from "../Misc/gradients";
 import { Observable } from "../Misc/observable";
 import { Matrix } from "../Maths/math.vector";
 import { Color4 } from "../Maths/math.color";
+import { VertexBuffer } from "../Buffers/buffer";
 import type { IParticleSystem } from "./IParticleSystem";
 import { BaseParticleSystem } from "./baseParticleSystem";
 import type { IDisposable } from "../scene";
@@ -10,6 +11,7 @@ import type { Effect } from "../Materials/effect";
 import { RawTexture } from "../Materials/Textures/rawTexture";
 import type { IAnimatable } from "../Animations/animatable.interface";
 import { ThinEngine } from "../Engines/thinEngine";
+import type { DataBuffer } from "../Buffers/dataBuffer";
 import { DrawWrapper } from "../Materials/drawWrapper";
 declare type Scene = import("../scene").Scene;
 import "../Shaders/gpuRenderParticles.fragment";
@@ -32,6 +34,7 @@ export declare class GPUParticleSystem extends BaseParticleSystem implements IDi
     private _buffer0;
     private _buffer1;
     private _spriteBuffer;
+    private _renderVertexBuffers;
     private _targetIndex;
     private _sourceBuffer;
     private _targetBuffer;
@@ -44,6 +47,8 @@ export declare class GPUParticleSystem extends BaseParticleSystem implements IDi
     _randomTexture: RawTexture;
     /** @internal */
     _randomTexture2: RawTexture;
+    /** Indicates that the update of particles is done in the animate function (and not in render). Default: false */
+    updateInAnimate: boolean;
     private _attributesStrideSize;
     private _cachedUpdateDefines;
     private _randomTextureSize;
@@ -84,6 +89,8 @@ export declare class GPUParticleSystem extends BaseParticleSystem implements IDi
      * Specifies if the particles are updated in emitter local space or world space.
      */
     isLocal: boolean;
+    /** Indicates that the particle system is GPU based */
+    readonly isGPU = true;
     /** Gets or sets a matrix to use to compute projection */
     defaultProjectionMatrix: Matrix;
     /**
@@ -152,6 +159,18 @@ export declare class GPUParticleSystem extends BaseParticleSystem implements IDi
      * Gets the name of the particle vertex shader
      */
     get vertexShaderName(): string;
+    /**
+     * Gets the vertex buffers used by the particle system
+     * Should be called after render() has been called for the current frame so that the buffers returned are the ones that have been updated
+     * in the current frame (there's a ping-pong between two sets of buffers - for a given frame, one set is used as the source and the other as the destination)
+     */
+    get vertexBuffers(): Immutable<{
+        [key: string]: VertexBuffer;
+    }>;
+    /**
+     * Gets the index buffer used by the particle system (null for GPU particle systems)
+     */
+    get indexBuffer(): Nullable<DataBuffer>;
     /** @internal */
     _colorGradientsTexture: RawTexture;
     protected _removeGradientAndTexture(gradient: number, gradients: Nullable<IValueGradient[]>, texture: RawTexture): BaseParticleSystem;
@@ -380,6 +399,8 @@ export declare class GPUParticleSystem extends BaseParticleSystem implements IDi
     private _createDragGradientTexture;
     private _createColorGradientTexture;
     private _render;
+    /** @internal */
+    _update(emitterWM?: Matrix): void;
     /**
      * Renders the particle system in its current state
      * @param preWarm defines if the system should only update the particles but not render them
@@ -401,9 +422,10 @@ export declare class GPUParticleSystem extends BaseParticleSystem implements IDi
      * Clones the particle system.
      * @param name The name of the cloned object
      * @param newEmitter The new emitter to use
+     * @param cloneTexture Also clone the textures if true
      * @returns the cloned particle system
      */
-    clone(name: string, newEmitter: any): GPUParticleSystem;
+    clone(name: string, newEmitter: any, cloneTexture?: boolean): GPUParticleSystem;
     /**
      * Serializes the particle system to a JSON object
      * @param serializeTexture defines if the texture must be serialized as well

package/Particles/gpuParticleSystem.js

@@ -41,12 +41,15 @@ export class GPUParticleSystem extends BaseParticleSystem {
          */
         this.layerMask = 0x0fffffff;
         this._accumulatedCount = 0;
+        this._renderVertexBuffers = [];
         this._targetIndex = 0;
         this._currentRenderId = -1;
         this._currentRenderingCameraUniqueId = -1;
         this._started = false;
         this._stopped = false;
         this._timeDelta = 0;
+        /** 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._rawTextureWidth = 256;
         /**
@@ -67,6 +70,8 @@ export class GPUParticleSystem extends BaseParticleSystem {
          * Specifies if the particles are updated in emitter local space or world space.
          */
         this.isLocal = false;
+        /** Indicates that the particle system is GPU based */
+        this.isGPU = true;
         /** @internal */
         this._onBeforeDrawParticlesObservable = null;
         if (!sceneOrEngine || sceneOrEngine.getClassName() === "Scene") {
@@ -308,6 +313,24 @@ export class GPUParticleSystem extends BaseParticleSystem {
     get vertexShaderName() {
         return "gpuRenderParticles";
     }
+    /**
+     * Gets the vertex buffers used by the particle system
+     * Should be called after render() has been called for the current frame so that the buffers returned are the ones that have been updated
+     * in the current frame (there's a ping-pong between two sets of buffers - for a given frame, one set is used as the source and the other as the destination)
+     */
+    get vertexBuffers() {
+        // We return the other buffers than those corresponding to this._targetIndex because it is assumed vertexBuffers will be called in the current frame
+        // after render() has been called, meaning that the buffers have already been swapped and this._targetIndex points to the buffers that will be updated
+        // in the next frame (and which are the sources in this frame) and (this._targetIndex ^ 1) points to the buffers that have been updated this frame
+        // (and that will be the source buffers in the next frame)
+        return this._renderVertexBuffers[this._targetIndex ^ 1];
+    }
+    /**
+     * Gets the index buffer used by the particle system (null for GPU particle systems)
+     */
+    get indexBuffer() {
+        return null;
+    }
     _removeGradientAndTexture(gradient, gradients, texture) {
         super._removeGradientAndTexture(gradient, gradients, texture);
         this._releaseBuffers();
@@ -711,6 +734,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
         }
         renderVertexBuffers["offset"] = spriteSource.createVertexBuffer("offset", 0, 2);
         renderVertexBuffers["uv"] = spriteSource.createVertexBuffer("uv", 2, 2);
+        this._renderVertexBuffers.push(renderVertexBuffers);
         this._platform.createVertexBuffers(updateBuffer, renderVertexBuffers);
         this.resetDrawCache();
     }
@@ -871,6 +895,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._buffer1 = new Buffer(engine, bufferData2, false, this._attributesStrideSize);
         this._spriteBuffer = new Buffer(engine, spriteData, false, 4);
         // Update & Render vertex buffers
+        this._renderVertexBuffers = [];
         this._createVertexBuffers(this._buffer0, this._buffer1, this._spriteBuffer);
         this._createVertexBuffers(this._buffer1, this._buffer0, this._spriteBuffer);
         // Links
@@ -1055,6 +1080,9 @@ export class GPUParticleSystem extends BaseParticleSystem {
                 this.stop();
             }
         }
+        if (this.updateInAnimate) {
+            this._update();
+        }
     }
     _createFactorGradientTexture(factorGradients, textureName) {
         const texture = this[textureName];
@@ -1174,6 +1202,62 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._engine.setAlphaMode(0);
         return this._currentActiveCount;
     }
+    /** @internal */
+    _update(emitterWM) {
+        if (!this.emitter) {
+            return;
+        }
+        this._recreateUpdateEffect();
+        if (this.emitter.position) {
+            const emitterMesh = this.emitter;
+            emitterWM = emitterMesh.getWorldMatrix();
+        }
+        else {
+            const emitterPosition = this.emitter;
+            emitterWM = TmpVectors.Matrix[0];
+            Matrix.TranslationToRef(emitterPosition.x, emitterPosition.y, emitterPosition.z, emitterWM);
+        }
+        this._platform.preUpdateParticleBuffer();
+        this._updateBuffer.setFloat("currentCount", this._currentActiveCount);
+        this._updateBuffer.setFloat("timeDelta", this._timeDelta);
+        this._updateBuffer.setFloat("stopFactor", this._stopped ? 0 : 1);
+        this._updateBuffer.setInt("randomTextureSize", this._randomTextureSize);
+        this._updateBuffer.setFloat2("lifeTime", this.minLifeTime, this.maxLifeTime);
+        this._updateBuffer.setFloat2("emitPower", this.minEmitPower, this.maxEmitPower);
+        if (!this._colorGradientsTexture) {
+            this._updateBuffer.setDirectColor4("color1", this.color1);
+            this._updateBuffer.setDirectColor4("color2", this.color2);
+        }
+        this._updateBuffer.setFloat2("sizeRange", this.minSize, this.maxSize);
+        this._updateBuffer.setFloat4("scaleRange", this.minScaleX, this.maxScaleX, this.minScaleY, this.maxScaleY);
+        this._updateBuffer.setFloat4("angleRange", this.minAngularSpeed, this.maxAngularSpeed, this.minInitialRotation, this.maxInitialRotation);
+        this._updateBuffer.setVector3("gravity", this.gravity);
+        if (this._limitVelocityGradientsTexture) {
+            this._updateBuffer.setFloat("limitVelocityDamping", this.limitVelocityDamping);
+        }
+        if (this.particleEmitterType) {
+            this.particleEmitterType.applyToShader(this._updateBuffer);
+        }
+        if (this._isAnimationSheetEnabled) {
+            this._updateBuffer.setFloat4("cellInfos", this.startSpriteCellID, this.endSpriteCellID, this.spriteCellChangeSpeed, this.spriteCellLoop ? 1 : 0);
+        }
+        if (this.noiseTexture) {
+            this._updateBuffer.setVector3("noiseStrength", this.noiseStrength);
+        }
+        if (!this.isLocal) {
+            this._updateBuffer.setMatrix("emitterWM", emitterWM);
+        }
+        this._platform.updateParticleBuffer(this._targetIndex, this._targetBuffer, this._currentActiveCount);
+        // Switch VAOs
+        this._targetIndex++;
+        if (this._targetIndex === 2) {
+            this._targetIndex = 0;
+        }
+        // Switch buffers
+        const tmpBuffer = this._sourceBuffer;
+        this._sourceBuffer = this._targetBuffer;
+        this._targetBuffer = tmpBuffer;
+    }
     /**
      * Renders the particle system in its current state
      * @param preWarm defines if the system should only update the particles but not render them
@@ -1190,7 +1274,6 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._createVelocityGradientTexture();
         this._createLimitVelocityGradientTexture();
         this._createDragGradientTexture();
-        this._recreateUpdateEffect();
         if (!this.isReady()) {
             return 0;
         }
@@ -1230,40 +1313,13 @@ export class GPUParticleSystem extends BaseParticleSystem {
         }
         else {
             const emitterPosition = this.emitter;
-            emitterWM = Matrix.Translation(emitterPosition.x, emitterPosition.y, emitterPosition.z);
+            emitterWM = TmpVectors.Matrix[0];
+            Matrix.TranslationToRef(emitterPosition.x, emitterPosition.y, emitterPosition.z, emitterWM);
         }
         const engine = this._engine;
-        this._platform.preUpdateParticleBuffer();
-        this._updateBuffer.setFloat("currentCount", this._currentActiveCount);
-        this._updateBuffer.setFloat("timeDelta", this._timeDelta);
-        this._updateBuffer.setFloat("stopFactor", this._stopped ? 0 : 1);
-        this._updateBuffer.setInt("randomTextureSize", this._randomTextureSize);
-        this._updateBuffer.setFloat2("lifeTime", this.minLifeTime, this.maxLifeTime);
-        this._updateBuffer.setFloat2("emitPower", this.minEmitPower, this.maxEmitPower);
-        if (!this._colorGradientsTexture) {
-            this._updateBuffer.setDirectColor4("color1", this.color1);
-            this._updateBuffer.setDirectColor4("color2", this.color2);
+        if (!this.updateInAnimate) {
+            this._update(emitterWM);
         }
-        this._updateBuffer.setFloat2("sizeRange", this.minSize, this.maxSize);
-        this._updateBuffer.setFloat4("scaleRange", this.minScaleX, this.maxScaleX, this.minScaleY, this.maxScaleY);
-        this._updateBuffer.setFloat4("angleRange", this.minAngularSpeed, this.maxAngularSpeed, this.minInitialRotation, this.maxInitialRotation);
-        this._updateBuffer.setVector3("gravity", this.gravity);
-        if (this._limitVelocityGradientsTexture) {
-            this._updateBuffer.setFloat("limitVelocityDamping", this.limitVelocityDamping);
-        }
-        if (this.particleEmitterType) {
-            this.particleEmitterType.applyToShader(this._updateBuffer);
-        }
-        if (this._isAnimationSheetEnabled) {
-            this._updateBuffer.setFloat4("cellInfos", this.startSpriteCellID, this.endSpriteCellID, this.spriteCellChangeSpeed, this.spriteCellLoop ? 1 : 0);
-        }
-        if (this.noiseTexture) {
-            this._updateBuffer.setVector3("noiseStrength", this.noiseStrength);
-        }
-        if (!this.isLocal) {
-            this._updateBuffer.setMatrix("emitterWM", emitterWM);
-        }
-        this._platform.updateParticleBuffer(this._targetIndex, this._targetBuffer, this._currentActiveCount);
         let outparticles = 0;
         if (!preWarm && !forceUpdateOnly) {
             engine.setState(false);
@@ -1278,15 +1334,6 @@ export class GPUParticleSystem extends BaseParticleSystem {
             }
             this._engine.setAlphaMode(0);
         }
-        // Switch VAOs
-        this._targetIndex++;
-        if (this._targetIndex === 2) {
-            this._targetIndex = 0;
-        }
-        // Switch buffers
-        const tmpBuffer = this._sourceBuffer;
-        this._sourceBuffer = this._targetBuffer;
-        this._targetBuffer = tmpBuffer;
         return outparticles;
     }
     /**
@@ -1328,6 +1375,13 @@ export class GPUParticleSystem extends BaseParticleSystem {
         }
         this._releaseBuffers();
         this._platform.releaseVertexBuffers();
+        for (let i = 0; i < this._renderVertexBuffers.length; ++i) {
+            const rvb = this._renderVertexBuffers[i];
+            for (const key in rvb) {
+                rvb[key].dispose();
+            }
+        }
+        this._renderVertexBuffers = [];
         if (this._colorGradientsTexture) {
             this._colorGradientsTexture.dispose();
             this._colorGradientsTexture = null;
@@ -1377,9 +1431,10 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * Clones the particle system.
      * @param name The name of the cloned object
      * @param newEmitter The new emitter to use
+     * @param cloneTexture Also clone the textures if true
      * @returns the cloned particle system
      */
-    clone(name, newEmitter) {
+    clone(name, newEmitter, cloneTexture = false) {
         const custom = { ...this._customWrappers };
         let program = null;
         const engine = this._engine;
@@ -1390,7 +1445,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
                 custom[0] = engine.createEffectForParticles(program.shaderPath.fragmentElement, program.shaderOptions.uniforms, program.shaderOptions.samplers, defines, undefined, undefined, undefined, this);
             }
         }
-        const serialization = this.serialize();
+        const serialization = this.serialize(cloneTexture);
         const result = GPUParticleSystem.Parse(serialization, this._scene || this._engine, this._rootUrl);
         result.name = name;
         result.customShader = program;