@rzmps/rzmps 1.0.0

package/build/modules/TransformByNoise.js

@@ -0,0 +1,32 @@
+import * as THREE from 'three';
+import Module from '../Module';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+import evaluateDynamicVector from '../helpers/evaluateDynamicVector3';
+import NoiseModule from './NoiseModule';
+class TransformByNoise extends Module {
+    constructor(options) {
+        const key = `transformByNoise-${Math.random().toString(36).slice(2)}`;
+        const noiseX = new NoiseModule(`${key}-x`, Object.assign(Object.assign({}, options), { offset: new THREE.Vector3(0, 0, 0) }));
+        const noiseY = new NoiseModule(`${key}-y`, Object.assign(Object.assign({}, options), { offset: new THREE.Vector3(31.416, 0, 0) }));
+        const noiseZ = new NoiseModule(`${key}-z`, Object.assign(Object.assign({}, options), { offset: new THREE.Vector3(0, 31.416, 0) }));
+        super((particle, deltaTime) => {
+            var _a, _b;
+            const scrollSpeed = evaluateDynamicNumber((_a = this.options.scrollSpeed) !== null && _a !== void 0 ? _a : 0, particle.time, particle.id);
+            const time = (particle.realtime / 1000) * scrollSpeed;
+            this.noiseX.time = time;
+            this.noiseY.time = time;
+            this.noiseZ.time = time;
+            const strength = evaluateDynamicVector(this.options.strength, particle.time, particle.id);
+            if (this.options.damping)
+                strength.multiplyScalar(1 / Math.max((_b = this.options.frequency) !== null && _b !== void 0 ? _b : 1, 1));
+            const force = new THREE.Vector3((particle.noise[this.noiseX.key].noise4d * 2 - 1) * strength.x, (particle.noise[this.noiseY.key].noise4d * 2 - 1) * strength.y, (particle.noise[this.noiseZ.key].noise4d * 2 - 1) * strength.z);
+            particle.velocity.addScaledVector(force, deltaTime);
+        }, options);
+        this.options = options;
+        this.noiseX = noiseX;
+        this.noiseY = noiseY;
+        this.noiseZ = noiseZ;
+        this.dependents.push(noiseX, noiseY, noiseZ);
+    }
+}
+export default TransformByNoise;

package/build/modules/VelocityOverLifetime.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import Module, { ModuleOptions } from '../Module';
+import { DynamicValue } from '../types/DynamicValue';
+export interface VelocityOverLifetimeOptions extends Partial<ModuleOptions> {
+    linear: DynamicValue<THREE.Vector3>;
+    orbital: DynamicValue<THREE.Vector3>;
+    orbitOffset: DynamicValue<THREE.Vector3>;
+    radial: DynamicValue<number>;
+    speedModifier: DynamicValue<number>;
+}
+declare class VelocityOverLifetime extends Module {
+    options: Partial<VelocityOverLifetimeOptions>;
+    constructor(options?: Partial<VelocityOverLifetimeOptions>);
+}
+export default VelocityOverLifetime;

package/build/modules/VelocityOverLifetime.js

@@ -0,0 +1,32 @@
+import * as THREE from 'three';
+import Module from '../Module';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+import evaluateDynamicVector from '../helpers/evaluateDynamicVector3';
+class VelocityOverLifetime extends Module {
+    constructor(options = {}) {
+        super((particle) => {
+            var _a;
+            const { time } = particle;
+            const velocity = particle.start.velocity.clone();
+            if (this.options.linear !== undefined) {
+                velocity.add(evaluateDynamicVector(this.options.linear, time, particle.id).clone());
+            }
+            const offset = evaluateDynamicVector((_a = this.options.orbitOffset) !== null && _a !== void 0 ? _a : new THREE.Vector3(), time, particle.id).clone();
+            const center = particle.start.position.clone().add(offset);
+            const fromCenter = particle.position.clone().sub(center);
+            if (this.options.orbital !== undefined && fromCenter.lengthSq() > 0) {
+                const angularVelocity = evaluateDynamicVector(this.options.orbital, time, particle.id).clone();
+                velocity.add(angularVelocity.cross(fromCenter.clone().normalize()));
+            }
+            if (this.options.radial !== undefined && fromCenter.lengthSq() > 0) {
+                velocity.add(fromCenter.normalize().multiplyScalar(evaluateDynamicNumber(this.options.radial, time, particle.id)));
+            }
+            particle.velocity = velocity;
+            if (this.options.speedModifier !== undefined) {
+                particle.speed = particle.start.speed * evaluateDynamicNumber(this.options.speedModifier, time, particle.id);
+            }
+        }, options);
+        this.options = options;
+    }
+}
+export default VelocityOverLifetime;

