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

package/src/engine-components/ParticleSystemModules.ts

@@ -1,173 +1,659 @@
+import { init } from "@dimforge/rapier3d-compat";
 import * as THREE from "three";
+import { Color, Matrix4, Object3D, Vector3 } from "three";
+import { Mathf } from "../engine/engine_math";
+import { serializeable } from "../engine/engine_serialization";
+import { RGBAColor } from "./js-extensions/RGBAColor";
+import { AnimationCurve } from "./AnimationCurve";
+import { Vec3 } from "../engine/engine_types";
+
+declare type Color4 = { r: number, g: number, b: number, a: number };
+declare type ColorKey = { time: number, color: Color4 };
+declare type AlphaKey = { time: number, alpha: number };
+
+export interface IParticleSystem {
+    get currentParticles(): number;
+    get maxParticles(): number;
+    get time(): number;
+    get duration(): number;
+    readonly main: MainModule;
+}
+
+export enum ParticleSystemRenderMode {
+    Billboard = 0,
+    //   Stretch = 1,
+    //   HorizontalBillboard = 2,
+    //   VerticalBillboard = 3,
+    Mesh = 4,
+    //   None = 5,
+}
+
+
+export class Gradient {
+    @serializeable()
+    alphaKeys!: Array<AlphaKey>;
+    @serializeable()
+    colorKeys!: Array<ColorKey>;
+
+    get duration(): number {
+        return 1;
+    }
+
+    evaluate(time: number, target: RGBAColor) {
+
+        // target.r = this.colorKeys[0].color.r;
+        // target.g = this.colorKeys[0].color.g;
+        // target.b = this.colorKeys[0].color.b;
+        // target.alpha = this.alphaKeys[0].alpha;
+        // return;
+
+        let closestAlpha: AlphaKey | undefined = undefined;
+        let closestAlphaIndex = 0;
+        let closestColor: ColorKey | null = null;
+        let closestColorIndex = 0;
+        for (let i = 0; i < this.alphaKeys.length; i++) {
+            const key = this.alphaKeys[i];
+            if (key.time < time || !closestAlpha) {
+                closestAlpha = key;
+                closestAlphaIndex = i;
+            }
+        }
+        for (let i = 0; i < this.colorKeys.length; i++) {
+            const key = this.colorKeys[i];
+            if (key.time < time || !closestColor) {
+                closestColor = key;
+                closestColorIndex = i;
+            }
+        }
+        if (closestColor) {
+            const hasNextColor = closestColorIndex + 1 < this.colorKeys.length;
+            if (hasNextColor) {
+                const nextColor = this.colorKeys[closestColorIndex + 1];
+                const t = Mathf.remap(time, closestColor.time, nextColor.time, 0, 1);
+                target.r = Mathf.lerp(closestColor.color.r, nextColor.color.r, t);
+                target.g = Mathf.lerp(closestColor.color.g, nextColor.color.g, t);
+                target.b = Mathf.lerp(closestColor.color.b, nextColor.color.b, t);
+            }
+            else {
+                target.r = closestColor.color.r;
+                target.g = closestColor.color.g;
+                target.b = closestColor.color.b;
+            }
+        }
+        if (closestAlpha) {
+            const hasNextAlpha = closestAlphaIndex + 1 < this.alphaKeys.length;
+            if (hasNextAlpha) {
+                const nextAlpha = this.alphaKeys[closestAlphaIndex + 1];
+                const t = Mathf.remap(time, closestAlpha.time, nextAlpha.time, 0, 1);
+                target.alpha = Mathf.lerp(closestAlpha.alpha, nextAlpha.alpha, t);
+            }
+            else {
+                target.alpha = closestAlpha.alpha;
+            }
+        }
+        return target;
+    }
+}
+
+export enum ParticleSystemCurveMode {
+    Constant = 0,
+    Curve = 1,
+    TwoCurves = 2,
+    TwoConstants = 3
+}
+
+export enum ParticleSystemGradientMode {
+    Color = 0,
+    Gradient = 1,
+    TwoColors = 2,
+    TwoGradients = 3,
+    RandomColor = 4,
+}
+
+export enum ParticleSystemSimulationSpace {
+    Local = 0,
+    World = 1,
+    Custom = 2
+}
+
+export enum ParticleSystemShapeType {
+    Sphere = 0,
+    SphereShell = 1,
+    Hemisphere = 2,
+    HemisphereShell = 3,
+    Cone = 4,
+    Box = 5,
+    Mesh = 6,
+    ConeShell = 7,
+    ConeVolume = 8,
+    ConeVolumeShell = 9,
+    Circle = 10,
+    CircleEdge = 11,
+    SingleSidedEdge = 12,
+    MeshRenderer = 13,
+    SkinnedMeshRenderer = 14,
+    BoxShell = 15,
+    BoxEdge = 16,
+    Donut = 17,
+    Rectangle = 18,
+    Sprite = 19,
+    SpriteRenderer = 20
+}
+
+
+export class MinMaxCurve {
+    @serializeable()
+    mode!: ParticleSystemCurveMode;
+    @serializeable()
+    constant!: number;
+    @serializeable()
+    constantMin!: number;
+    @serializeable()
+    constantMax!: number;
+    @serializeable(AnimationCurve)
+    curve?: AnimationCurve;
+    @serializeable(AnimationCurve)
+    curveMin?: AnimationCurve;
+    @serializeable(AnimationCurve)
+    curveMax?: AnimationCurve;
+    @serializeable()
+    curveMultiplier?: number;
+
+    evaluate(t01: number, lerpFactor?: number): number {
+        const t = lerpFactor === undefined ? Math.random() : lerpFactor;
+        switch (this.mode) {
+            case ParticleSystemCurveMode.Constant:
+                return this.constant;
+            case ParticleSystemCurveMode.Curve:
+                t01 %= this.curve!.duration;
+                return this.curve!.evaluate(t01);
+            case ParticleSystemCurveMode.TwoCurves:
+                const t1 = t01 * this.curveMin!.duration;
+                const t2 = t01 * this.curveMax!.duration;
+                return Mathf.lerp(this.curveMin!.evaluate(t1), this.curveMax!.evaluate(t2), t % 1);
+            case ParticleSystemCurveMode.TwoConstants:
+                return Mathf.lerp(this.constantMin, this.constantMax, t % 1);
+            default:
+                this.curveMax!.evaluate(t01) * this.curveMultiplier!;
+                break;
+        }
+        return 0;
+    }
+}
+
+export class MinMaxGradient {
+    mode!: ParticleSystemGradientMode;
+    @serializeable(RGBAColor)
+    color!: RGBAColor;
+    @serializeable(RGBAColor)
+    colorMin!: RGBAColor;
+    @serializeable(RGBAColor)
+    colorMax!: RGBAColor;
+    @serializeable(Gradient)
+    gradient!: Gradient;
+    @serializeable(Gradient)
+    gradientMin!: Gradient;
+    @serializeable(Gradient)
+    gradientMax!: Gradient;
+
+    private static _temp: RGBAColor = new RGBAColor(0, 0, 0, 1);
+    private static _temp2: RGBAColor = new RGBAColor(0, 0, 0, 1);
+
+    evaluate(t01: number, lerpFactor?: number): RGBAColor {
+        const t = lerpFactor === undefined ? Math.random() : lerpFactor;
+        switch (this.mode) {
+            case ParticleSystemGradientMode.Color:
+                return this.color;
+            case ParticleSystemGradientMode.Gradient:
+                this.gradient.evaluate(t01, MinMaxGradient._temp);
+                return MinMaxGradient._temp
+            case ParticleSystemGradientMode.TwoColors:
+                return MinMaxGradient._temp.lerpColors(this.colorMin, this.colorMax, t);
+            case ParticleSystemGradientMode.TwoGradients:
+                const t2 = Math.random();
+                this.gradientMin.evaluate(t2, MinMaxGradient._temp);
+                this.gradientMax.evaluate(t2, MinMaxGradient._temp2);
+                return MinMaxGradient._temp.lerp(MinMaxGradient._temp2, t);
+
+        }
+        // console.warn("Not implemented", ParticleSystemGradientMode[this.mode]);
+        MinMaxGradient._temp.set(0xff00ff)
+        MinMaxGradient._temp.alpha = 1;
+        return MinMaxGradient._temp;
+    }
+}
+
+declare type ParticleSystemScalingMode = {
+    Hierarchy: number;
+    Local: number;
+    Shape: number;
+}
 
 export class MainModule {
-    randomizeRotationDirection: number = 0;
-    duration: number = 5;
-    loop: boolean = true;
-    prewarm: boolean = false;
-    startDelay = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startDelayMultiplier: number = 0;
-    startLifetime = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startLifetimeMultiplier: number = 5;
-    startSpeed = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startSpeedMultiplier: number = 5;
-    startSize3D: boolean = false;
-    startSize = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startSizeMultiplier: number = 1;
-    startSizeX = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startSizeXMultiplier: number = 1;
-    startSizeY = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startSizeYMultiplier: number = 1;
-    startSizeZ = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startSizeZMultiplier: number = 1;
-    startRotation3D: boolean = false;
-    startRotation = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startRotationMultiplier: number = 0;
-    startRotationX = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startRotationXMultiplier: number = 0;
-    startRotationY = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startRotationYMultiplier: number = 0;
-    startRotationZ = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startRotationZMultiplier: number = 0;
-    flipRotation: number = 0;
-    startColor : THREE.Color = new THREE.Color(1, 1, 1);
-    startColor1 : THREE.Color | undefined = new THREE.Color(0, 0, 0); // this only exists in gradient mode
-    gravityModifier = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    gravityModifierMultiplier: number = 0;
-    simulationSpace: number = 0;
-    customSimulationSpace = null;
-    simulationSpeed: number = 1;
-    useUnscaledTime: boolean = false;
-    scalingMode: number = 1;
-    playOnAwake: boolean = true;
-    maxParticles: number = 1000;
-    emitterVelocityMode: number = 1;
-    stopAction: number = 0;
-    ringBufferMode: number = 0;
-    ringBufferLoopRange: THREE.Vector2 = new THREE.Vector2(0, 1);
-    cullingMode: number = 0;
+    cullingMode!: number;
+    duration!: number;
+    emitterVelocityMode!: number;
+    flipRotation!: number;
+    @serializeable(MinMaxCurve)
+    gravityModifier!: MinMaxCurve;
+    gravityModifierMultiplier!: number;
+    loop!: boolean;
+    maxParticles!: number;
+    playOnAwake!: boolean;
+    prewarm!: boolean;
+    ringBufferLoopRange!: { x: number, y: number };
+    ringBufferMode!: boolean;
+    scalingMode!: ParticleSystemScalingMode;
+    simulationSpace!: ParticleSystemSimulationSpace;
+    simulationSpeed!: number;
+    @serializeable(MinMaxGradient)
+    startColor!: MinMaxGradient;
+    @serializeable(MinMaxCurve)
+    startDelay!: MinMaxCurve;
+    startDelayMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    startLifetime!: MinMaxCurve;
+    startLifetimeMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    startRotation!: MinMaxCurve;
+    startRotationMultiplier!: number;
+    startRotation3D!: boolean;
+    @serializeable(MinMaxCurve)
+    startRotationX!: MinMaxCurve;
+    startRotationXMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    startRotationY!: MinMaxCurve;
+    startRotationYMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    startRotationZ!: MinMaxCurve;
+    startRotationZMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    startSize!: MinMaxCurve;
+    startSize3D!: boolean;
+    startSizeMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    startSizeX!: MinMaxCurve;
+    startSizeXMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    startSizeY!: MinMaxCurve;
+    startSizeYMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    startSizeZ!: MinMaxCurve;
+    startSizeZMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    startSpeed!: MinMaxCurve;
+    startSpeedMultiplier!: number;
+    stopAction!: number;
+    useUnscaledTime!: boolean;
 }
 
 
