@rzmps/rzmps 1.0.0

package/build/EmissionShape.d.ts

@@ -0,0 +1,33 @@
+import * as THREE from 'three';
+import { EmissionSource } from './enums/EmissionSource';
+interface EmissionShapeOptions {
+    geometry: THREE.BufferGeometry;
+    source: EmissionSource | `${EmissionSource}`;
+}
+declare class EmissionShape extends THREE.Object3D {
+    static maxVolumeIterations: number;
+    private static readonly _doubleSidedMaterial;
+    static Box(...args: any[]): EmissionShape;
+    static Sphere(...args: any[]): EmissionShape;
+    static Cone(...args: any[]): EmissionShape;
+    static Torus(...args: any[]): EmissionShape;
+    source: EmissionSource;
+    private _geometry;
+    private _surfaceSampler;
+    private _vertexNormals;
+    private _raycaster;
+    private _mesh;
+    constructor(options?: Partial<EmissionShapeOptions>);
+    set geometry(value: THREE.BufferGeometry);
+    get geometry(): THREE.BufferGeometry;
+    get vertices(): THREE.Vector3[];
+    private _calculatePointNormal;
+    computeVertexNormals(): void;
+    private _toParentPosition;
+    private _toParentNormal;
+    getPoint(overrideSource?: EmissionSource): {
+        position: THREE.Vector3;
+        normal: THREE.Vector3;
+    };
+}
+export default EmissionShape;

package/build/EmissionShape.js

