@rzmps/rzmps 1.0.0

package/build/materials/BasicSprite.js

@@ -0,0 +1,46 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as THREE from 'three';
+import basicSpriteVert from '../shaders/BasicSprite.vert.js';
+import basicSpriteFrag from '../shaders/BasicSprite.frag.js';
+const BasicSprite = (texture, options = {}) => {
+    const { gridSize, frames, alphaMap, normalMap, normalStrength = 1, normalLighting, sphericalNormals, roughness = 0.5, roughnessMap, envMap, envIntensity = 1.0, softParticles, softParticleDistance = 0 } = options, materialOptions = __rest(options, ["gridSize", "frames", "alphaMap", "normalMap", "normalStrength", "normalLighting", "sphericalNormals", "roughness", "roughnessMap", "envMap", "envIntensity", "softParticles", "softParticleDistance"]);
+    return new THREE.ShaderMaterial(Object.assign({ vertexShader: basicSpriteVert, fragmentShader: basicSpriteFrag, uniforms: THREE.UniformsUtils.merge([
+            THREE.UniformsLib.lights,
+            {
+                pointTexture: { value: texture },
+                gridSize: { value: gridSize !== null && gridSize !== void 0 ? gridSize : { x: 1, y: 1 } },
+                n_frames: { value: frames !== null && frames !== void 0 ? frames : 1 },
+                alphaMap: { value: alphaMap !== null && alphaMap !== void 0 ? alphaMap : null },
+                hasAlphaMap: { value: Boolean(alphaMap) },
+                normalMap: { value: normalMap !== null && normalMap !== void 0 ? normalMap : null },
+                hasNormalMap: { value: Boolean(normalMap) },
+                normalStrength: { value: normalStrength },
+                // Normal lighting, if not already set, defaults to 1 if there is a normal map present and 0 if not.
+                normalLighting: { value: normalLighting !== null && normalLighting !== void 0 ? normalLighting : (normalMap ? 1 : 0) },
+                sphericalNormals: { value: sphericalNormals !== null && sphericalNormals !== void 0 ? sphericalNormals : false },
+                roughness: { value: roughness },
+                roughnessMap: { value: roughnessMap !== null && roughnessMap !== void 0 ? roughnessMap : null },
+                hasRoughnessMap: { value: Boolean(roughnessMap) },
+                envMap: { value: envMap },
+                envIntensity: { value: envIntensity },
+                hasEnvMap: { value: Boolean(envMap) },
+                softParticles: { value: Boolean(softParticleDistance) },
+                softParticleDistance: { value: softParticleDistance },
+                sceneDepthTexture: { value: null },
+                depthResolution: { value: new THREE.Vector2() },
+                depthCameraNear: { value: 0.1 },
+                depthCameraFar: { value: 2000 },
+            },
+        ]), depthTest: true, depthWrite: false, lights: true, transparent: true, vertexColors: true }, materialOptions));
+};
+export default BasicSprite;

package/build/materials/UnlitSprite.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from 'three';
+export interface UnlitSpriteOptions {
+    gridSize: {
+        x: number;
+        y: number;
+    };
+    frames: number;
+    alphaMap: THREE.Texture;
+    softParticles: boolean;
+    softParticleDistance: number;
+}
+declare const UnlitSprite: (texture: THREE.Texture, options?: Partial<UnlitSpriteOptions>) => THREE.ShaderMaterial;
+export default UnlitSprite;

package/build/materials/UnlitSprite.js

@@ -0,0 +1,31 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as THREE from 'three';
+import unlitSpriteVert from '../shaders/UnlitSprite.vert.js';
+import unlitSpriteFrag from '../shaders/UnlitSprite.frag.js';
+const UnlitSprite = (texture, options = {}) => {
+    const { gridSize, frames, alphaMap, softParticles, softParticleDistance = 0 } = options, materialOptions = __rest(options, ["gridSize", "frames", "alphaMap", "softParticles", "softParticleDistance"]);
+    return new THREE.ShaderMaterial(Object.assign({ vertexShader: unlitSpriteVert, fragmentShader: unlitSpriteFrag, uniforms: {
+            pointTexture: { value: texture },
+            gridSize: { value: gridSize !== null && gridSize !== void 0 ? gridSize : { x: 1, y: 1 } },
+            n_frames: { value: frames !== null && frames !== void 0 ? frames : 1 },
+            alphaMap: { value: alphaMap !== null && alphaMap !== void 0 ? alphaMap : null },
+            hasAlphaMap: { value: Boolean(alphaMap) },
+            softParticles: { value: Boolean(softParticleDistance) },
+            softParticleDistance: { value: softParticleDistance },
+            sceneDepthTexture: { value: null },
+            depthResolution: { value: new THREE.Vector2() },
+            depthCameraNear: { value: 0.1 },
+            depthCameraFar: { value: 2000 },
+        }, depthTest: true, depthWrite: false, transparent: true, vertexColors: true }, materialOptions));
+};
+export default UnlitSprite;

