@rzmps/rzmps 1.0.0

package/build/modules/Collision.js

@@ -0,0 +1,162 @@
+import * as THREE from 'three';
+import Module from '../Module';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+import ThreeCollisionBackend from '../collision/ThreeCollisionBackend';
+const ACTIVE_COLLISION_BACKEND_KEY = "__rzmps_activeCollisionBackend";
+const PREVIOUS_POSITION_KEY = "__rzmps_collision_prevPosition";
+class Collision extends Module {
+    constructor(options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        // Priority > 0, occurs after movement
+        super((particle) => this.collide(particle), Object.assign(Object.assign({}, options), { priority: 1 }));
+        this.dampen = 0;
+        this.bounce = 1;
+        this.lifetimeLoss = 0;
+        this.applyImpulses = false;
+        this.radiusScale = 1;
+        this.minKillSpeed = 0;
+        this.maxKillSpeed = Number.POSITIVE_INFINITY;
+        this.collisionListeners = [];
+        // Priority < 0, cache position before movement
+        this.dependents = [
+            new Module((particle) => particle.data[PREVIOUS_POSITION_KEY] = particle.position.clone(), Object.assign(Object.assign({}, options), { priority: -1 }))
+        ];
+        this.dampen = (_a = options.dampen) !== null && _a !== void 0 ? _a : this.dampen;
+        this.bounce = (_b = options.bounce) !== null && _b !== void 0 ? _b : this.bounce;
+        this.lifetimeLoss = (_c = options.lifetimeLoss) !== null && _c !== void 0 ? _c : this.lifetimeLoss;
+        this.applyImpulses = (_d = options.applyImpulses) !== null && _d !== void 0 ? _d : this.applyImpulses;
+        this.radiusScale = (_e = options.radiusScale) !== null && _e !== void 0 ? _e : this.radiusScale;
+        this.minKillSpeed = (_f = options.minKillSpeed) !== null && _f !== void 0 ? _f : this.minKillSpeed;
+        this.maxKillSpeed = (_g = options.maxKillSpeed) !== null && _g !== void 0 ? _g : this.maxKillSpeed;
+        if (options.onCollision)
+            this.collisionListeners.push(options.onCollision);
+    }
+    onCollision(listener) {
+        this.collisionListeners.push(listener);
+    }
+    removeCollisionListener(listener) {
+        this.collisionListeners = this.collisionListeners.filter(l => l !== listener);
+    }
+    prepare(system, deltaTime) {
+        var _a, _b;
+        this._system = system;
+        if (system.scene) {
+            // Check if backend exists or needs to be updated
+            const cachedBackend = system.scene.userData[ACTIVE_COLLISION_BACKEND_KEY];
+            if (!this.backend || this.backend != cachedBackend) {
+                this.backend = cachedBackend !== null && cachedBackend !== void 0 ? cachedBackend : new ThreeCollisionBackend({ world: system.scene });
+                system.scene.userData[ACTIVE_COLLISION_BACKEND_KEY] =
+                    this.backend;
+            }
+        }
+        (_b = (_a = this.backend) === null || _a === void 0 ? void 0 : _a.update) === null || _b === void 0 ? void 0 : _b.call(_a, deltaTime);
+    }
+    collide(particle) {
+        if (!this.backend || !this._system)
+            return;
+        const startPosition = particle.data[PREVIOUS_POSITION_KEY];
+        const endPosition = particle.position;
+        if (startPosition.equals(endPosition))
+            return;
+        this._system.updateWorldMatrix(true, false);
+        const start = this._system.simulationSpace === 'world'
+            ? startPosition.clone()
+            : this._system.localToWorld(startPosition.clone());
+        const end = this._system.simulationSpace === 'world'
+            ? endPosition.clone()
+            : this._system.localToWorld(endPosition.clone());
+        const radius = this.getParticleRadius(particle);
+        const hit = this.backend.collide({
+            particle,
+            start,
+            end,
+            radius,
+        });
+        if (!hit)
+            return;
+        // Collision callbacks
+        this.collisionListeners.forEach((listener) => listener(particle, hit));
+        this._system.notifyCollision(particle, hit);
+        if (this._system.simulationSpace === 'local') {
+            const inverseWorld = this._system.matrixWorld.clone().invert();
+            hit.point = this._system.worldToLocal(hit.point.clone());
+            if (hit.position) {
+                hit.position = this._system.worldToLocal(hit.position.clone());
+            }
+            hit.normal = hit.normal
+                .clone()
+                .transformDirection(inverseWorld)
+                .normalize();
+        }
+        this.resolvePosition(particle, hit, radius);
+        // Store previous veolocity for impulses
+        const incomingVelocity = particle.velocity.clone();
+        this.resolveVelocity(particle, hit);
+        this.resolveLifetime(particle);
+        if (particle.mass > 0
+            && this.applyImpulses
+            && this.backend.applyImpulse) {
+            const impulse = particle.velocity
+                .clone()
+                .sub(incomingVelocity)
+                .multiplyScalar(-particle.mass);
+            this.backend.applyImpulse(hit, impulse);
+        }
+        const speed = particle.velocity.length();
+        if (speed < this.minKillSpeed
+            || speed > this.maxKillSpeed) {
+            this.killParticle(particle);
+        }
+    }
+    resolvePosition(particle, hit, radius) {
+        if (hit.position) {
+            particle.position.copy(hit.position);
+            return;
+        }
+        particle.position
+            .copy(hit.point)
+            .addScaledVector(hit.normal, radius);
+    }
+    resolveVelocity(particle, hit) {
+        var _a, _b;
+        const normal = hit.normal.clone().normalize();
+        const bounce = THREE.MathUtils.clamp(evaluateDynamicNumber((_a = this.bounce) !== null && _a !== void 0 ? _a : 1, particle.time, particle.id), 0, 1);
+        const dampen = THREE.MathUtils.clamp(evaluateDynamicNumber((_b = this.dampen) !== null && _b !== void 0 ? _b : 0, particle.time, particle.id), 0, 1);
+        const normalSpeed = particle.velocity.dot(normal);
+        /*
+         * Don't bounce if we're already travelling away
+         * from the surface.
+         */
+        if (normalSpeed >= 0)
+            return;
+        const normalVelocity = normal
+            .clone()
+            .multiplyScalar(normalSpeed);
+        const tangentVelocity = particle.velocity
+            .clone()
+            .sub(normalVelocity);
+        particle.velocity
+            .copy(tangentVelocity)
+            .addScaledVector(normalVelocity, -bounce)
+            .multiplyScalar(1 - dampen);
+    }
+    resolveLifetime(particle) {
+        var _a;
+        const loss = THREE.MathUtils.clamp(evaluateDynamicNumber((_a = this.lifetimeLoss) !== null && _a !== void 0 ? _a : 0, particle.time, particle.id), 0, 1);
+        if (loss === 0)
+            return;
+        particle.lifetime -= particle.start.lifetime * loss;
+        if (particle.lifetime <= (particle.realtime / 1000)) {
+            this.killParticle(particle);
+        }
+    }
+    getParticleRadius(particle) {
+        var _a;
+        const size = Math.max(Math.abs(particle.scale.x), Math.abs(particle.scale.y), Math.abs(particle.scale.z));
+        return size * 0.5 * ((_a = this.radiusScale) !== null && _a !== void 0 ? _a : 1);
+    }
+    killParticle(particle) {
+        particle.lifetime = 0;
+    }
+}
+export default Collision;

