@babylonjs/core 9.4.1 → 9.5.1

package/Particles/thinParticleSystem.d.ts

@@ -107,6 +107,19 @@ export declare class ThinParticleSystem extends BaseParticleSystem implements ID
     private _alive;
     private _useInstancing;
     private _vertexArrayObject;
+    private _useFixedCapacityForSnapshot;
+    private _fixedCapacityHighWaterMark;
+    /**
+     * Gets or sets a boolean indicating that the particle system should always render at full capacity.
+     * When enabled, the draw call always emits `getCapacity()` quads/instances and inactive slots are zero-filled in the
+     * vertex buffer (collapsing them to degenerate triangles that produce no fragments).
+     * This makes the particle system compatible with FAST snapshot rendering, where the recorded draw call parameters
+     * are baked into the GPU bundle. Activate via `SnapshotRenderingHelper.fixParticleSystem(ps)`.
+     * Note: vertex shader cost scales with capacity rather than the live particle count, so size capacity realistically.
+     * This property is runtime-only and is not persisted by `serialize()` / `Parse()`.
+     */
+    get useFixedCapacityForSnapshot(): boolean;
+    set useFixedCapacityForSnapshot(value: boolean);
     private _isDisposed;
     /**
      * Gets a boolean indicating that the particle system was disposed

package/Particles/thinParticleSystem.js

@@ -72,6 +72,21 @@ export class ThinParticleSystem extends BaseParticleSystem {
         }
         this._onDisposeObserver = this.onDisposeObservable.add(callback);
     }
+    /**
+     * Gets or sets a boolean indicating that the particle system should always render at full capacity.
+     * When enabled, the draw call always emits `getCapacity()` quads/instances and inactive slots are zero-filled in the
+     * vertex buffer (collapsing them to degenerate triangles that produce no fragments).
+     * This makes the particle system compatible with FAST snapshot rendering, where the recorded draw call parameters
+     * are baked into the GPU bundle. Activate via `SnapshotRenderingHelper.fixParticleSystem(ps)`.
+     * Note: vertex shader cost scales with capacity rather than the live particle count, so size capacity realistically.
+     * This property is runtime-only and is not persisted by `serialize()` / `Parse()`.
+     */
+    get useFixedCapacityForSnapshot() {
+        return this._useFixedCapacityForSnapshot;
+    }
+    set useFixedCapacityForSnapshot(value) {
+        this._useFixedCapacityForSnapshot = value;
+    }
     /**
      * Gets a boolean indicating that the particle system was disposed
      */
@@ -319,6 +334,8 @@ export class ThinParticleSystem extends BaseParticleSystem {
         this._scaledGravity = Vector3.Zero();
         this._currentRenderId = -1;
         this._useInstancing = false;
+        this._useFixedCapacityForSnapshot = false;
+        this._fixedCapacityHighWaterMark = 0;
         this._isDisposed = false;
         this._started = false;
         this._stopped = false;
@@ -389,6 +406,7 @@ export class ThinParticleSystem extends BaseParticleSystem {
             this._scene = sceneOrEngine || EngineStore.LastCreatedScene;
             this._engine = this._scene.getEngine();
             this.uniqueId = this._scene.getUniqueId();
+            this.layerMask = this._scene.defaultRenderableLayerMask;
             this._scene.particleSystems.push(this);
         }
         else {
@@ -1584,7 +1602,25 @@ export class ThinParticleSystem extends BaseParticleSystem {
                 offset += this._useInstancing ? 1 : 4;
             }
             if (this._vertexBuffer) {
-                this._vertexBuffer.updateDirectly(this._vertexData, 0, this._particles.length);
+                if (this._useFixedCapacityForSnapshot) {
+                    // The vertex buffer is uploaded at full capacity so the FAST-snapshot bundle's draw call stays valid.
+                    // Inactive slots must be zeroed so they collapse to degenerate (size=0) quads that emit no fragments.
+                    // Float32Array starts zeroed and `_appendParticleVertices` overwrites only the active range, so we
+                    // only need to clear slots that were active in a previous frame and aren't anymore — i.e. the range
+                    // [currentCount, highWaterMark). When the active count grows we just bump the high-water mark.
+                    const stride = this._vertexBufferSize * (this._useInstancing ? 1 : 4);
+                    const currentCount = this._particles.length;
+                    if (currentCount < this._fixedCapacityHighWaterMark) {
+                        this._vertexData.fill(0, currentCount * stride, this._fixedCapacityHighWaterMark * stride);
+                    }
+                    if (currentCount > this._fixedCapacityHighWaterMark) {
+                        this._fixedCapacityHighWaterMark = currentCount;
+                    }
+                    this._vertexBuffer.updateDirectly(this._vertexData, 0, this._capacity);
+                }
+                else {
+                    this._vertexBuffer.updateDirectly(this._vertexData, 0, this._particles.length);
+                }
             }
         }
         if (this.manualEmitCount === 0 && this.disposeOnStop) {
@@ -1741,18 +1777,18 @@ export class ThinParticleSystem extends BaseParticleSystem {
         }
         if (this._useInstancing) {
             if (this._scene?.forceWireframe) {
-                engine.drawElementsType(6, 0, 10, this._particles.length);
+                engine.drawElementsType(6, 0, 10, this._useFixedCapacityForSnapshot ? this._capacity : this._particles.length);
             }
             else {
-                engine.drawArraysType(7, 0, 4, this._particles.length);
+                engine.drawArraysType(7, 0, 4, this._useFixedCapacityForSnapshot ? this._capacity : this._particles.length);
             }
         }
         else {
             if (this._scene?.forceWireframe) {
-                engine.drawElementsType(1, 0, this._particles.length * 10);
+                engine.drawElementsType(1, 0, (this._useFixedCapacityForSnapshot ? this._capacity : this._particles.length) * 10);
             }
             else {
-                engine.drawElementsType(0, 0, this._particles.length * 6);
+                engine.drawElementsType(0, 0, (this._useFixedCapacityForSnapshot ? this._capacity : this._particles.length) * 6);
             }
         }
         return this._particles.length;
@@ -1763,7 +1799,7 @@ export class ThinParticleSystem extends BaseParticleSystem {
      */
     render() {
         // Check
-        if (!this.isReady() || !this._particles.length) {
+        if (!this.isReady() || (!this._particles.length && !this._useFixedCapacityForSnapshot)) {
             return 0;
         }
         const engine = this._engine;