package/build/materials/WebGPUBasicSprite.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import MeshStandardNodeMaterial from 'three/src/materials/nodes/MeshStandardNodeMaterial.js';
+import { BasicSpriteOptions } from './BasicSprite';
+type WebGPUBasicSpriteOptions = BasicSpriteOptions & {
+    sceneDepthTexture: THREE.DepthTexture;
+};
+declare const WebGPUBasicSprite: (pointTexture: THREE.Texture, options?: Partial<WebGPUBasicSpriteOptions>) => MeshStandardNodeMaterial;
+export default WebGPUBasicSprite;

package/build/materials/WebGPUBasicSprite.js

@@ -0,0 +1,65 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as THREE from 'three';
+import MeshStandardNodeMaterial from 'three/src/materials/nodes/MeshStandardNodeMaterial.js';
+import { cameraFar, cameraNear } from 'three/src/nodes/accessors/Camera.js';
+import { attribute } from 'three/src/nodes/core/AttributeNode.js';
+import { positionView } from 'three/src/nodes/accessors/Position.js';
+import { texture } from 'three/src/nodes/accessors/TextureNode.js';
+import { uv } from 'three/src/nodes/accessors/UV.js';
+import { viewportUV } from 'three/src/nodes/display/ScreenNode.js';
+import { perspectiveDepthToViewZ } from 'three/src/nodes/display/ViewportDepthNode.js';
+import { abs, dot, smoothstep } from 'three/src/nodes/math/MathNode.js';
+import { spritesheetUV } from 'three/src/nodes/utils/SpriteSheetUV.js';
+import { float, vec2, vec3 } from 'three/src/nodes/tsl/TSLBase.js';
+const WebGPUBasicSprite = (pointTexture, options = {}) => {
+    var _a, _b;
+    const { gridSize, frames, alphaMap, normalMap, normalStrength, roughness, roughnessMap, envMap, envIntensity, normalLighting, sphericalNormals, softParticles, softParticleDistance, sceneDepthTexture } = options, materialOptions = __rest(options, ["gridSize", "frames", "alphaMap", "normalMap", "normalStrength", "roughness", "roughnessMap", "envMap", "envIntensity", "normalLighting", "sphericalNormals", "softParticles", "softParticleDistance", "sceneDepthTexture"]);
+    const material = new MeshStandardNodeMaterial(Object.assign({ depthTest: true, depthWrite: false, metalness: 0, roughness: roughness !== null && roughness !== void 0 ? roughness : 0.5, transparent: true, vertexColors: true, side: THREE.DoubleSide }, materialOptions));
+    const spriteUv = spritesheetUV(vec2((_a = gridSize === null || gridSize === void 0 ? void 0 : gridSize.x) !== null && _a !== void 0 ? _a : 1, (_b = gridSize === null || gridSize === void 0 ? void 0 : gridSize.y) !== null && _b !== void 0 ? _b : 1), uv(), attribute('frame', 'float'));
+    const spriteColor = texture(pointTexture, spriteUv);
+    let opacity = spriteColor.a.mul(attribute('instanceAlpha', 'float'));
+    if (alphaMap) {
+        opacity = opacity.mul(texture(alphaMap, spriteUv).r);
+    }
+    if (softParticleDistance && sceneDepthTexture) {
+        const sceneViewZ = perspectiveDepthToViewZ(texture(sceneDepthTexture, viewportUV).r, cameraNear, cameraFar);
+        const particleViewZ = positionView.z;
+        const fade = smoothstep(float(0), float(softParticleDistance), abs(particleViewZ.sub(sceneViewZ)));
+        opacity = opacity.mul(fade);
+    }
+    if (sphericalNormals) {
+        const localUv = uv().mul(2).sub(1);
+        const normalZ = float(1).sub(dot(localUv, localUv)).max(0).sqrt();
+        material.normalNode = vec3(localUv.x, localUv.y, normalZ).normalize();
+    }
+    material.name = 'RZMPS WebGPU Basic Sprite';
+    material.colorNode = spriteColor.rgb;
+    material.opacityNode = opacity;
+    material.alphaTest = 0.001;
+    material.envMap = envMap !== null && envMap !== void 0 ? envMap : null;
+    material.envMapIntensity = envIntensity !== null && envIntensity !== void 0 ? envIntensity : 1;
+    material.roughnessNode = roughnessMap
+        ? texture(roughnessMap, spriteUv).r.mul(roughness !== null && roughness !== void 0 ? roughness : 0.5)
+        : float(roughness !== null && roughness !== void 0 ? roughness : 0.5);
+    material.metalnessNode = float(0);
+    material.userData.frames = frames !== null && frames !== void 0 ? frames : 1;
+    material.userData.normalMap = normalMap;
+    material.userData.normalStrength = normalStrength;
+    material.userData.roughnessMap = roughnessMap;
+    material.userData.normalLighting = normalLighting;
+    material.userData.sphericalNormals = sphericalNormals;
+    material.userData.softParticles = softParticles;
+    material.userData.softParticleDistance = softParticleDistance;
+    return material;
+};
+export default WebGPUBasicSprite;