package/build/modules/ColorBySpeed.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+export type SpeedRange = [number, number] | {
+    min: number;
+    max: number;
+};
+export interface ColorBySpeedOptions extends Partial<ModuleOptions> {
+    color?: DynamicValue<THREE.Color>;
+    alpha?: DynamicValue<number>;
+    speedRange?: SpeedRange;
+}
+declare class ColorBySpeed extends Module {
+    options: ColorBySpeedOptions;
+    constructor(options: ColorBySpeedOptions);
+    private getSpeedTime;
+}
+export default ColorBySpeed;

package/build/modules/ColorBySpeed.js

@@ -0,0 +1,26 @@
+import Module from '../Module';
+import evaluateDynamicColor from '../helpers/evaluateDynamicColor';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+class ColorBySpeed extends Module {
+    constructor(options) {
+        super((particle) => {
+            const t = this.getSpeedTime(particle.velocity.length());
+            if (this.options.color !== undefined) {
+                particle.color = particle.start.color.clone().multiply(evaluateDynamicColor(this.options.color, t, particle.id));
+            }
+            if (this.options.alpha !== undefined) {
+                particle.alpha = particle.start.alpha * evaluateDynamicNumber(this.options.alpha, t, particle.id);
+            }
+        }, options);
+        this.options = options;
+    }
+    getSpeedTime(speed) {
+        var _a, _b, _c, _d;
+        const min = Array.isArray(this.options.speedRange) ? this.options.speedRange[0] : (_b = (_a = this.options.speedRange) === null || _a === void 0 ? void 0 : _a.min) !== null && _b !== void 0 ? _b : 0;
+        const max = Array.isArray(this.options.speedRange) ? this.options.speedRange[1] : (_d = (_c = this.options.speedRange) === null || _c === void 0 ? void 0 : _c.max) !== null && _d !== void 0 ? _d : 1;
+        if (max === min)
+            return speed >= max ? 1 : 0;
+        return Math.min(Math.max((speed - min) / (max - min), 0), 1);
+    }
+}
+export default ColorBySpeed;

