@rzmps/rzmps 1.0.0

package/build/gpu/GpuParticleContext.d.ts

@@ -0,0 +1,63 @@
+import * as THREE from 'three';
+import Particle from '../Particle';
+import { DynamicValue } from '../types/DynamicValue';
+export type GpuCapableRenderer = {
+    compute?: (nodes: any, dispatchSize?: number | number[]) => Promise<void> | undefined;
+    computeAsync?: (nodes: any, dispatchSize?: number | number[]) => Promise<void>;
+    getArrayBufferAsync?: (attribute: THREE.BufferAttribute, target?: null, offset?: number, count?: number) => Promise<ArrayBuffer>;
+};
+export interface GpuParticleUpdateOptions {
+    deltaTime: number;
+    gravity: THREE.Vector3;
+}
+export declare const GPU_PREVIOUS_POSITION_KEY = "__rmps_collision_prevPosition";
+export declare class GpuParticleContext {
+    capacity: number;
+    count: number;
+    position: any;
+    previousPosition: any;
+    rotation: any;
+    scale: any;
+    velocity: any;
+    angularVelocity: any;
+    scalarVelocity: any;
+    acceleration: any;
+    angularAcceleration: any;
+    scalarAcceleration: any;
+    color: any;
+    meta: any;
+    mass: any;
+    seed: any;
+    startPosition: any;
+    startRotation: any;
+    startScale: any;
+    startVelocity: any;
+    startAngularVelocity: any;
+    startScalarVelocity: any;
+    startAcceleration: any;
+    startAngularAcceleration: any;
+    startScalarAcceleration: any;
+    startColor: any;
+    startMeta: any;
+    startMass: any;
+    private noiseBuffers;
+    readonly deltaTime: import("three/src/nodes/Nodes.js").UniformNode<"float", number>;
+    readonly gravity: import("three/src/nodes/Nodes.js").UniformNode<"vec3", THREE.Vector3>;
+    ensureCapacity(count: number): void;
+    updateUniforms(options: GpuParticleUpdateOptions): void;
+    upload(particles: Particle[]): void;
+    download(renderer: GpuCapableRenderer, particles: Particle[]): Promise<void>;
+    buildCoreUpdateNodes(gravityModifier: DynamicValue<number>): any[];
+    buildCoreUpdateNode(gravityModifier: DynamicValue<number>): any;
+    clear(): void;
+    private read;
+    private markNeedsUpdate;
+    getNoise(key: string): any;
+    private writeVec3;
+    private writeColor;
+    private writeMeta;
+    private readVec3;
+    private storageStride;
+    private writeStride;
+    private readStride;
+}

package/build/gpu/GpuParticleContext.js