@@ -0,0 +1,129 @@
+import * as THREE from 'three';
+import { MeshSurfaceSampler } from 'three/examples/jsm/math/MeshSurfaceSampler.js';
+import { EmissionSource } from './enums/EmissionSource';
+import isPointInMesh from './helpers/isPointInMesh';
+class EmissionShape extends THREE.Object3D {
+    static Box(...args) {
+        return new EmissionShape({ geometry: new THREE.BoxGeometry(...args) });
+    }
+    static Sphere(...args) {
+        return new EmissionShape({ geometry: new THREE.SphereGeometry(...args) });
+    }
+    static Cone(...args) {
+        return new EmissionShape({ geometry: new THREE.ConeGeometry(...args) });
+    }
+    static Torus(...args) {
+        return new EmissionShape({ geometry: new THREE.TorusGeometry(...args) });
+    }
+    constructor(options = {}) {
+        var _a, _b;
+        super();
+        this._vertexNormals = [];
+        this._raycaster = new THREE.Raycaster();
+        this._geometry = (_a = options.geometry) !== null && _a !== void 0 ? _a : new THREE.SphereGeometry();
+        this.source = (_b = options.source) !== null && _b !== void 0 ? _b : EmissionSource.Volume;
+        this._mesh = new THREE.Mesh(this._geometry, EmissionShape._doubleSidedMaterial);
+        this._surfaceSampler = new MeshSurfaceSampler(this._mesh)
+            .build();
+        this.computeVertexNormals();
+        this._geometry.computeBoundingBox();
+    }
+    set geometry(value) {
+        this._geometry = value;
+        this._mesh = new THREE.Mesh(this._geometry, EmissionShape._doubleSidedMaterial);
+        this._surfaceSampler = new MeshSurfaceSampler(this._mesh);
+        this.computeVertexNormals();
+        this._geometry.computeBoundingBox();
+        this._mesh.updateMatrix();
+    }
+    get geometry() { return this._geometry; }
+    get vertices() {
+        const vertices = this._geometry.getAttribute('position');
+        const res = [];
+        for (let i = 0; i < vertices.array.length; i += 3) {
+            res.push(new THREE.Vector3(vertices.array[i], vertices.array[i + 1], vertices.array[i + 2]));
+        }
+        return res;
+    }
+    // Calculate the normal of a point in the geometry volume
+    _calculatePointNormal(point, maxVertices = 5) {
+        // Get the closest vertices
+        const { vertices } = this;
+        const closest = vertices
+            .sort((a, b) => Math.abs(point.distanceTo(a)) - Math.abs(point.distanceTo(b)))
+            .splice(0, maxVertices);
+        // Get weighted average
+        const sumVectors = (vectors) => vectors.reduce((a, b) => a.addScaledVector(b, 1));
+        const sumArray = (values) => values.reduce((a, b) => a + b);
+        const weightedMean = (factorsArray, weightsArray) => sumVectors(factorsArray.map((factor, index) => factor.multiplyScalar(weightsArray[index]))).divideScalar(sumArray(weightsArray));
+        return weightedMean(closest, closest.map((vector) => Math.abs(point.distanceTo(vector))));
+    }
+    computeVertexNormals() {
+        this._geometry.computeVertexNormals();
+        const vertexNormals = this._geometry.getAttribute('normal');
+        const res = [];
+        for (let i = 0; i < vertexNormals.array.length; i += 3) {
+            res.push(new THREE.Vector3(vertexNormals.array[i], vertexNormals.array[i + 1], vertexNormals.array[i + 2]));
+        }
+        this._vertexNormals = res;
+    }
+    _toParentPosition(localPosition) {
+        this.updateWorldMatrix(true, false);
+        const worldPosition = localPosition.clone().applyMatrix4(this.matrixWorld);
+        return this.parent
+            ? this.parent.worldToLocal(worldPosition)
+            : worldPosition;
+    }
+    _toParentNormal(localNormal) {
+        const normalMatrix = new THREE.Matrix3().getNormalMatrix(this.matrix);
+        return localNormal
+            .clone()
+            .applyNormalMatrix(normalMatrix)
+            .normalize();
+    }
+    getPoint(overrideSource) {
+        switch (overrideSource !== null && overrideSource !== void 0 ? overrideSource : this.source) {
+            case EmissionSource.Vertices:
+                // Select random vertex
+                const { vertices } = this;
+                const vertexIndex = Math.floor(Math.random() * vertices.length);
+                return {
+                    position: this._toParentPosition(vertices[vertexIndex]),
+                    normal: this._toParentNormal(this._vertexNormals[vertexIndex]),
+                };
+            case EmissionSource.Surface:
+                // Use surface sampler to find random point on surface
+                const position = new THREE.Vector3(0, 0, 0);
+                const normal = new THREE.Vector3(0, 0, 0);
+                this._surfaceSampler.sample(position, normal);
+                return {
+                    position: this._toParentPosition(position),
+                    normal: this._toParentNormal(normal),
+                };
+            case EmissionSource.Volume:
+            default:
+                // If no bounding box, fallback to surface
+                if (!this._geometry.boundingBox)
+                    return this.getPoint(EmissionSource.Surface);
+                // Choose random points in bounding box until one is contained by geometry (volume)
+                const { min, max } = this._geometry.boundingBox;
+                const randomPoint = new THREE.Vector3(THREE.MathUtils.lerp(min.x, max.x, Math.random()), THREE.MathUtils.lerp(min.y, max.y, Math.random()), THREE.MathUtils.lerp(min.z, max.z, Math.random()));
+                // Search for the allotted iterations
+                let iterations = 0;
+                while (iterations < EmissionShape.maxVolumeIterations) {
+                    if (isPointInMesh(randomPoint, this._mesh)) {
+                        return {
+                            position: this._toParentPosition(randomPoint),
+                            normal: this._toParentNormal(this._calculatePointNormal(randomPoint)),
+                        };
+                    }
+                    iterations += 1;
+                }
+                // If not found, get from surface sampler
+                return this.getPoint(EmissionSource.Surface);
+        }
+    }
+}
+EmissionShape.maxVolumeIterations = 5;
+EmissionShape._doubleSidedMaterial = new THREE.MeshBasicMaterial({ side: THREE.DoubleSide });
+export default EmissionShape;

package/build/Emitter.d.ts