package/build/renderers/LightRenderer.d.ts

@@ -0,0 +1,54 @@
+import * as THREE from 'three';
+import Renderer, { RendererOptions } from '../Renderer';
+import ParticleSystem from '../ParticleSystem';
+import Particle from '../Particle';
+import { DynamicValue } from '../types/DynamicValue';
+export interface PointLightOptions {
+    color?: THREE.Color | string | number;
+    intensity?: number;
+    distance?: number;
+    decay?: number;
+    power?: number;
+}
+export interface LightRendererOptions extends RendererOptions {
+    brightness: DynamicValue<number>;
+    rangeMultiplier: DynamicValue<number>;
+    groupingRadiusRatio: number;
+    decay: number;
+    count: number;
+    ratio: number;
+    randomDistribution: boolean;
+    inheritParticleColor: boolean;
+    sizeAffectsRange: boolean;
+    alphaAffectsIntensity: boolean;
+    lightOptions: PointLightOptions;
+}
+declare class LightRenderer extends Renderer {
+    lights: THREE.PointLight[];
+    groupingRadiusRatio: number;
+    brightness: DynamicValue<number>;
+    rangeMultiplier: DynamicValue<number>;
+    decay: number;
+    ratio: number;
+    randomDistribution: boolean;
+    inheritParticleColor: boolean;
+    sizeAffectsRange: boolean;
+    alphaAffectsIntensity: boolean;
+    lightOptions: PointLightOptions;
+    private lightContainer;
+    private _count;
+    get count(): number;
+    set count(value: number);
+    constructor(options?: Partial<LightRendererOptions>);
+    setup(system: ParticleSystem): void;
+    _update(particles: Particle[]): void;
+    private _createLight;
+    private _getIntensity;
+    private _getDistance;
+    private _getLightParticles;
+    private _getParticleGroups;
+    private _getGroupingRadius;
+    private _syncLightCount;
+    destroy(): void;
+}
+export default LightRenderer;

package/build/renderers/LightRenderer.js