@@ -0,0 +1,291 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as THREE from 'three';
+import { Fn, instanceIndex, instancedArray, uniform, } from 'three/src/nodes/TSL.js';
+import seedrandom from 'seedrandom';
+import { gpuDynamicNumber } from './GpuDynamicValue';
+export const GPU_PREVIOUS_POSITION_KEY = '__rmps_collision_prevPosition';
+export class GpuParticleContext {
+    constructor() {
+        this.capacity = 0;
+        this.count = 0;
+        this.noiseBuffers = new Map();
+        this.deltaTime = uniform(0);
+        this.gravity = uniform(new THREE.Vector3(), 'vec3');
+    }
+    ensureCapacity(count) {
+        if (count <= this.capacity) {
+            this.count = count;
+            return;
+        }
+        this.capacity = Math.max(1, count);
+        this.count = count;
+        this.noiseBuffers.clear();
+        this.position = instancedArray(this.capacity, 'vec3').setName('RmpsPosition');
+        this.previousPosition = instancedArray(this.capacity, 'vec3').setName('RmpsPreviousPosition');
+        this.rotation = instancedArray(this.capacity, 'vec3').setName('RmpsRotation');
+        this.scale = instancedArray(this.capacity, 'vec3').setName('RmpsScale');
+        this.velocity = instancedArray(this.capacity, 'vec3').setName('RmpsVelocity');
+        this.angularVelocity = instancedArray(this.capacity, 'vec3').setName('RmpsAngularVelocity');
+        this.scalarVelocity = instancedArray(this.capacity, 'vec3').setName('RmpsScalarVelocity');
+        this.acceleration = instancedArray(this.capacity, 'vec3').setName('RmpsAcceleration');
+        this.angularAcceleration = instancedArray(this.capacity, 'vec3').setName('RmpsAngularAcceleration');
+        this.scalarAcceleration = instancedArray(this.capacity, 'vec3').setName('RmpsScalarAcceleration');
+        this.color = instancedArray(this.capacity, 'vec4').setName('RmpsColor');
+        this.meta = instancedArray(this.capacity, 'vec4').setName('RmpsMeta');
+        this.mass = instancedArray(this.capacity, 'float').setName('RmpsMass');
+        this.seed = instancedArray(this.capacity, 'float').setName('RmpsSeed');
+        this.startPosition = instancedArray(this.capacity, 'vec3').setName('RmpsStartPosition');
+        this.startRotation = instancedArray(this.capacity, 'vec3').setName('RmpsStartRotation');
+        this.startScale = instancedArray(this.capacity, 'vec3').setName('RmpsStartScale');
+        this.startVelocity = instancedArray(this.capacity, 'vec3').setName('RmpsStartVelocity');
+        this.startAngularVelocity = instancedArray(this.capacity, 'vec3').setName('RmpsStartAngularVelocity');
+        this.startScalarVelocity = instancedArray(this.capacity, 'vec3').setName('RmpsStartScalarVelocity');
+        this.startAcceleration = instancedArray(this.capacity, 'vec3').setName('RmpsStartAcceleration');
+        this.startAngularAcceleration = instancedArray(this.capacity, 'vec3').setName('RmpsStartAngularAcceleration');
+        this.startScalarAcceleration = instancedArray(this.capacity, 'vec3').setName('RmpsStartScalarAcceleration');
+        this.startColor = instancedArray(this.capacity, 'vec4').setName('RmpsStartColor');
+        this.startMeta = instancedArray(this.capacity, 'vec4').setName('RmpsStartMeta');
+        this.startMass = instancedArray(this.capacity, 'float').setName('RmpsStartMass');
+    }
+    updateUniforms(options) {
+        this.deltaTime.value = options.deltaTime;
+        this.gravity.value.copy(options.gravity);
+    }
+    upload(particles) {
+        this.ensureCapacity(particles.length);
+        particles.forEach((particle, index) => {
+            this.writeVec3(this.position, index, particle.position);
+            this.writeVec3(this.previousPosition, index, particle.position);
+            this.writeVec3(this.rotation, index, particle.rotation);
+            this.writeVec3(this.scale, index, particle.scale);
+            this.writeVec3(this.velocity, index, particle.velocity);
+            this.writeVec3(this.angularVelocity, index, particle.angularVelocity);
+            this.writeVec3(this.scalarVelocity, index, particle.scalarVelocity);
+            this.writeVec3(this.acceleration, index, particle.acceleration);
+            this.writeVec3(this.angularAcceleration, index, particle.angularAcceleration);
+            this.writeVec3(this.scalarAcceleration, index, particle.scalarAcceleration);
+            this.writeColor(this.color.value.array, index, particle.color, particle.alpha);
+            this.writeMeta(this.meta.value.array, index, particle.time, particle.realtime, particle.lifetime, particle.speed);
+            this.mass.value.array[index] = particle.mass;
+            this.seed.value.array[index] = seedrandom(particle.id).quick();
+            this.writeVec3(this.startPosition, index, particle.start.position);
+            this.writeVec3(this.startRotation, index, particle.start.rotation);
+            this.writeVec3(this.startScale, index, particle.start.scale);
+            this.writeVec3(this.startVelocity, index, particle.start.velocity);
+            this.writeVec3(this.startAngularVelocity, index, particle.start.angularVelocity);
+            this.writeVec3(this.startScalarVelocity, index, particle.start.scalarVelocity);
+            this.writeVec3(this.startAcceleration, index, particle.start.acceleration);
+            this.writeVec3(this.startAngularAcceleration, index, particle.start.angularAcceleration);
+            this.writeVec3(this.startScalarAcceleration, index, particle.start.scalarAcceleration);
+            this.writeColor(this.startColor.value.array, index, particle.start.color, particle.start.alpha);
+            this.writeMeta(this.startMeta.value.array, index, 0, 0, particle.start.lifetime, particle.start.speed);
+            this.startMass.value.array[index] = particle.start.mass;
+            this.noiseBuffers.forEach((node, key) => {
+                var _a, _b;
+                const noise = particle.noise[key];
+                const offset = index * 2;
+                node.value.array[offset] = (_a = noise === null || noise === void 0 ? void 0 : noise.noise) !== null && _a !== void 0 ? _a : 0;
+                node.value.array[offset + 1] = (_b = noise === null || noise === void 0 ? void 0 : noise.noise4d) !== null && _b !== void 0 ? _b : 0;
+            });
+        });
+        this.markNeedsUpdate();
+    }
+    download(renderer, particles) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!renderer.getArrayBufferAsync || this.count === 0)
+                return;
+            const [position, previousPosition, rotation, scale, velocity, angularVelocity, scalarVelocity, acceleration, angularAcceleration, scalarAcceleration, color, meta, mass,] = yield Promise.all([
+                this.read(renderer, this.position),
+                this.read(renderer, this.previousPosition),
+                this.read(renderer, this.rotation),
+                this.read(renderer, this.scale),
+                this.read(renderer, this.velocity),
+                this.read(renderer, this.angularVelocity),
+                this.read(renderer, this.scalarVelocity),
+                this.read(renderer, this.acceleration),
+                this.read(renderer, this.angularAcceleration),
+                this.read(renderer, this.scalarAcceleration),
+                this.read(renderer, this.color),
+                this.read(renderer, this.meta),
+                this.read(renderer, this.mass),
+            ]);
+            particles.forEach((particle, index) => {
+                this.readVec3(position, this.position, index, particle.position);
+                particle.data[GPU_PREVIOUS_POSITION_KEY] = new THREE.Vector3();
+                this.readVec3(previousPosition, this.previousPosition, index, particle.data[GPU_PREVIOUS_POSITION_KEY]);
+                this.readVec3(rotation, this.rotation, index, particle.rotation);
+                this.readVec3(scale, this.scale, index, particle.scale);
+                this.readVec3(velocity, this.velocity, index, particle.velocity);
+                this.readVec3(angularVelocity, this.angularVelocity, index, particle.angularVelocity);
+                this.readVec3(scalarVelocity, this.scalarVelocity, index, particle.scalarVelocity);
+                this.readVec3(acceleration, this.acceleration, index, particle.acceleration);
+                this.readVec3(angularAcceleration, this.angularAcceleration, index, particle.angularAcceleration);
+                this.readVec3(scalarAcceleration, this.scalarAcceleration, index, particle.scalarAcceleration);
+                const colorOffset = index * 4;
+                particle.color.setRGB(color[colorOffset], color[colorOffset + 1], color[colorOffset + 2]);
+                particle.alpha = color[colorOffset + 3];
+                const metaOffset = index * 4;
+                particle.time = meta[metaOffset];
+                particle.realtime = meta[metaOffset + 1];
+                particle.mass = mass[index];
+            });
+        });
+    }
+    buildCoreUpdateNodes(gravityModifier) {
+        const updatePosition = Fn(() => {
+            const index = instanceIndex;
+            const position = this.position.element(index);
+            const previousPosition = this.previousPosition.element(index);
+            const velocity = this.velocity.element(index);
+            const acceleration = this.acceleration.element(index);
+            const meta = this.meta.element(index);
+            const seed = this.seed.element(index);
+            const gravityMultiplier = gpuDynamicNumber(gravityModifier, meta.x, seed, 0);
+            previousPosition.assign(position);
+            velocity.addAssign(this.gravity.mul(this.deltaTime.mul(gravityMultiplier)));
+            meta.y.addAssign(this.deltaTime);
+            meta.x.assign(meta.y.div(meta.z));
+            position.addAssign(velocity.mul(this.deltaTime.mul(meta.w)));
+            velocity.addAssign(acceleration.mul(this.deltaTime.mul(meta.w)));
+        })().compute(this.count);
+        const updateRotation = Fn(() => {
+            const index = instanceIndex;
+            const rotation = this.rotation.element(index);
+            const angularVelocity = this.angularVelocity.element(index);
+            const angularAcceleration = this.angularAcceleration.element(index);
+            const meta = this.meta.element(index);
+            rotation.addAssign(angularVelocity.mul(this.deltaTime.mul(meta.w)));
+            angularVelocity.addAssign(angularAcceleration.mul(this.deltaTime.mul(meta.w)));
+        })().compute(this.count);
+        const updateScale = Fn(() => {
+            const index = instanceIndex;
+            const scale = this.scale.element(index);
+            const scalarVelocity = this.scalarVelocity.element(index);
+            const scalarAcceleration = this.scalarAcceleration.element(index);
+            const meta = this.meta.element(index);
+            scale.addAssign(scalarVelocity.mul(this.deltaTime.mul(meta.w)));
+            scalarVelocity.addAssign(scalarAcceleration.mul(this.deltaTime.mul(meta.w)));
+        })().compute(this.count);
+        const keepReadbackBuffersResident = Fn(() => {
+            const index = instanceIndex;
+            const color = this.color.element(index);
+            const mass = this.mass.element(index);
+            color.assign(color);
+            mass.assign(mass);
+        })().compute(this.count);
+        return [
+            updatePosition,
+            updateRotation,
+            updateScale,
+            keepReadbackBuffersResident,
+        ];
+    }
+    buildCoreUpdateNode(gravityModifier) {
+        return this.buildCoreUpdateNodes(gravityModifier);
+    }
+    clear() {
+        this.count = 0;
+    }
+    read(renderer, node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const buffer = yield renderer.getArrayBufferAsync(node.value, null, 0, this.count * this.storageStride(node) * 4);
+            return new Float32Array(buffer);
+        });
+    }
+    markNeedsUpdate() {
+        [
+            this.position,
+            this.previousPosition,
+            this.rotation,
+            this.scale,
+            this.velocity,
+            this.angularVelocity,
+            this.scalarVelocity,
+            this.acceleration,
+            this.angularAcceleration,
+            this.scalarAcceleration,
+            this.color,
+            this.meta,
+            this.mass,
+            this.seed,
+            this.startPosition,
+            this.startRotation,
+            this.startScale,
+            this.startVelocity,
+            this.startAngularVelocity,
+            this.startScalarVelocity,
+            this.startAcceleration,
+            this.startAngularAcceleration,
+            this.startScalarAcceleration,
+            this.startColor,
+            this.startMeta,
+            this.startMass,
+            ...Array.from(this.noiseBuffers.values()),
+        ].forEach((node) => {
+            if (node === null || node === void 0 ? void 0 : node.value)
+                node.value.needsUpdate = true;
+        });
+    }
+    getNoise(key) {
+        let node = this.noiseBuffers.get(key);
+        if (!node) {
+            node = instancedArray(this.capacity, 'vec2').setName(`RmpsNoise_${key.replace(/[^a-zA-Z0-9_]/g, '_')}`);
+            this.noiseBuffers.set(key, node);
+        }
+        return node;
+    }
+    writeVec3(node, index, value) {
+        const array = node.value.array;
+        const offset = index * this.writeStride(node);
+        array[offset] = value.x;
+        array[offset + 1] = value.y;
+        array[offset + 2] = value.z;
+    }
+    writeColor(array, index, color, alpha) {
+        const offset = index * 4;
+        array[offset] = color.r;
+        array[offset + 1] = color.g;
+        array[offset + 2] = color.b;
+        array[offset + 3] = alpha;
+    }
+    writeMeta(array, index, time, realtime, lifetime, speed) {
+        const offset = index * 4;
+        array[offset] = time;
+        array[offset + 1] = realtime;
+        array[offset + 2] = lifetime;
+        array[offset + 3] = speed;
+    }
+    readVec3(array, node, index, target) {
+        const offset = index * this.readStride(array, node);
+        target.set(array[offset], array[offset + 1], array[offset + 2]);
+    }
+    storageStride(node) {
+        var _a, _b, _c;
+        return ((_a = node === null || node === void 0 ? void 0 : node.value) === null || _a === void 0 ? void 0 : _a.itemSize) === 3 ? 4 : (_c = (_b = node === null || node === void 0 ? void 0 : node.value) === null || _b === void 0 ? void 0 : _b.itemSize) !== null && _c !== void 0 ? _c : 1;
+    }
+    writeStride(node) {
+        var _a, _b;
+        const itemSize = (_b = (_a = node === null || node === void 0 ? void 0 : node.value) === null || _a === void 0 ? void 0 : _a.itemSize) !== null && _b !== void 0 ? _b : 1;
+        if (itemSize !== 3)
+            return itemSize;
+        const array = node.value.array;
+        return array.length >= this.capacity * 4 ? 4 : 3;
+    }
+    readStride(array, node) {
+        var _a, _b;
+        const itemSize = (_b = (_a = node === null || node === void 0 ? void 0 : node.value) === null || _a === void 0 ? void 0 : _a.itemSize) !== null && _b !== void 0 ? _b : 1;
+        if (itemSize !== 3)
+            return itemSize;
+        if (this.count <= 0)
+            return 4;
+        return array.length >= this.count * 4 ? 4 : 3;
+    }
+}