@@ -0,0 +1,58 @@
+import * as THREE from 'three';
+import EmissionShape from './EmissionShape';
+import Particle from './Particle';
+import { InitialParticleValues } from './interfaces/InitialParticleValues';
+import ParticleSystem from './ParticleSystem';
+import { DynamicUntimedValue, DynamicValue } from './types/DynamicValue';
+import { Multiple, StrictMultiple } from './types/Multiple';
+import { Tag } from './types/Tag';
+import { TagSelectionMethod } from './enums/TagSelectionMethod';
+type SpawnBurst = {
+    time: number;
+    count: DynamicUntimedValue<number>;
+    fired?: boolean;
+};
+interface EmitterOptions {
+    initialValues: Partial<InitialParticleValues>;
+    source: EmissionShape;
+    bursts: Multiple<SpawnBurst>;
+    rate: DynamicValue<number>;
+    radialSpeed: DynamicValue<number>;
+    alignment: DynamicValue<number>;
+    tags: StrictMultiple<Tag>;
+    tagSelection: TagSelectionMethod | `${TagSelectionMethod}`;
+}
+export interface EmissionContext {
+    key?: string;
+    transform?: THREE.Matrix4;
+    time?: number;
+    duration?: number;
+    elapsedTime?: number;
+    looping?: boolean;
+    color?: THREE.Color;
+    alpha?: number;
+    mass?: number;
+    tags?: Tag[];
+}
+declare class Emitter {
+    source: EmissionShape;
+    rate: DynamicValue<number>;
+    bursts: SpawnBurst[];
+    initialValues: Partial<InitialParticleValues>;
+    radialSpeed: DynamicValue<number>;
+    alignment: DynamicValue<number>;
+    tags?: Tag[];
+    tagSelection: TagSelectionMethod;
+    private _lastTagIndex;
+    private _contextStates;
+    constructor(options?: Partial<EmitterOptions>);
+    reset(): void;
+    setup(particleSystem: ParticleSystem): void;
+    update(particles: Particle[], context?: EmissionContext): Particle[];
+    updateAt(particles: Particle[], context: EmissionContext): Particle[];
+    clearContext(key: string): void;
+    private getContextState;
+    private spawnParticle;
+    private _selectTags;
+}
+export default Emitter;

package/build/Emitter.js