package/build/modules/ColorOverLifetime.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+export interface ColorOverLifetimeOptions extends Partial<ModuleOptions> {
+    color?: DynamicValue<THREE.Color>;
+    alpha?: DynamicValue<number>;
+}
+declare class ColorOverLifetime extends Module {
+    options: ColorOverLifetimeOptions;
+    constructor(options?: ColorOverLifetimeOptions);
+}
+export default ColorOverLifetime;

package/build/modules/ColorOverLifetime.js

@@ -0,0 +1,17 @@
+import Module from '../Module';
+import evaluateDynamicColor from '../helpers/evaluateDynamicColor';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+class ColorOverLifetime extends Module {
+    constructor(options = {}) {
+        super((particle) => {
+            if (this.options.color !== undefined) {
+                particle.color = particle.start.color.clone().multiply(evaluateDynamicColor(this.options.color, particle.time, particle.id));
+            }
+            if (this.options.alpha !== undefined) {
+                particle.alpha = particle.start.alpha * evaluateDynamicNumber(this.options.alpha, particle.time, particle.id);
+            }
+        }, options);
+        this.options = options;
+    }
+}
+export default ColorOverLifetime;

package/build/modules/ExternalForces.d.ts

@@ -0,0 +1,21 @@
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+import { IParticleForceField } from '../interfaces/IParticleForceField';
+import ParticleForceField from '../ParticleForceField';
+import ParticleSystem from '../ParticleSystem';
+export interface ExternalForcesOptions extends Partial<ModuleOptions> {
+    multiplier?: DynamicValue<number>;
+    forceFieldFilter?: (forceField: ParticleForceField) => boolean;
+    forceFields?: IParticleForceField[];
+}
+declare class ExternalForces extends Module {
+    multiplier: DynamicValue<number>;
+    explicitForceFields?: IParticleForceField[];
+    forceFieldFilter?: (forceField: ParticleForceField) => boolean;
+    private forceFields;
+    private particleSystem?;
+    constructor(options: ExternalForcesOptions);
+    prepare(particleSystem: ParticleSystem, deltaTime: number): void;
+}
+export default ExternalForces;
+export { IParticleForceField };

package/build/modules/ExternalForces.js