package/build/helpers/acceptMultiple.d.ts

@@ -0,0 +1,2 @@
+import { Multiple } from '../types/Multiple';
+export default function acceptMultiple<T>(param?: Multiple<T>): NonNullable<T>[] | undefined;

package/build/helpers/acceptMultiple.js

@@ -0,0 +1,6 @@
+export default function acceptMultiple(param) {
+    if (!param)
+        return;
+    const arr = [];
+    return arr.concat(param).filter((e) => e != null);
+}

package/build/helpers/evaluateDynamic.d.ts

@@ -0,0 +1,2 @@
+import { DynamicValue } from '../types/DynamicValue';
+export default function evaluateDynamic<T>(value: DynamicValue<T>, interpolate: (a: T, b: T, t: number) => T, time?: number, seed?: string | undefined): T;

package/build/helpers/evaluateDynamic.js

@@ -0,0 +1,18 @@
+import seedrandom from 'seedrandom';
+export default function evaluateDynamic(value, interpolate, time = 0, seed = undefined) {
+    if (typeof value === 'function') {
+        return evaluateDynamic(value(time), interpolate, time, seed);
+    }
+    else if (Array.isArray(value)) {
+        const interpTime = seed == undefined ? Math.random() : seedrandom(seed).quick();
+        const min = evaluateDynamic(value[0], interpolate, time, seed);
+        const max = evaluateDynamic(value[1], interpolate, time, seed);
+        return interpolate(min, max, interpTime);
+    }
+    else if (value instanceof Set) {
+        const indexSelector = seed == undefined ? Math.random() : seedrandom(seed).quick();
+        const item = Array.from(value)[Math.floor(value.size * indexSelector)];
+        return evaluateDynamic(item, interpolate, time, seed);
+    }
+    return value;
+}