@@ -0,0 +1,166 @@
+import * as THREE from 'three';
+import EmissionShape from './EmissionShape';
+import Particle from './Particle';
+import evaluateDynamicVector from './helpers/evaluateDynamicVector3';
+import evaluateDynamicNumber from './helpers/evaluateDynamicNumber';
+import evaluateDynamicColor from './helpers/evaluateDynamicColor';
+import acceptMultiple from './helpers/acceptMultiple';
+import { TagSelectionMethod } from './enums/TagSelectionMethod';
+class Emitter {
+    constructor(options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        this.tagSelection = TagSelectionMethod.All;
+        this._lastTagIndex = 0;
+        // Used for subsystems
+        this._contextStates = new Map();
+        this.source = (_a = options.source) !== null && _a !== void 0 ? _a : EmissionShape.Sphere();
+        this.initialValues = (_b = options.initialValues) !== null && _b !== void 0 ? _b : {};
+        this.rate = (_c = options.rate) !== null && _c !== void 0 ? _c : 50;
+        this.bursts = (_d = acceptMultiple(options.bursts)) !== null && _d !== void 0 ? _d : [];
+        this.radialSpeed = (_e = options.radialSpeed) !== null && _e !== void 0 ? _e : 1;
+        this.alignment = (_f = options.alignment) !== null && _f !== void 0 ? _f : 0;
+        this.tags = acceptMultiple(options.tags);
+        this.tagSelection = (_g = options.tagSelection) !== null && _g !== void 0 ? _g : this.tagSelection;
+    }
+    /*
+      * CONTROLS
+    */
+    reset() {
+        this.bursts.forEach((burst) => {
+            burst.fired = false;
+        });
+        this._contextStates.clear();
+    }
+    /*
+      * SIMULATION
+    */
+    setup(particleSystem) {
+        particleSystem.add(this.source);
+    }
+    update(particles, context) {
+        var _a;
+        return this.updateAt(particles, Object.assign(Object.assign({}, context), { key: (_a = context === null || context === void 0 ? void 0 : context.key) !== null && _a !== void 0 ? _a : '__default' }));
+    }
+    updateAt(particles, context) {
+        var _a, _b, _c, _d, _e;
+        const now = Date.now();
+        const elapsedMilliseconds = context.elapsedTime === undefined
+            ? undefined
+            : context.elapsedTime * 1000;
+        const state = this.getContextState((_a = context.key) !== null && _a !== void 0 ? _a : '__default', elapsedMilliseconds !== null && elapsedMilliseconds !== void 0 ? elapsedMilliseconds : now);
+        const duration = (_b = context.duration) !== null && _b !== void 0 ? _b : 10;
+        const elapsedTime = (_c = context.elapsedTime) !== null && _c !== void 0 ? _c : ((now - state.startTime) / 1000);
+        const time = (_d = context.time) !== null && _d !== void 0 ? _d : (elapsedTime / duration);
+        const looping = (_e = context.looping) !== null && _e !== void 0 ? _e : true;
+        const spawned = [];
+        if (context.time === undefined && elapsedTime >= duration) {
+            if (!looping)
+                return spawned;
+            state.startTime = now;
+            state.lastSpawn = now;
+            state.firedBursts.clear();
+            return spawned;
+        }
+        const rate = evaluateDynamicNumber(this.rate, time);
+        if (rate > 0) {
+            const secondsPerParticle = 1000 / rate;
+            const spawnClock = elapsedMilliseconds !== null && elapsedMilliseconds !== void 0 ? elapsedMilliseconds : now;
+            const particlesDue = Math.floor((spawnClock - state.lastSpawn) / secondsPerParticle);
+            for (let i = 0; i < particlesDue; i += 1) {
+                const particle = this.spawnParticle(particles, time, context);
+                spawned.push(particle);
+            }
+            if (particlesDue > 0) {
+                state.lastSpawn = spawnClock;
+            }
+        }
+        this.bursts.forEach((burst, index) => {
+            if (!state.firedBursts.has(index) && burst.time <= time) {
+                const count = evaluateDynamicNumber(burst.count);
+                for (let i = 0; i < Math.floor(count); i += 1) {
+                    const particle = this.spawnParticle(particles, time, context);
+                    spawned.push(particle);
+                }
+                state.firedBursts.add(index);
+            }
+        });
+        return spawned;
+    }
+    clearContext(key) {
+        this._contextStates.delete(key);
+    }
+    getContextState(key, startTime) {
+        let state = this._contextStates.get(key);
+        if (!state) {
+            state = {
+                startTime,
+                lastSpawn: startTime,
+                firedBursts: new Set(),
+            };
+            this._contextStates.set(key, state);
+        }
+        return state;
+    }
+    spawnParticle(particles, time, context) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const point = this.source.getPoint();
+        const position = point.position.clone();
+        const normal = point.normal.clone();
+        if (context === null || context === void 0 ? void 0 : context.transform) {
+            position.applyMatrix4(context.transform);
+            normal.applyNormalMatrix(new THREE.Matrix3().getNormalMatrix(context.transform)).normalize();
+        }
+        const defaultRotationQuat = (new THREE.Quaternion).setFromUnitVectors(new THREE.Vector3(0, 0, 1), normal);
+        const defaultRotationEuler = new THREE.Euler().setFromQuaternion(defaultRotationQuat, 'YXZ');
+        const defaultRotation = new THREE.Vector3(defaultRotationEuler.x, defaultRotationEuler.y, defaultRotationEuler.z);
+        const rotation = new THREE.Vector3(0, 0, 0).lerp(defaultRotation, Math.max(Math.min(evaluateDynamicNumber(this.alignment, time), 1), 0));
+        const color = evaluateDynamicColor((_a = this.initialValues.color) !== null && _a !== void 0 ? _a : new THREE.Color(1, 1, 1), time);
+        if (context === null || context === void 0 ? void 0 : context.color) {
+            color.multiply(context.color);
+        }
+        let alpha = evaluateDynamicNumber((_b = this.initialValues.alpha) !== null && _b !== void 0 ? _b : 1, time);
+        if (context === null || context === void 0 ? void 0 : context.alpha) {
+            alpha *= context.alpha;
+        }
+        let mass = evaluateDynamicNumber((_c = this.initialValues.mass) !== null && _c !== void 0 ? _c : 0, time);
+        if (context === null || context === void 0 ? void 0 : context.mass) {
+            mass *= context.mass;
+        }
+        const particle = new Particle(Object.assign({ position, rotation: evaluateDynamicVector((_d = this.initialValues.rotation) !== null && _d !== void 0 ? _d : rotation, time), scale: evaluateDynamicVector((_e = this.initialValues.scale) !== null && _e !== void 0 ? _e : new THREE.Vector3(1, 1, 1), time), lifetime: evaluateDynamicNumber((_f = this.initialValues.lifetime) !== null && _f !== void 0 ? _f : 1, time), color,
+            alpha,
+            mass }, ((this.tags || (context === null || context === void 0 ? void 0 : context.tags)) && {
+            tags: [...((_g = context === null || context === void 0 ? void 0 : context.tags) !== null && _g !== void 0 ? _g : []), ...((_h = this._selectTags()) !== null && _h !== void 0 ? _h : [])],
+        })));
+        particle.speed = evaluateDynamicNumber((_j = this.initialValues.speed) !== null && _j !== void 0 ? _j : 1, time);
+        particle.velocity = evaluateDynamicVector((_k = this.initialValues.velocity) !== null && _k !== void 0 ? _k : new THREE.Vector3(0, 0, 0), time).clone()
+            .add(normal.multiplyScalar(evaluateDynamicNumber(this.radialSpeed, time)));
+        if (this.initialValues.angularVelocity)
+            particle.angularVelocity = evaluateDynamicVector(this.initialValues.angularVelocity, time).clone();
+        if (this.initialValues.scalarVelocity)
+            particle.scalarVelocity = evaluateDynamicVector(this.initialValues.scalarVelocity, time).clone();
+        if (this.initialValues.acceleration)
+            particle.acceleration = evaluateDynamicVector(this.initialValues.acceleration, time).clone();
+        if (this.initialValues.angularAcceleration)
+            particle.angularAcceleration = evaluateDynamicVector(this.initialValues.angularAcceleration, time).clone();
+        if (this.initialValues.scalarAcceleration)
+            particle.scalarAcceleration = evaluateDynamicVector(this.initialValues.scalarAcceleration, time).clone();
+        particle.cacheStartValues();
+        particles.push(particle);
+        return particle;
+    }
+    _selectTags() {
+        if (!this.tags)
+            return;
+        switch (this.tagSelection) {
+            case 'random':
+                return [this.tags[Math.floor(Math.random() * this.tags.length)]];
+            case 'distribute':
+                this._lastTagIndex = (this._lastTagIndex + 1) % this.tags.length;
+                return [this.tags[this._lastTagIndex]];
+            case 'all':
+            default:
+                return this.tags;
+        }
+    }
+}
+export default Emitter;