@@ -0,0 +1,61 @@
+import * as THREE from 'three';
+import Module from '../Module';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+import ParticleForceField from '../ParticleForceField';
+class ExternalForces extends Module {
+    constructor(options) {
+        var _a;
+        super((particle, deltaTime) => {
+            var _a;
+            const multiplier = evaluateDynamicNumber((_a = this.multiplier) !== null && _a !== void 0 ? _a : 1, particle.time, particle.id);
+            const particleSystem = this.particleSystem;
+            if (!particleSystem)
+                return;
+            particleSystem.updateWorldMatrix(true, false);
+            const particlePosition = particleSystem.simulationSpace === 'world'
+                ? particle.position
+                : particleSystem.localToWorld(particle.position.clone());
+            const worldQuaternion = particleSystem.simulationSpace === 'local'
+                ? particleSystem.getWorldQuaternion(new THREE.Quaternion())
+                : undefined;
+            const inverseWorldQuaternion = worldQuaternion === null || worldQuaternion === void 0 ? void 0 : worldQuaternion.clone().invert();
+            const forceParticle = particleSystem.simulationSpace === 'world'
+                ? particle
+                : Object.assign(Object.create(Object.getPrototypeOf(particle)), particle, {
+                    position: particlePosition,
+                    velocity: particle.velocity
+                        .clone()
+                        .applyQuaternion(worldQuaternion),
+                });
+            this.forceFields.forEach((forceField) => {
+                const force = forceField.getForce(forceParticle, deltaTime);
+                if (inverseWorldQuaternion) {
+                    force.applyQuaternion(inverseWorldQuaternion);
+                }
+                particle.acceleration.addScaledVector(force, multiplier);
+            });
+        }, options);
+        this.multiplier = 1;
+        this.forceFields = new Set();
+        this.explicitForceFields = options.forceFields;
+        this.forceFieldFilter = (_a = options.forceFieldFilter) !== null && _a !== void 0 ? _a : (() => true);
+    }
+    prepare(particleSystem, deltaTime) {
+        var _a;
+        this.particleSystem = particleSystem;
+        // If explicit force fields are provided, just use those
+        if (Array.isArray(this.explicitForceFields)) {
+            this.forceFields = new Set(this.explicitForceFields);
+            return;
+        }
+        this.forceFields.clear();
+        // Otherwise, scan the scene for force fields
+        (_a = particleSystem.scene) === null || _a === void 0 ? void 0 : _a.traverse((object) => {
+            var _a;
+            if (object instanceof ParticleForceField
+                && ((_a = this.forceFieldFilter) === null || _a === void 0 ? void 0 : _a.call(this, object)))
+                this.forceFields.add(object);
+        });
+    }
+}
+export default ExternalForces;

package/build/modules/ForceOverLifetime.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+export interface ForceOverLifetimeOptions extends Partial<ModuleOptions> {
+    force: DynamicValue<THREE.Vector3>;
+}
+declare class ForceOverLifetime extends Module {
+    options: ForceOverLifetimeOptions;
+    constructor(options: ForceOverLifetimeOptions);
+}
+export default ForceOverLifetime;

package/build/modules/ForceOverLifetime.js

@@ -0,0 +1,12 @@
+import Module from '../Module';
+import evaluateDynamicVector from '../helpers/evaluateDynamicVector3';
+class ForceOverLifetime extends Module {
+    constructor(options) {
+        super((particle) => {
+            particle.acceleration = particle.start.acceleration.clone()
+                .add(evaluateDynamicVector(this.options.force, particle.time, particle.id));
+        }, options);
+        this.options = options;
+    }
+}
+export default ForceOverLifetime;

package/build/modules/LimitVelocityOverLifetime.d.ts

@@ -0,0 +1,16 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+export interface LimitVelocityOverLifetimeOptions extends Partial<ModuleOptions> {
+    limit: DynamicValue<THREE.Vector3>;
+    dampen?: number;
+    drag?: DynamicValue<number>;
+    multiplyDragBySize?: boolean;
+    multiplyDragByVelocity?: boolean;
+}
+declare class LimitVelocityOverLifetime extends Module {
+    options: LimitVelocityOverLifetimeOptions;
+    constructor(options: LimitVelocityOverLifetimeOptions);
+    private dampenAxis;
+}
+export default LimitVelocityOverLifetime;