package/build/helpers/evaluateDynamicColor.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from 'three';
+import { DynamicValue } from '../types/DynamicValue';
+export default function evaluateDynamicColor(value?: DynamicValue<THREE.Color>, time?: number, seed?: string | undefined): THREE.Color;

package/build/helpers/evaluateDynamicColor.js

@@ -0,0 +1,5 @@
+import * as THREE from 'three';
+import evaluateDynamic from './evaluateDynamic';
+export default function evaluateDynamicColor(value = new THREE.Color(), time = 0, seed = undefined) {
+    return evaluateDynamic(value, (a, b, t) => (a.clone().add((b.clone().sub(a).multiplyScalar(t)))), time, seed).clone();
+}

package/build/helpers/evaluateDynamicNumber.d.ts

@@ -0,0 +1,2 @@
+import { DynamicValue } from '../types/DynamicValue';
+export default function evaluateDynamicNumber(value?: DynamicValue<number>, time?: number, seed?: string | undefined): number;

package/build/helpers/evaluateDynamicNumber.js

@@ -0,0 +1,4 @@
+import evaluateDynamic from './evaluateDynamic';
+export default function evaluateDynamicNumber(value = 0, time = 0, seed = undefined) {
+    return evaluateDynamic(value, (a, b, t) => (a + (b - a) * t), time, seed);
+}

