@rzmps/rzmps 1.0.0

package/build/ParticleForceField.js

@@ -0,0 +1,101 @@
+import * as THREE from 'three';
+import evaluateDynamicNumber from './helpers/evaluateDynamicNumber';
+import evaluateDynamicVector from './helpers/evaluateDynamicVector3';
+import isPointInMesh from './helpers/isPointInMesh';
+import acceptMultiple from './helpers/acceptMultiple';
+import tagsIntersect from './helpers/tagsIntersect';
+class ParticleForceField extends THREE.Object3D {
+    static Box(options, ...args) {
+        return new ParticleForceField(Object.assign(Object.assign({}, options), { geometry: new THREE.BoxGeometry(...args) }));
+    }
+    static Sphere(options, ...args) {
+        return new ParticleForceField(Object.assign(Object.assign({}, options), { geometry: new THREE.SphereGeometry(...args) }));
+    }
+    static Cone(options, ...args) {
+        return new ParticleForceField(Object.assign(Object.assign({}, options), { geometry: new THREE.ConeGeometry(...args) }));
+    }
+    static Torus(options, ...args) {
+        return new ParticleForceField(Object.assign(Object.assign({}, options), { geometry: new THREE.TorusGeometry(...args) }));
+    }
+    set geometry(value) {
+        this._geometry = value;
+        this._geometry.computeBoundingBox();
+        this._mesh.geometry = value;
+    }
+    get geometry() {
+        return this._geometry;
+    }
+    constructor(options) {
+        var _a;
+        super();
+        if (options.position) {
+            this.position.copy(options.position);
+        }
+        if (options.scale) {
+            this.scale.copy(options.scale);
+        }
+        this.direction = options.direction;
+        this.gravity = options.gravity;
+        this.rotationSpeed = options.rotationSpeed;
+        this.rotationAttraction = options.rotationAttraction;
+        this.drag = options.drag;
+        this.tags = acceptMultiple(options.tags);
+        this._geometry = (_a = options.geometry) !== null && _a !== void 0 ? _a : new THREE.SphereGeometry();
+        this._geometry.computeBoundingBox();
+        this._mesh = new THREE.Mesh(this._geometry, ParticleForceField._doubleSidedMaterial);
+    }
+    getForce(particle) {
+        var _a;
+        this.updateWorldMatrix(true, false);
+        if (!this.contains(particle.position)
+            || (this.tags && !tagsIntersect(this.tags, (_a = particle.tags) !== null && _a !== void 0 ? _a : [])))
+            return new THREE.Vector3();
+        const { time } = particle;
+        const force = new THREE.Vector3();
+        const center = new THREE.Vector3();
+        this.getWorldPosition(center);
+        const toCenter = center.clone().sub(particle.position);
+        const distanceSq = toCenter.lengthSq();
+        if (this.direction !== undefined) {
+            const direction = evaluateDynamicVector(this.direction, time).clone();
+            const rotation = this.getWorldQuaternion(new THREE.Quaternion());
+            direction.applyQuaternion(rotation);
+            force.add(direction);
+        }
+        if (this.gravity !== undefined && distanceSq > 0) {
+            force.add(toCenter.clone().normalize().multiplyScalar(evaluateDynamicNumber(this.gravity, time)));
+        }
+        if (this.rotationSpeed !== undefined && distanceSq > 0) {
+            const rotationAxis = new THREE.Vector3(0, 1, 0)
+                .applyQuaternion(this.getWorldQuaternion(new THREE.Quaternion()));
+            const fromCenter = particle.position.clone().sub(center);
+            const tangent = rotationAxis.cross(fromCenter).normalize();
+            force.add(tangent.multiplyScalar(evaluateDynamicNumber(this.rotationSpeed, time)));
+        }
+        if (this.rotationAttraction !== undefined && distanceSq > 0) {
+            force.add(toCenter.clone().normalize().multiplyScalar(evaluateDynamicNumber(this.rotationAttraction, time)));
+        }
+        if (this.drag !== undefined) {
+            force.addScaledVector(particle.velocity, -evaluateDynamicNumber(this.drag, time));
+        }
+        return force.multiplyScalar(this.getFalloff(particle.position));
+    }
+    contains(position) {
+        const localPosition = this.worldToLocal(position.clone());
+        return isPointInMesh(localPosition, this._mesh);
+    }
+    getFalloff(position) {
+        const localPosition = this.worldToLocal(position.clone());
+        if (!this._geometry.boundingBox) {
+            this._geometry.computeBoundingBox();
+        }
+        const size = new THREE.Vector3();
+        this._geometry.boundingBox.getSize(size);
+        const radius = size.length() * 0.5;
+        if (radius <= 0)
+            return 0;
+        return 1 - Math.min(localPosition.length() / radius, 1);
+    }
+}
+ParticleForceField._doubleSidedMaterial = new THREE.MeshBasicMaterial({ side: THREE.DoubleSide });
+export default ParticleForceField;