package/build/modules/LimitVelocityOverLifetime.js

@@ -0,0 +1,34 @@
+import Module from '../Module';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+import evaluateDynamicVector from '../helpers/evaluateDynamicVector3';
+class LimitVelocityOverLifetime extends Module {
+    constructor(options) {
+        super((particle, deltaTime) => {
+            var _a;
+            const limit = evaluateDynamicVector(this.options.limit, particle.time, particle.id);
+            const dampen = (_a = this.options.dampen) !== null && _a !== void 0 ? _a : 1;
+            this.dampenAxis(particle.velocity, 'x', Math.abs(limit.x), dampen);
+            this.dampenAxis(particle.velocity, 'y', Math.abs(limit.y), dampen);
+            this.dampenAxis(particle.velocity, 'z', Math.abs(limit.z), dampen);
+            if (this.options.drag !== undefined) {
+                let drag = evaluateDynamicNumber(this.options.drag, particle.time, particle.id);
+                if (this.options.multiplyDragBySize) {
+                    drag *= (particle.scale.x + particle.scale.y + particle.scale.z) / 3;
+                }
+                if (this.options.multiplyDragByVelocity) {
+                    drag *= particle.velocity.length();
+                }
+                particle.velocity.multiplyScalar(Math.max(0, 1 - drag * deltaTime));
+            }
+        }, options);
+        this.options = options;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    dampenAxis(velocity, axis, limit, dampen) {
+        if (Math.abs(velocity[axis]) <= limit)
+            return;
+        const clamped = Math.sign(velocity[axis]) * limit;
+        velocity[axis] += (clamped - velocity[axis]) * Math.min(Math.max(dampen, 0), 1);
+    }
+}
+export default LimitVelocityOverLifetime;

package/build/modules/MassOverLifetime.d.ts

@@ -0,0 +1,11 @@
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+export interface MassOverLifetimeOptions extends Partial<ModuleOptions> {
+    mass: DynamicValue<number>;
+    multiplyMassBySize: boolean;
+}
+declare class MassOverLifetime extends Module {
+    options: MassOverLifetimeOptions;
+    constructor(options: MassOverLifetimeOptions);
+}
+export default MassOverLifetime;

package/build/modules/MassOverLifetime.js

@@ -0,0 +1,15 @@
+import Module from '../Module';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+class MassOverLifetime extends Module {
+    constructor(options) {
+        super((particle) => {
+            var _a;
+            const sizeRatio = particle.scale.length() / particle.start.scale.length();
+            particle.mass = particle.start.mass
+                * evaluateDynamicNumber(this.options.mass, particle.time, particle.id)
+                * (((_a = options.multiplyMassBySize) !== null && _a !== void 0 ? _a : true) ? sizeRatio : 1);
+        }, options);
+        this.options = options;
+    }
+}
+export default MassOverLifetime;

package/build/modules/NoiseModule.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+export interface NoiseOptions extends Partial<ModuleOptions> {
+    octaves: number;
+    frequency: number;
+    lacunarity: number;
+    persistence: number;
+    time: number;
+    offset: THREE.Vector3;
+}
+declare class NoiseModule extends Module {
+    octaves: number;
+    frequency: number;
+    lacunarity: number;
+    persistence: number;
+    time: number;
+    offset: THREE.Vector3;
+    key: string;
+    private noiseGenerator;
+    constructor(key: string, options?: Partial<NoiseOptions>);
+    private generateNoise;
+}
+export default NoiseModule;

package/build/modules/NoiseModule.js

@@ -0,0 +1,45 @@
+import { makeNoise4D } from 'fast-simplex-noise';
+import * as THREE from 'three';
+import Module from '../Module';
+class NoiseModule extends Module {
+    constructor(key, options = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        super((particle) => {
+            particle.noise[key] = {
+                noise: this.generateNoise(particle),
+                noise4d: this.generateNoise(particle, true),
+            };
+        }, options);
+        this.octaves = 1;
+        this.frequency = 1;
+        this.lacunarity = 2.0;
+        this.persistence = 0.5;
+        this.time = 0;
+        this.offset = new THREE.Vector3();
+        this.noiseGenerator = makeNoise4D();
+        this.key = key;
+        this.octaves = (_a = options.octaves) !== null && _a !== void 0 ? _a : this.octaves;
+        this.frequency = (_b = options.frequency) !== null && _b !== void 0 ? _b : this.frequency;
+        this.lacunarity = (_c = options.lacunarity) !== null && _c !== void 0 ? _c : this.lacunarity;
+        this.persistence = (_d = options.persistence) !== null && _d !== void 0 ? _d : this.persistence;
+        this.time = (_e = options.time) !== null && _e !== void 0 ? _e : this.time;
+        this.offset = (_f = options.offset) !== null && _f !== void 0 ? _f : this.offset;
+    }
+    generateNoise(particle, w = false) {
+        const layers = [];
+        for (let i = 0; i < this.octaves; i += 1) {
+            const frequency = this.frequency * (Math.pow(this.lacunarity, i));
+            const amplitude = Math.pow(this.persistence, i);
+            // Clamp because float math is nuts
+            const rawNoise = Math.min(Math.max((this.noiseGenerator((particle.position.x + this.offset.x) * frequency, (particle.position.y + this.offset.y) * frequency, (particle.position.z + this.offset.z) * frequency, w ? this.time : 0) + 1) / 2, 0), 1);
+            layers.push({
+                value: rawNoise * amplitude,
+                weight: amplitude,
+            });
+        }
+        // Use weighted average to maintain 0 - 1 range
+        return layers.map((layer) => layer.value).reduce((a, b) => a + b)
+            / layers.map((layer) => layer.weight).reduce((a, b) => a + b);
+    }
+}
+export default NoiseModule;

package/build/modules/RotationBySpeed.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+import { SpeedRange } from './ColorBySpeed';
+export interface RotationBySpeedOptions extends Partial<ModuleOptions> {
+    angularVelocity: DynamicValue<THREE.Vector3>;
+    speedRange?: SpeedRange;
+}
+declare class RotationBySpeed extends Module {
+    options: RotationBySpeedOptions;
+    constructor(options: RotationBySpeedOptions);
+    private getSpeedTime;
+}
+export default RotationBySpeed;

package/build/modules/RotationBySpeed.js

@@ -0,0 +1,19 @@
+import Module from '../Module';
+import evaluateDynamicVector from '../helpers/evaluateDynamicVector3';
+class RotationBySpeed extends Module {
+    constructor(options) {
+        super((particle) => {
+            particle.angularVelocity = particle.start.angularVelocity.clone().add(evaluateDynamicVector(this.options.angularVelocity, this.getSpeedTime(particle.velocity.length()), particle.id));
+        }, options);
+        this.options = options;
+    }
+    getSpeedTime(speed) {
+        var _a, _b, _c, _d;
+        const min = Array.isArray(this.options.speedRange) ? this.options.speedRange[0] : (_b = (_a = this.options.speedRange) === null || _a === void 0 ? void 0 : _a.min) !== null && _b !== void 0 ? _b : 0;
+        const max = Array.isArray(this.options.speedRange) ? this.options.speedRange[1] : (_d = (_c = this.options.speedRange) === null || _c === void 0 ? void 0 : _c.max) !== null && _d !== void 0 ? _d : 1;
+        if (max === min)
+            return speed >= max ? 1 : 0;
+        return Math.min(Math.max((speed - min) / (max - min), 0), 1);
+    }
+}
+export default RotationBySpeed;

package/build/modules/RotationOverLifetime.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+export interface RotationOverLifetimeOptions extends Partial<ModuleOptions> {
+    angularVelocity: DynamicValue<THREE.Vector3>;
+}
+declare class RotationOverLifetime extends Module {
+    options: RotationOverLifetimeOptions;
+    constructor(options: RotationOverLifetimeOptions);
+}
+export default RotationOverLifetime;

package/build/modules/RotationOverLifetime.js

@@ -0,0 +1,12 @@
+import Module from '../Module';
+import evaluateDynamicVector from '../helpers/evaluateDynamicVector3';
+class RotationOverLifetime extends Module {
+    constructor(options) {
+        super((particle) => {
+            particle.angularVelocity = particle.start.angularVelocity.clone()
+                .add(evaluateDynamicVector(this.options.angularVelocity, particle.time, particle.id));
+        }, options);
+        this.options = options;
+    }
+}
+export default RotationOverLifetime;

package/build/modules/ScaleBySpeed.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+import { SpeedRange } from './ColorBySpeed';
+export interface ScaleBySpeedOptions extends Partial<ModuleOptions> {
+    scale: DynamicValue<THREE.Vector3>;
+    speedRange?: SpeedRange;
+}
+declare class ScaleBySpeed extends Module {
+    options: ScaleBySpeedOptions;
+    constructor(options: ScaleBySpeedOptions);
+    private getSpeedTime;
+}
+export default ScaleBySpeed;

package/build/modules/ScaleBySpeed.js

@@ -0,0 +1,19 @@
+import Module from '../Module';
+import evaluateDynamicVector from '../helpers/evaluateDynamicVector3';
+class ScaleBySpeed extends Module {
+    constructor(options) {
+        super((particle) => {
+            particle.scale = particle.start.scale.clone().multiply(evaluateDynamicVector(this.options.scale, this.getSpeedTime(particle.velocity.length()), particle.id));
+        }, options);
+        this.options = options;
+    }
+    getSpeedTime(speed) {
+        var _a, _b, _c, _d;
+        const min = Array.isArray(this.options.speedRange) ? this.options.speedRange[0] : (_b = (_a = this.options.speedRange) === null || _a === void 0 ? void 0 : _a.min) !== null && _b !== void 0 ? _b : 0;
+        const max = Array.isArray(this.options.speedRange) ? this.options.speedRange[1] : (_d = (_c = this.options.speedRange) === null || _c === void 0 ? void 0 : _c.max) !== null && _d !== void 0 ? _d : 1;
+        if (max === min)
+            return speed >= max ? 1 : 0;
+        return Math.min(Math.max((speed - min) / (max - min), 0), 1);
+    }
+}
+export default ScaleBySpeed;

package/build/modules/ScaleOverLifetime.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+export interface ScaleOverLifetimeOptions extends Partial<ModuleOptions> {
+    scale: DynamicValue<THREE.Vector3>;
+}
+declare class ScaleOverLifetime extends Module {
+    options: ScaleOverLifetimeOptions;
+    constructor(options: ScaleOverLifetimeOptions);
+}
+export default ScaleOverLifetime;

package/build/modules/ScaleOverLifetime.js

@@ -0,0 +1,11 @@
+import Module from '../Module';
+import evaluateDynamicVector from '../helpers/evaluateDynamicVector3';
+class ScaleOverLifetime extends Module {
+    constructor(options) {
+        super((particle) => {
+            particle.scale = particle.start.scale.clone().multiply(evaluateDynamicVector(this.options.scale, particle.time, particle.id));
+        }, options);
+        this.options = options;
+    }
+}
+export default ScaleOverLifetime;

package/build/modules/TransformByNoise.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+import { NoiseOptions } from './NoiseModule';
+export interface TransformByNoiseOptions extends Partial<ModuleOptions>, NoiseOptions {
+    strength: DynamicValue<THREE.Vector3>;
+    scrollSpeed: DynamicValue<number>;
+    damping: boolean;
+}
+declare class TransformByNoise extends Module {
+    options: Partial<TransformByNoiseOptions>;
+    private noiseX;
+    private noiseY;
+    private noiseZ;
+    constructor(options: Partial<TransformByNoiseOptions>);
+}
+export default TransformByNoise;