package/build/helpers/evaluateDynamicVector3.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from 'three';
+import { DynamicValue } from '../types/DynamicValue';
+export default function evaluateDynamicVector(value?: DynamicValue<THREE.Vector3>, time?: number, seed?: string | undefined): THREE.Vector3;

package/build/helpers/evaluateDynamicVector3.js

@@ -0,0 +1,5 @@
+import * as THREE from 'three';
+import evaluateDynamic from './evaluateDynamic';
+export default function evaluateDynamicVector(value = new THREE.Vector3(), time = 0, seed = undefined) {
+    return evaluateDynamic(value, (a, b, t) => (a.clone().add((b.clone().sub(a).multiplyScalar(t)))), time, seed);
+}

package/build/helpers/isPointInMesh.d.ts

@@ -0,0 +1,2 @@
+import * as THREE from 'three';
+export default function isPointInMesh(point: THREE.Vector3, mesh: THREE.Mesh): boolean;

package/build/helpers/isPointInMesh.js

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+const raycaster = new THREE.Raycaster();
+const rayDirection = new THREE.Vector3(1, 0.371, 0.529).normalize();
+export default function isPointInMesh(point, mesh) {
+    raycaster.set(point, rayDirection);
+    const intersects = raycaster.intersectObject(mesh, false);
+    return intersects.length % 2 === 1;
+}