package/build/ParticleForceFieldHelper.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+import ParticleForceField from './ParticleForceField';
+declare class ParticleForceFieldHelper extends THREE.Object3D {
+    forceField: ParticleForceField;
+    color: THREE.Color;
+    private shapeHelper?;
+    private directionHelper?;
+    private sourceGeometry?;
+    constructor(forceField: ParticleForceField, color?: THREE.ColorRepresentation);
+    update(): void;
+    setColor(color: THREE.ColorRepresentation): void;
+    dispose(): void;
+    private _updateTransform;
+    private _disposeShape;
+    private _disposeDirection;
+    onBeforeRender(): void;
+}
+export default ParticleForceFieldHelper;

package/build/ParticleForceFieldHelper.js

@@ -0,0 +1,103 @@
+import * as THREE from 'three';
+class ParticleForceFieldHelper extends THREE.Object3D {
+    constructor(forceField, color = 0xffff00) {
+        super();
+        this.forceField = forceField;
+        this.color = new THREE.Color(color);
+        this.name = `${forceField.name || 'ParticleForceField'}Helper`;
+        this.update();
+    }
+    update() {
+        /*
+         * Only rebuild the shape geometry if the force field geometry
+         * itself changed.
+         */
+        if (!this.shapeHelper
+            || this.sourceGeometry !== this.forceField.geometry) {
+            this._disposeShape();
+            const material = new THREE.LineBasicMaterial({
+                color: this.color,
+                transparent: true,
+                opacity: 0.5,
+                depthTest: false,
+                toneMapped: false,
+            });
+            const geometry = new THREE.WireframeGeometry(this.forceField.geometry);
+            this.shapeHelper = new THREE.LineSegments(geometry, material);
+            this.shapeHelper.renderOrder = 999;
+            this.add(this.shapeHelper);
+            this.sourceGeometry = this.forceField.geometry;
+        }
+        /*
+         * Rebuild the directional arrow.
+         *
+         * We can only show a meaningful static arrow when direction is
+         * actually a Vector3. Functional/curve-based DynamicValues don't
+         * have one universal direction to visualize.
+         */
+        this._disposeDirection();
+        if (this.forceField.direction instanceof THREE.Vector3) {
+            const direction = this.forceField.direction.clone();
+            const length = direction.length();
+            if (length > 0) {
+                direction.normalize();
+                this.directionHelper = new THREE.ArrowHelper(direction, new THREE.Vector3(), Math.min(length, 2), this.color);
+                /*
+                 * Keep the arrow readable even when the force itself is very
+                 * weak or very strong.
+                 */
+                this.directionHelper.setLength(Math.min(Math.max(length, 0.5), 2), 0.35, 0.2);
+                this.add(this.directionHelper);
+            }
+        }
+        this._updateTransform();
+    }
+    setColor(color) {
+        var _a, _b;
+        this.color.set(color);
+        if (((_a = this.shapeHelper) === null || _a === void 0 ? void 0 : _a.material)
+            instanceof THREE.LineBasicMaterial) {
+            this.shapeHelper.material.color.copy(this.color);
+        }
+        (_b = this.directionHelper) === null || _b === void 0 ? void 0 : _b.setColor(this.color);
+    }
+    dispose() {
+        this._disposeShape();
+        this._disposeDirection();
+        this.sourceGeometry = undefined;
+    }
+    _updateTransform() {
+        this.forceField.updateWorldMatrix(true, false);
+        this.forceField.getWorldPosition(this.position);
+        this.forceField.getWorldQuaternion(this.quaternion);
+        this.forceField.getWorldScale(this.scale);
+    }
+    _disposeShape() {
+        if (!this.shapeHelper)
+            return;
+        this.shapeHelper.removeFromParent();
+        /*
+         * This is a WireframeGeometry owned by the helper, so disposing it
+         * does NOT dispose the ParticleForceField's actual geometry.
+         */
+        this.shapeHelper.geometry.dispose();
+        if (Array.isArray(this.shapeHelper.material)) {
+            this.shapeHelper.material.forEach(material => material.dispose());
+        }
+        else {
+            this.shapeHelper.material.dispose();
+        }
+        this.shapeHelper = undefined;
+    }
+    _disposeDirection() {
+        if (!this.directionHelper)
+            return;
+        this.directionHelper.removeFromParent();
+        this.directionHelper.dispose();
+        this.directionHelper = undefined;
+    }
+    onBeforeRender() {
+        this._updateTransform();
+    }
+}
+export default ParticleForceFieldHelper;

package/build/ParticleSystem.d.ts