package/build/GpuModule.d.ts

@@ -0,0 +1,28 @@
+import Module, { ModuleOptions } from './Module';
+import Particle from './Particle';
+import type ParticleSystem from './ParticleSystem';
+import { GpuCapableRenderer, GpuParticleContext } from './gpu/GpuParticleContext';
+import { DynamicValue } from './types/DynamicValue';
+export interface GpuModuleBuildContext {
+    particles: GpuParticleContext;
+    deltaTime: number;
+    renderer: GpuCapableRenderer;
+    system: ParticleSystem;
+}
+export type GpuModuleBuilder = (context: GpuModuleBuildContext) => any | any[];
+export type GpuModulePredicate = (context: GpuModuleBuildContext) => boolean;
+export interface GpuModuleOptions extends Partial<ModuleOptions> {
+    gpu?: GpuModuleBuilder;
+    canRunGpu?: GpuModulePredicate;
+}
+declare class GpuModule extends Module {
+    readonly supportsGpu = true;
+    constructor(modify: ((particle: Particle, deltaTime: number) => void), options?: GpuModuleOptions);
+    private _buildGpu?;
+    private _canRunGpu?;
+    canRunGpu(context: GpuModuleBuildContext): boolean;
+    buildGpu(context: GpuModuleBuildContext): any | any[];
+}
+export declare function isGpuModule(module: Module): module is GpuModule;
+export declare function isGpuStaticValue<T>(value: DynamicValue<T> | undefined): value is T;
+export default GpuModule;

package/build/GpuModule.js

@@ -0,0 +1,28 @@
+import Module from './Module';
+class GpuModule extends Module {
+    constructor(modify, options = {}) {
+        super(modify, options);
+        this.supportsGpu = true;
+        this._buildGpu = options.gpu;
+        this._canRunGpu = options.canRunGpu;
+    }
+    canRunGpu(context) {
+        var _a, _b;
+        return !!this._buildGpu && ((_b = (_a = this._canRunGpu) === null || _a === void 0 ? void 0 : _a.call(this, context)) !== null && _b !== void 0 ? _b : true);
+    }
+    buildGpu(context) {
+        var _a, _b;
+        return (_b = (_a = this._buildGpu) === null || _a === void 0 ? void 0 : _a.call(this, context)) !== null && _b !== void 0 ? _b : [];
+    }
+}
+export function isGpuModule(module) {
+    return module instanceof GpuModule || (module.supportsGpu === true
+        && typeof module.buildGpu === 'function');
+}
+export function isGpuStaticValue(value) {
+    return value !== undefined
+        && typeof value !== 'function'
+        && !Array.isArray(value)
+        && !(value instanceof Set);
+}
+export default GpuModule;