@@ -0,0 +1,141 @@
+import * as THREE from 'three';
+import Renderer from '../Renderer';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+import particleRatio from '../helpers/particleRatio';
+class LightRenderer extends Renderer {
+    get count() {
+        return this._count;
+    }
+    set count(value) {
+        const next = Number.isFinite(value)
+            ? Math.max(0, Math.floor(value))
+            : 0;
+        if (next === this._count)
+            return;
+        this._count = next;
+        this._syncLightCount();
+    }
+    constructor(options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        super(options);
+        this.lights = [];
+        this.lightContainer = new THREE.Object3D();
+        this._count = 0;
+        this.brightness = (_a = options.brightness) !== null && _a !== void 0 ? _a : 1;
+        this.rangeMultiplier = (_b = options.rangeMultiplier) !== null && _b !== void 0 ? _b : 1;
+        this.groupingRadiusRatio = (_c = options.groupingRadiusRatio) !== null && _c !== void 0 ? _c : 0.25;
+        this.lightOptions = (_d = options.lightOptions) !== null && _d !== void 0 ? _d : {};
+        this.decay = (_f = (_e = options.decay) !== null && _e !== void 0 ? _e : this.lightOptions.decay) !== null && _f !== void 0 ? _f : 2;
+        this.count = (_g = options.count) !== null && _g !== void 0 ? _g : 50;
+        this.ratio = Math.min(Math.max((_h = options.ratio) !== null && _h !== void 0 ? _h : 1, 0), 1);
+        this.randomDistribution = (_j = options.randomDistribution) !== null && _j !== void 0 ? _j : true;
+        this.inheritParticleColor = (_k = options.inheritParticleColor) !== null && _k !== void 0 ? _k : true;
+        this.sizeAffectsRange = (_l = options.sizeAffectsRange) !== null && _l !== void 0 ? _l : false;
+        this.alphaAffectsIntensity = (_m = options.alphaAffectsIntensity) !== null && _m !== void 0 ? _m : false;
+    }
+    setup(system) {
+        system.addRendererObject(this.lightContainer);
+    }
+    _update(particles) {
+        const lightParticles = this._getLightParticles(particles);
+        const groups = this._getParticleGroups(lightParticles).slice(0, this.count);
+        if (groups.length < this.lights.length) {
+            // To reduce initialization lag, just turn intensity to 0
+            [...this.lights].splice(groups.length).forEach((light) => { light.intensity = 0; });
+        }
+        groups.forEach((group, index) => {
+            var _a, _b;
+            const light = this.lights[index];
+            if (!light)
+                return;
+            const position = group.reduce((sum, value) => sum.add(value.position), new THREE.Vector3(0, 0, 0)).divideScalar(group.length);
+            light.position.set(position.x, position.y, position.z);
+            const color = new THREE.Color((_a = this.lightOptions.color) !== null && _a !== void 0 ? _a : 0xffffff);
+            if (this.inheritParticleColor) {
+                color.multiply(group.reduce((sum, value) => sum.add(value.color), new THREE.Color(0x000000)).multiplyScalar(1 / group.length));
+            }
+            light.color = color;
+            light.decay = (_b = this.lightOptions.decay) !== null && _b !== void 0 ? _b : this.decay;
+            light.distance = this._getDistance(group);
+            light.intensity = group.reduce((sum, value) => sum + this._getIntensity(value), 0) / group.length;
+        });
+    }
+    _createLight() {
+        var _a, _b;
+        const light = new THREE.PointLight((_a = this.lightOptions.color) !== null && _a !== void 0 ? _a : 0xffffff, 0, (_b = this.lightOptions.distance) !== null && _b !== void 0 ? _b : 0, this.decay);
+        if (this.lightOptions.power !== undefined)
+            light.power = this.lightOptions.power;
+        return light;
+    }
+    _getIntensity(particle) {
+        var _a;
+        let intensity = ((_a = this.lightOptions.intensity) !== null && _a !== void 0 ? _a : 1)
+            * evaluateDynamicNumber(this.brightness, particle.time, particle.id);
+        if (this.alphaAffectsIntensity) {
+            intensity *= particle.alpha;
+        }
+        return intensity;
+    }
+    _getDistance(group) {
+        var _a;
+        const distance = (_a = this.lightOptions.distance) !== null && _a !== void 0 ? _a : 0;
+        if (distance === 0)
+            return 0;
+        return group.reduce((sum, particle) => {
+            let range = distance * evaluateDynamicNumber(this.rangeMultiplier, particle.time, particle.id);
+            if (this.sizeAffectsRange) {
+                range *= (particle.scale.x + particle.scale.y + particle.scale.z) / 3;
+            }
+            return sum + range;
+        }, 0) / group.length;
+    }
+    _getLightParticles(particles) {
+        if (this.ratio <= 0)
+            return [];
+        if (this.ratio >= 1)
+            return particles;
+        if (this.randomDistribution) {
+            return particles.filter((particle) => particleRatio(particle, this.ratio));
+        }
+        const step = Math.max(1, Math.round(1 / this.ratio));
+        return particles.filter((particle, index) => index % step === 0);
+    }
+    _getParticleGroups(particles) {
+        if (particles.length === 0)
+            return [];
+        // Group particle
+        let particlesCopy = [...particles];
+        const radius = this._getGroupingRadius(particles);
+        const groups = [[particlesCopy[0]]];
+        particlesCopy.splice(0, 1);
+        while (particlesCopy.length > 0) {
+            // Get group
+            const group = particlesCopy.filter((p) => particlesCopy[0].position.distanceTo(p.position) <= radius);
+            // Remove group from particlesCopy
+            particlesCopy = particlesCopy.filter((p) => particlesCopy[0].position.distanceTo(p.position) > radius);
+            groups.push(group);
+        }
+        return groups;
+    }
+    _getGroupingRadius(particles) {
+        const range = particles.reduce((highest, next) => (highest > next.position.length() ? highest : next.position.length()), 0) * 2;
+        return this.groupingRadiusRatio * range;
+    }
+    _syncLightCount() {
+        while (this.lights.length < this._count) {
+            const light = this._createLight();
+            this.lights.push(light);
+            this.lightContainer.add(light);
+        }
+        if (this.lights.length > this._count) {
+            const removed = this.lights.splice(this._count);
+            removed.forEach((light) => {
+                light.removeFromParent();
+            });
+        }
+    }
+    destroy() {
+        this.lightContainer.removeFromParent();
+    }
+}
+export default LightRenderer;

