@onerjs/core 8.48.4 → 8.48.6

package/Particles/gpuParticleSystem.js

@@ -1,4 +1,4 @@
-import { FactorGradient, ColorGradient, GradientHelper } from "../Misc/gradients.js";
+import { ColorGradient, GradientHelper } from "../Misc/gradients.js";
 import { Observable } from "../Misc/observable.js";
 import { Vector3, Matrix, TmpVectors } from "../Maths/math.vector.js";
 import { Color4, TmpColors } from "../Maths/math.color.js";
@@ -6,6 +6,8 @@ import { Lerp } from "../Maths/math.scalar.functions.js";
 import { VertexBuffer, Buffer } from "../Buffers/buffer.js";
 import { BaseParticleSystem } from "./baseParticleSystem.js";
 import { ParticleSystem } from "./particleSystem.js";
+import { Attractor } from "./attractor.js";
+import { Logger } from "../Misc/logger.js";
 import { BoxParticleEmitter } from "../Particles/EmitterTypes/boxParticleEmitter.js";
 import { Scene } from "../scene.js";
 import { ImageProcessingConfiguration } from "../Materials/imageProcessingConfiguration.js";
@@ -79,6 +81,17 @@ export class GPUParticleSystem extends BaseParticleSystem {
     set activeParticleCount(value) {
         this.maxActiveParticleCount = value;
     }
+    /**
+     * Add an attractor to the particle system. Attractors are used to change the direction of the particles in the system.
+     * @param attractor - The attractor to add to the particle system
+     */
+    addAttractor(attractor) {
+        if (this._attractors.length >= this.maxAttractors) {
+            Logger.Warn(`GPU particle system supports a maximum of ${this.maxAttractors} attractors. Ignoring additional attractor.`);
+            return;
+        }
+        super.addAttractor(attractor);
+    }
     /**
      * Creates a Point Emitter for the particle system (emits directly from the emitter position)
      * @param direction1 Particles are emitted between the direction1 and direction2 from within the box
@@ -430,23 +443,19 @@ export class GPUParticleSystem extends BaseParticleSystem {
             drawWrapper.drawContext?.reset();
         }
     }
-    _addFactorGradient(factorGradients, gradient, factor) {
-        const valueGradient = new FactorGradient(gradient, factor);
-        factorGradients.push(valueGradient);
-        this._releaseBuffers();
-    }
     /**
      * Adds a new size gradient
      * @param gradient defines the gradient to use (between 0 and 1)
      * @param factor defines the size factor to affect to the specified gradient
+     * @param factor2 defines an additional factor used to define a range ([factor, factor2]) with main value to pick the final value from
      * @returns the current particle system
      */
-    addSizeGradient(gradient, factor) {
+    addSizeGradient(gradient, factor, factor2) {
         if (!this._sizeGradients) {
             this._sizeGradients = [];
         }
-        this._addFactorGradient(this._sizeGradients, gradient, factor);
-        this._refreshFactorGradient(this._sizeGradients, "_sizeGradientsTexture", true);
+        this._addFactorGradient(this._sizeGradients, gradient, factor, factor2);
+        this._refreshFactorGradient(this._sizeGradients, "_sizeGradientsTexture");
         this._releaseBuffers();
         return this;
     }
@@ -460,21 +469,10 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._sizeGradientsTexture = null;
         return this;
     }
-    _refreshFactorGradient(factorGradients, textureName, reorder = false) {
+    _refreshFactorGradient(factorGradients, textureName) {
         if (!factorGradients) {
             return;
         }
-        if (reorder) {
-            factorGradients.sort((a, b) => {
-                if (a.gradient < b.gradient) {
-                    return -1;
-                }
-                else if (a.gradient > b.gradient) {
-                    return 1;
-                }
-                return 0;
-            });
-        }
         const that = this;
         if (that[textureName]) {
             that[textureName].dispose();
@@ -485,14 +483,15 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * Adds a new angular speed gradient
      * @param gradient defines the gradient to use (between 0 and 1)
      * @param factor defines the angular speed to affect to the specified gradient
+     * @param factor2 defines an additional factor used to define a range ([factor, factor2]) with main value to pick the final value from
      * @returns the current particle system
      */
-    addAngularSpeedGradient(gradient, factor) {
+    addAngularSpeedGradient(gradient, factor, factor2) {
         if (!this._angularSpeedGradients) {
             this._angularSpeedGradients = [];
         }
-        this._addFactorGradient(this._angularSpeedGradients, gradient, factor);
-        this._refreshFactorGradient(this._angularSpeedGradients, "_angularSpeedGradientsTexture", true);
+        this._addFactorGradient(this._angularSpeedGradients, gradient, factor, factor2);
+        this._refreshFactorGradient(this._angularSpeedGradients, "_angularSpeedGradientsTexture");
         this._releaseBuffers();
         return this;
     }
@@ -510,14 +509,15 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * Adds a new velocity gradient
      * @param gradient defines the gradient to use (between 0 and 1)
      * @param factor defines the velocity to affect to the specified gradient
+     * @param factor2 defines an additional factor used to define a range ([factor, factor2]) with main value to pick the final value from
      * @returns the current particle system
      */
-    addVelocityGradient(gradient, factor) {
+    addVelocityGradient(gradient, factor, factor2) {
         if (!this._velocityGradients) {
             this._velocityGradients = [];
         }
-        this._addFactorGradient(this._velocityGradients, gradient, factor);
-        this._refreshFactorGradient(this._velocityGradients, "_velocityGradientsTexture", true);
+        this._addFactorGradient(this._velocityGradients, gradient, factor, factor2);
+        this._refreshFactorGradient(this._velocityGradients, "_velocityGradientsTexture");
         this._releaseBuffers();
         return this;
     }
@@ -535,14 +535,15 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * Adds a new limit velocity gradient
      * @param gradient defines the gradient to use (between 0 and 1)
      * @param factor defines the limit velocity value to affect to the specified gradient
+     * @param factor2 defines an additional factor used to define a range ([factor, factor2]) with main value to pick the final value from
      * @returns the current particle system
      */
-    addLimitVelocityGradient(gradient, factor) {
+    addLimitVelocityGradient(gradient, factor, factor2) {
         if (!this._limitVelocityGradients) {
             this._limitVelocityGradients = [];
         }
-        this._addFactorGradient(this._limitVelocityGradients, gradient, factor);
-        this._refreshFactorGradient(this._limitVelocityGradients, "_limitVelocityGradientsTexture", true);
+        this._addFactorGradient(this._limitVelocityGradients, gradient, factor, factor2);
+        this._refreshFactorGradient(this._limitVelocityGradients, "_limitVelocityGradientsTexture");
         this._releaseBuffers();
         return this;
     }
@@ -560,14 +561,15 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * Adds a new drag gradient
      * @param gradient defines the gradient to use (between 0 and 1)
      * @param factor defines the drag value to affect to the specified gradient
+     * @param factor2 defines an additional factor used to define a range ([factor, factor2]) with main value to pick the final value from
      * @returns the current particle system
      */
-    addDragGradient(gradient, factor) {
+    addDragGradient(gradient, factor, factor2) {
         if (!this._dragGradients) {
             this._dragGradients = [];
         }
-        this._addFactorGradient(this._dragGradients, gradient, factor);
-        this._refreshFactorGradient(this._dragGradients, "_dragGradientsTexture", true);
+        this._addFactorGradient(this._dragGradients, gradient, factor, factor2);
+        this._refreshFactorGradient(this._dragGradients, "_dragGradientsTexture");
         this._releaseBuffers();
         return this;
     }
@@ -817,6 +819,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._currentActiveCount = 0;
         this._isAnimationSheetEnabled = isAnimationSheetEnabled;
         this._emitRateControl = !!options.emitRateControl;
+        this.maxAttractors = options.maxAttractors ?? 8;
         this.particleEmitterType = new BoxParticleEmitter();
         // Random data
         const maxTextureSize = Math.min(this._engine.getCaps().maxTextureSize, fullOptions.randomTextureSize);
@@ -1123,6 +1126,10 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (this.isLocal) {
             defines += "\n#define LOCAL";
         }
+        if (this._attractors.length > 0) {
+            defines += "\n#define ATTRACTORS";
+            defines += "\n#define MAX_ATTRACTORS " + this.maxAttractors;
+        }
         if (this._emitRateControl) {
             defines += "\n#define EMITRATECTRL";
         }
@@ -1288,14 +1295,17 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (!factorGradients || !factorGradients.length || texture) {
             return;
         }
-        const data = new Float32Array(this._rawTextureWidth);
+        const data = new Float32Array(this._rawTextureWidth * 2);
         for (let x = 0; x < this._rawTextureWidth; x++) {
             const ratio = x / this._rawTextureWidth;
             GradientHelper.GetCurrentGradient(ratio, factorGradients, (currentGradient, nextGradient, scale) => {
-                data[x] = Lerp(currentGradient.factor1, nextGradient.factor1, scale);
+                const cg = currentGradient;
+                const ng = nextGradient;
+                data[x * 2] = Lerp(cg.factor1, ng.factor1, scale);
+                data[x * 2 + 1] = Lerp(cg.factor2 ?? cg.factor1, ng.factor2 ?? ng.factor1, scale);
             });
         }
-        this[textureName] = RawTexture.CreateRTexture(data, this._rawTextureWidth, 1, this._scene || this._engine, false, false, 1);
+        this[textureName] = new RawTexture(data, this._rawTextureWidth, 1, 7, this._scene || this._engine, false, false, 1, 1);
         this[textureName].name = textureName.substring(1);
     }
     _createSizeGradientTexture() {
@@ -1460,6 +1470,27 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (!this.isLocal) {
             this._updateBuffer.setMatrix("emitterWM", emitterWM);
         }
+        if (this._attractors.length > 0) {
+            this._updateBuffer.setInt("attractorCount", this._attractors.length);
+            // Compute inverse world matrix once for all attractors when in local space
+            let invWorld;
+            if (this.isLocal) {
+                invWorld = TmpVectors.Matrix[1];
+                emitterWM.invertToRef(invWorld);
+            }
+            for (let i = 0; i < this._attractors.length; i++) {
+                const attractor = this._attractors[i];
+                const name = "attractorPositionAndStrength[" + i + "]";
+                if (invWorld) {
+                    const localPos = TmpVectors.Vector3[0];
+                    Vector3.TransformCoordinatesToRef(attractor.position, invWorld, localPos);
+                    this._updateBuffer.setFloat4(name, localPos.x, localPos.y, localPos.z, attractor.strength);
+                }
+                else {
+                    this._updateBuffer.setFloat4(name, attractor.position.x, attractor.position.y, attractor.position.z, attractor.strength);
+                }
+            }
+        }
         this._platform.updateParticleBuffer(this._targetIndex, this._targetBuffer, this._currentActiveCount);
         // Switch VAOs
         this._targetIndex++;
@@ -1750,12 +1781,20 @@ export class GPUParticleSystem extends BaseParticleSystem {
         serializationObject.activeParticleCount = this.activeParticleCount;
         serializationObject.randomTextureSize = this._randomTextureSize;
         serializationObject.emitRateControl = this._emitRateControl;
+        serializationObject.maxAttractors = this.maxAttractors;
         serializationObject.customShader = this.customShader;
         serializationObject.preventAutoStart = this.preventAutoStart;
         serializationObject.worldOffset = this.worldOffset.asArray();
         if (this.metadata) {
             serializationObject.metadata = this.metadata;
         }
+        // Attractors
+        if (this._attractors.length > 0) {
+            serializationObject.attractors = [];
+            for (const attractor of this._attractors) {
+                serializationObject.attractors.push(attractor.serialize());
+            }
+        }
         return serializationObject;
     }
     /**
@@ -1782,6 +1821,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
             capacity: capacity || parsedParticleSystem.capacity,
             randomTextureSize: parsedParticleSystem.randomTextureSize,
             emitRateControl: parsedParticleSystem.emitRateControl,
+            maxAttractors: parsedParticleSystem.maxAttractors,
         }, sceneOrEngine, null, parsedParticleSystem.isAnimationSheetEnabled);
         particleSystem._rootUrl = rootUrl;
         if (parsedParticleSystem.customShader && engine.createEffectForParticles) {
@@ -1808,6 +1848,15 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (parsedParticleSystem.metadata) {
             particleSystem.metadata = parsedParticleSystem.metadata;
         }
+        // Attractors
+        if (parsedParticleSystem.attractors) {
+            for (const attractorData of parsedParticleSystem.attractors) {
+                const attractor = new Attractor();
+                attractor.position = Vector3.FromArray(attractorData.position);
+                attractor.strength = attractorData.strength;
+                particleSystem.addAttractor(attractor);
+            }
+        }
         if (!doNotStart && !particleSystem.preventAutoStart) {
             particleSystem.start();
         }