@@ -0,0 +1,122 @@
+import * as THREE from 'three';
+import Particle from './Particle';
+import Emitter from './Emitter';
+import Module from './Module';
+import Renderer from './Renderer';
+import { Multiple } from './types/Multiple';
+import { DynamicValue } from './types/DynamicValue';
+import { CollisionListener } from './modules/Collision';
+import { CollisionHit } from './interfaces/ICollisionBackend';
+import { EndBehavior } from './enums/EndBehavior';
+import { SimulationSpace } from './enums/SimulationSpace';
+interface ParticleSystemOptions {
+    emitters: Multiple<Emitter>;
+    renderers: Multiple<Renderer>;
+    modules: Multiple<Module>;
+    simulationSpeed: number;
+    duration: number;
+    looping: boolean;
+    endBehavior: EndBehavior | `${EndBehavior}`;
+    gravity: THREE.Vector3;
+    gravityModifier: DynamicValue<number>;
+    simulationSpace: SimulationSpace | `${SimulationSpace}`;
+}
+export interface SubSystemOptions {
+    shouldEmit: boolean | ((particle: Particle) => boolean);
+    ratio: number;
+    emitContinuous: boolean;
+    emitOnCollision: boolean;
+    emitOnSpawn: boolean;
+    emitOnDeath: boolean;
+    inheritScale: boolean;
+    inheritLifetime: boolean;
+    inheritColor: boolean;
+    inheritAlpha: boolean;
+    inheritMass: boolean;
+}
+export type ParticleListener = (particle: Particle) => void;
+declare class ParticleSystem extends THREE.Object3D {
+    particles: Particle[];
+    emitters: Emitter[];
+    modules: Module[];
+    renderers: Renderer[];
+    subSystems: Map<ParticleSystem, SubSystemOptions>;
+    gravity: THREE.Vector3;
+    gravityModifier: DynamicValue<number>;
+    simulationSpeed: number;
+    duration: number;
+    looping: boolean;
+    endBehavior: EndBehavior;
+    private _simulationSpace;
+    get simulationSpace(): SimulationSpace;
+    set simulationSpace(value: SimulationSpace);
+    private _scene?;
+    get scene(): THREE.Scene<THREE.Object3DEventMap> | undefined;
+    private _camera?;
+    get sceneCamera(): THREE.Camera | undefined;
+    private _renderer?;
+    get sceneRenderer(): THREE.WebGLRenderer | undefined;
+    private deltaTime;
+    private lastFrame;
+    private _subSystemParent?;
+    get isSubSystem(): boolean;
+    private _deathListeners;
+    private _spawnListeners;
+    private _collisionListeners;
+    private _emissionRuns;
+    private _nextEmissionRunId;
+    private _playing;
+    private _paused;
+    private _elapsedTime;
+    private _ended;
+    private _destroyed;
+    get destroyed(): boolean;
+    private readonly _rendererObjects;
+    private readonly _worldRendererRoot;
+    constructor(options?: Partial<ParticleSystemOptions>);
+    update(): void;
+    private _calculateDeltaTime;
+    private _scaleDeltaTime;
+    private _processParticles;
+    private _updateParticles;
+    private _updateSubSystems;
+    private _updateAsSubSystem;
+    private _updateEmissionRuns;
+    private _canEmitForParticle;
+    private _startEmissionRunAtParticle;
+    private _particleEmissionTransform;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(clearParticles: boolean): void;
+    destroy(): void;
+    clearParticles(): void;
+    addEmitter(emitter: Emitter): this;
+    removeEmitter(emitter: Emitter): this;
+    addModule(module: Module): this;
+    removeModule(module: Module): this;
+    addRenderer(renderer: Renderer): this;
+    removeRenderer(renderer: Renderer): this;
+    addRendererObject(object: THREE.Object3D): void;
+    addSubSystem(subSystem: ParticleSystem, options: Partial<SubSystemOptions>): this;
+    removeSubSystem(subSystem: ParticleSystem): this;
+    onDeath(listener: ParticleListener): this;
+    removeDeathListener(listener: ParticleListener): this;
+    onSpawn(listener: ParticleListener): this;
+    removeSpawnListener(listener: ParticleListener): this;
+    onCollision(listener: CollisionListener): this;
+    removeCollisionListener(listener: CollisionListener): this;
+    notifyCollision(particle: Particle, collision: CollisionHit): void;
+    private _notifyDeath;
+    private _notifySpawn;
+    private cleanup;
+    private getEmitterContext;
+    private _updateSystemTime;
+    private _handleEndBehavior;
+    private getRendererParent;
+    private syncRendererParents;
+    private getWorldRendererParent;
+    private convertParticlesToSimulationSpace;
+    private localDirectionToWorld;
+}
+export default ParticleSystem;