package/build/renderers/MeshRenderer.d.ts

@@ -0,0 +1,27 @@
+import * as THREE from 'three';
+import Renderer, { RendererOptions } from '../Renderer';
+import ParticleSystem from '../ParticleSystem';
+import Particle from '../Particle';
+export interface MeshRendererOptions extends RendererOptions {
+    mesh: THREE.Mesh;
+    maxParticles: number;
+    geometry: THREE.BufferGeometry;
+    material: THREE.MeshStandardMaterial;
+    materialOptions: THREE.MeshStandardMaterialParameters;
+    castShadow: boolean;
+    receiveShadow: boolean;
+}
+declare class MeshRenderer extends Renderer {
+    mesh: THREE.Mesh;
+    instances: THREE.InstancedMesh;
+    castShadow: boolean;
+    receiveShadow: boolean;
+    private _alphaAttr;
+    private dummy;
+    constructor(options?: Partial<MeshRendererOptions>);
+    setup(system: ParticleSystem): void;
+    _update(particles: Particle[]): void;
+    destroy(): void;
+    private preprocessMaterial;
+}
+export default MeshRenderer;

package/build/renderers/MeshRenderer.js

@@ -0,0 +1,70 @@
+import * as THREE from 'three';
+import { attribute } from 'three/src/nodes/core/AttributeNode.js';
+import Renderer from '../Renderer';
+class MeshRenderer extends Renderer {
+    constructor(options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        super(options);
+        this.castShadow = false;
+        this.receiveShadow = false;
+        this.mesh = (_a = options.mesh) !== null && _a !== void 0 ? _a : new THREE.Mesh((_b = options.geometry) !== null && _b !== void 0 ? _b : new THREE.SphereGeometry(), (_c = options.material) !== null && _c !== void 0 ? _c : new THREE.MeshStandardMaterial(options.materialOptions));
+        this.instances = new THREE.InstancedMesh(this.mesh.geometry, this.mesh.material, (_d = options.maxParticles) !== null && _d !== void 0 ? _d : 10000);
+        this.instances.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+        this.instances.frustumCulled = false;
+        this.instances.setColorAt(0, new THREE.Color(1, 1, 1));
+        this.castShadow = (_e = options.castShadow) !== null && _e !== void 0 ? _e : this.castShadow;
+        this.receiveShadow = (_f = options.receiveShadow) !== null && _f !== void 0 ? _f : this.receiveShadow;
+        this._alphaAttr = new THREE.InstancedBufferAttribute(new Float32Array((_g = options.maxParticles) !== null && _g !== void 0 ? _g : 10000), 1);
+        this.mesh.geometry.setAttribute('instanceAlpha', this._alphaAttr);
+        this.dummy = new THREE.Object3D();
+        this.preprocessMaterial(this.mesh.material);
+    }
+    setup(system) {
+        system.addRendererObject(this.instances);
+    }
+    _update(particles) {
+        this.instances.count = particles.length;
+        this.instances.castShadow = this.castShadow;
+        this.instances.receiveShadow = this.receiveShadow;
+        particles.forEach((particle, i) => {
+            this.dummy.position.set(...particle.position.toArray());
+            this.dummy.rotation.set(...particle.rotation.toArray());
+            this.dummy.scale.set(...particle.scale.toArray());
+            this.dummy.updateMatrix();
+            this.instances.setMatrixAt(i, this.dummy.matrix);
+            this.instances.setColorAt(i, particle.color);
+            this._alphaAttr.setX(i, particle.alpha);
+        });
+        if (this.instances.instanceColor)
+            this.instances.instanceColor.needsUpdate = true;
+        this.instances.instanceMatrix.needsUpdate = true;
+        this._alphaAttr.needsUpdate = true;
+    }
+    destroy() {
+        this.instances.removeFromParent();
+    }
+    preprocessMaterial(material) {
+        if (Array.isArray(material))
+            return material.forEach((mat) => this.preprocessMaterial(mat));
+        material.transparent = true;
+        material.opacityNode =
+            attribute('instanceAlpha', 'float');
+        material.onBeforeCompile = (shader) => {
+            shader.vertexShader = `
+attribute float instanceAlpha;
+varying float vInstanceAlpha;
+${shader.vertexShader}
+        `.replace('#include <begin_vertex>', `
+#include <begin_vertex>
+vInstanceAlpha = instanceAlpha;`);
+            shader.fragmentShader = `
+varying float vInstanceAlpha;
+${shader.fragmentShader}
+        `.replace('#include <opaque_fragment>', `
+#include <opaque_fragment>
+gl_FragColor.a *= vInstanceAlpha;`);
+        };
+        material.needsUpdate = true;
+    }
+}
+export default MeshRenderer;