package/build/materials/WebGPUUnlitSprite.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import MeshBasicNodeMaterial from 'three/src/materials/nodes/MeshBasicNodeMaterial.js';
+import { UnlitSpriteOptions } from './UnlitSprite';
+type WebGPUUnlitSpriteOptions = UnlitSpriteOptions & {
+    sceneDepthTexture: THREE.DepthTexture;
+};
+declare const WebGPUUnlitSprite: (pointTexture: THREE.Texture, options?: Partial<WebGPUUnlitSpriteOptions>) => MeshBasicNodeMaterial;
+export default WebGPUUnlitSprite;

package/build/materials/WebGPUUnlitSprite.js

@@ -0,0 +1,49 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as THREE from 'three';
+import MeshBasicNodeMaterial from 'three/src/materials/nodes/MeshBasicNodeMaterial.js';
+import { cameraFar, cameraNear } from 'three/src/nodes/accessors/Camera.js';
+import { attribute } from 'three/src/nodes/core/AttributeNode.js';
+import { positionView } from 'three/src/nodes/accessors/Position.js';
+import { texture } from 'three/src/nodes/accessors/TextureNode.js';
+import { uv } from 'three/src/nodes/accessors/UV.js';
+import { viewportUV } from 'three/src/nodes/display/ScreenNode.js';
+import { perspectiveDepthToViewZ } from 'three/src/nodes/display/ViewportDepthNode.js';
+import { abs, smoothstep } from 'three/src/nodes/math/MathNode.js';
+import { spritesheetUV } from 'three/src/nodes/utils/SpriteSheetUV.js';
+import { float, vec2 } from 'three/src/nodes/tsl/TSLBase.js';
+const WebGPUUnlitSprite = (pointTexture, options = {}) => {
+    var _a, _b;
+    const { gridSize, frames, alphaMap, softParticles, softParticleDistance, sceneDepthTexture } = options, materialOptions = __rest(options, ["gridSize", "frames", "alphaMap", "softParticles", "softParticleDistance", "sceneDepthTexture"]);
+    const material = new MeshBasicNodeMaterial(Object.assign({ depthTest: true, depthWrite: false, transparent: true, vertexColors: true, side: THREE.DoubleSide }, materialOptions));
+    const spriteUv = spritesheetUV(vec2((_a = gridSize === null || gridSize === void 0 ? void 0 : gridSize.x) !== null && _a !== void 0 ? _a : 1, (_b = gridSize === null || gridSize === void 0 ? void 0 : gridSize.y) !== null && _b !== void 0 ? _b : 1), uv(), attribute('frame', 'float'));
+    const spriteColor = texture(pointTexture, spriteUv);
+    let opacity = spriteColor.a.mul(attribute('instanceAlpha', 'float'));
+    if (alphaMap) {
+        opacity = opacity.mul(texture(alphaMap, spriteUv).r);
+    }
+    if (softParticleDistance && sceneDepthTexture) {
+        const sceneViewZ = perspectiveDepthToViewZ(texture(sceneDepthTexture, viewportUV).r, cameraNear, cameraFar);
+        const particleViewZ = positionView.z;
+        const fade = smoothstep(float(0), float(softParticleDistance), abs(particleViewZ.sub(sceneViewZ)));
+        opacity = opacity.mul(fade);
+    }
+    material.name = 'RZMPS WebGPU Unlit Sprite';
+    material.colorNode = spriteColor.rgb;
+    material.opacityNode = opacity;
+    material.alphaTest = 0.001;
+    material.userData.frames = frames !== null && frames !== void 0 ? frames : 1;
+    material.userData.softParticles = softParticles;
+    material.userData.softParticleDistance = softParticleDistance;
+    return material;
+};
+export default WebGPUUnlitSprite;

