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

package/src/engine-components/ParticleSystem.ts

@@ -1,368 +1,770 @@
 import { Behaviour, GameObject } from "./Component";
 import * as THREE from "three";
-import { MainModule, EmissionModule, ShapeModule, ParticleSystemShapeType, MinMaxCurve, MinMaxGradient, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, ParticleSystemSimulationSpace } from "./ParticleSystemModules"
+import { MainModule, EmissionModule, ShapeModule, ParticleSystemShapeType, MinMaxCurve, MinMaxGradient, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, ParticleSystemSimulationSpace, ParticleBurst, IParticleSystem, ParticleSystemRenderMode, TrailModule, VelocityOverLifetimeModule, TextureSheetAnimationModule, RotationOverLifetimeModule } from "./ParticleSystemModules"
 import { getParam } from "../engine/engine_utils";
-import System, {
-    Emitter,
-    Rate,
-    Span,
-    Position,
-    Mass,
-    Radius,
-    Life,
-    PointZone,
-    Vector3D,
-    Alpha,
-    Scale,
-    Color,
-    SpriteRenderer,
-    RadialVelocity,
-    BoxZone,
-    Particle,
-    Gravity,
-    SphereZone,
-} 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 { Time } from "../engine/engine_time";
-import { Context } from "../engine/engine_setup";
 import { RGBAColor } from "./js-extensions/RGBAColor";
+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, 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";
-import { Vec3 } from "../engine/engine_types";
-import { AxesHelper, Material, Object3D, Sprite, SpriteMaterial, Vector3 } from "three";
-import { Renderer } from "./Renderer";
-import { getWorldQuaternion, getWorldScale } from "../engine/engine_three_utils";
 
 const debug = getParam("debugparticles");
 
 
-
 export class ParticleSystemRenderer extends Behaviour {
 
+    @serializeable()
+    renderMode?: ParticleSystemRenderMode;
+
     @serializeable(Material)
     particleMaterial?: SpriteMaterial;
-}
 
-export class ParticleSystem extends Behaviour {
+    // @serializeable(Mesh)
+    particleMesh?: Mesh | string;
 
-    @serializeable(ColorOverLifetimeModule)
-    colorOverLifetime!: ColorOverLifetimeModule;
+    get transparent(): boolean {
+        const res = this.particleMaterial?.transparent ?? false;
+        // console.log(res, this.particleMaterial);
+        return res;
+    }
 
-    @serializeable(MainModule)
-    main!: MainModule;
+    getMesh() {
+        let geo: BufferGeometry | null = 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;
+    }
+}
 
-    @serializeable(EmissionModule)
-    emission!: EmissionModule;
+class MinMaxCurveFunction implements FunctionValueGenerator {
 
-    @serializeable(SizeOverLifetimeModule)
-    sizeOverLifetime!: SizeOverLifetimeModule;
+    private _curve: MinMaxCurve;
 
-    @serializeable(ShapeModule)
-    shape!: ShapeModule;
+    constructor(curve: MinMaxCurve) { this._curve = curve; }
 
-    @serializeable(NoiseModule)
-    noise!: NoiseModule;
+    type: "function" = "function";
 
-    renderer!: ParticleSystemRenderer;
+    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.");
+    }
+}
 
-    private _system!: System;
-    private _emitter: Emitter;
-    private _size!: SizeBehaviour;
+class MinMaxGradientFunction implements FunctionColorGenerator {
 
-    awake(): void {
-        if (debug) {
-            console.log(this);
-            this.gameObject.add(new AxesHelper(1))
-        }
+    private _curve: MinMaxGradient;
 
-        this.renderer = this.gameObject.getComponent(ParticleSystemRenderer) as 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 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);
-        }
+    constructor(curve: MinMaxGradient) { this._curve = curve; }
 
-        this._system.addRenderer(renderer);
+    type: "function" = "function";
 
-        const initializers: Array<any> = [];
-        const behaviours: Array<any> = [];
+    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.");
+    }
 
+}
 
+abstract class BaseValueGenerator implements ValueGenerator {
 
-        const life = new Life();
-        life.lifePan = new MinMaxCurveSpan(this.main.startLifetime, 1);
-        initializers.push(life);
+    type: "value" = "value";
+    toJSON(): FunctionJSON {
+        throw new Error("Method not implemented.");
+    }
+    clone(): ValueGenerator {
+        throw new Error("Method not implemented.");
+    }
 
-        const shape = new Position(this.shape);
-        initializers.push(shape);
+    abstract genValue(): number;
 
-        const size = this._size = new SizeBehaviour(this.main.startSize, this.main.startSizeMultiplier);
-        size.sizeOverLifetimeModule = this.sizeOverLifetime;
-        behaviours.push(size);
+    readonly system: ParticleSystem;
 
-        const color = new GradientBehaviour(this.main.startColor, this.colorOverLifetime?.enabled ? this.colorOverLifetime.color : undefined);
-        behaviours.push(color);
+    constructor(system: ParticleSystem) {
+        this.system = system;
+    }
+}
 
