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

package/lib/engine-components/ParticleSystemModules.js

@@ -1,61 +1,470 @@
-import * as THREE from "three";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Matrix4, 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";
+export var ParticleSystemRenderMode;
+(function (ParticleSystemRenderMode) {
+    ParticleSystemRenderMode[ParticleSystemRenderMode["Billboard"] = 0] = "Billboard";
+    //   Stretch = 1,
+    //   HorizontalBillboard = 2,
+    //   VerticalBillboard = 3,
+    ParticleSystemRenderMode[ParticleSystemRenderMode["Mesh"] = 4] = "Mesh";
+    //   None = 5,
+})(ParticleSystemRenderMode || (ParticleSystemRenderMode = {}));
+export class Gradient {
+    alphaKeys;
+    colorKeys;
+    get duration() {
+        return 1;
+    }
+    evaluate(time, target) {
+        // 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 = undefined;
+        let closestAlphaIndex = 0;
+        let closestColor = 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;
+    }
+}
+__decorate([
+    serializeable()
+], Gradient.prototype, "alphaKeys", void 0);
+__decorate([
+    serializeable()
+], Gradient.prototype, "colorKeys", void 0);
+export var ParticleSystemCurveMode;
+(function (ParticleSystemCurveMode) {
+    ParticleSystemCurveMode[ParticleSystemCurveMode["Constant"] = 0] = "Constant";
+    ParticleSystemCurveMode[ParticleSystemCurveMode["Curve"] = 1] = "Curve";
+    ParticleSystemCurveMode[ParticleSystemCurveMode["TwoCurves"] = 2] = "TwoCurves";
+    ParticleSystemCurveMode[ParticleSystemCurveMode["TwoConstants"] = 3] = "TwoConstants";
+})(ParticleSystemCurveMode || (ParticleSystemCurveMode = {}));
+export var ParticleSystemGradientMode;
+(function (ParticleSystemGradientMode) {
+    ParticleSystemGradientMode[ParticleSystemGradientMode["Color"] = 0] = "Color";
+    ParticleSystemGradientMode[ParticleSystemGradientMode["Gradient"] = 1] = "Gradient";
+    ParticleSystemGradientMode[ParticleSystemGradientMode["TwoColors"] = 2] = "TwoColors";
+    ParticleSystemGradientMode[ParticleSystemGradientMode["TwoGradients"] = 3] = "TwoGradients";
+    ParticleSystemGradientMode[ParticleSystemGradientMode["RandomColor"] = 4] = "RandomColor";
+})(ParticleSystemGradientMode || (ParticleSystemGradientMode = {}));
+export var ParticleSystemSimulationSpace;
+(function (ParticleSystemSimulationSpace) {
+    ParticleSystemSimulationSpace[ParticleSystemSimulationSpace["Local"] = 0] = "Local";
+    ParticleSystemSimulationSpace[ParticleSystemSimulationSpace["World"] = 1] = "World";
+    ParticleSystemSimulationSpace[ParticleSystemSimulationSpace["Custom"] = 2] = "Custom";
+})(ParticleSystemSimulationSpace || (ParticleSystemSimulationSpace = {}));
+export var ParticleSystemShapeType;
+(function (ParticleSystemShapeType) {
+    ParticleSystemShapeType[ParticleSystemShapeType["Sphere"] = 0] = "Sphere";
+    ParticleSystemShapeType[ParticleSystemShapeType["SphereShell"] = 1] = "SphereShell";
+    ParticleSystemShapeType[ParticleSystemShapeType["Hemisphere"] = 2] = "Hemisphere";
+    ParticleSystemShapeType[ParticleSystemShapeType["HemisphereShell"] = 3] = "HemisphereShell";
+    ParticleSystemShapeType[ParticleSystemShapeType["Cone"] = 4] = "Cone";
+    ParticleSystemShapeType[ParticleSystemShapeType["Box"] = 5] = "Box";
+    ParticleSystemShapeType[ParticleSystemShapeType["Mesh"] = 6] = "Mesh";
+    ParticleSystemShapeType[ParticleSystemShapeType["ConeShell"] = 7] = "ConeShell";
+    ParticleSystemShapeType[ParticleSystemShapeType["ConeVolume"] = 8] = "ConeVolume";
+    ParticleSystemShapeType[ParticleSystemShapeType["ConeVolumeShell"] = 9] = "ConeVolumeShell";
+    ParticleSystemShapeType[ParticleSystemShapeType["Circle"] = 10] = "Circle";
+    ParticleSystemShapeType[ParticleSystemShapeType["CircleEdge"] = 11] = "CircleEdge";
+    ParticleSystemShapeType[ParticleSystemShapeType["SingleSidedEdge"] = 12] = "SingleSidedEdge";
+    ParticleSystemShapeType[ParticleSystemShapeType["MeshRenderer"] = 13] = "MeshRenderer";
+    ParticleSystemShapeType[ParticleSystemShapeType["SkinnedMeshRenderer"] = 14] = "SkinnedMeshRenderer";
+    ParticleSystemShapeType[ParticleSystemShapeType["BoxShell"] = 15] = "BoxShell";
+    ParticleSystemShapeType[ParticleSystemShapeType["BoxEdge"] = 16] = "BoxEdge";
+    ParticleSystemShapeType[ParticleSystemShapeType["Donut"] = 17] = "Donut";
+    ParticleSystemShapeType[ParticleSystemShapeType["Rectangle"] = 18] = "Rectangle";
+    ParticleSystemShapeType[ParticleSystemShapeType["Sprite"] = 19] = "Sprite";
+    ParticleSystemShapeType[ParticleSystemShapeType["SpriteRenderer"] = 20] = "SpriteRenderer";
+})(ParticleSystemShapeType || (ParticleSystemShapeType = {}));
+export class MinMaxCurve {
+    mode;
+    constant;
+    constantMin;
+    constantMax;
+    curve;
+    curveMin;
+    curveMax;
+    curveMultiplier;
+    evaluate(t01, lerpFactor) {
+        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;
+    }
+}
+__decorate([
+    serializeable()
+], MinMaxCurve.prototype, "mode", void 0);
+__decorate([
+    serializeable()
+], MinMaxCurve.prototype, "constant", void 0);
+__decorate([
+    serializeable()
+], MinMaxCurve.prototype, "constantMin", void 0);
+__decorate([
+    serializeable()
+], MinMaxCurve.prototype, "constantMax", void 0);
+__decorate([
+    serializeable(AnimationCurve)
+], MinMaxCurve.prototype, "curve", void 0);
+__decorate([
+    serializeable(AnimationCurve)
+], MinMaxCurve.prototype, "curveMin", void 0);
+__decorate([
+    serializeable(AnimationCurve)
+], MinMaxCurve.prototype, "curveMax", void 0);
+__decorate([
+    serializeable()
+], MinMaxCurve.prototype, "curveMultiplier", void 0);
+export class MinMaxGradient {
+    mode;
+    color;
+    colorMin;
+    colorMax;
+    gradient;
+    gradientMin;
+    gradientMax;
+    static _temp = new RGBAColor(0, 0, 0, 1);
+    static _temp2 = new RGBAColor(0, 0, 0, 1);
+    evaluate(t01, lerpFactor) {
+        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;
+    }
+}
+__decorate([
+    serializeable(RGBAColor)
+], MinMaxGradient.prototype, "color", void 0);
+__decorate([
+    serializeable(RGBAColor)
+], MinMaxGradient.prototype, "colorMin", void 0);
+__decorate([
+    serializeable(RGBAColor)
+], MinMaxGradient.prototype, "colorMax", void 0);
+__decorate([
+    serializeable(Gradient)
+], MinMaxGradient.prototype, "gradient", void 0);
+__decorate([
+    serializeable(Gradient)
+], MinMaxGradient.prototype, "gradientMin", void 0);
+__decorate([
+    serializeable(Gradient)
+], MinMaxGradient.prototype, "gradientMax", void 0);
 export class MainModule {
-    randomizeRotationDirection = 0;
-    duration = 5;
-    loop = true;
-    prewarm = false;
-    startDelay = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startDelayMultiplier = 0;
-    startLifetime = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startLifetimeMultiplier = 5;
-    startSpeed = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startSpeedMultiplier = 5;
-    startSize3D = false;
-    startSize = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startSizeMultiplier = 1;
-    startSizeX = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startSizeXMultiplier = 1;
-    startSizeY = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startSizeYMultiplier = 1;
-    startSizeZ = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startSizeZMultiplier = 1;
-    startRotation3D = false;
-    startRotation = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startRotationMultiplier = 0;
-    startRotationX = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startRotationXMultiplier = 0;
-    startRotationY = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startRotationYMultiplier = 0;
-    startRotationZ = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    startRotationZMultiplier = 0;
-    flipRotation = 0;
-    startColor = new THREE.Color(1, 1, 1);
-    startColor1 = new THREE.Color(0, 0, 0); // this only exists in gradient mode
-    gravityModifier = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
-    gravityModifierMultiplier = 0;
-    simulationSpace = 0;
-    customSimulationSpace = null;
-    simulationSpeed = 1;
-    useUnscaledTime = false;
-    scalingMode = 1;
-    playOnAwake = true;
-    maxParticles = 1000;
-    emitterVelocityMode = 1;
-    stopAction = 0;
-    ringBufferMode = 0;
-    ringBufferLoopRange = new THREE.Vector2(0, 1);
-    cullingMode = 0;
+    cullingMode;
+    duration;
+    emitterVelocityMode;
+    flipRotation;
+    gravityModifier;
+    gravityModifierMultiplier;
+    loop;
+    maxParticles;
+    playOnAwake;
+    prewarm;
+    ringBufferLoopRange;
+    ringBufferMode;
+    scalingMode;
+    simulationSpace;
+    simulationSpeed;
+    startColor;
+    startDelay;
+    startDelayMultiplier;
+    startLifetime;
+    startLifetimeMultiplier;
+    startRotation;
+    startRotationMultiplier;
+    startRotation3D;
+    startRotationX;
+    startRotationXMultiplier;
+    startRotationY;
+    startRotationYMultiplier;
+    startRotationZ;
+    startRotationZMultiplier;
+    startSize;
+    startSize3D;
+    startSizeMultiplier;
+    startSizeX;
+    startSizeXMultiplier;
+    startSizeY;
+    startSizeYMultiplier;
+    startSizeZ;
+    startSizeZMultiplier;
+    startSpeed;
+    startSpeedMultiplier;
+    stopAction;
+    useUnscaledTime;
+}
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "gravityModifier", void 0);
+__decorate([
+    serializeable(MinMaxGradient)
+], MainModule.prototype, "startColor", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "startDelay", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "startLifetime", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "startRotation", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "startRotationX", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "startRotationY", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "startRotationZ", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "startSize", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "startSizeX", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "startSizeY", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "startSizeZ", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], MainModule.prototype, "startSpeed", void 0);
+export class ParticleBurst {
+    cycleCount;
+    maxCount;
+    minCount;
+    probability;
+    repeatInterval;
+    time;
+    count;
+    _performed = 0;
+    reset() {
+        this._performed = 0;
+    }
+    run(time) {
+        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 = 0;
-    enabled = true;
-    rate = 10;
-    rateMutliplier = 1;
-    rateOverDistance = 0;
-    rateOverDistanceMultiplier = 0;
-    rateOverTime = 0;
-    rateOverTimeMultiplier = 0;
+    enabled;
+    get burstCount() {
+        return this.bursts?.length ?? 0;
+    }
+    bursts;
+    rateOverTime;
+    rateOverTimeMultiplier;
+    rateOverDistance;
+    rateOverDistanceMultiplier;
+    /** set from system */
+    system;
+    get time() { return this.system.time; }
+    _summed = 0;
+    // private _didEmit: boolean = false;
+    /** called by nebula */
+    init() {
+    }
+    /** called by nebula */
+    getValue(deltaTime) {
+        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);
+    }
 }