package/build/Module.d.ts

@@ -0,0 +1,19 @@
+import Particle from './Particle';
+import ParticleSystem from './ParticleSystem';
+import { Tag } from './types/Tag';
+import { StrictMultiple } from './types/Multiple';
+export interface ModuleOptions {
+    priority: number;
+    tags: StrictMultiple<Tag>;
+}
+export default class Module {
+    _modify: ((particle: Particle, deltaTime: number) => void);
+    dependents: Module[];
+    tags?: Tag[];
+    priority: number;
+    constructor(_modify: ((particle: Particle, deltaTime: number) => void), options?: Partial<ModuleOptions>);
+    modify(particles: Particle[], deltaTime: number): void;
+    withDependents(): Module[];
+    prepare(particleSystem: ParticleSystem, deltaTime: number): void;
+    cleanup(): void;
+}

package/build/Module.js

@@ -0,0 +1,31 @@
+import acceptMultiple from './helpers/acceptMultiple';
+import tagsIntersect from './helpers/tagsIntersect';
+export default class Module {
+    constructor(_modify, options = {}) {
+        var _a;
+        this._modify = _modify;
+        // Sub-modules on which this module depends.
+        // Useful for pre-processing or combining priority stages.
+        this.dependents = [];
+        this.priority = -1;
+        this.tags = acceptMultiple(options.tags);
+        this.priority = (_a = options.priority) !== null && _a !== void 0 ? _a : this.priority;
+    }
+    modify(particles, deltaTime) {
+        particles.filter((p) => { var _a; return !this.tags || tagsIntersect(this.tags, (_a = p.tags) !== null && _a !== void 0 ? _a : []); })
+            .forEach((p) => this._modify(p, deltaTime));
+    }
+    // Process into array including self and dependents
+    withDependents() {
+        // Run dependents before this
+        return [
+            ...(this.dependents.flatMap(d => d.withDependents())),
+            this,
+        ];
+    }
+    // Optional preparation hook called once-per-update rather than per particle
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    prepare(particleSystem, deltaTime) { }
+    // Optional clean up hook for modules that require it
+    cleanup() { }
+}

package/build/Particle.d.ts

@@ -0,0 +1,60 @@
+import * as THREE from 'three';
+import { Tag } from './types/Tag';
+export interface ParticleOptions {
+    position: THREE.Vector3;
+    rotation: THREE.Vector3;
+    scale: THREE.Vector3;
+    color: THREE.Color;
+    tags: Tag[];
+    alpha: number;
+    lifetime: number;
+    mass: number;
+}
+export interface ParticleStartValues {
+    lifetime: number;
+    position: THREE.Vector3;
+    rotation: THREE.Vector3;
+    scale: THREE.Vector3;
+    velocity: THREE.Vector3;
+    angularVelocity: THREE.Vector3;
+    scalarVelocity: THREE.Vector3;
+    acceleration: THREE.Vector3;
+    angularAcceleration: THREE.Vector3;
+    scalarAcceleration: THREE.Vector3;
+    speed: number;
+    color: THREE.Color;
+    alpha: number;
+    mass: number;
+}
+export interface ParticleNoiseValues {
+    noise: number;
+    noise4d: number;
+}
+declare class Particle {
+    position: THREE.Vector3;
+    rotation: THREE.Vector3;
+    scale: THREE.Vector3;
+    velocity: THREE.Vector3;
+    angularVelocity: THREE.Vector3;
+    scalarVelocity: THREE.Vector3;
+    acceleration: THREE.Vector3;
+    angularAcceleration: THREE.Vector3;
+    scalarAcceleration: THREE.Vector3;
+    speed: number;
+    color: THREE.Color;
+    alpha: number;
+    mass: number;
+    startTime: number;
+    lifetime: number;
+    time: number;
+    realtime: number;
+    id: string;
+    start: ParticleStartValues;
+    noise: Record<string, ParticleNoiseValues>;
+    tags?: Tag[];
+    data: any;
+    constructor(options?: Partial<ParticleOptions>);
+    cacheStartValues(): void;
+    private createStartValues;
+}
+export default Particle;

package/build/Particle.js

