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

package/src/engine-components/ParticleSystem.ts

@@ -1,18 +1,19 @@
 import { Behaviour, GameObject } from "./Component";
 import * as THREE from "three";
-import { MainModule, EmissionModule, ShapeModule, ParticleSystemShapeType, MinMaxCurve, MinMaxGradient, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, ParticleSystemSimulationSpace, ParticleBurst, IParticleSystem, ParticleSystemRenderMode } from "./ParticleSystemModules"
+import { MainModule, EmissionModule, ShapeModule, ParticleSystemShapeType, MinMaxCurve, MinMaxGradient, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, ParticleSystemSimulationSpace, ParticleBurst, IParticleSystem, ParticleSystemRenderMode, TrailModule, 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 { Time } from "../engine/engine_time";
-import { Context } from "../engine/engine_setup";
 import { RGBAColor } from "./js-extensions/RGBAColor";
-import { AxesHelper, BufferGeometry, Material, Mesh, Object3D, Sprite, SpriteMaterial, Vector3 } from "three";
-import { getWorldQuaternion, getWorldScale } from "../engine/engine_three_utils";
+import { AxesHelper, BufferGeometry, Color, Material, Mesh, MeshStandardMaterial, Object3D, OneMinusDstAlphaFactor, Quaternion, Sprite, SpriteMaterial, Vector3, Vector4 } from "three";
+import { getWorldPosition, getWorldQuaternion, getWorldScale } from "../engine/engine_three_utils";
 import { assign } from "../engine/engine_serialization_core";
+import { BatchedParticleRenderer, Behavior, BillBoardSettings, BurstParameters, ColorGenerator, ConstantColor, ConstantValue, EmissionState, EmitterShape, FunctionColorGenerator, FunctionJSON, FunctionValueGenerator, MeshSettings, Particle, ParticleEmitter, ParticleSystem as _ParticleSystem, ParticleSystemParameters, PointEmitter, RenderMode, RotationGenerator, SizeOverLife, TrailBatch, TrailSettings, ValueGenerator } from "three.quarks";
+import { createFlatTexture } from "../engine/engine_shaders";
+import { Mathf } from "../engine/engine_math";
 
 const debug = getParam("debugparticles");
 
@@ -28,6 +29,11 @@ export class ParticleSystemRenderer extends Behaviour {
     // @serializeable(Mesh)
     particleMesh?: Mesh | string;
 
+    get transparent(): boolean {
+        const res = this.particleMaterial?.transparent ?? false;
+        // console.log(res, this.particleMaterial);
+        return res;
+    }
 
     getMesh() {
         let geo: BufferGeometry | null = null;
@@ -40,405 +46,622 @@ export class ParticleSystemRenderer extends Behaviour {
     }
 }
 
-export class ParticleSystem extends Behaviour implements IParticleSystem {
+class MinMaxCurveFunction implements FunctionValueGenerator {
 
-    @serializeable(ColorOverLifetimeModule)
-    readonly colorOverLifetime!: ColorOverLifetimeModule;
+    private _curve: MinMaxCurve;
 
-    @serializeable(MainModule)
-    readonly main!: MainModule;
+    constructor(curve: MinMaxCurve) { this._curve = curve; }
 
-    @serializeable(EmissionModule)
-    readonly emission!: EmissionModule;
+    type: "function" = "function";
 
-    @serializeable(SizeOverLifetimeModule)
-    readonly sizeOverLifetime!: SizeOverLifetimeModule;
+    genValue(t: number): number {
+        return this._curve.evaluate(t, Math.random());
+    }
+    toJSON(): FunctionJSON {
+        throw new Error("Method not implemented.");
+    }
+    clone(): FunctionValueGenerator {
+        throw new Error("Method not implemented.");
+    }
+}
 
-    @serializeable(ShapeModule)
-    readonly shape!: ShapeModule;
+class MinMaxGradientFunction implements FunctionColorGenerator {
 
-    @serializeable(NoiseModule)
-    readonly noise!: NoiseModule;
+    private _curve: MinMaxGradient;
 
-    get renderer(): ParticleSystemRenderer {
-        return this._renderer;
+    constructor(curve: MinMaxGradient) { this._curve = curve; }
+
+    type: "function" = "function";
+
+    genColor(color: THREE.Vector4, t: number): THREE.Vector4 {
+        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(): FunctionJSON {
+        throw new Error("Method not implemented.");
+    }
+    clone(): FunctionColorGenerator {
+        throw new Error("Method not implemented.");
     }
 
-    get currentParticles() {
-        return this._system?.getCount() ?? 0;
+}
+
+abstract class BaseValueGenerator implements ValueGenerator {
+
+    type: "value" = "value";
+    toJSON(): FunctionJSON {
+        throw new Error("Method not implemented.");
     }
-    get maxParticles() {
-        return this.main.maxParticles;
+    clone(): ValueGenerator {
+        throw new Error("Method not implemented.");
     }
-    get time() {
-        return this._time;
+
+    abstract genValue(): number;
+
+    readonly system: ParticleSystem;
+
+    constructor(system: ParticleSystem) {
+        this.system = system;
     }
-    get duration() {
-        return this.main.duration;
+}
+
+class TextureSheetStartFrameGenerator extends BaseValueGenerator {
+    genValue(): number {
+        return this.system.textureSheetAnimation.getStartIndex();
     }
 
-    private _renderer!: ParticleSystemRenderer;
-    private _system!: System;
-    private _emitter: Emitter;
-    private _size!: SizeBehaviour;
-    private _container?: Object3D;
-    private _time: number = 0;
+}
 
-    /** called from deserialization */
-    private set bursts(arr: ParticleBurst[]) {
-        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;
-            }
+class ParticleSystemEmissionOverTime extends BaseValueGenerator {
+
+    private _lastPosition: Vector3 = new Vector3();
+    private _lastDistance: number = 0;
+
+    update() {
+        const currentPosition = getWorldPosition(this.system.gameObject);
+        this._lastDistance = this._lastPosition.distanceTo(currentPosition)
+        this._lastPosition.copy(currentPosition);
+    }
+
+    genValue(): number {
+        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;
         }
-        this._bursts = arr;
+        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);
     }
-    private _bursts?: ParticleBurst[];
+}
 
-    awake(): void {
-        this._renderer = this.gameObject.getComponent(ParticleSystemRenderer) as ParticleSystemRenderer;
-        this._system = new System();
+class ParticleSystemEmissionOverDistance extends BaseValueGenerator {
 
-        if (this.main.simulationSpace == ParticleSystemSimulationSpace.Local) {
-            this._container = new Object3D();
-            this._container.matrixAutoUpdate = false;
-            this.gameObject.add(this._container);
-        }
+    genValue(): number {
+        // 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;
+    }
+}
 
-        const container = this.main.simulationSpace == ParticleSystemSimulationSpace.Local ? this._container : this.context.scene;
+abstract class ParticleSystemBaseBehaviour implements Behavior {
+    readonly system: ParticleSystem;
 
-        if (debug) {
-            console.log(this);
-            this.gameObject.add(new AxesHelper(1))
-        }
-        const renderMode = this._renderer.renderMode;
-        let renderer: any = 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;
+    get scaleFactorDiff(): number {
+        return this.system.worldScale.x - this.system.scale;
+    }
+
+    constructor(ps: ParticleSystem) {
+        this.system = ps;
+    }
+
+    abstract type: string;
+
+    initialize(_particle: Particle): void {
+    }
+    update(_particle: Particle, _delta: number): void {
+    }
+    frameUpdate(_delta: number): void {
+    }
+    toJSON() { throw new Error("Method not implemented."); }
+    clone(): Behavior { throw new Error("Method not implemented."); }
+}
+
+class TextureSheetAnimationBehaviour extends ParticleSystemBaseBehaviour {
+    type: string = "NeedleTextureSheet"
+
+    update(particle: Particle, _delta: number) {
+        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: string = "NeedleRotation"
+
+    update(particle: Particle, delta: number) {
+        if (particle.rotation === undefined) return;
+        if (particle.rotation instanceof Quaternion) {
 
-        if (!renderer) {
-            console.error("No renderer for particle system");
-            return;
         }
+        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;
 
-        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);
+            if (this.system.rotationBySpeed.enabled) {
+                const speed = particle.velocity.length();
+                particle.rotation += this.system.rotationBySpeed.evaluate(particle.age / particle.life, speed) * delta;
             }
         }
+    }
+}
 
-        this._system.addRenderer(renderer);
+class SizeBehaviour extends ParticleSystemBaseBehaviour {
 
-        const initializers: Array<any> = [];
-        const behaviours: Array<any> = [];
+    type: string = "NeedleSize";
 
-        const life = new Life();
-        life.lifePan = new MinMaxCurveSpan(this.main.startLifetime, 1);
-        initializers.push(life);
+    update(particle: Particle, _delta: number): void {
+        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 shape = new Position(this.shape);
-        initializers.push(shape);
+const $startVelocity = Symbol("startVelocity");
+const $gravityFactor = Symbol("gravityModifier");
+const temp3 = new Vector3();
+const temp4 = new Quaternion();
 
-        const size = this._size = new SizeBehaviour(this.main.startSize, this.main.startSizeMultiplier);
-        size.sizeOverLifetimeModule = this.sizeOverLifetime;
-        behaviours.push(size);
+class VelocityBehaviour extends ParticleSystemBaseBehaviour {
+    type: string = "NeedleVelocity";
 
-        const color = new GradientBehaviour(this.main.startColor, this.colorOverLifetime?.enabled ? this.colorOverLifetime.color : undefined);
-        behaviours.push(color);
+    private _gravityDirection = new Vector3();
 
-        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);
+    initialize(particle: Particle): void {
+        const factor = 1 + this.scaleFactorDiff;
 
-        if (renderMode === ParticleSystemRenderMode.Mesh) {
-            initializers.push(new Body(this._renderer.getMesh()))
-        }
+        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 emitter = this._emitter = new Emitter({});
-        emitter.setInitializers(initializers);
-        emitter.setBehaviours(behaviours);
-        emitter.setRate(this.emission);
-        emitter.damping = 0;
-    }
+        const gravityFactor = this.system.main.gravityModifier.evaluate(Math.random(), Math.random());// * factor;
+        particle[$gravityFactor] = gravityFactor;
 
-    onEnable() {
-        this._emitter.emit();
-        this._system.addEmitter(this._emitter);
-        this._system.emit({ onStart: () => { }, onUpdate: () => { }, onEnd: () => { }, });
-        this._time = 0;
-    }
+        this._gravityDirection.set(0, -1, 0);
+        if (this.system.main.simulationSpace === ParticleSystemSimulationSpace.Local)
+            this._gravityDirection.applyQuaternion(this.system.worldQuaternionInverted);
 
-    onDisable() {
-        this._system.removeEmitter(this._emitter);
     }
 
-    onBeforeRender() {
-        if (this._bursts) {
-            this.emission.bursts = this._bursts;
-        }
+    update(particle: Particle, delta: number): void {
 
-        // sprite materials must be scaled in AR
-        const cam = this.context.mainCamera;
-        if (cam) {
-            const scale = getWorldScale(cam);
-            this._size.cameraScale = scale.x;
+        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);
 
-        if (this._container && this.gameObject?.parent) {
-            // this._container.matrix.copy(this.gameObject.matrixWorld);
-            // this._container.matrixWorld.copy(this.gameObject.matrixWorld);
+        const t01 = particle.age / particle.life;
 
-            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);
+        const noise = this.system.noise;
+        if (noise.enabled) {
+            noise.apply(0, particle.position, particle.velocity, delta, particle.age, particle.life);
         }
-        // this._system.time
-        // this._system.duration = this.main.duration;
-        this.emission.system = this;
-        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);
-        this._time += this.context.time.deltaTime;
-        if (this._time > this.duration) this._time = 0;
-    }
-
-}
 
+        const velocity = this.system.velocityOverLifetime;
+        if (velocity.enabled) {
+            velocity.apply(0, particle.position, particle.velocity, delta, particle.age, particle.life);
+        }
 
-class MinMaxCurveSpan {
-
-    readonly time: Time;
-    readonly curve: MinMaxCurve;
-    multiplier: number = 1;
+        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);
+        }
 
-    constructor(minMaxCurve: MinMaxCurve, multiplier: number = 1) {
-        this.time = Context.Current.time;
-        this.curve = minMaxCurve;
-        this.multiplier = multiplier;
-    }
+        // const speed = particle.velocity.length();
+        // particle.velocity.multiplyScalar(1-delta);
 
-    /** called by nebula */
-    getValue(lerp?: number) {
-        const res = this.curve.evaluate(this.time.time, lerp) * this.multiplier;
-        return res;
+        // const vel = this.system.velocityOverLifetime.evaluate(particle.age / particle.life);
     }
 }
 
-abstract class CustomBehaviour extends Behaviour {
-    abstract applyBehaviour(target: Particle | Emitter, time: number, index: number);
-    abstract initialize(particle: Particle);
-}
-
-abstract class MinMaxCurveBehaviour extends CustomBehaviour {
+class ColorBehaviour extends ParticleSystemBaseBehaviour {
+    type: string = "NeedleColor";
 
-    readonly startCurve: MinMaxCurve;
-    startMultiplier: number = 1;
+    initialize(particle: Particle): void {
+        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);
+    }
 
-    constructor(startCurve: MinMaxCurve, startMultiplier: number = 1) {
-        super();
-        this.startCurve = startCurve;
-        this.startMultiplier = startMultiplier;
+    update(particle: Particle, _delta: number): void {
+        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);
+        }
     }
 }
 
-declare type ParticleWithScale = Particle & { target: Object3D, start_scale: number };
+class ParticleSystemInterface implements ParticleSystemParameters {
 
-class SizeBehaviour extends MinMaxCurveBehaviour {
+    private readonly system: ParticleSystem;
+    private readonly emission: ParticleSystemEmissionOverTime;
+    private get anim(): TextureSheetAnimationModule {
+        return this.system.textureSheetAnimation;
+    }
 
-    sizeOverLifetimeModule!: SizeOverLifetimeModule;
+    constructor(system: ParticleSystem) {
+        this.system = system;
+        this.emission = new ParticleSystemEmissionOverTime(this.system);
+    }
 
-    cameraScale: number = 1;
+    update() {
+        this.emission.update();
+    }
 
-    applyBehaviour(particle: ParticleWithScale, _deltaTime: number, _index: number) {
-        if (particle.target.type === "Sprite") {
-            particle.radius = 1 / this.cameraScale;
+    autoDestroy?: boolean | undefined;
+    get looping() { return this.system.main.loop; }
+    get duration() { return this.system.duration; }
+    get shape(): EmitterShape { 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?: ValueGenerator | FunctionValueGenerator | undefined; /** 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?: BurstParameters[] | undefined;
+    onlyUsedByOther?: boolean | undefined;
+    readonly behaviors: Behavior[] = [];
+    get instancingGeometry() {
+        return this.system.renderer.getMesh().geometry;
+    }
+    get renderMode() {
+        if (this.system.trails["enabled"] === true) {
+            return RenderMode.Trail;
         }
-        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);
+        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;
     }
-    initialize(particle: ParticleWithScale) {
-        particle.scale = this.startCurve.evaluate(0, Math.random());// * this.startMultiplier;
-        particle.start_scale = particle.scale;
-
+    rendererEmitterSettings: TrailSettings = {
+        startLength: new ConstantValue(220),
+        followLocalOrigin: false,
+    };
+    get speedFactor() { return this.system.main.simulationSpeed; }
+    get texture(): THREE.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(): THREE.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; }
+
 }
 
-declare type ParticleWithColor = Particle & { color_start: { r: number, g: number, b: number }, alpha_start: number };
+class ParticlesEmissionState implements EmissionState {
+
+    burstIndex: number = 0;
+    burstWaveIndex: number = 0;
+    time: number = 0;
+    waitEmiting: number = 0;
+}
 
-class GradientBehaviour extends CustomBehaviour {
+export class ParticleSystem extends Behaviour implements IParticleSystem {
 
-    private startGradient: MinMaxGradient;
-    private gradient?: MinMaxGradient;
+    play(includeChildren: boolean = false) {
+        if (includeChildren) {
+            GameObject.foreachComponent(this.gameObject, comp => {
+                if (comp instanceof ParticleSystem && comp !== this) {
+                    comp.play(false);
+                }
+            }, true)
+        }
+        this._isPlaying = true;
+        this._time = 0;
 
-    constructor(startGradient: MinMaxGradient, gradient?: MinMaxGradient) {
-        super();
-        this.startGradient = startGradient;
-        this.gradient = gradient;
+        // https://github.com/Alchemist0823/three.quarks/pull/35
+        if (this._particleSystem) {
+            this._particleSystem["emissionState"].time = 0;
+            this._particleSystem["emitEnded"] = false;
+        }
+        this.emission?.reset();
     }
 
-    /** 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;
-            }
+    pause() {
+        this._isPlaying = false;
+    }
+    stop() {
+        this._isPlaying = false;
+        this._time = 0;
+    }
+
+    private _state?: ParticlesEmissionState;
+    emit(count: number) {
+        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;
         }
     }
 
-    private id = Symbol('gradientId');
-    private _internalId: number = 0;
+    @serializeable(ColorOverLifetimeModule)
+    readonly colorOverLifetime!: ColorOverLifetimeModule;
 
-    /** called from nebula */
-    initialize(particle: ParticleWithColor) {
+    @serializeable(MainModule)
+    readonly main!: MainModule;
 
-        // 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
+    @serializeable(EmissionModule)
+    readonly emission!: EmissionModule;
 
-        particle.age = 0;
+    @serializeable(SizeOverLifetimeModule)
+    readonly sizeOverLifetime!: SizeOverLifetimeModule;
 
-        particle.color_start = { r: ev.r, g: ev.g, b: ev.b };
-        particle.alpha_start = ev.alpha;
+    @serializeable(ShapeModule)
+    readonly shape!: ShapeModule;
 
-        particle.useColor = true;
-        particle.useAlpha = true;
+    @serializeable(NoiseModule)
+    readonly noise!: NoiseModule;
 
-        if (particle[this.id] === undefined)
-            particle[this.id] = this._internalId++;
-    }
-}
+    // @serializeable(TrailModule)
+    readonly trails!: TrailModule;
 
+    @serializeable(VelocityOverLifetimeModule)
+    readonly velocityOverLifetime!: VelocityOverLifetimeModule;
 
-declare type ParticleWithVelocity = Particle & { velocity_start: { x: number, y: number, u: number }, gravity: number };
+    @serializeable(LimitVelocityOverLifetimeModule)
+    readonly limitVelocityOverLifetime!: LimitVelocityOverLifetimeModule;
 
-class VelocityBehaviour extends CustomBehaviour {
+    @serializeable(TextureSheetAnimationModule)
+    readonly textureSheetAnimation!: TextureSheetAnimationModule;
 
-    container: Object3D;
+    @serializeable(RotationOverLifetimeModule)
+    readonly rotationOverLifetime!: RotationOverLifetimeModule;
 
-    shape: ShapeModule;
-    noise: NoiseModule;
+    @serializeable(RotationBySpeedModule)
+    readonly rotationBySpeed!: RotationBySpeedModule;
 
-    startSpeed: MinMaxCurve;
-    startMultiplier: number = 1;
+    get renderer(): ParticleSystemRenderer {
+        return this._renderer;
+    }
 
-    gravity?: MinMaxCurve;
-    gravityModifierMultiplier: number = 1;
+    get isPlaying() { return this.isPlaying; }
 
-    downDirection = new Vector3();
-    private _temp: Vector3 = new Vector3();
+    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(): number {
+        return this._cameraScale;
+    }
+    private _cameraScale: number = 1;
 
-    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;
+    get container(): Object3D {
+        return this._container!;
+    }
 
+    get worldspace() {
+        return this.main.simulationSpace === ParticleSystemSimulationSpace.World;
     }
 
-    applyBehaviour(target: ParticleWithVelocity | Emitter, deltaTime: number, index: number) {
+    private __worldQuaternion = new Quaternion();
+    get worldQuaternion(): Quaternion {
+        return this.__worldQuaternion;
+    }
+    private _worldQuaternionInverted = new Quaternion();
+    get worldQuaternionInverted(): Quaternion {
+        return this._worldQuaternionInverted;
+    }
+    private _worldScale = new Vector3();
+    get worldScale(): Vector3 {
+        return this._worldScale;
+    }
 
-        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);
-            }
+    private _renderer!: ParticleSystemRenderer;
 
-            if (this.noise) {
-                this.noise.applyNoise(index, target.position, target.velocity, deltaTime, target.age, target.life);
+    private _batchSystem?: BatchedParticleRenderer;
+    private _particleSystem?: _ParticleSystem;
+    private _interface!: ParticleSystemInterface;
+
+    // private _system!: System;
+    // private _emitter: Emitter;
+    // private _size!: SizeBehaviour;
+    private _container!: Object3D;
+    private _time: number = 0;
+    private _isPlaying: boolean = true;
+
+    /** called from deserialization */
+    private set bursts(arr: ParticleBurst[]) {
+        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;
     }
+    private _bursts?: ParticleBurst[];
+
+    awake(): void {
+        this._renderer = this.gameObject.getComponent(ParticleSystemRenderer) as ParticleSystemRenderer;
 
-    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;
+        this._container = new Object3D();
+        this._container.matrixAutoUpdate = false;
+        if (this.main.simulationSpace == ParticleSystemSimulationSpace.Local) {
+            this.gameObject.add(this._container);
         }
         else {
-            particle.gravity = 0;
+            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);
 
-        const quat = getWorldQuaternion(this.container);
-        this.downDirection.set(0, -1, 0).applyQuaternion(quat);
+        if (debug) {
+            console.log(this);
+            this.gameObject.add(new AxesHelper(1))
+        }
+
+        // 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.play();
     }
 
-}
+    onDisable() {
+    }
+
+    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._cameraScale = scale.x;
+        }
+
+        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;
+            this._container.matrix.identity();
+            this._container.matrix.scale(scale);
+        }
+
+        this.emission.system = this;
+        const dt = this.deltaTime;
+        this._interface.update();
+        this.shape.update(this, 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;
+    }
+
+}