package/build/modules/Audio.d.ts

@@ -0,0 +1,60 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+import Particle from '../Particle';
+import ParticleSystem from '../ParticleSystem';
+import { DynamicValue } from '../types/DynamicValue';
+import { StrictMultiple } from '../types/Multiple';
+export interface AudioOptions extends Partial<ModuleOptions> {
+    listener: THREE.AudioListener;
+    sound: StrictMultiple<AudioBuffer>;
+    onCollisionSound: StrictMultiple<AudioBuffer>;
+    onSpawnSound: StrictMultiple<AudioBuffer>;
+    onDeathSound: StrictMultiple<AudioBuffer>;
+    shouldPlay: (particle: Particle) => boolean;
+    loop: boolean;
+    ratio: number;
+    collisionRatio: number;
+    pitch: DynamicValue<number>;
+    volume: DynamicValue<number>;
+    sizeAffectsPitch: number;
+    sizeAffectsVolume: number;
+    alphaAffectsPitch: number;
+    alphaAffectsVolume: number;
+    speedAffectsPitch: number;
+    speedAffectsVolume: number;
+}
+declare class Audio extends Module {
+    listener?: THREE.AudioListener;
+    sound?: AudioBuffer[];
+    onCollisionSound?: AudioBuffer[];
+    onSpawnSound?: AudioBuffer[];
+    onDeathSound?: AudioBuffer[];
+    shouldPlay: (particle: Particle) => boolean;
+    loop: boolean;
+    ratio: number;
+    collisionRatio: number;
+    pitch: DynamicValue<number>;
+    volume: DynamicValue<number>;
+    sizeAffectsPitch: number;
+    sizeAffectsVolume: number;
+    alphaAffectsPitch: number;
+    alphaAffectsVolume: number;
+    speedAffectsPitch: number;
+    speedAffectsVolume: number;
+    private _system?;
+    private _particleAudio;
+    private _eventAudio;
+    private _setupCallbacks;
+    constructor(options?: Partial<AudioOptions>);
+    prepare(system: ParticleSystem): void;
+    private _updateParticle;
+    private _handleEvent;
+    private _playOneShot;
+    private _getPitch;
+    private _getVolume;
+    private _getEffect;
+    private _cleanParticleAudio;
+    private _removeParticleAudio;
+    cleanup(): void;
+}
+export default Audio;

package/build/modules/Audio.js