@@ -0,0 +1,52 @@
+import { nanoid } from 'nanoid';
+import * as THREE from 'three';
+class Particle {
+    constructor(options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        this.velocity = new THREE.Vector3(0, 0, 0);
+        this.angularVelocity = new THREE.Vector3(0, 0, 0);
+        this.scalarVelocity = new THREE.Vector3(0, 0, 0);
+        this.acceleration = new THREE.Vector3(0, 0, 0);
+        this.angularAcceleration = new THREE.Vector3(0, 0, 0);
+        this.scalarAcceleration = new THREE.Vector3(0, 0, 0);
+        this.speed = 1;
+        this.mass = 0;
+        this.position = (_a = options.position) !== null && _a !== void 0 ? _a : new THREE.Vector3();
+        this.rotation = (_b = options.rotation) !== null && _b !== void 0 ? _b : new THREE.Vector3();
+        this.scale = (_c = options.scale) !== null && _c !== void 0 ? _c : new THREE.Vector3(1, 1, 1);
+        this.color = (_d = options.color) !== null && _d !== void 0 ? _d : new THREE.Color(0xffffff);
+        this.alpha = (_e = options.alpha) !== null && _e !== void 0 ? _e : 1;
+        this.mass = (_f = options.mass) !== null && _f !== void 0 ? _f : 0;
+        this.lifetime = (_g = options.lifetime) !== null && _g !== void 0 ? _g : 5;
+        this.startTime = Date.now();
+        this.time = 0;
+        this.realtime = 0;
+        this.id = nanoid();
+        this.tags = options.tags;
+        this.start = this.createStartValues();
+        this.noise = {};
+        this.data = {};
+    }
+    cacheStartValues() {
+        this.start = this.createStartValues();
+    }
+    createStartValues() {
+        return {
+            lifetime: this.lifetime,
+            position: this.position.clone(),
+            rotation: this.rotation.clone(),
+            scale: this.scale.clone(),
+            velocity: this.velocity.clone(),
+            angularVelocity: this.angularVelocity.clone(),
+            scalarVelocity: this.scalarVelocity.clone(),
+            acceleration: this.acceleration.clone(),
+            angularAcceleration: this.angularAcceleration.clone(),
+            scalarAcceleration: this.scalarAcceleration.clone(),
+            speed: this.speed,
+            mass: this.mass,
+            color: this.color.clone(),
+            alpha: this.alpha,
+        };
+    }
+}
+export default Particle;

package/build/ParticleForceField.d.ts

@@ -0,0 +1,39 @@
+import * as THREE from 'three';
+import Particle from './Particle';
+import { IParticleForceField } from './interfaces/IParticleForceField';
+import { DynamicValue } from './types/DynamicValue';
+import { StrictMultiple } from './types/Multiple';
+import { Tag } from './types/Tag';
+export interface ForceFieldOptions {
+    position: THREE.Vector3;
+    direction: DynamicValue<THREE.Vector3>;
+    gravity: DynamicValue<number>;
+    rotationSpeed: DynamicValue<number>;
+    rotationAttraction: DynamicValue<number>;
+    drag: DynamicValue<number>;
+    scale: THREE.Vector3;
+    geometry: THREE.BufferGeometry;
+    tags: StrictMultiple<Tag>;
+}
+declare class ParticleForceField extends THREE.Object3D implements IParticleForceField {
+    private static readonly _doubleSidedMaterial;
+    static Box(options?: Partial<ForceFieldOptions>, ...args: any[]): ParticleForceField;
+    static Sphere(options?: Partial<ForceFieldOptions>, ...args: any[]): ParticleForceField;
+    static Cone(options?: Partial<ForceFieldOptions>, ...args: any[]): ParticleForceField;
+    static Torus(options?: Partial<ForceFieldOptions>, ...args: any[]): ParticleForceField;
+    direction?: DynamicValue<THREE.Vector3>;
+    gravity?: DynamicValue<number>;
+    rotationSpeed?: DynamicValue<number>;
+    rotationAttraction?: DynamicValue<number>;
+    drag?: DynamicValue<number>;
+    tags?: Tag[];
+    private _geometry;
+    set geometry(value: THREE.BufferGeometry);
+    get geometry(): THREE.BufferGeometry;
+    private _mesh;
+    constructor(options: Partial<ForceFieldOptions>);
+    getForce(particle: Particle): THREE.Vector3;
+    private contains;
+    private getFalloff;
+}
+export default ParticleForceField;