-        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);
+class TextureSheetStartFrameGenerator extends BaseValueGenerator {
+    genValue(): number {
+        return this.system.textureSheetAnimation.getStartIndex();
+    }
 
+}
 
-        const emitter = this._emitter = new Emitter({});
-        emitter.setInitializers(initializers);
-        emitter.setBehaviours(behaviours);
-        emitter.setRate(this.emission);
-        emitter.damping = 0;
-    }
+class ParticleSystemEmissionOverTime extends BaseValueGenerator {
 
-    onEnable() {
-        this._emitter.emit();
-        this._system.addEmitter(this._emitter);
-        this._system.emit({ onStart: () => { }, onUpdate: () => { }, onEnd: () => { }, });
-    }
+    private _lastPosition: Vector3 = new Vector3();
+    private _lastDistance: number = 0;
 
-    onDisable() {
-        this._system.removeEmitter(this._emitter);
+    update() {
+        const currentPosition = getWorldPosition(this.system.gameObject);
+        this._lastDistance = this._lastPosition.distanceTo(currentPosition)
+        this._lastPosition.copy(currentPosition);
     }
 
-    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);
-
-        // sprite materials must be scaled in AR
-        const cam = this.context.mainCamera;
-        if (cam) {
-            const scale = getWorldScale(cam);
-            this._size.cameraScale = scale.x;
+    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;
         }
-    }
 
+        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(): 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;
+    }
+}
 
+abstract class ParticleSystemBaseBehaviour implements Behavior {
+    readonly system: ParticleSystem;
 
-class MinMaxCurveSpan {
+    constructor(ps: ParticleSystem) {
+        this.system = ps;
+    }
 
-    readonly time: Time;
-    readonly curve: MinMaxCurve;
-    multiplier: number = 1;
+    abstract type: string;
 
-    constructor(minMaxCurve: MinMaxCurve, multiplier: number = 1) {
-        this.time = Context.Current.time;
-        this.curve = minMaxCurve;
-        this.multiplier = multiplier;
+    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."); }
+}
 
-    /** called by nebula */
-    getValue(lerp?: number) {
-        const res = this.curve.evaluate(this.time.time, lerp) * this.multiplier;
-        return res;
+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;
+        }
     }
+
 }
 
-abstract class CustomBehaviour extends Behaviour {
-    abstract applyBehaviour(target: Particle | Emitter, time: number, index: number);
-    abstract initialize(particle: Particle);
+class RotationBehaviour extends ParticleSystemBaseBehaviour {
+    type: string = "NeedleRotation"
+
+    update(particle: Particle, delta: number) {
+        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;
+        }
+    }
 }
 
-abstract class MinMaxCurveBehaviour extends CustomBehaviour {
+class SizeBehaviour extends ParticleSystemBaseBehaviour {
 
-    readonly startCurve: MinMaxCurve;
-    startMultiplier: number = 1;
+    type: string = "NeedleSize";
 
-    constructor(startCurve: MinMaxCurve, startMultiplier: number = 1) {
-        super();
-        this.startCurve = startCurve;
-        this.startMultiplier = startMultiplier;
+    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.scale / this.system.cameraScale;
+        particle.size = particle.startSize * size * scaleFactor;
+        // console.log(particle.startSize, size, this.system.scale, this.system.cameraScale);
     }
 }
 
-declare type ParticleWithScale = Particle & { target: Object3D, start_scale: number };
+const $startVelocity = Symbol("startVelocity");
+const $gravityFactor = Symbol("gravityModifier");
+const temp3 = new Vector3();
+const temp4 = new Quaternion();
+
+class VelocityBehaviour extends ParticleSystemBaseBehaviour {
+    type: string = "NeedleVelocity";
 
-class SizeBehaviour extends MinMaxCurveBehaviour {
+    private _gravityDirection = new Vector3();
 
-    sizeOverLifetimeModule!: SizeOverLifetimeModule;
+    initialize(particle: Particle): void {
+        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);
 
-    cameraScale: number = 1;
+        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);
+    }
 
-    applyBehaviour(particle: ParticleWithScale, _deltaTime: number, _index: number) {
-        if (particle.target.type === "Sprite") {
-            particle.radius = 1 / this.cameraScale;
+    update(particle: Particle, delta: number): void {
+        // 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);
         }
-        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);
+        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);
     }
-    initialize(particle: ParticleWithScale) {
-        particle.scale = this.startCurve.evaluate(0, Math.random());// * this.startMultiplier;
-        particle.start_scale = particle.scale;
+}
 
