@needle-tools/engine 2.41.0-pre → 2.43.0-pre

package/lib/engine-components/ParticleSystem.js

@@ -6,21 +6,319 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Behaviour } from "./Component";
 import * as THREE from "three";
-import { MainModule, EmissionModule, ShapeModule, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, ParticleSystemSimulationSpace } from "./ParticleSystemModules";
+import { MainModule, EmissionModule, ShapeModule, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, ParticleSystemSimulationSpace, ParticleBurst, ParticleSystemRenderMode, VelocityOverLifetimeModule, TextureSheetAnimationModule, RotationOverLifetimeModule } from "./ParticleSystemModules";
 import { getParam } from "../engine/engine_utils";
-import System, { Emitter, Position, Life, SpriteRenderer, Particle, } from 'three-nebula';
 // https://github.dev/creativelifeform/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, 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) {
+            geo = this.particleMesh.geometry;
+        }
+        if (geo === null)
+            geo = new THREE.BoxGeometry(1, 1, 1);
+        const res = new Mesh(geo, this.particleMaterial);
+        return res;
+    }
 }
+__decorate([
+    serializeable()
+], ParticleSystemRenderer.prototype, "renderMode", void 0);
 __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;
+    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;
+        }
+    }
+}
+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.scale / 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 scale = this.system.scale;
+        particle.startSpeed = this.system.main.startSpeed.evaluate(Math.random(), Math.random());
+        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);
+        let gravityFactor = Math.PI / scale;
+        gravityFactor = this.system.main.gravityModifier.evaluate(Math.random(), Math.random()) * gravityFactor;
+        particle[$gravityFactor] = gravityFactor;
+        this._gravityDirection.set(0, -1, 0).applyQuaternion(this.system.worldQuaternionInverted);
+    }
+    update(particle, delta) {
+        // const t = particle.age / particle.life;
+        // console.log(this.system.deltaTime, 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 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);
+        }
+        // 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; }
+}
 export class ParticleSystem extends Behaviour {
     colorOverLifetime;
     main;
@@ -28,84 +326,157 @@ export class ParticleSystem extends Behaviour {
     sizeOverLifetime;
     shape;
     noise;
-    renderer;
-    _system;
-    _emitter;
-    _size;
+    // @serializeable(TrailModule)
+    trails;
+    velocityOverLifetime;
+    textureSheetAnimation;
+    rotationOverLifetime;
+    get renderer() {
+        return this._renderer;
+    }
+    get currentParticles() {
+        return this._particleSystem?.particleNum ?? 0;
+    }
+    get maxParticles() {
+        return this.main.maxParticles;
+    }
+    get time() {
+        return this._time;
+    }
+    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;
+    }
+    __worldQuaternion = new Quaternion();
+    get worldQuaternion() {
+        return this.__worldQuaternion;
+    }
+    _worldQuaternionInverted = new Quaternion();
+    get worldQuaternionInverted() {
+        return this._worldQuaternionInverted;
+    }
+    _renderer;
+    _batchSystem;
+    _particleSystem;
+    _interface;
+    // private _system!: System;
+    // private _emitter: Emitter;
+    // private _size!: SizeBehaviour;
+    _container;
+    _time = 0;
+    /** called from deserialization */
+    set bursts(arr) {
+        for (let i = 0; i < arr.length; i++) {
+            const burst = arr[i];
+            if ((burst instanceof ParticleBurst) === false) {
+                const instance = new ParticleBurst();
+                assign(instance, burst);
+                arr[i] = instance;
+            }
+        }
+        this._bursts = arr;
+    }
+    _bursts;
     awake() {
+        this._renderer = this.gameObject.getComponent(ParticleSystemRenderer);
+        this._container = new Object3D();
+        this._container.matrixAutoUpdate = false;
+        if (this.main.simulationSpace == ParticleSystemSimulationSpace.Local) {
+            this.gameObject.add(this._container);
+        }
+        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));
-        }
-        this.renderer = this.gameObject.getComponent(ParticleSystemRenderer);
-        this._system = new System();
-        const container = this.main.simulationSpace == ParticleSystemSimulationSpace.Local ? this.gameObject : this.context.scene;
-        const renderer = new SpriteRenderer(container, THREE);
-        renderer.logRendererType = () => { };
-        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.container.add(new AxesHelper(1));
         }
-        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);
-        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);
+        //     }
+        // }
     }
     onEnable() {
-        this._emitter.emit();
-        this._system.addEmitter(this._emitter);
-        this._system.emit({ onStart: () => { }, onUpdate: () => { }, onEnd: () => { }, });
+        this._time = 0;
     }
     onDisable() {
-        this._system.removeEmitter(this._emitter);
     }
     onBeforeRender() {
-        this.emission.currentParticles = this._system.getCount();
-        this.emission.maxParticles = this.main.maxParticles;
-        this.shape.update(this.context, this.main.simulationSpace, this.gameObject);
-        this.noise.update(this.context);
-        this._system.update(this.context.time.deltaTime * this.main.simulationSpeed);
+        if (this._bursts) {
+            this.emission.bursts = this._bursts;
+        }
         // 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;
+        }
+        let rotationSource = this._container;
+        if (this.main.simulationSpace === ParticleSystemSimulationSpace.World)
+            rotationSource = this.gameObject;
+        getWorldQuaternion(rotationSource, this.__worldQuaternion);
+        this._worldQuaternionInverted.copy(this.__worldQuaternion).invert();
+        if (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;
+            this._container.matrix.identity();
+            this._container.matrix.scale(scale);
         }