package/build/helpers/particleRatio.d.ts

@@ -0,0 +1,2 @@
+import Particle from "../Particle";
+export default function particleRatio(particle: Particle, ratio: number): boolean;

package/build/helpers/particleRatio.js

@@ -0,0 +1,13 @@
+export default function particleRatio(particle, ratio) {
+    if (ratio <= 0)
+        return false;
+    if (ratio >= 1)
+        return true;
+    let hash = 0;
+    for (let i = 0; i < particle.id.length; i += 1) {
+        // eslint-disable-next-line no-bitwise
+        hash = (hash * 31 + particle.id.charCodeAt(i)) >>> 0;
+    }
+    const value = hash / 0xffffffff;
+    return value < ratio;
+}

package/build/helpers/tagsIntersect.d.ts

@@ -0,0 +1,2 @@
+import { Tag } from "../types/Tag";
+export default function tagsIntersect(a: Tag[], b: Tag[]): boolean;

package/build/helpers/tagsIntersect.js

@@ -0,0 +1,4 @@
+export default function tagsIntersect(a, b) {
+    const intersection = new Set(a).intersection(new Set(b));
+    return intersection.size !== 0;
+}

package/build/index.d.ts

@@ -0,0 +1,37 @@
+export { default as ParticleSystem } from './ParticleSystem';
+export { default as Particle } from './Particle';
+export { EndBehavior } from './enums/EndBehavior';
+export { SimulationSpace } from './enums/SimulationSpace';
+export { default as EmissionShape } from './EmissionShape';
+export { default as Emitter } from './Emitter';
+export { EmissionSource } from './enums/EmissionSource';
+export { TagSelectionMethod } from './enums/TagSelectionMethod';
+export { default as Renderer } from './Renderer';
+export { default as LightRenderer } from './renderers/LightRenderer';
+export { default as MeshRenderer } from './renderers/MeshRenderer';
+export { default as SpriteRenderer } from './renderers/SpriteRenderer';
+export { SpriteMaterialType } from './enums/SpriteMaterialType';
+export { default as TrailRenderer } from './renderers/TrailRenderer';
+export { TrailMode } from './enums/TrailMode';
+export { TrailTextureMode } from './enums/TrailTextureMode';
+export { default as Module, ModuleOptions } from './Module';
+export { default as NoiseModule } from './modules/NoiseModule';
+export { default as VelocityOverLifetime } from './modules/VelocityOverLifetime';
+export { default as ForceOverLifetime } from './modules/ForceOverLifetime';
+export { default as LimitVelocityOverLifetime } from './modules/LimitVelocityOverLifetime';
+export { default as TransformByNoise } from './modules/TransformByNoise';
+export { default as ColorOverLifetime } from './modules/ColorOverLifetime';
+export { default as ColorBySpeed } from './modules/ColorBySpeed';
+export { default as ScaleOverLifetime } from './modules/ScaleOverLifetime';
+export { default as ScaleBySpeed } from './modules/ScaleBySpeed';
+export { default as RotationOverLifetime } from './modules/RotationOverLifetime';
+export { default as RotationBySpeed } from './modules/RotationBySpeed';
+export { default as ExternalForces } from './modules/ExternalForces';
+export { default as Collision } from './modules/Collision';
+export { default as Audio } from './modules/Audio';
+export { IParticleForceField } from './interfaces/IParticleForceField';
+export { default as ParticleForceField } from './ParticleForceField';
+export { default as ParticleForceFieldHelper } from './ParticleForceFieldHelper';
+export { ICollisionBackend, CollisionHit, CollisionQuery } from './interfaces/ICollisionBackend';
+export { default as ThreeCollisionBackend } from './collision/ThreeCollisionBackend';
+export { DynamicValue } from './types/DynamicValue';