+class ColorBehaviour extends ParticleSystemBaseBehaviour {
+    type: string = "NeedleColor";
+
+    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);
+    }
+
+    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 ParticleWithColor = Particle & { color_start: { r: number, g: number, b: number }, alpha_start: number };
+class ParticleSystemInterface implements ParticleSystemParameters {
 
-class GradientBehaviour extends CustomBehaviour {
+    private readonly system: ParticleSystem;
+    private readonly emission: ParticleSystemEmissionOverTime;
+    private get anim(): TextureSheetAnimationModule {
+        return this.system.textureSheetAnimation;
+    }
 
-    private startGradient: MinMaxGradient;
-    private gradient?: MinMaxGradient;
+    constructor(system: ParticleSystem) {
+        this.system = system;
+        this.emission = new ParticleSystemEmissionOverTime(this.system);
+    }
 
-    constructor(startGradient: MinMaxGradient, gradient?: MinMaxGradient) {
-        super();
-        this.startGradient = startGradient;
-        this.gradient = gradient;
+    update() {
+        this.emission.update();
     }
 
-    /** 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;
-            }
+    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;
+        }
+        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: 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; }
 
-    private id = Symbol('gradientId');
-    private _internalId: number = 0;
+}
 
-    /** called from nebula */
-    initialize(particle: ParticleWithColor) {
+export class ParticleSystem extends Behaviour implements IParticleSystem {
 
-        // 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(ColorOverLifetimeModule)
+    readonly colorOverLifetime!: ColorOverLifetimeModule;
 
-        particle.age = 0;
+    @serializeable(MainModule)
+    readonly main!: MainModule;
 
-        particle.color_start = { r: ev.r, g: ev.g, b: ev.b };
-        particle.alpha_start = ev.alpha;
+    @serializeable(EmissionModule)
+    readonly emission!: EmissionModule;
 
-        particle.useColor = true;
-        particle.useAlpha = true;
+    @serializeable(SizeOverLifetimeModule)
+    readonly sizeOverLifetime!: SizeOverLifetimeModule;
 
-        if (particle[this.id] === undefined)
-            particle[this.id] = this._internalId++;
-    }
-}
+    @serializeable(ShapeModule)
+    readonly shape!: ShapeModule;
 
+    @serializeable(NoiseModule)
+    readonly noise!: NoiseModule;
 
-declare type ParticleWithVelocity = Particle & { velocity_start: { x: number, y: number, u: number }, gravity: number };
+    // @serializeable(TrailModule)
+    readonly trails!: TrailModule;
 
-class VelocityBehaviour extends CustomBehaviour {
+    @serializeable(VelocityOverLifetimeModule)
+    readonly velocityOverLifetime!: VelocityOverLifetimeModule;
 
-    container: Object3D;
+    @serializeable(TextureSheetAnimationModule)
+    readonly textureSheetAnimation!: TextureSheetAnimationModule;
 
-    shape: ShapeModule;
-    noise: NoiseModule;
+    @serializeable(RotationOverLifetimeModule)
+    readonly rotationOverLifetime!: RotationOverLifetimeModule;
 
-    startSpeed: MinMaxCurve;
-    startMultiplier: number = 1;
+    get renderer(): ParticleSystemRenderer {
+        return this._renderer;
+    }
 
-    gravity?: MinMaxCurve;
-    gravityModifierMultiplier: number = 1;
+    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;
 
-    downDirection = new Vector3(0, -1, 0);
-    private _temp: Vector3 = new Vector3();
+    get container(): Object3D {
+        return this._container!;
+    }
 
-    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;
+    private __worldQuaternion = new Quaternion();
+    get worldQuaternion(): Quaternion {
+        return this.__worldQuaternion;
+    }
+    private _worldQuaternionInverted = new Quaternion();
+    get worldQuaternionInverted(): Quaternion {
+        return this._worldQuaternionInverted;
+    }
 
-        const quat = getWorldQuaternion(container);
-        this.downDirection.applyQuaternion(quat);
+    private _renderer!: ParticleSystemRenderer;
+
+    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;
+
+    /** 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[];
 
-    applyBehaviour(target: ParticleWithVelocity | Emitter, deltaTime: number, index: number) {
+    awake(): void {
+        this._renderer = this.gameObject.getComponent(ParticleSystemRenderer) as ParticleSystemRenderer;
 
-        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);
-            }
+        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.container.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);
+        //     }
+        // }
+
+    }
+
+    onEnable() {
+        this._time = 0;
+    }
+
+    onDisable() {
     }
 
-    initialize(particle: ParticleWithVelocity) {
-        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;
+    onBeforeRender() {
+        if (this._bursts) {
+            this.emission.bursts = this._bursts;
         }
-        else {
-            particle.gravity = 0;
+
+        // sprite materials must be scaled in AR
+        const cam = this.context.mainCamera;
+        if (cam) {
+            const scale = getWorldScale(cam);
+            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);
         }
 
-        // particle.acceleration.y = 1;
-        // console.log(particle);
+        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;
     }
 
-}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// 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);
+//     }
+
+// }