@needle-tools/engine 2.42.0-pre → 2.44.0-pre

package/lib/engine-components/ParticleSystem.js

@@ -4,23 +4,31 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Behaviour } from "./Component";
+import { Behaviour, GameObject } from "./Component";
 import * as THREE from "three";
-import { MainModule, EmissionModule, ShapeModule, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, ParticleSystemSimulationSpace, ParticleBurst, ParticleSystemRenderMode } from "./ParticleSystemModules";
+import { MainModule, EmissionModule, ShapeModule, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, ParticleSystemSimulationSpace, ParticleBurst, ParticleSystemRenderMode, VelocityOverLifetimeModule, TextureSheetAnimationModule, RotationOverLifetimeModule, LimitVelocityOverLifetimeModule, RotationBySpeedModule } from "./ParticleSystemModules";
 import { getParam } from "../engine/engine_utils";
 // https://github.dev/creativelifeform/three-nebula
-import System, { Emitter, Position, Life, SpriteRenderer, Particle, Body, MeshRenderer, } from 'three-nebula';
+// import System, { Emitter, Position, Life, SpriteRenderer, Particle, Body, MeshRenderer, } from 'three-nebula';
 import { serializeable } from "../engine/engine_serialization";
-import { Context } from "../engine/engine_setup";
-import { AxesHelper, Material, Mesh, Object3D, Vector3 } from "three";
-import { getWorldQuaternion, getWorldScale } from "../engine/engine_three_utils";
+import { RGBAColor } from "./js-extensions/RGBAColor";
+import { AxesHelper, Material, Mesh, Object3D, Quaternion, Vector3, Vector4 } from "three";
+import { getWorldPosition, getWorldQuaternion, getWorldScale } from "../engine/engine_three_utils";
 import { assign } from "../engine/engine_serialization_core";