@@ -0,0 +1,181 @@
+import * as THREE from 'three';
+import Module from '../Module';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+import particleRatio from '../helpers/particleRatio';
+import acceptMultiple from '../helpers/acceptMultiple';
+const AUDIO_LISTENER_KEY = "__rzmps_audioListener";
+class Audio extends Module {
+    constructor(options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        super((particle) => this._updateParticle(particle), options);
+        this.shouldPlay = () => true;
+        this.loop = true;
+        this._particleAudio = new Map();
+        this._eventAudio = new Set();
+        this._setupCallbacks = false;
+        this.listener = options.listener;
+        this.sound = options.sound
+            ? acceptMultiple(options.sound)
+            : undefined;
+        this.onCollisionSound = options.onCollisionSound
+            ? acceptMultiple(options.onCollisionSound)
+            : undefined;
+        this.onSpawnSound = options.onSpawnSound
+            ? acceptMultiple(options.onSpawnSound)
+            : undefined;
+        this.onDeathSound = options.onDeathSound
+            ? acceptMultiple(options.onDeathSound)
+            : undefined;
+        this.shouldPlay = (_a = options.shouldPlay) !== null && _a !== void 0 ? _a : this.shouldPlay;
+        this.loop = (_b = options.loop) !== null && _b !== void 0 ? _b : this.loop;
+        this.ratio = THREE.MathUtils.clamp((_c = options.ratio) !== null && _c !== void 0 ? _c : 1, 0, 1);
+        this.collisionRatio = THREE.MathUtils.clamp((_d = options.collisionRatio) !== null && _d !== void 0 ? _d : this.ratio, 0, 1);
+        this.pitch = (_e = options.pitch) !== null && _e !== void 0 ? _e : 1;
+        this.volume = (_f = options.volume) !== null && _f !== void 0 ? _f : 1;
+        this.sizeAffectsPitch = Math.max(0, (_g = options.sizeAffectsPitch) !== null && _g !== void 0 ? _g : 0);
+        this.sizeAffectsVolume = Math.max(0, (_h = options.sizeAffectsVolume) !== null && _h !== void 0 ? _h : 0);
+        this.alphaAffectsPitch = Math.max(0, (_j = options.alphaAffectsPitch) !== null && _j !== void 0 ? _j : 0);
+        this.alphaAffectsVolume = Math.max(0, (_k = options.alphaAffectsVolume) !== null && _k !== void 0 ? _k : 0);
+        this.speedAffectsPitch = Math.max(0, (_l = options.speedAffectsPitch) !== null && _l !== void 0 ? _l : 0);
+        this.speedAffectsVolume = Math.max(0, (_m = options.speedAffectsVolume) !== null && _m !== void 0 ? _m : 0);
+    }
+    prepare(system) {
+        this._system = system;
+        if (!this._setupCallbacks) {
+            system.onCollision((particle, _) => this._handleEvent(particle, this.onCollisionSound));
+            system.onDeath((particle) => this._handleEvent(particle, this.onDeathSound));
+            system.onSpawn((particle) => this._handleEvent(particle, this.onSpawnSound));
+            this._setupCallbacks = true;
+        }
+        if (!this.listener) {
+            // Try to get listener from cache
+            if (system.scene)
+                this.listener = system.scene.userData[AUDIO_LISTENER_KEY];
+            // Try to get listener from camera
+            if (system.sceneCamera) {
+                system.sceneCamera.traverse((object) => {
+                    if (!this.listener && object instanceof THREE.AudioListener) {
+                        this.listener = object;
+                    }
+                });
+                // Add to camera if its not there
+                if (!this.listener) {
+                    this.listener = new THREE.AudioListener();
+                    system.sceneCamera.add(this.listener);
+                }
+            }
+            // If we found a listener, add it to the scene cache
+            if (this.listener && system.scene)
+                system.scene.userData[AUDIO_LISTENER_KEY] = this.listener;
+        }
+        this._cleanParticleAudio(system.particles);
+    }
+    _updateParticle(particle) {
+        if (!this.listener || !this.sound || !this._system)
+            return;
+        if (!particleRatio(particle, this.ratio) || !this.shouldPlay(particle)) {
+            this._removeParticleAudio(particle.id);
+            return;
+        }
+        let state = this._particleAudio.get(particle.id);
+        if (!state) {
+            const audio = new THREE.PositionalAudio(this.listener);
+            const sound = this.sound[Math.floor(Math.random() * this.sound.length)];
+            audio.setBuffer(sound);
+            audio.setLoop(this.loop);
+            this._system.add(audio);
+            state = {
+                audio,
+                buffer: sound,
+            };
+            this._particleAudio.set(particle.id, state);
+            audio.play();
+        }
+        state.audio.position.copy(particle.position);
+        state.audio.setPlaybackRate(this._getPitch(particle));
+        state.audio.setVolume(this._getVolume(particle));
+    }
+    _handleEvent(particle, audio) {
+        if (!audio
+            || (audio === null || audio === void 0 ? void 0 : audio.length) === 0
+            || !particleRatio(particle, this.collisionRatio)
+            || !this.shouldPlay(particle)) {
+            return;
+        }
+        this._playOneShot(audio[Math.floor(Math.random() * audio.length)], particle);
+    }
+    _playOneShot(clip, particle) {
+        if (!this.listener || !this._system)
+            return;
+        const audio = new THREE.PositionalAudio(this.listener);
+        audio.setBuffer(clip);
+        audio.setLoop(false);
+        audio.position.copy(particle.position);
+        audio.setPlaybackRate(this._getPitch(particle));
+        audio.setVolume(this._getVolume(particle));
+        this._system.add(audio);
+        this._eventAudio.add(audio);
+        audio.play();
+        /*
+         * THREE.Audio creates a new AudioBufferSourceNode when play() is
+         * called. Clean the temporary source up once that playback ends.
+         */
+        if (audio.source) {
+            audio.source.addEventListener('ended', () => {
+                this._eventAudio.delete(audio);
+                audio.removeFromParent();
+            });
+        }
+    }
+    _getPitch(particle) {
+        const base = evaluateDynamicNumber(this.pitch, particle.time, particle.id);
+        return Math.max(0, base
+            * this._getEffect(particle.scale.length(), this.sizeAffectsPitch)
+            * this._getEffect(particle.alpha, this.alphaAffectsPitch)
+            * this._getEffect(particle.velocity.length() * particle.speed, this.speedAffectsPitch));
+    }
+    _getVolume(particle) {
+        const base = evaluateDynamicNumber(this.volume, particle.time, particle.id);
+        return Math.max(0, base
+            * this._getEffect(particle.scale.length(), this.sizeAffectsVolume)
+            * this._getEffect(particle.alpha, this.alphaAffectsVolume)
+            * this._getEffect(particle.velocity.length(), this.speedAffectsVolume));
+    }
+    // eslint-disable-next-line class-methods-use-this
+    _getEffect(value, effect) {
+        return Math.pow(Math.max(0, value), effect);
+    }
+    _cleanParticleAudio(particles) {
+        const activeParticles = new Set(particles
+            .filter((particle) => particleRatio(particle, this.ratio))
+            .map((particle) => particle.id));
+        this._particleAudio.forEach((_state, id) => {
+            if (!activeParticles.has(id)) {
+                this._removeParticleAudio(id);
+            }
+        });
+    }
+    _removeParticleAudio(id) {
+        const state = this._particleAudio.get(id);
+        if (!state)
+            return;
+        if (state.audio.isPlaying) {
+            state.audio.stop();
+        }
+        state.audio.removeFromParent();
+        this._particleAudio.delete(id);
+    }
+    cleanup() {
+        this._particleAudio.forEach((_state, id) => {
+            this._removeParticleAudio(id);
+        });
+        this._eventAudio.forEach((audio) => {
+            if (audio.isPlaying) {
+                audio.stop();
+            }
+            audio.removeFromParent();
+        });
+        this._eventAudio.clear();
+    }
+}
+export default Audio;