+export class ParticleBurst {
+    cycleCount!: number;
+    maxCount!: number;
+    minCount!: number;
+    probability!: number;
+    repeatInterval!: number;
+    time!: number;
+    count!: {
+        constant: number;
+        constantMax: number;
+        constantMin: number;
+        curve?: AnimationCurve;
+        curveMax?: AnimationCurve;
+        curveMin?: AnimationCurve;
+        curveMultiplier?: number;
+        mode: ParticleSystemCurveMode;
+    }
+
+
+    private _performed: number = 0;
+
+
+    reset() {
+        this._performed = 0;
+    }
+    run(time: number): number {
+        if (time <= this.time) {
+            this.reset();
+            return 0;
+        }
+        let amount = 0;
+        if (this.cycleCount === 0 || this._performed < this.cycleCount) {
+            const nextTime = this.time + this.repeatInterval * this._performed;
+            if (time >= nextTime) {
+                this._performed += 1;
+                if (Math.random() < this.probability) {
+                    switch (this.count.mode) {
+                        case ParticleSystemCurveMode.Constant:
+                            amount = this.count.constant;
+                            break;
+                        case ParticleSystemCurveMode.TwoConstants:
+                            amount = Mathf.lerp(this.count.constantMin, this.count.constantMax, Math.random());
+                            break;
+                        case ParticleSystemCurveMode.Curve:
+                            amount = this.count.curve!.evaluate(Math.random());
+                            break;
+                        case ParticleSystemCurveMode.TwoCurves:
+                            const t = Math.random();
+                            amount = Mathf.lerp(this.count.curveMin!.evaluate(t), this.count.curveMax!.evaluate(t), Math.random());
+                            break;
+                    }
+                }
+            }
+        }
+        return amount;
+    }
+}
+
 export class EmissionModule {
-    burstCount: number = 0;
-    enabled: boolean = true;
-    rate: number = 10;
-    rateMutliplier: number = 1;
-    rateOverDistance: number = 0;
-    rateOverDistanceMultiplier: number = 0;
-    rateOverTime: number = 0;
-    rateOverTimeMultiplier: number = 0;
-    // type: number = 0; // is obsolete, time and emission are both active
+
+    @serializeable()
+    enabled!: boolean;
+
+
+    get burstCount() {
+        return this.bursts?.length ?? 0;
+    }
+
+    @serializeable()
+    bursts!: ParticleBurst[];
+
+    @serializeable(MinMaxCurve)
+    rateOverTime!: MinMaxCurve;
+    @serializeable()
+    rateOverTimeMultiplier!: number;
+
+    @serializeable(MinMaxCurve)
+    rateOverDistance!: MinMaxCurve;
+    @serializeable()
+    rateOverDistanceMultiplier!: number;
+
+
+    /** set from system */
+    system!: IParticleSystem;
+    get time() { return this.system.time; }
+
+    private _summed: number = 0;
+    // private _didEmit: boolean = false;
+
+    /** called by nebula */
+    init() {
+    }
+
+    /** called by nebula */
+    getValue(deltaTime: number) {
+        if (this.system.currentParticles >= this.system.maxParticles)
+            return 0;
+        if (!this.enabled) return 0;
+        let count = this.rateOverTime.evaluate(this.time / this.system.duration, Math.random());
+        this._summed += count * deltaTime;
+        let amount = Math.floor(this._summed);
+        this._summed -= amount;
+
+        if (this.burstCount > 0) {
+            for (let i = 0; i < this.burstCount; i++) {
+                const burst = this.bursts[i];
+                if (burst.time >= this.time) {
+                    burst.reset();
+                    continue;
+                }
+                amount += Math.round(burst.run(this.time));
+            }
+        }
+
+        // dont emit more than we are allowed to
+        return amount;//Mathf.clamp(amount, 0, this.system.maxParticles - this.system.currentParticles);
+    }
+}
+
+export class ColorOverLifetimeModule {
+    enabled!: boolean;
+    @serializeable(MinMaxGradient)
+    color!: MinMaxGradient;
+}
+
+export class SizeOverLifetimeModule {
+    enabled!: boolean;
+    separateAxes!: boolean;
+    @serializeable(MinMaxCurve)
+    size!: MinMaxCurve;
+    sizeMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    sizeX!: MinMaxCurve;
+    sizeXMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    sizeY!: MinMaxCurve;
+    sizeYMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    sizeZ!: MinMaxCurve;
+    sizeZMultiplier!: number;
+
+    private _time: number = 0;
+
+    evaluate(t01: number, target: Vec3) {
+        if (!this.separateAxes) {
+            const scale = this.size.evaluate(t01) * this.sizeMultiplier;
+            target.x = scale;
+            // target.y = scale;
+            // target.z = scale;
+        }
+        else {
+            target.x = this.sizeX.evaluate(this._time) * this.sizeXMultiplier;
+            // target.y = this.sizeY.evaluate(this._time) * this.sizeYMultiplier;
+            // target.z = this.sizeZ.evaluate(this._time) * this.sizeZMultiplier;
+        }
+        return target;
+    }
 }
 
 export class ShapeModule {
-    shapeType : ParticleSystemShapeType = ParticleSystemShapeType.Box;
+    @serializeable()
+    shapeType: ParticleSystemShapeType = ParticleSystemShapeType.Box;
+    @serializeable()
     enabled: boolean = true;
+    @serializeable()
     alignToDirection: boolean = false;
+    @serializeable()
     angle: number = 0;
+    @serializeable()
     arc: number = 360;
+    @serializeable()
     arcmode: number = 0; // TODO: enum?
     // arcSpeed, arcSpeedMult, arcSpread
-    box: THREE.Vector3 = new THREE.Vector3(1, 1, 1);
-    boxThickness: THREE.Vector3 = new THREE.Vector3(0, 0, 0);
-    position : THREE.Vector3 = new THREE.Vector3(0, 0, 0);
-    rotation : THREE.Vector3 = new THREE.Vector3(0, 0, 0);
-    scale : THREE.Vector3 = new THREE.Vector3(1, 1, 1);
+    // @serializeable(Vector3)
+    // box!: Vector3;
+    @serializeable(Vector3)
+    boxThickness!: Vector3;
+    @serializeable(Vector3)
+    position!: Vector3;
+    @serializeable(Vector3)
+    rotation!: Vector3;
+    @serializeable(Vector3)
+    scale!: Vector3;
+
+    @serializeable()
+    radius!: number;
+    @serializeable()
+    radiusThickness!: number;
+    @serializeable()
+    sphericalDirectionAmount!: number;
+
+    private _space?: ParticleSystemSimulationSpace;
+    private readonly _worldSpacePosition: Matrix4 = new Matrix4();
+
+    update(_context: Context, simulationSpace: ParticleSystemSimulationSpace, obj: Object3D) {
+        this._space = simulationSpace;
+        if (simulationSpace === ParticleSystemSimulationSpace.World) {
+            this._worldSpacePosition.copy(obj.matrixWorld);
+            // set scale to 1
+            this._worldSpacePosition.elements[0] = 1;
+            this._worldSpacePosition.elements[5] = 1;
+            this._worldSpacePosition.elements[10] = 1;
+        }
+    }
 
-    radius : number = 1;
-    sphericalDirectionAmount : number = 0;
+    /** nebula implementations: */
+
+    /** initializer implementation */
+    private _vector: Vector3 = new Vector3(0, 0, 0);
+    private _temp: Vector3 = new Vector3(0, 0, 0);
+    /** called by nebula on initialize */
+    get vector() {
+        return this._vector;
+    }
+    /** called by nebula */
+    getPosition(): void {
+        switch (this.shapeType) {
+            case ParticleSystemShapeType.Box:
+                this._vector.x = Math.random() * this.scale.x - this.scale.x / 2;
+                this._vector.y = Math.random() * this.scale.y - this.scale.y / 2;
+                this._vector.z = Math.random() * this.scale.z - this.scale.z / 2;
+                break;
+            case ParticleSystemShapeType.Sphere:
+                randomSpherePoint(this.position.x, this.position.y, this.position.z, this.radius, this.radiusThickness, this.arc, this._vector);
+                break;
+            // case ParticleSystemShapeType.Hemisphere:
+            //     randomSpherePoint(this.position.x, this.position.y, this.position.z, this.radius, this.radiusThickness, 180, this._vector);
+            //     break;
+        }
+        if (this._space === ParticleSystemSimulationSpace.World) {
+            this._vector.applyMatrix4(this._worldSpacePosition);
+        }
+    }
+
+
+
+    private _dir: Vector3 = new Vector3();
+    getDirection(position): Vector3 {
+        switch (this.shapeType) {
+            case ParticleSystemShapeType.Box:
+                return this._dir.set(0, 0, 1);
+            case ParticleSystemShapeType.Sphere:
+                const rx = position.x;
+                const ry = position.y;
+                const rz = position.z;
+                return this._dir.set(rx, ry, rz).normalize();
+        }
+        return this._dir.set(0, 1, 0);
+    }
 }
 
 