package/build/renderers/SpriteRenderer.d.ts

@@ -0,0 +1,95 @@
+import * as THREE from 'three';
+import Renderer, { RendererOptions } from '../Renderer';
+import Particle from '../Particle';
+import ParticleSystem from '../ParticleSystem';
+import { UnlitSpriteOptions } from '../materials/UnlitSprite';
+import { BasicSpriteOptions } from '../materials/BasicSprite';
+import { DynamicValue } from '../types/DynamicValue';
+import { SpriteMaterialType } from '../enums/SpriteMaterialType';
+export declare const SPRITE_RENDERER_USER_DATA_KEY = "__rzmps_spriteRenderer";
+export declare const SCENE_DEPTH_DATA_USER_DATA_KEY = "__rzmps_sceneDepthData";
+export declare const WEBGPU_SCENE_DEPTH_DATA_USER_DATA_KEY = "__rzmps_webgpuSceneDepthData";
+export declare const WEBGPU_SCENE_DEPTH_TEXTURE: THREE.DepthTexture<THREE.DepthTextureImageData>;
+export interface SpriteRendererOptions extends RendererOptions {
+    fps: DynamicValue<number>;
+    tileSize: {
+        x: number;
+        y: number;
+    };
+    tileMargin: {
+        x: number;
+        y: number;
+    };
+    gridSize: {
+        x: number;
+        y: number;
+    };
+    frames: number;
+    randomStartFrame: boolean;
+    alphaMap: string | THREE.Texture;
+    material: SpriteMaterialType | `${SpriteMaterialType}`;
+    materialOptions: BasicSpriteOptions | UnlitSpriteOptions;
+    castShadow: boolean;
+    softParticleDistance: number;
+}
+declare class SpriteRenderer extends Renderer {
+    texture: THREE.Texture;
+    frames: number;
+    alphaMap?: THREE.Texture;
+    materialType: SpriteMaterialType;
+    tileSize: THREE.Vector2;
+    tileMargin: THREE.Vector2;
+    gridSize: THREE.Vector2;
+    fps: DynamicValue<number>;
+    randomStartFrame: boolean;
+    castShadow: boolean;
+    softParticleDistance: number;
+    private material;
+    private webgpuMaterial;
+    private readonly hiddenMaterial;
+    private _materialOptions;
+    get materialOptions(): BasicSpriteOptions | UnlitSpriteOptions | undefined;
+    set materialOptions(value: BasicSpriteOptions | UnlitSpriteOptions | undefined);
+    private environmentSource?;
+    private environmentRenderer?;
+    private environmentRenderTarget?;
+    private readonly geometry;
+    private readonly points;
+    private readonly webgpuGeometry;
+    private readonly webgpuMesh;
+    private webgpuFrameAttribute;
+    private webgpuAlphaAttribute;
+    private webgpuCapacity;
+    private readonly matrix;
+    private readonly quaternion;
+    private readonly cameraQuaternion;
+    private readonly rollQuaternion;
+    private readonly rollAxis;
+    private readonly scaleVector;
+    private readonly color;
+    constructor(texture?: string | THREE.Texture, options?: Partial<SpriteRendererOptions>);
+    setup(system: ParticleSystem): void;
+    _update(particles: Particle[], system: ParticleSystem): void;
+    private updateAttributes;
+    destroy(): void;
+    private loadMaterial;
+    private loadWebGPUMaterial;
+    private isWebGPURenderer;
+    private setActiveRenderer;
+    private updateWebGPUInstances;
+    private getWebGPUWorldScale;
+    private getParticleFrame;
+    private updateWebGPUEnvironmentMap;
+    private updateWebGPUSoftParticles;
+    private updateEnvironmentMap;
+    private setEnvironmentMap;
+    private setUniformValue;
+    private getUniformValue;
+    private getSceneDepth;
+    private getWebGPUSceneDepth;
+    private hideSpriteRenderers;
+    private hideParticleRenderers;
+    private restoreSpriteRenderers;
+    private restoreParticleRenderers;
+}
+export default SpriteRenderer;