+import { BatchedParticleRenderer, ConstantColor, ConstantValue, ParticleSystem as _ParticleSystem, RenderMode } from "three.quarks";
+import { createFlatTexture } from "../engine/engine_shaders";
+import { Mathf } from "../engine/engine_math";
 const debug = getParam("debugparticles");
 export class ParticleSystemRenderer extends Behaviour {
     renderMode;
     particleMaterial;
     // @serializeable(Mesh)
     particleMesh;
+    get transparent() {
+        const res = this.particleMaterial?.transparent ?? false;
+        // console.log(res, this.particleMaterial);
+        return res;
+    }
     getMesh() {
         let geo = null;
         if (this.particleMesh instanceof Mesh) {
@@ -38,18 +46,356 @@ __decorate([
 __decorate([
     serializeable(Material)
 ], ParticleSystemRenderer.prototype, "particleMaterial", void 0);
+class MinMaxCurveFunction {
+    _curve;
+    constructor(curve) { this._curve = curve; }
+    type = "function";
+    genValue(t) {
+        return this._curve.evaluate(t, Math.random());
+    }
+    toJSON() {
+        throw new Error("Method not implemented.");
+    }
+    clone() {
+        throw new Error("Method not implemented.");
+    }
+}
+class MinMaxGradientFunction {
+    _curve;
+    constructor(curve) { this._curve = curve; }
+    type = "function";
+    genColor(color, t) {
+        const col = this._curve.evaluate(t, Math.random());
+        // TODO: incoming color should probably be blended?
+        color.set(col.r, col.g, col.b, col.alpha);
+        return color;
+    }
+    toJSON() {
+        throw new Error("Method not implemented.");
+    }
+    clone() {
+        throw new Error("Method not implemented.");
+    }
+}
+class BaseValueGenerator {
+    type = "value";
+    toJSON() {
+        throw new Error("Method not implemented.");
+    }
+    clone() {
+        throw new Error("Method not implemented.");
+    }
+    system;
+    constructor(system) {
+        this.system = system;
+    }
+}
+class TextureSheetStartFrameGenerator extends BaseValueGenerator {
+    genValue() {
+        return this.system.textureSheetAnimation.getStartIndex();
+    }
+}
+class ParticleSystemEmissionOverTime extends BaseValueGenerator {
+    _lastPosition = new Vector3();
+    _lastDistance = 0;
+    update() {
+        const currentPosition = getWorldPosition(this.system.gameObject);
+        this._lastDistance = this._lastPosition.distanceTo(currentPosition);
+        this._lastPosition.copy(currentPosition);
+    }
+    genValue() {
+        if (this.system.currentParticles >= this.system.maxParticles)
+            return 0;
+        // emission over time
+        let emission = this.system.emission.rateOverTime.evaluate(this.system.time / this.system.duration, Math.random());
+        // if(this.system.currentParticles + emission > this.system.maxParticles) 
+        //     emission = (this.system.maxParticles - this.system.currentParticles);
+        // const res = Mathf.clamp(emission, 0, this.system.maxParticles - this.system.currentParticles);
+        if (this.system.deltaTime > 0) {
+            const distanceEmission = this.system.emission.rateOverDistance.evaluate(this.system.time / this.system.duration, Math.random());
+            const meterPerSecond = this._lastDistance / this.system.deltaTime;
+            let distanceEmissionValue = meterPerSecond * distanceEmission;
+            if (!Number.isFinite(distanceEmissionValue))
+                distanceEmissionValue = 0;
+            emission += distanceEmissionValue;
+        }
+        const burst = this.system.emission.getBurst();
+        if (burst > 0)
+            emission += burst / this.system.deltaTime;
+        const maxEmission = (this.system.maxParticles - this.system.currentParticles);
+        return Mathf.clamp(emission, 0, maxEmission / this.system.deltaTime);
+    }
+}
+class ParticleSystemEmissionOverDistance extends BaseValueGenerator {
+    genValue() {
+        // this seems not be called yet
+        return 0;
+        // if (this.system.currentParticles >= this.system.maxParticles) return 0;
+        // const emission = this.system.emission.rateOverDistance.evaluate(this.system.time / this.system.duration, Math.random());
+        // return emission;
+    }
+}
+class ParticleSystemBaseBehaviour {
+    system;
+    get scaleFactorDiff() {
+        return this.system.worldScale.x - this.system.scale;
+    }
+    constructor(ps) {
+        this.system = ps;
+    }
+    initialize(_particle) {
+    }
+    update(_particle, _delta) {
+    }
+    frameUpdate(_delta) {
+    }
+    toJSON() { throw new Error("Method not implemented."); }
+    clone() { throw new Error("Method not implemented."); }
+}
+class TextureSheetAnimationBehaviour extends ParticleSystemBaseBehaviour {
+    type = "NeedleTextureSheet";
+    update(particle, _delta) {
+        const sheet = this.system.textureSheetAnimation;
+        if (sheet.enabled) {
+            const t01 = particle.age / particle.life;
+            const index = sheet.evaluate(t01);
+            ;
+            if (index !== undefined)
+                particle.uvTile = index;
+        }
+    }
+}
+class RotationBehaviour extends ParticleSystemBaseBehaviour {
+    type = "NeedleRotation";
+    update(particle, delta) {
+        if (particle.rotation === undefined)
+            return;
+        if (particle.rotation instanceof Quaternion) {
+        }
+        else {
+            if (this.system.rotationOverLifetime.enabled) {
+                particle.rotation += this.system.rotationOverLifetime.evaluate(particle.age / particle.life) * delta;
+            }
+            // HACK flip y
+            else
+                particle.rotation = Math.PI;
+            if (this.system.rotationBySpeed.enabled) {
+                const speed = particle.velocity.length();
+                particle.rotation += this.system.rotationBySpeed.evaluate(particle.age / particle.life, speed) * delta;
+            }
+        }
+    }
+}
+class SizeBehaviour extends ParticleSystemBaseBehaviour {
+    type = "NeedleSize";
+    update(particle, _delta) {
+        const t = particle.age / particle.life;
+        let size = 1;
+        if (this.system.sizeOverLifetime.enabled)
+            size *= this.system.sizeOverLifetime.evaluate(t).x;
+        const scaleFactor = this.system.worldScale.x / this.system.cameraScale;
+        particle.size = particle.startSize * size * scaleFactor;
+        // console.log(particle.startSize, size, this.system.scale, this.system.cameraScale);
+    }
+}
+const $startVelocity = Symbol("startVelocity");
+const $gravityFactor = Symbol("gravityModifier");
+const temp3 = new Vector3();
+const temp4 = new Quaternion();
+class VelocityBehaviour extends ParticleSystemBaseBehaviour {
+    type = "NeedleVelocity";
+    _gravityDirection = new Vector3();
+    initialize(particle) {
+        const factor = 1 + this.scaleFactorDiff;
+        particle.startSpeed = this.system.main.startSpeed.evaluate(Math.random(), Math.random()) * factor;
+        particle.velocity.copy(this.system.shape.getDirection(particle.position)).multiplyScalar(particle.startSpeed);
+        if (!particle[$startVelocity])
+            particle[$startVelocity] = particle.velocity.clone();
+        else
+            particle[$startVelocity].copy(particle.velocity);
+        const gravityFactor = this.system.main.gravityModifier.evaluate(Math.random(), Math.random()); // * factor;
+        particle[$gravityFactor] = gravityFactor;
+        this._gravityDirection.set(0, -1, 0);
+        if (this.system.main.simulationSpace === ParticleSystemSimulationSpace.Local)
+            this._gravityDirection.applyQuaternion(this.system.worldQuaternionInverted);
+    }
+    update(particle, delta) {
+        const baseVelocity = particle[$startVelocity];
+        let gravityFactor = particle[$gravityFactor];
+        if (gravityFactor !== 0) {
+            // gravityFactor *= -1;
+            temp3.copy(this._gravityDirection).multiplyScalar(gravityFactor * delta * Math.PI);
+            // Gizmos.DrawDirection(particle.position, temp3, 0xff0000, 0, false, 10);
+            baseVelocity.add(temp3);
+        }
+        particle.velocity.copy(baseVelocity);
+        const t01 = particle.age / particle.life;
+        const noise = this.system.noise;
+        if (noise.enabled) {
+            noise.apply(0, particle.position, particle.velocity, delta, particle.age, particle.life);
+        }
+        const velocity = this.system.velocityOverLifetime;
+        if (velocity.enabled) {
+            velocity.apply(0, particle.position, particle.velocity, delta, particle.age, particle.life);
+        }
+        const limitVelocityOverLifetime = this.system.limitVelocityOverLifetime;
+        if (limitVelocityOverLifetime.enabled) {
+            // const factor = this.system.worldScale.x;
+            limitVelocityOverLifetime.apply(particle.position, baseVelocity, particle.velocity, particle.size, t01, delta, 1);
+        }
+        // const speed = particle.velocity.length();
+        // particle.velocity.multiplyScalar(1-delta);
+        // const vel = this.system.velocityOverLifetime.evaluate(particle.age / particle.life);
+    }
+}
+class ColorBehaviour extends ParticleSystemBaseBehaviour {
+    type = "NeedleColor";
+    initialize(particle) {
+        const col = this.system.main.startColor.evaluate(particle.age / particle.life, Math.random());
+        particle.startColor.set(col.r, col.g, col.b, col.alpha);
+        particle.color.copy(particle.startColor);
+    }
+    update(particle, _delta) {
+        if (this.system.colorOverLifetime.enabled) {
+            const t = particle.age / particle.life;
+            const col = this.system.colorOverLifetime.color.evaluate(t);
+            particle.color.set(col.r, col.g, col.b, col.alpha).multiply(particle.startColor);
+        }
+    }
+}
+class ParticleSystemInterface {
+    system;
+    emission;
+    get anim() {
+        return this.system.textureSheetAnimation;
+    }
+    constructor(system) {
+        this.system = system;
+        this.emission = new ParticleSystemEmissionOverTime(this.system);
+    }
+    update() {
+        this.emission.update();
+    }
+    autoDestroy;
+    get looping() { return this.system.main.loop; }
+    get duration() { return this.system.duration; }
+    get shape() { return this.system.shape; }
+    get startLife() { return new MinMaxCurveFunction(this.system.main.startLifetime); }
+    get startSpeed() { return new MinMaxCurveFunction(this.system.main.startSpeed); }
+    get startRotation() { return new MinMaxCurveFunction(this.system.main.startRotation); }
+    get startSize() { return new MinMaxCurveFunction(this.system.main.startSize); }
+    startLength; /** start length is for trails */
+    get startColor() { return new ConstantColor(new Vector4(1, 1, 1, 1)); }
+    get emissionOverTime() { return this.emission; }
+    /** this is not supported yet */
+    get emissionOverDistance() { return new ParticleSystemEmissionOverDistance(this.system); }
+    /** not used - burst is controled via emissionOverTime */
+    emissionBursts;
+    onlyUsedByOther;
+    behaviors = [];
+    get instancingGeometry() {
+        return this.system.renderer.getMesh().geometry;
+    }
+    get renderMode() {
+        if (this.system.trails["enabled"] === true) {
+            return RenderMode.Trail;
+        }
+        switch (this.system.renderer.renderMode) {
+            case ParticleSystemRenderMode.Billboard: return RenderMode.BillBoard;
+            // case ParticleSystemRenderMode.Stretch: return RenderMode.Stretch;
+            // case ParticleSystemRenderMode.HorizontalBillboard: return RenderMode.HorizontalBillboard;
+            // case ParticleSystemRenderMode.VerticalBillboard: return RenderMode.VerticalBillboard;
+            case ParticleSystemRenderMode.Mesh: return RenderMode.LocalSpace;
+        }
+        return RenderMode.BillBoard;
+    }
+    rendererEmitterSettings = {
+        startLength: new ConstantValue(220),
+        followLocalOrigin: false,
+    };
+    get speedFactor() { return this.system.main.simulationSpeed; }
+    get texture() {
+        const mat = this.system.renderer.particleMaterial;
+        if (mat && mat["map"]) {
+            const tex = mat["map"];
+            tex.premultiplyAlpha = false;
+            tex.encoding = THREE.LinearEncoding;
+            return tex;
+        }
+        return createFlatTexture(new RGBAColor(1, 1, 1, 1), 1);
+    }
+    get startTileIndex() { return new TextureSheetStartFrameGenerator(this.system); }
+    get uTileCount() { return this.anim.enabled ? this.anim?.numTilesX : undefined; }
+    get vTileCount() { return this.anim.enabled ? this.anim?.numTilesY : undefined; }
+    get renderOrder() { return 1; }
+    get blending() { return this.system.renderer.particleMaterial?.blending ?? THREE.NormalBlending; }
+    get transparent() { return this.system.renderer.transparent; }
+    get worldSpace() { return this.system.main.simulationSpace === ParticleSystemSimulationSpace.World; }
+}
+class ParticlesEmissionState {
+    burstIndex = 0;
+    burstWaveIndex = 0;
+    time = 0;
+    waitEmiting = 0;
+}
 export class ParticleSystem extends Behaviour {
+    play(includeChildren = false) {
+        if (includeChildren) {
+            GameObject.foreachComponent(this.gameObject, comp => {
+                if (comp instanceof ParticleSystem && comp !== this) {
+                    comp.play(false);
+                }
+            }, true);
+        }
+        this._isPlaying = true;
+        this._time = 0;
+        // https://github.com/Alchemist0823/three.quarks/pull/35
+        if (this._particleSystem) {
+            this._particleSystem["emissionState"].time = 0;
+            this._particleSystem["emitEnded"] = false;
+        }
+        this.emission?.reset();
+    }
+    pause() {
+        this._isPlaying = false;
+    }
+    stop() {
+        this._isPlaying = false;
+        this._time = 0;
+    }
+    _state;
+    emit(count) {
+        if (this._particleSystem) {
+            count = Math.min(count, this.maxParticles - this.currentParticles);
+            if (!this._state)
+                this._state = new ParticlesEmissionState();
+            this._state.waitEmiting = count;
+            this._state.time = 0;
+            const emitEndedState = this._particleSystem["emitEnded"];
+            this._particleSystem["emitEnded"] = false;
+            this._particleSystem.emit(this.deltaTime, this._state, this._particleSystem.emitter.matrixWorld);
+            this._particleSystem["emitEnded"] = emitEndedState;
+        }
+    }
     colorOverLifetime;
     main;
     emission;
     sizeOverLifetime;
     shape;
     noise;
+    // @serializeable(TrailModule)
+    trails;
+    velocityOverLifetime;
+    limitVelocityOverLifetime;
+    textureSheetAnimation;
+    rotationOverLifetime;
+    rotationBySpeed;
     get renderer() {
         return this._renderer;
     }
+    get isPlaying() { return this.isPlaying; }
     get currentParticles() {
-        return this._system?.getCount() ?? 0;
+        return this._particleSystem?.particleNum ?? 0;
     }
     get maxParticles() {
         return this.main.maxParticles;
@@ -60,12 +406,44 @@ export class ParticleSystem extends Behaviour {
     get duration() {
         return this.main.duration;
     }
+    get deltaTime() {
+        return this.context.time.deltaTime * this.main.simulationSpeed;
+    }
+    get scale() {
+        return this.gameObject.scale.x;
+    }
+    get cameraScale() {
+        return this._cameraScale;
+    }
+    _cameraScale = 1;
+    get container() {
+        return this._container;
+    }
+    get worldspace() {
+        return this.main.simulationSpace === ParticleSystemSimulationSpace.World;
+    }
+    __worldQuaternion = new Quaternion();
+    get worldQuaternion() {
+        return this.__worldQuaternion;
+    }
+    _worldQuaternionInverted = new Quaternion();
+    get worldQuaternionInverted() {
+        return this._worldQuaternionInverted;
+    }
+    _worldScale = new Vector3();
+    get worldScale() {
+        return this._worldScale;
+    }
     _renderer;
-    _system;
-    _emitter;
-    _size;
+    _batchSystem;
+    _particleSystem;
+    _interface;
+    // private _system!: System;
+    // private _emitter: Emitter;
+    // private _size!: SizeBehaviour;
     _container;
     _time = 0;
+    _isPlaying = true;
     /** called from deserialization */
     set bursts(arr) {
         for (let i = 0; i < arr.length; i++) {
@@ -81,125 +459,97 @@ export class ParticleSystem extends Behaviour {
     _bursts;
     awake() {
         this._renderer = this.gameObject.getComponent(ParticleSystemRenderer);
-        this._system = new System();
+        this._container = new Object3D();
+        this._container.matrixAutoUpdate = false;
         if (this.main.simulationSpace == ParticleSystemSimulationSpace.Local) {
-            this._container = new Object3D();
-            this._container.matrixAutoUpdate = false;
             this.gameObject.add(this._container);
         }
-        const container = this.main.simulationSpace == ParticleSystemSimulationSpace.Local ? this._container : this.context.scene;
+        else {
+            this.context.scene.add(this._container);
+        }
+        // else this._container = this.context.scene;
+        this._batchSystem = new BatchedParticleRenderer();
+        this._container.add(this._batchSystem);
+        this._interface = new ParticleSystemInterface(this);
+        this._particleSystem = new _ParticleSystem(this._batchSystem, this._interface);
+        this._particleSystem.addBehavior(new SizeBehaviour(this));
+        this._particleSystem.addBehavior(new VelocityBehaviour(this));
+        this._particleSystem.addBehavior(new ColorBehaviour(this));
+        this._particleSystem.addBehavior(new TextureSheetAnimationBehaviour(this));
+        this._particleSystem.addBehavior(new RotationBehaviour(this));
+        const emitter = this._particleSystem.emitter;
+        this.context.scene.add(emitter);
         if (debug) {
             console.log(this);
             this.gameObject.add(new AxesHelper(1));
         }
-        const renderMode = this._renderer.renderMode;
-        let renderer = undefined;
-        switch (renderMode) {
-            case ParticleSystemRenderMode.Mesh:
-                // https://three-nebula-docs.netlify.app/class/src/renderer/meshrenderer.js~meshrenderer
-                // mesh renderer example: https://github.com/creativelifeform/three-nebula/blob/master/website/components/Examples/MeshRenderer/init.js
-                renderer = new MeshRenderer(container, THREE);
-                break;
-            case ParticleSystemRenderMode.Billboard:
-                renderer = new SpriteRenderer(container, THREE);
-                break;
-        }
-        if (!renderer) {
-            console.error("No renderer for particle system");
-            return;
-        }
-        renderer.logRendererType = () => { };
-        if (renderMode === ParticleSystemRenderMode.Billboard) {
-            if (this.renderer.particleMaterial) {
-                const sprite = renderer._body;
-                sprite.layers.disableAll();
-                sprite.layers.set(2); // ignore raycasting particles
-                sprite.renderOrder = 1;
-                sprite.material.map = this.renderer.particleMaterial.map;
-                sprite.material.transparent = true;
-                // sprite.material.sizeAttenuation = false;
-                sprite.material.blending = this.renderer.particleMaterial.blending;
-                sprite.material.blendDst = this.renderer.particleMaterial.blendDst;
-                sprite.material.blendDstAlpha = this.renderer.particleMaterial.blendDstAlpha;
-                sprite.material.blendEquation = this.renderer.particleMaterial.blendEquation;
-                sprite.material.blendEquationAlpha = this.renderer.particleMaterial.blendEquationAlpha;
-                sprite.material.blendSrc = this.renderer.particleMaterial.blendSrc;
-                sprite.material.blendSrcAlpha = this.renderer.particleMaterial.blendSrcAlpha;
-                sprite.material.premultipliedAlpha = this.renderer.particleMaterial.premultipliedAlpha;
-                sprite.material.depthWrite = false;
-                sprite.material.depthTest = true;
-                if (debug)
-                    console.log(sprite);
-            }
-        }
-        this._system.addRenderer(renderer);
-        const initializers = [];
-        const behaviours = [];
-        const life = new Life();
-        life.lifePan = new MinMaxCurveSpan(this.main.startLifetime, 1);
-        initializers.push(life);
-        const shape = new Position(this.shape);
-        initializers.push(shape);
-        const size = this._size = new SizeBehaviour(this.main.startSize, this.main.startSizeMultiplier);
-        size.sizeOverLifetimeModule = this.sizeOverLifetime;
-        behaviours.push(size);
-        const color = new GradientBehaviour(this.main.startColor, this.colorOverLifetime?.enabled ? this.colorOverLifetime.color : undefined);
-        behaviours.push(color);
-        const velocity = new VelocityBehaviour(renderer.container, this.shape, this.noise, this.main.startSpeed, 1);
-        velocity.gravity = this.main.gravityModifier;
-        velocity.gravityModifierMultiplier = this.main.gravityModifierMultiplier;
-        behaviours.push(velocity);
-        if (renderMode === ParticleSystemRenderMode.Mesh) {
-            initializers.push(new Body(this._renderer.getMesh()));
-        }
-        const emitter = this._emitter = new Emitter({});
-        emitter.setInitializers(initializers);
-        emitter.setBehaviours(behaviours);
-        emitter.setRate(this.emission);
-        emitter.damping = 0;
+        // renderer.logRendererType = () => { };
+        // if (renderMode === ParticleSystemRenderMode.Billboard) {
+        //     if (this.renderer.particleMaterial) {
+        //         const sprite = renderer._body as Sprite;
+        //         sprite.layers.disableAll();
+        //         sprite.layers.set(2); // ignore raycasting particles
+        //         sprite.renderOrder = 1;
+        //         sprite.material.map = this.renderer.particleMaterial.map;
+        //         sprite.material.transparent = true;
+        //         // sprite.material.sizeAttenuation = false;
+        //         sprite.material.blending = this.renderer.particleMaterial.blending;
+        //         sprite.material.blendDst = this.renderer.particleMaterial.blendDst;
+        //         sprite.material.blendDstAlpha = this.renderer.particleMaterial.blendDstAlpha;
+        //         sprite.material.blendEquation = this.renderer.particleMaterial.blendEquation;
+        //         sprite.material.blendEquationAlpha = this.renderer.particleMaterial.blendEquationAlpha;
+        //         sprite.material.blendSrc = this.renderer.particleMaterial.blendSrc;
+        //         sprite.material.blendSrcAlpha = this.renderer.particleMaterial.blendSrcAlpha;
+        //         sprite.material.premultipliedAlpha = this.renderer.particleMaterial.premultipliedAlpha;
+        //         sprite.material.depthWrite = false;
+        //         sprite.material.depthTest = true;
+        //         if (debug) console.log(sprite);
+        //     }
+        // }
+        // setInterval(()=>{
+        //     this.emit(100);
+        // }, 1000)
     }
     onEnable() {
-        this._emitter.emit();
-        this._system.addEmitter(this._emitter);
-        this._system.emit({ onStart: () => { }, onUpdate: () => { }, onEnd: () => { }, });
-        this._time = 0;
+        this.play();
     }
     onDisable() {
-        this._system.removeEmitter(this._emitter);
     }
     onBeforeRender() {
         if (this._bursts) {
             this.emission.bursts = this._bursts;
+            delete this._bursts;
         }
+        if (!this._isPlaying)
+            return;
         // sprite materials must be scaled in AR
         const cam = this.context.mainCamera;
         if (cam) {
             const scale = getWorldScale(cam);
-            this._size.cameraScale = scale.x;
+            this._cameraScale = scale.x;
         }
-        if (this._container && this.gameObject?.parent) {
-            // this._container.matrix.copy(this.gameObject.matrixWorld);
-            // this._container.matrixWorld.copy(this.gameObject.matrixWorld);
+        let source = this._container;
+        if (this.worldspace)
+            source = this.gameObject;
+        getWorldQuaternion(source, this.__worldQuaternion);
+        this._worldQuaternionInverted.copy(this.__worldQuaternion).invert();
+        getWorldScale(this.gameObject, this._worldScale);
+        if (!this.worldspace && this._container && this.gameObject?.parent) {
             const scale = getWorldScale(this.gameObject.parent);
             scale.x = 1 / scale.x;
             scale.y = 1 / scale.y;
             scale.z = 1 / scale.z;
-            // console.log(scale);
-            // this._container.scale.copy(scale);
-            // // this._container.updateMatrix();
-            // // this._container.updateMatrixWorld();
-            // // // set scale to 1
             this._container.matrix.identity();
             this._container.matrix.scale(scale);
-            // this._container.matrixWorld.copy(this._container.matrix);
         }
-        // this._system.time
-        // this._system.duration = this.main.duration;
         this.emission.system = this;
-        this.shape.update(this.context, this.main.simulationSpace, this.gameObject);
+        const dt = this.deltaTime;
+        this._interface.update();
+        this.shape.update(this, this.context, this.main.simulationSpace, this.gameObject);
         this.noise.update(this.context);
-        this._system.update(this.context.time.deltaTime * this.main.simulationSpeed);
-        this._time += this.context.time.deltaTime;
+        this.velocityOverLifetime.update(this);
+        this._batchSystem?.update(dt);
+        this._time += dt;
         if (this._time > this.duration)
             this._time = 0;
     }
@@ -222,154 +572,19 @@ __decorate([
 __decorate([
     serializeable(NoiseModule)
 ], ParticleSystem.prototype, "noise", void 0);
-class MinMaxCurveSpan {
-    time;
-    curve;
-    multiplier = 1;
-    constructor(minMaxCurve, multiplier = 1) {
-        this.time = Context.Current.time;
-        this.curve = minMaxCurve;
-        this.multiplier = multiplier;
-    }
-    /** called by nebula */
-    getValue(lerp) {
-        const res = this.curve.evaluate(this.time.time, lerp) * this.multiplier;
-        return res;
-    }
-}
-class CustomBehaviour extends Behaviour {
-}
-class MinMaxCurveBehaviour extends CustomBehaviour {
-    startCurve;
-    startMultiplier = 1;
-    constructor(startCurve, startMultiplier = 1) {
-        super();
-        this.startCurve = startCurve;
-        this.startMultiplier = startMultiplier;
-    }
-}
-class SizeBehaviour extends MinMaxCurveBehaviour {
-    sizeOverLifetimeModule;
-    cameraScale = 1;
-    applyBehaviour(particle, _deltaTime, _index) {
-        if (particle.target.type === "Sprite") {
-            particle.radius = 1 / this.cameraScale;
-        }
-        else
-            particle.radius = 1;
-        // particle.target.scale.set(1,1,1);
-        if (this.sizeOverLifetimeModule?.enabled) {
-            const time = particle.age / particle.life;
-            const scaleVector = particle.target.scale;
-            this.sizeOverLifetimeModule.evaluate?.call(this.sizeOverLifetimeModule, time, scaleVector);
-            // scaleVector.set(.1, .1, .1)
-            particle.scale = particle.start_scale * scaleVector.x;
-            // console.log(time, particle.scale);
-        }
-    }
-    initialize(particle) {
-        particle.scale = this.startCurve.evaluate(0, Math.random()); // * this.startMultiplier;
-        particle.start_scale = particle.scale;
-    }
-}
-class GradientBehaviour extends CustomBehaviour {
-    startGradient;
-    gradient;
-    constructor(startGradient, gradient) {
-        super();
-        this.startGradient = startGradient;
-        this.gradient = gradient;
-    }
-    /** called from nebula */
-    applyBehaviour(target, _deltaTime, _index) {
-        // console.log(target, time, index)
-        if (target instanceof Particle) {
-            if (this.gradient) {
-                const t = target.age / target.life;
-                const ev = this.gradient.evaluate(t);
-                const startColor = target.color_start;
-                target.color.r = startColor.r * ev.r;
-                target.color.g = startColor.g * ev.g;
-                target.color.b = startColor.b * ev.b;
-                target.alpha = ev.alpha * target.alpha_start;
-            }
-        }
-    }
-    id = Symbol('gradientId');
-    _internalId = 0;
-    /** called from nebula */
-    initialize(particle) {
-        // console.log(particle);
-        // const context = Context.Current;
-        // const time = context.time.time;
-        const ev = this.startGradient.evaluate(Math.random());
-        particle.color.r = ev.r;
-        particle.color.g = ev.g;
-        particle.color.b = ev.b;
-        particle.alpha = ev.alpha;
-        particle.age = 0;
-        particle.color_start = { r: ev.r, g: ev.g, b: ev.b };
-        particle.alpha_start = ev.alpha;
-        particle.useColor = true;
-        particle.useAlpha = true;
-        if (particle[this.id] === undefined)
-            particle[this.id] = this._internalId++;
-    }
-}
-class VelocityBehaviour extends CustomBehaviour {
-    container;
-    shape;
-    noise;
-    startSpeed;
-    startMultiplier = 1;
-    gravity;
-    gravityModifierMultiplier = 1;
-    downDirection = new Vector3();
-    _temp = new Vector3();
-    constructor(container, shape, noise, startCurve, startMultiplier) {
-        super();
-        this.container = container;
-        this.shape = shape;
-        this.noise = noise;
-        this.startSpeed = startCurve;
-        this.startMultiplier = startMultiplier;
-    }
-    applyBehaviour(target, deltaTime, index) {
-        if (target instanceof Particle) {
-            // target.velocity.x = target.velocity_start.x;
-            // target.velocity.y = target.velocity_start.y;
-            // target.velocity.z = target.velocity_start.z;
-            if (target.gravity !== 0 && this.gravity) {
-                // get world down vector
-                this._temp.copy(this.downDirection);
-                this._temp.multiplyScalar(target.gravity * deltaTime);
-                target.velocity.add(this._temp);
-            }
-            if (this.noise) {
-                this.noise.applyNoise(index, target.position, target.velocity, deltaTime, target.age, target.life);
-            }
-        }
-    }
-    initialize(particle) {
-        const dir = this.shape.getDirection(particle.position);
-        // dir.applyQuaternion(quat);
-        const speed = this.startSpeed.evaluate(0, Math.random()) * this.startMultiplier;
-        particle.velocity.x = dir.x * speed;
-        particle.velocity.y = dir.y * speed;
-        particle.velocity.z = dir.z * speed;
-        if (!particle.velocity_start)
-            particle.velocity_start = {};
-        particle.velocity_start.x = particle.velocity.x;
-        particle.velocity_start.y = particle.velocity.y;
-        particle.velocity_start.z = particle.velocity.z;
-        if (this.gravity) {
-            particle.gravity = this.gravity.evaluate(Math.random(), Math.random()) * 9.81;
-        }
-        else {
-            particle.gravity = 0;
-        }
-        const quat = getWorldQuaternion(this.container);
-        this.downDirection.set(0, -1, 0).applyQuaternion(quat);
-    }
-}
+__decorate([
+    serializeable(VelocityOverLifetimeModule)
+], ParticleSystem.prototype, "velocityOverLifetime", void 0);
+__decorate([
+    serializeable(LimitVelocityOverLifetimeModule)
+], ParticleSystem.prototype, "limitVelocityOverLifetime", void 0);
+__decorate([
+    serializeable(TextureSheetAnimationModule)
+], ParticleSystem.prototype, "textureSheetAnimation", void 0);
+__decorate([
+    serializeable(RotationOverLifetimeModule)
+], ParticleSystem.prototype, "rotationOverLifetime", void 0);
+__decorate([
+    serializeable(RotationBySpeedModule)
+], ParticleSystem.prototype, "rotationBySpeed", void 0);
 //# sourceMappingURL=ParticleSystem.js.map