-/// <summary>
-///   <para>The emission shape.</para>
-/// </summary>
-export enum ParticleSystemShapeType {
-    /// <summary>
-    ///   <para>Emit from a sphere.</para>
-    /// </summary>
-    Sphere = 0,
-    /// <summary>
-    ///   <para>Emit from the surface of a sphere.</para>
-    /// </summary>
-    // [Obsolete("SphereShell is deprecated and does nothing. Please use ShapeModule.radiusThickness instead, to control edge emission.", false)] SphereShell,
-    SphereShell,
-    /// <summary>
-    ///   <para>Emit from a half-sphere.</para>
-    /// </summary>
-    Hemisphere,
-    // / <summary>
-    // /   <para>Emit from the surface of a half-sphere.</para>
-    // / </summary>
-    // [Obsolete("HemisphereShell is deprecated and does nothing. Please use ShapeModule.radiusThickness instead, to control edge emission.", false)] HemisphereShell,
-    HemisphereShell,
-    /// <summary>
-    ///   <para>Emit from the base of a cone.</para>
-    /// </summary>
-    Cone,
-    /// <summary>
-    ///   <para>Emit from the volume of a box.</para>
-    /// </summary>
-    Box = 5,
-    /// <summary>
-    ///   <para>Emit from a mesh.</para>
-    /// </summary>
-    Mesh,
-    /// <summary>
-    ///   <para>Emit from the base surface of a cone.</para>
-    /// </summary>
-    // [Obsolete("ConeShell is deprecated and does nothing. Please use ShapeModule.radiusThickness instead, to control edge emission.", false)] ConeShell,
-    // /// <summary>
-    // ///   <para>Emit from a cone.</para>
-    // /// </summary>
-    ConeVolume,
-    /// <summary>
-    ///   <para>Emit from the surface of a cone.</para>
-    /// </summary>
-    // [Obsolete("ConeVolumeShell is deprecated and does nothing. Please use ShapeModule.radiusThickness instead, to control edge emission.", false)] ConeVolumeShell,
-    // /// <summary>
-    // ///   <para>Emit from a circle.</para>
-    // /// </summary>
-    Circle = 10,
-    /// <summary>
-    ///   <para>Emit from the edge of a circle.</para>
-    /// </summary>
-    // [Obsolete("CircleEdge is deprecated and does nothing. Please use ShapeModule.radiusThickness instead, to control edge emission.", false)] CircleEdge,
-    // /// <summary>
-    // ///   <para>Emit from an edge.</para>
-    // /// </summary>
-    SingleSidedEdge,
-    /// <summary>
-    ///   <para>Emit from a mesh renderer.</para>
-    /// </summary>
-    MeshRenderer,
-    /// <summary>
-    ///   <para>Emit from a skinned mesh renderer.</para>
-    /// </summary>
-    SkinnedMeshRenderer,
-    /// <summary>
-    ///   <para>Emit from the surface of a box.</para>
-    /// </summary>
-    BoxShell,
-    /// <summary>
-    ///   <para>Emit from the edges of a box.</para>
-    /// </summary>
-    BoxEdge,
-    /// <summary>
-    ///   <para>Emit from a Donut.</para>
-    /// </summary>
-    Donut,
-    /// <summary>
-    ///   <para>Emit from a rectangle.</para>
-    /// </summary>
-    Rectangle,
-    /// <summary>
-    ///   <para>Emit from a sprite.</para>
-    /// </summary>
-    Sprite,
-    /// <summary>
-    ///   <para>Emit from a sprite renderer.</para>
-    /// </summary>
-    SpriteRenderer,
+
+function randomSpherePoint(x0: number, y0: number, z0: number, radius: number, thickness: number, arc: number, vec: Vec3) {
+    const u = Math.random();
+    const v = Math.random();
+    const theta = 2 * Math.PI * u * (arc / 360);
+    const phi = Math.acos(2 * v - 1);
+
+    const r = Mathf.lerp(1, 1 - (Math.pow(1 - Math.random(), Math.PI)), thickness) * radius;
+    const x = x0 + (-r * Math.sin(phi) * Math.cos(theta));
+    const y = y0 + (r * Math.sin(phi) * Math.sin(theta));
+    const z = z0 + (r * Math.cos(phi));
+    vec.x = x;
+    vec.y = y;
+    vec.z = z;
+}
+
+
+import { createNoise4D, NoiseFunction4D } from 'simplex-noise';
+import { Context } from "../engine/engine_setup";
+
+export class NoiseModule {
+    @serializeable()
+    damping!: boolean;
+    @serializeable()
+    enabled!: boolean;
+    @serializeable()
+    frequency!: number;
+    @serializeable()
+    octaveCount!: number;
+    @serializeable()
+    octaveMultiplier!: number;
+    @serializeable()
+    octaveScale!: number;
+    @serializeable(MinMaxCurve)
+    positionAmount!: MinMaxCurve;
+    @serializeable()
+    quality!: number;
+
+    @serializeable(MinMaxCurve)
+    remap!: MinMaxCurve;
+    @serializeable()
+    remapEnabled!: boolean;
+    @serializeable()
+    remapMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    remapX!: MinMaxCurve;
+    @serializeable()
+    remapXMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    remapY!: MinMaxCurve;
+    @serializeable()
+    remapYMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    remapZ!: MinMaxCurve;
+    @serializeable()
+    remapZMultiplier!: number;
+
+    @serializeable()
+    scrollSpeedMultiplier!: number;
+    @serializeable()
+    separateAxes!: boolean;
+    @serializeable()
+    strengthMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    strengthX!: MinMaxCurve;
+    @serializeable()
+    strengthXMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    strengthY!: MinMaxCurve;
+    @serializeable()
+    strengthYMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    strengthZ!: MinMaxCurve;
+    @serializeable()
+    strengthZMultiplier!: number;
+
+
+    private _noise?: NoiseFunction4D;
+    private _time: number = 0;
+
+    update(context: Context) {
+        this._time += context.time.deltaTime * this.scrollSpeedMultiplier;
+    }
+
+    /** nebula implementations: */
+    private _temp: Vector3 = new Vector3();
+    applyNoise(index: number, pos: Vec3, vel: Vec3, deltaTime: number, age: number, life: number) {
+        if (!this.enabled) return;
+        if (!this._noise) {
+            this._noise = createNoise4D(() => 0);
+        }
+        const t = age / life;
+        const dt = Context.Current.time.deltaTime;
+        const temp = this._temp.set(pos.x, pos.y, pos.z).multiplyScalar(this.frequency);
+        const nx = this._noise(temp.x, temp.y, temp.z, this._time);
+        const ny = this._noise(temp.x, temp.y, temp.z, this._time + .2);
+        const nz = this._noise(temp.x, temp.y, temp.z, this._time + .5);
+        this._temp.set(nx, ny, nz).normalize();
+
+        let strengthFactor = this.positionAmount.evaluate(t);
+        if (!this.separateAxes) {
+            if (this.strengthX)
+                strengthFactor *= this.strengthX.evaluate(t, index * 1.1);
+            else strengthFactor *= this.strengthMultiplier;
+            strengthFactor *= deltaTime;
+            this._temp.multiplyScalar(strengthFactor);
+        }
+        if (this.separateAxes) {
+            this._temp.x *= strengthFactor * deltaTime * this.strengthXMultiplier
+            this._temp.y *= strengthFactor * deltaTime * this.strengthYMultiplier;
+            this._temp.z *= strengthFactor * deltaTime * this.strengthZMultiplier;
+        }
+        vel.x += this._temp.x;
+        vel.y += this._temp.y;
+        vel.z += this._temp.z;
+    }
 }