package/build/index.js

@@ -0,0 +1,34 @@
+export { default as ParticleSystem } from './ParticleSystem';
+export { default as Particle } from './Particle';
+export { EndBehavior } from './enums/EndBehavior';
+export { SimulationSpace } from './enums/SimulationSpace';
+export { default as EmissionShape } from './EmissionShape';
+export { default as Emitter } from './Emitter';
+export { EmissionSource } from './enums/EmissionSource';
+export { TagSelectionMethod } from './enums/TagSelectionMethod';
+export { default as Renderer } from './Renderer';
+export { default as LightRenderer } from './renderers/LightRenderer';
+export { default as MeshRenderer } from './renderers/MeshRenderer';
+export { default as SpriteRenderer } from './renderers/SpriteRenderer';
+export { SpriteMaterialType } from './enums/SpriteMaterialType';
+export { default as TrailRenderer } from './renderers/TrailRenderer';
+export { TrailMode } from './enums/TrailMode';
+export { TrailTextureMode } from './enums/TrailTextureMode';
+export { default as Module } from './Module';
+export { default as NoiseModule } from './modules/NoiseModule';
+export { default as VelocityOverLifetime } from './modules/VelocityOverLifetime';
+export { default as ForceOverLifetime } from './modules/ForceOverLifetime';
+export { default as LimitVelocityOverLifetime } from './modules/LimitVelocityOverLifetime';
+export { default as TransformByNoise } from './modules/TransformByNoise';
+export { default as ColorOverLifetime } from './modules/ColorOverLifetime';
+export { default as ColorBySpeed } from './modules/ColorBySpeed';
+export { default as ScaleOverLifetime } from './modules/ScaleOverLifetime';
+export { default as ScaleBySpeed } from './modules/ScaleBySpeed';
+export { default as RotationOverLifetime } from './modules/RotationOverLifetime';
+export { default as RotationBySpeed } from './modules/RotationBySpeed';
+export { default as ExternalForces } from './modules/ExternalForces';
+export { default as Collision } from './modules/Collision';
+export { default as Audio } from './modules/Audio';
+export { default as ParticleForceField } from './ParticleForceField';
+export { default as ParticleForceFieldHelper } from './ParticleForceFieldHelper';
+export { default as ThreeCollisionBackend } from './collision/ThreeCollisionBackend';