package/build/modules/Collision.d.ts

@@ -0,0 +1,40 @@
+import Module, { ModuleOptions } from '../Module';
+import Particle from '../Particle';
+import { DynamicValue } from '../types/DynamicValue';
+import { ICollisionBackend, CollisionHit } from '../interfaces/ICollisionBackend';
+import ParticleSystem from '../ParticleSystem';
+export type CollisionListener = (particle: Particle, collision: CollisionHit) => void;
+export interface CollisionOptions extends Partial<ModuleOptions> {
+    backend: ICollisionBackend;
+    dampen: DynamicValue<number>;
+    bounce: DynamicValue<number>;
+    lifetimeLoss: DynamicValue<number>;
+    applyImpulses: boolean;
+    radiusScale: number;
+    minKillSpeed: number;
+    maxKillSpeed: number;
+    onCollision?: CollisionListener;
+}
+declare class Collision extends Module {
+    backend?: ICollisionBackend;
+    dampen: DynamicValue<number>;
+    bounce: DynamicValue<number>;
+    lifetimeLoss: DynamicValue<number>;
+    applyImpulses: boolean;
+    radiusScale: number;
+    minKillSpeed: number;
+    maxKillSpeed: number;
+    private collisionListeners;
+    private _system?;
+    constructor(options?: Partial<CollisionOptions>);
+    onCollision(listener: CollisionListener): void;
+    removeCollisionListener(listener: CollisionListener): void;
+    prepare(system: ParticleSystem, deltaTime: number): void;
+    private collide;
+    private resolvePosition;
+    private resolveVelocity;
+    private resolveLifetime;
+    private getParticleRadius;
+    private killParticle;
+}
+export default Collision;