+        this.emission.system = this;
+        const dt = this.deltaTime;
+        this._interface.update();
+        this.shape.update(this.context, this.main.simulationSpace, this.gameObject);
+        this.noise.update(this.context);
+        this.velocityOverLifetime.update(this);
+        this._batchSystem?.update(dt);
+        this._time += dt;
+        if (this._time > this.duration)
+            this._time = 0;
     }
 }
 __decorate([
@@ -126,155 +497,152 @@ __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(0, -1, 0);
-    _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;
-        const quat = getWorldQuaternion(container);
-        this.downDirection.applyQuaternion(quat);
-    }
-    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) {
-                // get world down vector
-                this._temp.copy(this.downDirection);
-                this._temp.multiplyScalar(target.gravity * deltaTime);
-                target.velocity.sub(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);
-        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(0, Math.random()) * this.gravityModifierMultiplier * 9.81;
-        }
-        else {
-            particle.gravity = 0;
-        }
-        // particle.acceleration.y = 1;
-        // console.log(particle);
-    }
-}
+__decorate([
+    serializeable(VelocityOverLifetimeModule)
+], ParticleSystem.prototype, "velocityOverLifetime", void 0);
+__decorate([
+    serializeable(TextureSheetAnimationModule)
+], ParticleSystem.prototype, "textureSheetAnimation", void 0);
+__decorate([
+    serializeable(RotationOverLifetimeModule)
+], ParticleSystem.prototype, "rotationOverLifetime", void 0);
+// abstract class CustomBehaviour extends Behaviour {
+//     abstract applyBehaviour(target: Particle | Emitter, time: number, index: number);
+//     abstract initialize(particle: Particle);
+// }
+// abstract class MinMaxCurveBehaviour extends CustomBehaviour {
+//     readonly startCurve: MinMaxCurve;
+//     startMultiplier: number = 1;
+//     constructor(startCurve: MinMaxCurve, startMultiplier: number = 1) {
+//         super();
+//         this.startCurve = startCurve;
+//         this.startMultiplier = startMultiplier;
+//     }
+// }
+// declare type ParticleWithScale = Particle & { target: Object3D, start_scale: number };
+// class SizeBehaviour extends MinMaxCurveBehaviour {
+//     sizeOverLifetimeModule!: SizeOverLifetimeModule;
+//     cameraScale: number = 1;
+//     applyBehaviour(particle: ParticleWithScale, _deltaTime: number, _index: number) {
+//         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: ParticleWithScale) {
+//         particle.scale = this.startCurve.evaluate(0, Math.random());// * this.startMultiplier;
+//         particle.start_scale = particle.scale;
+//     }
+// }
+// declare type ParticleWithColor = Particle & { color_start: { r: number, g: number, b: number }, alpha_start: number };
+// class GradientBehaviour extends CustomBehaviour {
+//     private startGradient: MinMaxGradient;
+//     private gradient?: MinMaxGradient;
+//     constructor(startGradient: MinMaxGradient, gradient?: MinMaxGradient) {
+//         super();
+//         this.startGradient = startGradient;
+//         this.gradient = gradient;
+//     }
+//     /** called from nebula */
+//     applyBehaviour(target: ParticleWithColor | Emitter, _deltaTime: number, _index: number) {
+//         // console.log(target, time, index)
+//         if (target instanceof Particle) {
+//             if (this.gradient) {
+//                 const t = target.age / target.life;
+//                 const ev = this.gradient.evaluate(t) as RGBAColor;
+//                 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;
+//             }
+//         }
+//     }
+//     private id = Symbol('gradientId');
+//     private _internalId: number = 0;
+//     /** called from nebula */
+//     initialize(particle: ParticleWithColor) {
+//         // console.log(particle);
+//         // const context = Context.Current;
+//         // const time = context.time.time;
+//         const ev = this.startGradient.evaluate(Math.random()) as RGBAColor;
+//         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++;
+//     }
+// }
+// declare type ParticleWithVelocity = Particle & { velocity_start: { x: number, y: number, u: number }, gravity: number };
+// class VelocityBehaviour extends CustomBehaviour {
+//     container: Object3D;
+//     shape: ShapeModule;
+//     noise: NoiseModule;
+//     startSpeed: MinMaxCurve;
+//     startMultiplier: number = 1;
+//     gravity?: MinMaxCurve;
+//     gravityModifierMultiplier: number = 1;
+//     downDirection = new Vector3();
+//     private _temp: Vector3 = new Vector3();
+//     constructor(container: Object3D, shape: ShapeModule, noise: NoiseModule, startCurve: MinMaxCurve, startMultiplier: number) {
+//         super();
+//         this.container = container;
+//         this.shape = shape;
+//         this.noise = noise;
+//         this.startSpeed = startCurve;
+//         this.startMultiplier = startMultiplier;
+//     }
+//     applyBehaviour(target: ParticleWithVelocity | Emitter, deltaTime: number, index: number) {
+//         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: ParticleWithVelocity) {
+//         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);
+//     }
+// }
 //# sourceMappingURL=ParticleSystem.js.map