+__decorate([
+    serializeable()
+], EmissionModule.prototype, "enabled", void 0);
+__decorate([
+    serializeable()
+], EmissionModule.prototype, "bursts", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], EmissionModule.prototype, "rateOverTime", void 0);
+__decorate([
+    serializeable()
+], EmissionModule.prototype, "rateOverTimeMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], EmissionModule.prototype, "rateOverDistance", void 0);
+__decorate([
+    serializeable()
+], EmissionModule.prototype, "rateOverDistanceMultiplier", void 0);
+export class ColorOverLifetimeModule {
+    enabled;
+    color;
+}
+__decorate([
+    serializeable(MinMaxGradient)
+], ColorOverLifetimeModule.prototype, "color", void 0);
+export class SizeOverLifetimeModule {
+    enabled;
+    separateAxes;
+    size;
+    sizeMultiplier;
+    sizeX;
+    sizeXMultiplier;
+    sizeY;
+    sizeYMultiplier;
+    sizeZ;
+    sizeZMultiplier;
+    _time = 0;
+    evaluate(t01, target) {
+        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;
+    }
+}
+__decorate([
+    serializeable(MinMaxCurve)
+], SizeOverLifetimeModule.prototype, "size", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], SizeOverLifetimeModule.prototype, "sizeX", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], SizeOverLifetimeModule.prototype, "sizeY", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], SizeOverLifetimeModule.prototype, "sizeZ", void 0);
 export class ShapeModule {
     shapeType = ParticleSystemShapeType.Box;
     enabled = true;
@@ -64,104 +473,264 @@ export class ShapeModule {
     arc = 360;
     arcmode = 0; // TODO: enum?
     // arcSpeed, arcSpeedMult, arcSpread
-    box = new THREE.Vector3(1, 1, 1);
-    boxThickness = new THREE.Vector3(0, 0, 0);
-    position = new THREE.Vector3(0, 0, 0);
-    rotation = new THREE.Vector3(0, 0, 0);
-    scale = new THREE.Vector3(1, 1, 1);
-    radius = 1;
-    sphericalDirectionAmount = 0;
+    // @serializeable(Vector3)
+    // box!: Vector3;
+    boxThickness;
+    position;
+    rotation;
+    scale;
+    radius;
+    radiusThickness;
+    sphericalDirectionAmount;
+    _space;
+    _worldSpacePosition = new Matrix4();
+    update(_context, simulationSpace, obj) {
+        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;
+        }
+    }
+    /** nebula implementations: */
+    /** initializer implementation */
+    _vector = new Vector3(0, 0, 0);
+    _temp = new Vector3(0, 0, 0);
+    /** called by nebula on initialize */
+    get vector() {
+        return this._vector;
+    }
+    /** called by nebula */
+    getPosition() {
+        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);
+        }
+    }
+    _dir = new Vector3();
+    getDirection(position) {
+        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 var ParticleSystemShapeType;
-(function (ParticleSystemShapeType) {
-    /// <summary>
-    ///   <para>Emit from a sphere.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["Sphere"] = 0] = "Sphere";
-    /// <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,
-    ParticleSystemShapeType[ParticleSystemShapeType["SphereShell"] = 1] = "SphereShell";
-    /// <summary>
-    ///   <para>Emit from a half-sphere.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["Hemisphere"] = 2] = "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,
-    ParticleSystemShapeType[ParticleSystemShapeType["HemisphereShell"] = 3] = "HemisphereShell";
-    /// <summary>
-    ///   <para>Emit from the base of a cone.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["Cone"] = 4] = "Cone";
-    /// <summary>
-    ///   <para>Emit from the volume of a box.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["Box"] = 5] = "Box";
-    /// <summary>
-    ///   <para>Emit from a mesh.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["Mesh"] = 6] = "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>
-    ParticleSystemShapeType[ParticleSystemShapeType["ConeVolume"] = 7] = "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>
-    ParticleSystemShapeType[ParticleSystemShapeType["Circle"] = 10] = "Circle";
-    /// <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>
-    ParticleSystemShapeType[ParticleSystemShapeType["SingleSidedEdge"] = 11] = "SingleSidedEdge";
-    /// <summary>
-    ///   <para>Emit from a mesh renderer.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["MeshRenderer"] = 12] = "MeshRenderer";
-    /// <summary>
-    ///   <para>Emit from a skinned mesh renderer.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["SkinnedMeshRenderer"] = 13] = "SkinnedMeshRenderer";
-    /// <summary>
-    ///   <para>Emit from the surface of a box.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["BoxShell"] = 14] = "BoxShell";
-    /// <summary>
-    ///   <para>Emit from the edges of a box.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["BoxEdge"] = 15] = "BoxEdge";
-    /// <summary>
-    ///   <para>Emit from a Donut.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["Donut"] = 16] = "Donut";
-    /// <summary>
-    ///   <para>Emit from a rectangle.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["Rectangle"] = 17] = "Rectangle";
-    /// <summary>
-    ///   <para>Emit from a sprite.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["Sprite"] = 18] = "Sprite";
-    /// <summary>
-    ///   <para>Emit from a sprite renderer.</para>
-    /// </summary>
-    ParticleSystemShapeType[ParticleSystemShapeType["SpriteRenderer"] = 19] = "SpriteRenderer";
-})(ParticleSystemShapeType || (ParticleSystemShapeType = {}));
+__decorate([
+    serializeable()
+], ShapeModule.prototype, "shapeType", void 0);
+__decorate([
+    serializeable()
+], ShapeModule.prototype, "enabled", void 0);
+__decorate([
+    serializeable()
+], ShapeModule.prototype, "alignToDirection", void 0);
+__decorate([
+    serializeable()
+], ShapeModule.prototype, "angle", void 0);
+__decorate([
+    serializeable()
+], ShapeModule.prototype, "arc", void 0);
+__decorate([
+    serializeable()
+], ShapeModule.prototype, "arcmode", void 0);
+__decorate([
+    serializeable(Vector3)
+], ShapeModule.prototype, "boxThickness", void 0);
+__decorate([
+    serializeable(Vector3)
+], ShapeModule.prototype, "position", void 0);
+__decorate([
+    serializeable(Vector3)
+], ShapeModule.prototype, "rotation", void 0);
+__decorate([
+    serializeable(Vector3)
+], ShapeModule.prototype, "scale", void 0);
+__decorate([
+    serializeable()
+], ShapeModule.prototype, "radius", void 0);
+__decorate([
+    serializeable()
+], ShapeModule.prototype, "radiusThickness", void 0);
+__decorate([
+    serializeable()
+], ShapeModule.prototype, "sphericalDirectionAmount", void 0);
+function randomSpherePoint(x0, y0, z0, radius, thickness, arc, vec) {
+    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 } from 'simplex-noise';
+import { Context } from "../engine/engine_setup";
+export class NoiseModule {
+    damping;
+    enabled;
+    frequency;
+    octaveCount;
+    octaveMultiplier;
+    octaveScale;
+    positionAmount;
+    quality;
+    remap;
+    remapEnabled;
+    remapMultiplier;
+    remapX;
+    remapXMultiplier;
+    remapY;
+    remapYMultiplier;
+    remapZ;
+    remapZMultiplier;
+    scrollSpeedMultiplier;
+    separateAxes;
+    strengthMultiplier;
+    strengthX;
+    strengthXMultiplier;
+    strengthY;
+    strengthYMultiplier;
+    strengthZ;
+    strengthZMultiplier;
+    _noise;
+    _time = 0;
+    update(context) {
+        this._time += context.time.deltaTime * this.scrollSpeedMultiplier;
+    }
+    /** nebula implementations: */
+    _temp = new Vector3();
+    applyNoise(index, pos, vel, deltaTime, age, life) {
+        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;
+    }
+}
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "damping", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "enabled", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "frequency", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "octaveCount", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "octaveMultiplier", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "octaveScale", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], NoiseModule.prototype, "positionAmount", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "quality", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], NoiseModule.prototype, "remap", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "remapEnabled", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "remapMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], NoiseModule.prototype, "remapX", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "remapXMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], NoiseModule.prototype, "remapY", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "remapYMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], NoiseModule.prototype, "remapZ", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "remapZMultiplier", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "scrollSpeedMultiplier", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "separateAxes", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "strengthMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], NoiseModule.prototype, "strengthX", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "strengthXMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], NoiseModule.prototype, "strengthY", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "strengthYMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], NoiseModule.prototype, "strengthZ", void 0);
+__decorate([
+    serializeable()
+], NoiseModule.prototype, "strengthZMultiplier", void 0);
 //# sourceMappingURL=ParticleSystemModules.js.map