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

package/lib/engine-components/ParticleSystemModules.js

@@ -143,12 +143,12 @@ export class MinMaxCurve {
             case ParticleSystemCurveMode.Constant:
                 return this.constant;
             case ParticleSystemCurveMode.Curve:
-                t01 %= this.curve.duration;
-                return this.curve.evaluate(t01);
+                t01 = Mathf.clamp01(t01);
+                return this.curve.evaluate(t01) * this.curveMultiplier;
             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);
+                return Mathf.lerp(this.curveMin.evaluate(t1), this.curveMax.evaluate(t2), t % 1) * this.curveMultiplier;
             case ParticleSystemCurveMode.TwoConstants:
                 return Mathf.lerp(this.constantMin, this.constantMax, t % 1);
             default:
@@ -201,7 +201,8 @@ export class MinMaxGradient {
                 this.gradient.evaluate(t01, MinMaxGradient._temp);
                 return MinMaxGradient._temp;
             case ParticleSystemGradientMode.TwoColors:
-                return MinMaxGradient._temp.lerpColors(this.colorMin, this.colorMax, t);
+                const col1 = MinMaxGradient._temp.lerpColors(this.colorMin, this.colorMax, t);
+                return col1;
             case ParticleSystemGradientMode.TwoGradients:
                 const t2 = Math.random();
                 this.gradientMin.evaluate(t2, MinMaxGradient._temp);
@@ -371,34 +372,21 @@ export class EmissionModule {
     rateOverDistanceMultiplier;
     /** set from system */
     system;
-    get time() { return this.system.time; }
-    _summed = 0;
-    // private _didEmit: boolean = false;
-    /** called by nebula */
-    init() {
+    reset() {
+        this.bursts?.forEach(b => b.reset());
     }
-    /** 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;
+    getBurst() {
+        let amount = 0;
         if (this.burstCount > 0) {
             for (let i = 0; i < this.burstCount; i++) {
                 const burst = this.bursts[i];
-                if (burst.time >= this.time) {
+                if (burst.time >= this.system.time) {
                     burst.reset();
-                    continue;
                 }
-                amount += Math.round(burst.run(this.time));
+                amount += Math.round(burst.run(this.system.time));
             }
         }
-        // dont emit more than we are allowed to
-        return amount; //Mathf.clamp(amount, 0, this.system.maxParticles - this.system.currentParticles);
+        return amount;
     }
 }
 __decorate([
@@ -431,14 +419,21 @@ export class SizeOverLifetimeModule {
     separateAxes;
     size;
     sizeMultiplier;
-    sizeX;
-    sizeXMultiplier;
-    sizeY;
-    sizeYMultiplier;
-    sizeZ;
-    sizeZMultiplier;
+    x;
+    xMultiplier;
+    y;
+    yMultiplier;
+    z;
+    zMultiplier;
     _time = 0;
+    _temp = new Vector3();
     evaluate(t01, target) {
+        if (!target)
+            target = this._temp;
+        if (!this.enabled) {
+            target.x = target.y = target.z = 1;
+            return target;
+        }
         if (!this.separateAxes) {
             const scale = this.size.evaluate(t01) * this.sizeMultiplier;
             target.x = scale;
@@ -446,9 +441,9 @@ export class SizeOverLifetimeModule {
             // 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;
+            target.x = this.x.evaluate(t01) * this.xMultiplier;
+            target.y = this.y.evaluate(t01) * this.yMultiplier;
+            target.z = this.z.evaluate(t01) * this.zMultiplier;
         }
         return target;
     }
@@ -458,14 +453,27 @@ __decorate([
 ], SizeOverLifetimeModule.prototype, "size", void 0);
 __decorate([
     serializeable(MinMaxCurve)
-], SizeOverLifetimeModule.prototype, "sizeX", void 0);
+], SizeOverLifetimeModule.prototype, "x", void 0);
 __decorate([
     serializeable(MinMaxCurve)
-], SizeOverLifetimeModule.prototype, "sizeY", void 0);
+], SizeOverLifetimeModule.prototype, "y", void 0);
 __decorate([
     serializeable(MinMaxCurve)
-], SizeOverLifetimeModule.prototype, "sizeZ", void 0);
+], SizeOverLifetimeModule.prototype, "z", void 0);
 export class ShapeModule {
+    get type() {
+        return ParticleSystemShapeType[this.shapeType];
+    }
+    initialize(particle) {
+        this.getPosition();
+        particle.position.copy(this._vector);
+    }
+    toJSON() {
+        return this;
+    }
+    clone() {
+        return new ShapeModule();
+    }
     shapeType = ParticleSystemShapeType.Box;
     enabled = true;
     alignToDirection = false;
@@ -482,16 +490,20 @@ export class ShapeModule {
     radius;
     radiusThickness;
     sphericalDirectionAmount;
+    system;
     _space;
-    _worldSpacePosition = new Matrix4();
-    update(_context, simulationSpace, obj) {
+    _worldSpaceMatrix = new Matrix4();
+    _worldSpaceMatrixInverse = new Matrix4();
+    update(system, _context, simulationSpace, obj) {
+        this.system = system;
         this._space = simulationSpace;
         if (simulationSpace === ParticleSystemSimulationSpace.World) {
-            this._worldSpacePosition.copy(obj.matrixWorld);
+            this._worldSpaceMatrix.copy(obj.matrixWorld);
             // set scale to 1
-            this._worldSpacePosition.elements[0] = 1;
-            this._worldSpacePosition.elements[5] = 1;
-            this._worldSpacePosition.elements[10] = 1;
+            this._worldSpaceMatrix.elements[0] = 1;
+            this._worldSpaceMatrix.elements[5] = 1;
+            this._worldSpaceMatrix.elements[10] = 1;
+            this._worldSpaceMatrixInverse.copy(this._worldSpaceMatrix).invert();
         }
     }
     /** nebula implementations: */
@@ -502,7 +514,6 @@ export class ShapeModule {
     get vector() {
         return this._vector;
     }
-    /** called by nebula */
     getPosition() {
         switch (this.shapeType) {
             case ParticleSystemShapeType.Box:
@@ -511,28 +522,42 @@ export class ShapeModule {
                 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);
+                randomSpherePoint(this.position.x, this.position.y, this.position.z, this.radius * this.system.worldScale.x, this.radiusThickness, this.arc, this._vector);
+                // this._vector.y += 1;
+                break;
+            default:
+                this._vector.set(0, 0, 0);
                 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);
+            this._vector.applyMatrix4(this._worldSpaceMatrix);
         }
     }
     _dir = new Vector3();
     getDirection(position) {
         switch (this.shapeType) {
             case ParticleSystemShapeType.Box:
-                return this._dir.set(0, 0, 1);
+                this._dir.set(0, 0, 1);
+                break;
             case ParticleSystemShapeType.Sphere:
                 const rx = position.x;
                 const ry = position.y;
                 const rz = position.z;
-                return this._dir.set(rx, ry, rz).normalize();
+                this._dir.set(rx, ry, rz);
+                break;
+            default:
+                this._dir.set(0, 0, 1);
+                break;
         }
-        return this._dir.set(0, 1, 0);
+        if (this._space === ParticleSystemSimulationSpace.World) {
+            this._dir.applyMatrix4(this._worldSpaceMatrixInverse);
+        }
+        this._dir.normalize();
+        // Gizmos.DrawDirection(position, this._dir, 0xff0000, .5);
+        return this._dir;
     }
 }
 __decorate([
@@ -588,7 +613,6 @@ function randomSpherePoint(x0, y0, z0, radius, thickness, arc, vec) {
     vec.z = z;
 }
 import { createNoise4D } from 'simplex-noise';
-import { Context } from "../engine/engine_setup";
 export class NoiseModule {
     damping;
     enabled;
@@ -623,33 +647,33 @@ export class NoiseModule {
     }
     /** nebula implementations: */
     _temp = new Vector3();
-    applyNoise(index, pos, vel, deltaTime, age, life) {
+    apply(_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);
+        const ny = this._noise(temp.x, temp.y, temp.z, this._time + .3);
+        const nz = this._noise(temp.x, temp.y, temp.z, this._time + 1);
         this._temp.set(nx, ny, nz).normalize();
+        const t = age / life;
         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;
+            if (this.strengthX) {
+                strengthFactor *= this.strengthX.evaluate(t) * Math.PI;
+            }
+            // 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;
+        else {
+            this._temp.x *= strengthFactor * this.strengthXMultiplier;
+            this._temp.y *= strengthFactor * this.strengthYMultiplier;
+            this._temp.z *= strengthFactor * this.strengthZMultiplier;
         }
+        // this._temp.setLength(strengthFactor * deltaTime);
         vel.x += this._temp.x;
         vel.y += this._temp.y;
         vel.z += this._temp.z;
@@ -733,4 +757,378 @@ __decorate([
 __decorate([
     serializeable()
 ], NoiseModule.prototype, "strengthZMultiplier", void 0);
+export class TrailModule {
+    enabled;
+}
+__decorate([
+    serializeable()
+], TrailModule.prototype, "enabled", void 0);
+export class VelocityOverLifetimeModule {
+    enabled;
+    /* orbital settings */
+    space = ParticleSystemSimulationSpace.Local;
+    speedModifier;
+    speedModifierMultiplier;
+    x;
+    xMultiplier;
+    y;
+    yMultiplier;
+    z;
+    zMultiplier;
+    _system;
+    // private _worldRotation: Quaternion = new Quaternion();
+    update(system) {
+        this._system = system;
+    }
+    _temp = new Vector3();
+    apply(_index, _pos, vel, _dt, age, life) {
+        if (!this.enabled)
+            return;
+        const t = age / life;
+        const speed = this.speedModifier.evaluate(t) * this.speedModifierMultiplier;
+        const x = this.x.evaluate(t) * speed;
+        const y = this.y.evaluate(t) * speed;
+        const z = this.z.evaluate(t) * speed;
+        this._temp.set(-x, y, z);
+        if (this._system) {
+            if (this.space === ParticleSystemSimulationSpace.World) {
+                this._temp.applyQuaternion(this._system.worldQuaternionInverted);
+            }
+            if (this._system.main.simulationSpace === ParticleSystemSimulationSpace.World) {
+                this._temp.applyQuaternion(this._system.worldQuaternion);
+            }
+        }
+        vel.x += this._temp.x;
+        vel.y += this._temp.y;
+        vel.z += this._temp.z;
+    }
+}
+__decorate([
+    serializeable()
+], VelocityOverLifetimeModule.prototype, "enabled", void 0);
+__decorate([
+    serializeable()
+], VelocityOverLifetimeModule.prototype, "space", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], VelocityOverLifetimeModule.prototype, "speedModifier", void 0);
+__decorate([
+    serializeable()
+], VelocityOverLifetimeModule.prototype, "speedModifierMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], VelocityOverLifetimeModule.prototype, "x", void 0);
+__decorate([
+    serializeable()
+], VelocityOverLifetimeModule.prototype, "xMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], VelocityOverLifetimeModule.prototype, "y", void 0);
+__decorate([
+    serializeable()
+], VelocityOverLifetimeModule.prototype, "yMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], VelocityOverLifetimeModule.prototype, "z", void 0);
+__decorate([
+    serializeable()
+], VelocityOverLifetimeModule.prototype, "zMultiplier", void 0);
+var ParticleSystemAnimationTimeMode;
+(function (ParticleSystemAnimationTimeMode) {
+    ParticleSystemAnimationTimeMode[ParticleSystemAnimationTimeMode["Lifetime"] = 0] = "Lifetime";
+    ParticleSystemAnimationTimeMode[ParticleSystemAnimationTimeMode["Speed"] = 1] = "Speed";
+    ParticleSystemAnimationTimeMode[ParticleSystemAnimationTimeMode["FPS"] = 2] = "FPS";
+})(ParticleSystemAnimationTimeMode || (ParticleSystemAnimationTimeMode = {}));
+var ParticleSystemAnimationMode;
+(function (ParticleSystemAnimationMode) {
+    ParticleSystemAnimationMode[ParticleSystemAnimationMode["Grid"] = 0] = "Grid";
+    ParticleSystemAnimationMode[ParticleSystemAnimationMode["Sprites"] = 1] = "Sprites";
+})(ParticleSystemAnimationMode || (ParticleSystemAnimationMode = {}));
+var ParticleSystemAnimationRowMode;
+(function (ParticleSystemAnimationRowMode) {
+    ParticleSystemAnimationRowMode[ParticleSystemAnimationRowMode["Custom"] = 0] = "Custom";
+    ParticleSystemAnimationRowMode[ParticleSystemAnimationRowMode["Random"] = 1] = "Random";
+    ParticleSystemAnimationRowMode[ParticleSystemAnimationRowMode["MeshIndex"] = 2] = "MeshIndex";
+})(ParticleSystemAnimationRowMode || (ParticleSystemAnimationRowMode = {}));
+var ParticleSystemAnimationType;
+(function (ParticleSystemAnimationType) {
+    ParticleSystemAnimationType[ParticleSystemAnimationType["WholeSheet"] = 0] = "WholeSheet";
+    ParticleSystemAnimationType[ParticleSystemAnimationType["SingleRow"] = 1] = "SingleRow";
+})(ParticleSystemAnimationType || (ParticleSystemAnimationType = {}));
+export class TextureSheetAnimationModule {
+    animation;
+    enabled;
+    cycleCount;
+    frameOverTime;
+    frameOverTimeMultiplier;
+    numTilesX;
+    numTilesY;
+    startFrame;
+    startFrameMultiplier;
+    rowMode;
+    rowIndex;
+    spriteCount;
+    timeMode;
+    sampleOnceAtStart() {
+        if (this.timeMode === ParticleSystemAnimationTimeMode.Lifetime) {
+            switch (this.frameOverTime.mode) {
+                case ParticleSystemCurveMode.Constant:
+                case ParticleSystemCurveMode.TwoConstants:
+                    return true;
+            }
+        }
+        return false;
+    }
+    getStartIndex() {
+        if (this.sampleOnceAtStart()) {
+            return this.frameOverTime.evaluate(Math.random());
+        }
+        return 0;
+    }
+    evaluate(t01) {
+        if (this.sampleOnceAtStart()) {
+            return;
+        }
+        return this.getIndex(t01);
+    }
+    getIndex(t01) {
+        const tiles = this.numTilesX * this.numTilesY;
+        // let pos = t01 * this.cycleCount;
+        let index = this.frameOverTime.evaluate(t01 % 1);
+        index *= this.frameOverTimeMultiplier;
+        index *= tiles;
+        index = index % tiles;
+        index = Math.floor(index);
+        // console.log(index);
+        return index;
+    }
+}
+__decorate([
+    serializeable()
+], TextureSheetAnimationModule.prototype, "animation", void 0);
+__decorate([
+    serializeable()
+], TextureSheetAnimationModule.prototype, "enabled", void 0);
+__decorate([
+    serializeable()
+], TextureSheetAnimationModule.prototype, "cycleCount", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], TextureSheetAnimationModule.prototype, "frameOverTime", void 0);
+__decorate([
+    serializeable()
+], TextureSheetAnimationModule.prototype, "frameOverTimeMultiplier", void 0);
+__decorate([
+    serializeable()
+], TextureSheetAnimationModule.prototype, "numTilesX", void 0);
+__decorate([
+    serializeable()
+], TextureSheetAnimationModule.prototype, "numTilesY", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], TextureSheetAnimationModule.prototype, "startFrame", void 0);
+__decorate([
+    serializeable()
+], TextureSheetAnimationModule.prototype, "startFrameMultiplier", void 0);
+__decorate([
+    serializeable()
+], TextureSheetAnimationModule.prototype, "rowMode", void 0);
+__decorate([
+    serializeable()
+], TextureSheetAnimationModule.prototype, "rowIndex", void 0);
+__decorate([
+    serializeable()
+], TextureSheetAnimationModule.prototype, "spriteCount", void 0);
+__decorate([
+    serializeable()
+], TextureSheetAnimationModule.prototype, "timeMode", void 0);
+export class RotationOverLifetimeModule {
+    enabled;
+    separateAxes;
+    x;
+    xMultiplier;
+    y;
+    yMultiplier;
+    z;
+    zMultiplier;
+    evaluate(t01) {
+        if (!this.enabled)
+            return 0;
+        if (!this.separateAxes) {
+            const rot = this.z.evaluate(t01) * -1;
+            return rot;
+        }
+        return 0;
+    }
+}
+__decorate([
+    serializeable()
+], RotationOverLifetimeModule.prototype, "enabled", void 0);
+__decorate([
+    serializeable()
+], RotationOverLifetimeModule.prototype, "separateAxes", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], RotationOverLifetimeModule.prototype, "x", void 0);
+__decorate([
+    serializeable()
+], RotationOverLifetimeModule.prototype, "xMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], RotationOverLifetimeModule.prototype, "y", void 0);
+__decorate([
+    serializeable()
+], RotationOverLifetimeModule.prototype, "yMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], RotationOverLifetimeModule.prototype, "z", void 0);
+__decorate([
+    serializeable()
+], RotationOverLifetimeModule.prototype, "zMultiplier", void 0);
+export class RotationBySpeedModule {
+    enabled;
+    range;
+    separateAxes;
+    x;
+    xMultiplier;
+    y;
+    yMultiplier;
+    z;
+    zMultiplier;
+    evaluate(_t01, speed) {
+        if (!this.enabled)
+            return 0;
+        if (!this.separateAxes) {
+            const t = Mathf.lerp(this.range.x, this.range.y, speed);
+            const rot = this.z.evaluate(t) * -1;
+            return rot;
+        }
+        return 0;
+    }
+}
+__decorate([
+    serializeable()
+], RotationBySpeedModule.prototype, "enabled", void 0);
+__decorate([
+    serializeable()
+], RotationBySpeedModule.prototype, "range", void 0);
+__decorate([
+    serializeable()
+], RotationBySpeedModule.prototype, "separateAxes", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], RotationBySpeedModule.prototype, "x", void 0);
+__decorate([
+    serializeable()
+], RotationBySpeedModule.prototype, "xMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], RotationBySpeedModule.prototype, "y", void 0);
+__decorate([
+    serializeable()
+], RotationBySpeedModule.prototype, "yMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], RotationBySpeedModule.prototype, "z", void 0);
+__decorate([
+    serializeable()
+], RotationBySpeedModule.prototype, "zMultiplier", void 0);
+export class LimitVelocityOverLifetimeModule {
+    enabled;
+    dampen;
+    drag;
+    dragMultiplier;
+    limit;
+    limitMultiplier;
+    separateAxes;
+    limitX;
+    limitXMultiplier;
+    limitY;
+    limitYMultiplier;
+    limitZ;
+    limitZMultiplier;
+    multiplyDragByParticleSize = false;
+    multiplyDragByParticleVelocity = false;
+    space;
+    _temp = new Vector3();
+    _temp2 = new Vector3();
+    apply(_position, baseVelocity, currentVelocity, _size, t01, _dt, _scale) {
+        if (!this.enabled)
+            return;
+        // if (this.separateAxes) {
+        //     // const maxX = this.limitX.evaluate(t01) * this.limitXMultiplier;
+        //     // const maxY = this.limitY.evaluate(t01) * this.limitYMultiplier;
+        //     // const maxZ = this.limitZ.evaluate(t01) * this.limitZMultiplier;
+        // }
+        // else 
+        {
+            const max = this.limit.evaluate(t01) * this.limitMultiplier;
+            const speed = baseVelocity.length();
+            if (speed > max) {
+                this._temp.copy(baseVelocity).normalize().multiplyScalar(max);
+                let t = this.dampen * .5;
+                // t *= scale;
+                baseVelocity.x = Mathf.lerp(baseVelocity.x, this._temp.x, t);
+                baseVelocity.y = Mathf.lerp(baseVelocity.y, this._temp.y, t);
+                baseVelocity.z = Mathf.lerp(baseVelocity.z, this._temp.z, t);
+                // this._temp2.set(0, 0, 0);
+                currentVelocity.x = Mathf.lerp(currentVelocity.x, this._temp.x, t);
+                currentVelocity.y = Mathf.lerp(currentVelocity.y, this._temp.y, t);
+                currentVelocity.z = Mathf.lerp(currentVelocity.z, this._temp.z, t);
+            }
+            // vel.multiplyScalar(dragFactor);
+        }
+        // vel.x *= 0.3;
+        // vel.y *= 0.3;
+        // vel.z *= 0.3;
+    }
+}
+__decorate([
+    serializeable()
+], LimitVelocityOverLifetimeModule.prototype, "enabled", void 0);
+__decorate([
+    serializeable()
+], LimitVelocityOverLifetimeModule.prototype, "dampen", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], LimitVelocityOverLifetimeModule.prototype, "drag", void 0);
+__decorate([
+    serializeable()
+], LimitVelocityOverLifetimeModule.prototype, "dragMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], LimitVelocityOverLifetimeModule.prototype, "limit", void 0);
+__decorate([
+    serializeable()
+], LimitVelocityOverLifetimeModule.prototype, "limitMultiplier", void 0);
+__decorate([
+    serializeable()
+], LimitVelocityOverLifetimeModule.prototype, "separateAxes", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], LimitVelocityOverLifetimeModule.prototype, "limitX", void 0);
+__decorate([
+    serializeable()
+], LimitVelocityOverLifetimeModule.prototype, "limitXMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], LimitVelocityOverLifetimeModule.prototype, "limitY", void 0);
+__decorate([
+    serializeable()
+], LimitVelocityOverLifetimeModule.prototype, "limitYMultiplier", void 0);
+__decorate([
+    serializeable(MinMaxCurve)
+], LimitVelocityOverLifetimeModule.prototype, "limitZ", void 0);
+__decorate([
+    serializeable()
+], LimitVelocityOverLifetimeModule.prototype, "limitZMultiplier", void 0);
+__decorate([
+    serializeable()
+], LimitVelocityOverLifetimeModule.prototype, "multiplyDragByParticleSize", void 0);
+__decorate([
+    serializeable()
+], LimitVelocityOverLifetimeModule.prototype, "multiplyDragByParticleVelocity", void 0);
+__decorate([
+    serializeable()
+], LimitVelocityOverLifetimeModule.prototype, "space", void 0);
 //# sourceMappingURL=ParticleSystemModules.js.map