package/build/interfaces/ICollisionBackend.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+import Particle from '../Particle';
+export interface CollisionQuery {
+    particle: Particle;
+    start: THREE.Vector3;
+    end: THREE.Vector3;
+    radius: number;
+}
+export interface CollisionHit {
+    point: THREE.Vector3;
+    normal: THREE.Vector3;
+    position?: THREE.Vector3;
+    object?: THREE.Object3D;
+    backendData?: unknown;
+}
+export interface ICollisionBackend {
+    update?(deltaTime: number): void;
+    collide(query: CollisionQuery): CollisionHit | null;
+    applyImpulse?(hit: CollisionHit, impulse: THREE.Vector3): void;
+    destroy?(): void;
+}

package/build/interfaces/ICollisionBackend.js

@@ -0,0 +1 @@
+export {};

package/build/interfaces/IParticleForceField.d.ts

@@ -0,0 +1,5 @@
+import * as THREE from 'three';
+import Particle from '../Particle';
+export interface IParticleForceField {
+    getForce(particle: Particle, deltaTime: number): THREE.Vector3;
+}

package/build/interfaces/IParticleForceField.js

@@ -0,0 +1 @@
+export {};

package/build/interfaces/InitialParticleValues.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+import { DynamicValue } from '../types/DynamicValue';
+export interface InitialParticleValues {
+    lifetime: DynamicValue<number>;
+    speed: DynamicValue<number>;
+    position: DynamicValue<THREE.Vector3>;
+    rotation: DynamicValue<THREE.Vector3>;
+    scale: DynamicValue<THREE.Vector3>;
+    velocity: DynamicValue<THREE.Vector3>;
+    angularVelocity: DynamicValue<THREE.Vector3>;
+    scalarVelocity: DynamicValue<THREE.Vector3>;
+    acceleration: DynamicValue<THREE.Vector3>;
+    angularAcceleration: DynamicValue<THREE.Vector3>;
+    scalarAcceleration: DynamicValue<THREE.Vector3>;
+    color: DynamicValue<THREE.Color>;
+    alpha: DynamicValue<number>;
+    mass: DynamicValue<number>;
+}

package/build/interfaces/InitialParticleValues.js

@@ -0,0 +1 @@
+export {};

package/build/materials/BasicSprite.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+export interface BasicSpriteOptions extends THREE.ShaderMaterialParameters {
+    gridSize: {
+        x: number;
+        y: number;
+    };
+    frames: number;
+    alphaMap: THREE.Texture;
+    normalMap: THREE.Texture;
+    normalStrength: number;
+    normalLighting: number;
+    sphericalNormals: boolean;
+    roughness: number;
+    roughnessMap: THREE.Texture;
+    envMap: THREE.Texture;
+    envIntensity: number;
+    softParticles: boolean;
+    softParticleDistance: number;
+}
+declare const BasicSprite: (texture: THREE.Texture, options?: Partial<BasicSpriteOptions>) => THREE.ShaderMaterial;
+export default BasicSprite;