@rzmps/rzmps 1.0.0

package/build/renderers/TrailRenderer.js

@@ -0,0 +1,400 @@
+import * as THREE from 'three';
+import seedrandom from 'seedrandom';
+import Renderer from '../Renderer';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+import evaluateDynamicColor from '../helpers/evaluateDynamicColor';
+import { TrailMode } from '../enums/TrailMode';
+import { TrailTextureMode } from '../enums/TrailTextureMode';
+export const TRAIL_RENDERER_USER_DATA_KEY = "__rzmps_trailRenderer";
+class TrailRenderer extends Renderer {
+    constructor(options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        super(options);
+        this.mode = TrailMode.Particle;
+        this.ratio = 1;
+        this.lifetime = 1;
+        this.minimumVertexDistance = 0.1;
+        this.dieWithParticles = true;
+        this.ribbonCount = 1;
+        this.textureMode = TrailTextureMode.Stretch;
+        this.width = 1;
+        this.sizeAffectsWidth = false;
+        this.sizeAffectsLifetime = false;
+        this.inheritParticleColor = true;
+        this.colorOverLifetime = new THREE.Color(0xffffff);
+        this.widthOverTrail = 1;
+        this.colorOverTrail = new THREE.Color(0xffffff);
+        this.castShadow = false;
+        this.receiveShadow = false;
+        this.particles = [];
+        this.trails = new Map();
+        this.elapsedTime = 0;
+        this.mode = (_a = options.mode) !== null && _a !== void 0 ? _a : this.mode;
+        this.ratio = (_b = options.ratio) !== null && _b !== void 0 ? _b : this.ratio;
+        this.lifetime = (_c = options.lifetime) !== null && _c !== void 0 ? _c : this.lifetime;
+        this.minimumVertexDistance = (_d = options.minimumVertexDistance) !== null && _d !== void 0 ? _d : this.minimumVertexDistance;
+        this.dieWithParticles = (_e = options.dieWithParticles) !== null && _e !== void 0 ? _e : this.dieWithParticles;
+        this.ribbonCount = (_f = options.ribbonCount) !== null && _f !== void 0 ? _f : this.ribbonCount;
+        this.textureMode = (_g = options.textureMode) !== null && _g !== void 0 ? _g : this.textureMode;
+        this.width = (_h = options.width) !== null && _h !== void 0 ? _h : this.width;
+        this.sizeAffectsWidth = (_j = options.sizeAffectsWidth) !== null && _j !== void 0 ? _j : this.sizeAffectsWidth;
+        this.sizeAffectsLifetime = (_k = options.sizeAffectsLifetime) !== null && _k !== void 0 ? _k : this.sizeAffectsLifetime;
+        this.widthOverTrail = (_l = options.widthOverTrail) !== null && _l !== void 0 ? _l : this.widthOverTrail;
+        this.inheritParticleColor = (_m = options.inheritParticleColor) !== null && _m !== void 0 ? _m : this.inheritParticleColor;
+        this.colorOverLifetime = (_o = options.colorOverLifetime) !== null && _o !== void 0 ? _o : this.colorOverLifetime;
+        this.colorOverTrail = (_p = options.colorOverTrail) !== null && _p !== void 0 ? _p : this.colorOverTrail;
+        this.castShadow = (_q = options.castShadow) !== null && _q !== void 0 ? _q : this.castShadow;
+        this.receiveShadow = (_r = options.receiveShadow) !== null && _r !== void 0 ? _r : this.receiveShadow;
+        this.geometry = new THREE.BufferGeometry();
+        this.setEmptyGeometry();
+        this.material = (_s = options.material) !== null && _s !== void 0 ? _s : new THREE.MeshStandardMaterial(Object.assign({ vertexColors: true, side: THREE.DoubleSide, transparent: true, depthWrite: false }, options.materialOptions));
+        this.preprocessMaterial(this.material);
+        this.mesh = new THREE.Mesh(this.geometry, this.material);
+        // Add user data to the mesh so we can recognize it elsewhere
+        this.mesh.userData[TRAIL_RENDERER_USER_DATA_KEY] = true;
+        this.mesh.frustumCulled = false;
+    }
+    setup(system) {
+        system.addRendererObject(this.mesh);
+        this.mesh.onBeforeRender = (renderer, _scene, camera) => {
+            if (!renderer.isWebGPURenderer)
+                return;
+            this.rebuildGeometry(camera);
+        };
+    }
+    _update(particles, system, deltaTime) {
+        this.particles = particles;
+        this.elapsedTime += Math.max(0, deltaTime);
+        this.mesh.castShadow = this.castShadow;
+        this.mesh.receiveShadow = this.receiveShadow;
+        if (this.mode === TrailMode.Particle) {
+            this.updateParticleTrails(particles);
+        }
+        if (system.sceneCamera) {
+            this.rebuildGeometry(system.sceneCamera);
+        }
+    }
+    destroy() {
+        this.geometry.dispose();
+        this.trails.clear();
+        this.mesh.removeFromParent();
+    }
+    updateParticleTrails(particles) {
+        const now = this.elapsedTime;
+        const aliveParticles = new Set();
+        // Adding new trail points
+        particles.forEach((particle) => {
+            aliveParticles.add(particle.id);
+            if (!this.particleHasTrail(particle.id)) {
+                return;
+            }
+            let trail = this.trails.get(particle.id);
+            if (!trail) {
+                trail = {
+                    particleId: particle.id,
+                    points: [],
+                    alive: true,
+                    headPosition: particle.position.clone(),
+                    particleTime: particle.time,
+                    particleColor: particle.color.clone(),
+                    particleAlpha: particle.alpha,
+                    particleSize: this.getParticleSize(particle),
+                };
+                this.trails.set(particle.id, trail);
+                this.addTrailPoint(trail, particle, now);
+            }
+            trail.alive = true;
+            trail.headPosition.copy(particle.position);
+            trail.particleTime = particle.time;
+            trail.particleColor.copy(particle.color);
+            trail.particleAlpha = particle.alpha;
+            trail.particleSize = this.getParticleSize(particle);
+            const lastPoint = trail.points[trail.points.length - 1];
+            if (!lastPoint
+                || lastPoint.position.distanceTo(particle.position) >= this.minimumVertexDistance) {
+                this.addTrailPoint(trail, particle, now);
+            }
+        });
+        // Disposing of dead trails
+        for (const [id, trail] of this.trails) {
+            if (!aliveParticles.has(id)) {
+                trail.alive = false;
+                if (this.dieWithParticles) {
+                    this.trails.delete(id);
+                    continue;
+                }
+            }
+            while (trail.points.length > 0 && trail.points[0].expiresAt <= now) {
+                trail.points.shift();
+            }
+            if (!trail.alive && trail.points.length === 0) {
+                this.trails.delete(id);
+            }
+        }
+    }
+    addTrailPoint(trail, particle, now) {
+        let vertexLifetime = particle.lifetime * evaluateDynamicNumber(this.lifetime, particle.time, particle.id);
+        if (this.sizeAffectsLifetime) {
+            vertexLifetime *= this.getParticleSize(particle);
+        }
+        trail.points.push({
+            position: particle.position.clone(),
+            createdAt: now,
+            expiresAt: now + Math.max(0, vertexLifetime),
+        });
+    }
+    getPaths() {
+        if (this.mode === TrailMode.Ribbon) {
+            return this.getRibbonPaths();
+        }
+        return this.getParticlePaths();
+    }
+    getParticlePaths() {
+        const paths = [];
+        for (const trail of this.trails.values()) {
+            if (trail.points.length === 0) {
+                continue;
+            }
+            const path = trail.points.map((point) => ({
+                position: point.position,
+                particleTime: trail.particleTime,
+                particleColor: trail.particleColor,
+                particleAlpha: trail.particleAlpha,
+                particleSize: trail.particleSize,
+                particleId: trail.particleId,
+            }));
+            if (trail.alive) {
+                const lastPosition = path[path.length - 1].position;
+                if (lastPosition.distanceToSquared(trail.headPosition) > 0) {
+                    path.push({
+                        position: trail.headPosition,
+                        particleTime: trail.particleTime,
+                        particleColor: trail.particleColor,
+                        particleAlpha: trail.particleAlpha,
+                        particleSize: trail.particleSize,
+                        particleId: trail.particleId,
+                    });
+                }
+            }
+            if (path.length >= 2) {
+                paths.push(path);
+            }
+        }
+        return paths;
+    }
+    getRibbonPaths() {
+        const ribbonCount = Math.max(1, Math.floor(this.ribbonCount));
+        // Ordering based on age
+        const particles = this.particles
+            .filter((particle) => this.particleHasTrail(particle.id))
+            .sort((a, b) => a.startTime - b.startTime);
+        const ribbons = Array.from({ length: ribbonCount }, () => []);
+        particles.forEach((particle, index) => {
+            const ribbonIndex = index % ribbonCount;
+            ribbons[ribbonIndex].push({
+                position: particle.position,
+                particleTime: particle.time,
+                particleColor: particle.color,
+                particleAlpha: particle.alpha,
+                particleSize: this.getParticleSize(particle),
+                particleId: particle.id,
+            });
+        });
+        return ribbons.filter((ribbon) => ribbon.length >= 2);
+    }
+    rebuildGeometry(camera) {
+        const paths = this.getPaths();
+        const positions = [];
+        const normals = [];
+        const uvs = [];
+        const colors = [];
+        const indices = [];
+        const cameraPosition = camera.getWorldPosition(new THREE.Vector3());
+        this.mesh.worldToLocal(cameraPosition);
+        for (const path of paths) {
+            this.appendPathGeometry(path, cameraPosition, positions, normals, uvs, colors, indices);
+        }
+        if (positions.length === 0) {
+            this.setEmptyGeometry();
+            return;
+        }
+        this.geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+        this.geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
+        this.geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+        this.geometry.setAttribute('color', new THREE.Float32BufferAttribute(colors, 4));
+        this.geometry.setIndex(indices);
+        this.geometry.setDrawRange(0, Infinity);
+        if (positions.length > 0) {
+            this.geometry.computeBoundingSphere();
+        }
+        else {
+            this.geometry.boundingSphere = null;
+        }
+    }
+    setEmptyGeometry() {
+        this.geometry.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(12), 3));
+        this.geometry.setAttribute('normal', new THREE.Float32BufferAttribute(new Float32Array([
+            0, 0, 1,
+            0, 0, 1,
+            0, 0, 1,
+            0, 0, 1,
+        ]), 3));
+        this.geometry.setAttribute('uv', new THREE.Float32BufferAttribute(new Float32Array(8), 2));
+        this.geometry.setAttribute('color', new THREE.Float32BufferAttribute(new Float32Array([
+            1, 1, 1, 0,
+            1, 1, 1, 0,
+            1, 1, 1, 0,
+            1, 1, 1, 0,
+        ]), 4));
+        this.geometry.setIndex([0, 1, 2, 1, 3, 2]);
+        this.geometry.setDrawRange(0, 0);
+        this.geometry.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 0);
+    }
+    appendPathGeometry(path, cameraPosition, positions, normals, uvs, colors, indices) {
+        if (path.length < 2) {
+            return;
+        }
+        const baseVertex = positions.length / 3;
+        const distances = new Array(path.length);
+        distances[0] = 0;
+        for (let i = 1; i < path.length; i++) {
+            distances[i] = distances[i - 1] + path[i].position.distanceTo(path[i - 1].position);
+        }
+        const totalDistance = distances[distances.length - 1];
+        let previousSide;
+        for (let i = 0; i < path.length; i++) {
+            const point = path[i];
+            const trailT = totalDistance > 0 ? distances[i] / totalDistance : 0;
+            const tangent = this.getTangent(path, i);
+            const viewDirection = cameraPosition.clone().sub(point.position);
+            if (viewDirection.lengthSq() > 0) {
+                viewDirection.normalize();
+            }
+            else {
+                viewDirection.set(0, 0, 1);
+            }
+            const side = new THREE.Vector3().crossVectors(tangent, viewDirection);
+            if (side.lengthSq() < 0.000001) {
+                if (previousSide) {
+                    side.copy(previousSide);
+                }
+                else {
+                    side.copy(this.getPerpendicular(tangent));
+                }
+            }
+            side.normalize();
+            if (previousSide && side.dot(previousSide) < 0) {
+                side.negate();
+            }
+            previousSide = side.clone();
+            const normal = new THREE.Vector3()
+                .crossVectors(side, tangent)
+                .normalize();
+            let width = evaluateDynamicNumber(this.width, point.particleTime, point.particleId);
+            width *= evaluateDynamicNumber(this.widthOverTrail, trailT, point.particleId);
+            if (this.sizeAffectsWidth) {
+                width *= point.particleSize;
+            }
+            const halfWidth = width * 0.5;
+            const left = point.position
+                .clone()
+                .addScaledVector(side, -halfWidth);
+            const right = point.position
+                .clone()
+                .addScaledVector(side, halfWidth);
+            positions.push(left.x, left.y, left.z, right.x, right.y, right.z);
+            normals.push(normal.x, normal.y, normal.z, normal.x, normal.y, normal.z);
+            const u = this.getTextureU(i, path.length, distances[i], totalDistance);
+            uvs.push(u, 0, u, 1);
+            const lifetimeColor = evaluateDynamicColor(this.colorOverLifetime, point.particleTime, point.particleId).clone();
+            const trailColor = evaluateDynamicColor(this.colorOverTrail, trailT, point.particleId).clone();
+            const finalColor = lifetimeColor.multiply(trailColor);
+            if (this.inheritParticleColor) {
+                finalColor.multiply(point.particleColor);
+            }
+            const alpha = this.inheritParticleColor ? point.particleAlpha : 1;
+            colors.push(finalColor.r, finalColor.g, finalColor.b, alpha, finalColor.r, finalColor.g, finalColor.b, alpha);
+        }
+        // Build tris
+        for (let i = 0; i < path.length - 1; i++) {
+            const a = baseVertex + i * 2;
+            const b = a + 1;
+            const c = a + 2;
+            const d = a + 3;
+            indices.push(a, b, c, b, d, c);
+        }
+    }
+    getTangent(path, index) {
+        const tangent = new THREE.Vector3();
+        if (index === 0) {
+            tangent.subVectors(path[1].position, path[0].position);
+        }
+        else if (index === path.length - 1) {
+            tangent.subVectors(path[index].position, path[index - 1].position);
+        }
+        else {
+            tangent.subVectors(path[index + 1].position, path[index - 1].position);
+        }
+        /*
+         * Duplicate trail positions can otherwise give us an
+         * unusable zero-length tangent.
+         */
+        if (tangent.lengthSq() < 0.000001) {
+            if (index > 0) {
+                tangent.subVectors(path[index].position, path[index - 1].position);
+            }
+            if (tangent.lengthSq() < 0.000001 && index < path.length - 1) {
+                tangent.subVectors(path[index + 1].position, path[index].position);
+            }
+        }
+        if (tangent.lengthSq() < 0.000001) {
+            tangent.set(1, 0, 0);
+        }
+        return tangent.normalize();
+    }
+    getPerpendicular(tangent) {
+        const reference = Math.abs(tangent.z) < 0.9
+            ? new THREE.Vector3(0, 0, 1)
+            : new THREE.Vector3(0, 1, 0);
+        return new THREE.Vector3()
+            .crossVectors(tangent, reference)
+            .normalize();
+    }
+    getTextureU(index, pointCount, distance, totalDistance) {
+        switch (this.textureMode) {
+            case TrailTextureMode.Tile:
+                return distance;
+            case TrailTextureMode.RepeatPerSegment:
+                return index;
+            case TrailTextureMode.DistributePerSegment:
+                return pointCount > 1 ? index / (pointCount - 1) : 0;
+            case TrailTextureMode.Stretch:
+            default:
+                return totalDistance > 0 ? distance / totalDistance : 0;
+        }
+    }
+    getParticleSize(particle) {
+        return Math.max(Math.abs(particle.scale.x), Math.abs(particle.scale.y), Math.abs(particle.scale.z));
+    }
+    particleHasTrail(id) {
+        const ratio = THREE.MathUtils.clamp(this.ratio, 0, 1);
+        if (ratio <= 0) {
+            return false;
+        }
+        if (ratio >= 1) {
+            return true;
+        }
+        const random = seedrandom(id).quick();
+        return random < ratio;
+    }
+    preprocessMaterial(material) {
+        if (Array.isArray(material)) {
+            material.forEach((item) => this.preprocessMaterial(item));
+            return;
+        }
+        material.vertexColors = true;
+        material.transparent = true;
+        material.needsUpdate = true;
+    }
+}
+export default TrailRenderer;

package/build/shaders/BasicSprite.frag.js

@@ -0,0 +1 @@
+export default "uniform sampler2D pointTexture;\n\nuniform sampler2D alphaMap;\nuniform bool hasAlphaMap;\n\nuniform sampler2D normalMap;\nuniform bool hasNormalMap;\nuniform float normalStrength;\n\nuniform float normalLighting;\nuniform bool sphericalNormals;\n\nuniform float roughness;\nuniform sampler2D roughnessMap;\nuniform bool hasRoughnessMap;\n\nuniform vec2 gridSize;\nuniform int n_frames;\n\nuniform sampler2D envMap;\nuniform float envIntensity;\nuniform bool hasEnvMap;\n\nuniform bool softParticles;\nuniform float softParticleDistance;\nuniform sampler2D sceneDepthTexture;\nuniform vec2 depthResolution;\nuniform float depthCameraNear;\nuniform float depthCameraFar;\n\nvarying vec4 vColor;\nvarying float aspectRatio;\nvarying float angle;\n\nvarying vec3 vViewPosition;\nvarying vec3 vNormal;\n\nflat in int fragFrame;\n\n// Provides:\n// IncidentLight\n// ReflectedLight\n// saturate()\n// pow2(), pow4(), etc.\n#include <common>\n\n// Provides:\n// ambientLightColor\n// directionalLights[]\n// pointLights[]\n// spotLights[]\n// hemisphereLights[]\n// getDirectionalLightInfo()\n// getPointLightInfo()\n// getSpotLightInfo()\n#include <lights_pars_begin>\n\n// Provides PMREM environment decoding\n#include <cube_uv_reflection_fragment>\n\n// perspectiveDepthToViewZ\n#include <packing>\n\n\nvec2 rotate_vector(vec2 value, float rotation)\n{\n    return vec2(\n        cos(rotation) * value.x + sin(rotation) * value.y,\n        cos(rotation) * value.y - sin(rotation) * value.x\n    );\n}\n\n\nvec2 sprite_coord(vec2 coord, int frame)\n{\n    float f_frame = mod(float(frame), float(n_frames));\n\n    return vec2(\n        (coord.x / gridSize.x)\n            + (\n                mod(f_frame, gridSize.x)\n                * (1.0 / gridSize.x)\n            ),\n\n        1.0 - (\n            (coord.y / gridSize.y)\n            + (\n                floor(f_frame / gridSize.x)\n                * (1.0 / gridSize.y)\n            )\n        )\n    );\n}\n\nvec2 directionToEquirectUv(vec3 dir)\n{\n    dir = normalize(dir);\n\n    return vec2(\n        atan(dir.z, dir.x) / (2.0 * PI) + 0.5,\n        asin(clamp(dir.y, -1.0, 1.0)) / PI + 0.5\n    );\n}\n\n\nvoid accumulateLight(\n    IncidentLight light,\n    vec3 normal,\n    vec3 viewDirection,\n    float shininess,\n    float specularStrength,\n    float normalLighting,\n    inout vec3 diffuseLight,\n    inout vec3 specularLight\n)\n{\n    if (!light.visible)\n        return;\n\n    float normalDiffuse =\n        max(dot(normal, light.direction), 0.0);\n\n    float diffuseFactor =\n        mix(1.0, normalDiffuse, normalLighting);\n\n    diffuseLight +=\n        light.color * diffuseFactor;\n\n    if (normalLighting > 0.0 && normalDiffuse > 0.0)\n    {\n        vec3 halfDirection =\n            normalize(light.direction + viewDirection);\n\n        float specular =\n            pow(\n                max(dot(normal, halfDirection), 0.0),\n                shininess\n            );\n\n        specularLight +=\n            light.color\n            * specular\n            * specularStrength\n            * normalLighting;\n    }\n}\n\n\nvoid main()\n{\n    //\n    // SPRITE UV\n    //\n\n    vec2 scaleVector;\n\n    if (aspectRatio < 1.0 / aspectRatio)\n    {\n        scaleVector =\n            vec2(1.0, 1.0 / aspectRatio);\n    }\n    else\n    {\n        scaleVector =\n            vec2(aspectRatio, 1.0);\n    }\n\n    // Transform in LOCAL TILE coordinates first.\n    vec2 fromCenter =\n        gl_PointCoord - vec2(0.5);\n\n    // Undo the particle rotation in the square point-sprite space FIRST.\n    vec2 rotatedFromCenter =\n        rotate_vector(fromCenter, angle);\n\n    // Then account for the non-square sprite dimensions.\n    vec2 scaledFromCenter =\n        rotatedFromCenter * scaleVector;\n\n    vec2 rotatedLocalCoord =\n        vec2(0.5) + scaledFromCenter;\n\n    // Rotation can push us outside this sprite's tile.\n    // Discard rather than sampling an adjacent tile.\n    if (\n        rotatedLocalCoord.x < 0.0\n        || rotatedLocalCoord.x > 1.0\n        || rotatedLocalCoord.y < 0.0\n        || rotatedLocalCoord.y > 1.0\n    )\n    {\n        discard;\n    }\n\n    vec2 spriteCoord =\n        sprite_coord(\n            rotatedLocalCoord,\n            fragFrame\n        );\n\n\n    //\n    // BASE COLOR / ALPHA\n    //\n\n    vec4 textureColor =\n        texture2D(pointTexture, spriteCoord);\n\n    vec4 baseColor =\n        vColor * textureColor;\n\n    if (hasAlphaMap)\n    {\n        baseColor.a *=\n            texture2D(alphaMap, spriteCoord).r;\n    }\n\n    if (baseColor.a <= 0.0)\n        discard;\n\n\n    //\n    // NORMAL\n    //\n\n    vec3 normal =\n        normalize(vNormal);\n\n    if (sphericalNormals)\n    {\n        vec2 p =\n            rotatedLocalCoord * 2.0 - 1.0;\n\n        float r2 = dot(p, p);\n\n        if (r2 <= 1.0)\n        {\n            normal = normalize(vec3(\n                p.x,\n                -p.y,\n                sqrt(1.0 - r2)\n            ));\n        }\n    }\n\n    if (hasNormalMap)\n    {\n        vec3 mapNormal =\n            texture2D(\n                normalMap,\n                spriteCoord\n            ).xyz * 2.0 - 1.0;\n\n        // Normal map rotates with sprite.\n        mapNormal.xy =\n            rotate_vector(\n                mapNormal.xy,\n                angle\n            );\n\n        mapNormal.xy *= normalStrength;\n\n        normal =\n            normalize(mapNormal);\n    }\n\n\n    //\n    // ROUGHNESS -> BLINN/PHONG PARAMETERS\n    //\n\n    float roughnessValue =\n        roughness;\n\n    if (hasRoughnessMap)\n    {\n        roughnessValue *=\n            texture2D(\n                roughnessMap,\n                spriteCoord\n            ).r;\n    }\n\n    roughnessValue =\n        clamp(roughnessValue, 0.0, 1.0);\n\n    // We're not implementing full PBR here.\n    // Convert roughness to something sensible\n    // for a Blinn-Phong highlight.\n    float shininess =\n        mix(128.0, 2.0, roughnessValue);\n\n    float specularStrength =\n        1.0 - roughnessValue;\n\n\n    //\n    // LIGHTING\n    //\n\n    vec3 viewDirection =\n        normalize(vViewPosition);\n\n    // Sample environment lighting\n    vec3 environmentSpecular = vec3(0.0);\n    vec3 environmentDiffuse = vec3(0.0);\n\n    #ifdef ENVMAP_TYPE_CUBE_UV\n    if (hasEnvMap && envIntensity > 0.0)\n    {\n        vec3 worldNormal =\n            normalize(\n                inverseTransformDirection(\n                    normal,\n                    viewMatrix\n                )\n            );\n\n        vec3 worldViewDirection =\n            normalize(\n                inverseTransformDirection(\n                    viewDirection,\n                    viewMatrix\n                )\n            );\n\n        vec3 reflectionDirection =\n            reflect(\n                -worldViewDirection,\n                worldNormal\n            );\n\n        reflectionDirection =\n            normalize(\n                mix(\n                    reflectionDirection,\n                    worldNormal,\n                    pow(roughnessValue, 4.0)\n                )\n            );\n\n        environmentSpecular =\n            textureCubeUV(\n                envMap,\n                reflectionDirection,\n                roughnessValue\n            ).rgb\n            * envIntensity;\n\n        float NdotV =\n            max(dot(normal, viewDirection), 0.0);\n\n        float fresnel =\n            pow(1.0 - NdotV, 5.0);\n\n        float specularFactor =\n            mix(0.04, 1.0, fresnel);\n\n        environmentSpecular *= specularFactor;\n\n        environmentDiffuse =\n            textureCubeUV(\n                envMap,\n                worldNormal,\n                1.0\n            ).rgb\n            * envIntensity;\n    }\n    #endif\n\n    // Three gives ambient light as a combined color.\n    vec3 diffuseLight =\n        ambientLightColor\n        + environmentDiffuse;\n\n    vec3 specularLight =\n        environmentSpecular;\n\n    IncidentLight directLight;\n\n\n    //\n    // DIRECTIONAL LIGHTS\n    //\n\n    #if NUM_DIR_LIGHTS > 0\n\n        DirectionalLight directionalLight;\n\n        #pragma unroll_loop_start\n\n        for (\n            int i = 0;\n            i < NUM_DIR_LIGHTS;\n            i++\n        )\n        {\n            directionalLight =\n                directionalLights[i];\n\n            getDirectionalLightInfo(\n                directionalLight,\n                directLight\n            );\n\n            accumulateLight(\n                directLight,\n                normal,\n                viewDirection,\n                shininess,\n                specularStrength,\n                normalLighting,\n                diffuseLight,\n                specularLight\n            );\n        }\n\n        #pragma unroll_loop_end\n\n    #endif\n\n\n    //\n    // POINT LIGHTS\n    //\n\n    #if NUM_POINT_LIGHTS > 0\n\n        PointLight pointLight;\n\n        #pragma unroll_loop_start\n\n        for (\n            int i = 0;\n            i < NUM_POINT_LIGHTS;\n            i++\n        )\n        {\n            pointLight =\n                pointLights[i];\n\n            getPointLightInfo(\n                pointLight,\n                -vViewPosition,\n                directLight\n            );\n\n            accumulateLight(\n                directLight,\n                normal,\n                viewDirection,\n                shininess,\n                specularStrength,\n                normalLighting,\n                diffuseLight,\n                specularLight\n            );\n        }\n\n        #pragma unroll_loop_end\n\n    #endif\n\n\n    //\n    // SPOT LIGHTS\n    //\n\n    #if NUM_SPOT_LIGHTS > 0\n\n        SpotLight spotLight;\n\n        #pragma unroll_loop_start\n\n        for (\n            int i = 0;\n            i < NUM_SPOT_LIGHTS;\n            i++\n        )\n        {\n            spotLight =\n                spotLights[i];\n\n            getSpotLightInfo(\n                spotLight,\n                -vViewPosition,\n                directLight\n            );\n\n            accumulateLight(\n                directLight,\n                normal,\n                viewDirection,\n                shininess,\n                specularStrength,\n                normalLighting,\n                diffuseLight,\n                specularLight\n            );\n        }\n\n        #pragma unroll_loop_end\n\n    #endif\n\n\n    //\n    // HEMISPHERE LIGHTS\n    //\n\n    #if NUM_HEMI_LIGHTS > 0\n\n        #pragma unroll_loop_start\n\n        for (\n            int i = 0;\n            i < NUM_HEMI_LIGHTS;\n            i++\n        )\n        {\n            diffuseLight +=\n                getHemisphereLightIrradiance(\n                    hemisphereLights[i],\n                    normal\n                );\n        }\n\n        #pragma unroll_loop_end\n\n    #endif\n\n    //\n    // SOFT PARTICLES\n    //\n\n    float finalAlpha = baseColor.a;\n\n    if (softParticles)\n    {\n        float particleViewZ =\n            perspectiveDepthToViewZ(\n                gl_FragCoord.z,\n                depthCameraNear,\n                depthCameraFar\n            );\n\n        vec2 screenUv =\n            gl_FragCoord.xy / depthResolution;\n\n        float sceneDepth =\n            texture2D(\n                sceneDepthTexture,\n                screenUv\n            ).x;\n\n        float sceneViewZ =\n            perspectiveDepthToViewZ(\n                sceneDepth,\n                depthCameraNear,\n                depthCameraFar\n            );\n\n        float depthDifference =\n            abs(particleViewZ - sceneViewZ);\n\n        float softFade =\n            smoothstep(\n                0.0,\n                softParticleDistance,\n                depthDifference\n            );\n\n        finalAlpha *= softFade;\n    }\n\n\n    //\n    // FINAL COLOR\n    //\n\n    vec3 litColor =\n        baseColor.rgb * diffuseLight\n        + specularLight;\n\n    gl_FragColor =\n        vec4(\n            litColor,\n            finalAlpha\n        );\n}\n";

package/build/shaders/BasicSprite.vert.js

@@ -0,0 +1 @@
+export default "attribute vec3 scale;\nattribute vec3 rotation;\nattribute float frame;\n\nvarying vec4 vColor;\nvarying float aspectRatio;\nvarying float angle;\n\nvarying vec3 vViewPosition;\nvarying vec3 vNormal;\n\nflat out int fragFrame;\n\nvoid main()\n{\n    vColor = color;\n    angle = rotation.x;\n\n    vec4 mvPosition =\n        modelViewMatrix\n        * vec4(position, 1.0);\n\n    aspectRatio =\n        float(scale.y)\n        / float(scale.x);\n\n    gl_PointSize =\n        max(scale.x, scale.y)\n        * (300.0 / -mvPosition.z);\n\n    gl_Position =\n        projectionMatrix\n        * mvPosition;\n\n    fragFrame =\n        int(frame);\n\n    // Match Three's convention:\n    // vector from fragment toward camera.\n    vViewPosition =\n        -mvPosition.xyz;\n\n    // Point sprites always face the camera,\n    // so their base normal in view space points forward.\n    vNormal =\n        vec3(0.0, 0.0, 1.0);\n}\n";

package/build/shaders/UnlitSprite.frag.js

@@ -0,0 +1 @@
+export default "uniform sampler2D pointTexture;\nuniform sampler2D alphaMap;\nuniform bool hasAlphaMap;\nuniform vec2 gridSize;\nuniform int n_frames;\n\nuniform bool softParticles;\nuniform float softParticleDistance;\nuniform sampler2D sceneDepthTexture;\nuniform vec2 depthResolution;\nuniform float depthCameraNear;\nuniform float depthCameraFar;\n\nvarying vec4 vColor;\nvarying float aspectRatio;\nvarying float angle;\n\nflat in int fragFrame;\n\n// perspectiveDepthToViewZ\n#include <packing>\n\nvec2 sprite_coord(vec2 coord, int frame) {\n    float f_frame = mod(float(frame), float(n_frames));\n\n    return vec2(\n        (coord.x / gridSize.x) + (mod(f_frame, gridSize.x) * (1.0 / gridSize.x)),\n        1.0 - ((coord.y / gridSize.y) + (floor(f_frame / gridSize.x) * (1.0 / gridSize.y)))\n    );\n}\n\nvec2 rotate_vector(vec2 value, float rotation)\n{\n    return vec2(\n        cos(rotation) * value.x\n            + sin(rotation) * value.y,\n\n        cos(rotation) * value.y\n            - sin(rotation) * value.x\n    );\n}\n\n\nvoid main() {\n\n    gl_FragColor = vColor;\n\n    vec2 scaleVector;\n    if (aspectRatio < 1.0/aspectRatio) {\n        scaleVector = vec2(1.0, 1.0/aspectRatio);\n    } else {\n        scaleVector = vec2(aspectRatio, 1.0);\n    }\n\n    vec2 fromCenter =\n        gl_PointCoord - vec2(0.5);\n\n    vec2 rotatedFromCenter =\n        rotate_vector(fromCenter, angle);\n\n    vec2 scaledFromCenter =\n        rotatedFromCenter * scaleVector;\n\n    vec2 rotatedCoord =\n        vec2(0.5) + scaledFromCenter;\n\n    if (\n        rotatedCoord.x < 0.0\n        || rotatedCoord.x > 1.0\n        || rotatedCoord.y < 0.0\n        || rotatedCoord.y > 1.0\n    )\n    {\n        discard;\n    }\n\n    vec2 spriteCoord = sprite_coord(rotatedCoord, fragFrame);\n\n    vec4 baseColor = gl_FragColor * texture2D(pointTexture, spriteCoord);\n\n    //\n    // SOFT PARTICLES\n    //\n\n    float finalAlpha = baseColor.a;\n    if (softParticles)\n    {\n        float particleViewZ =\n            perspectiveDepthToViewZ(\n                gl_FragCoord.z,\n                depthCameraNear,\n                depthCameraFar\n            );\n\n        vec2 screenUv =\n            gl_FragCoord.xy / depthResolution;\n\n        float sceneDepth =\n            texture2D(\n                sceneDepthTexture,\n                screenUv\n            ).x;\n\n        float sceneViewZ =\n            perspectiveDepthToViewZ(\n                sceneDepth,\n                depthCameraNear,\n                depthCameraFar\n            );\n\n        float depthDifference =\n            abs(particleViewZ - sceneViewZ);\n\n        float softFade =\n            smoothstep(\n                0.0,\n                softParticleDistance,\n                depthDifference\n            );\n\n        finalAlpha *= softFade;\n    }\n\n    if (hasAlphaMap) {\n        finalAlpha *= texture2D(alphaMap, spriteCoord).r;\n    }\n\n    gl_FragColor = vec4(\n        baseColor.rgb,\n        finalAlpha\n    );\n}\n";

package/build/shaders/UnlitSprite.vert.js

@@ -0,0 +1 @@
+export default "attribute vec4 scale;\nattribute vec3 rotation;\nattribute float frame;\n\nvarying vec4 vColor;\nvarying float aspectRatio;\nvarying float angle;\nflat out int fragFrame;\n\nvoid main() {\n\n    vColor = color;\n\n    angle = rotation.x;\n\n    vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n\n    aspectRatio = float(scale.y) / float(scale.x);\n\n    gl_PointSize = max(scale.x, scale.y) * ( 300.0 / -mvPosition.z );\n\n    gl_Position = projectionMatrix * mvPosition;\n\n    fragFrame = int(frame);\n\n}\n";

package/build/types/DynamicValue.d.ts

@@ -0,0 +1,2 @@
+export type DynamicValue<T> = T | ((t: number) => DynamicValue<T>) | [DynamicValue<T>, DynamicValue<T>] | Set<DynamicValue<T>>;
+export type DynamicUntimedValue<T> = Exclude<DynamicValue<T>, ((t: number) => DynamicValue<T>)>;

package/build/types/DynamicValue.js

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

package/build/types/EnumStringLiteral.d.ts

@@ -0,0 +1 @@
+export type EnumStringLiteral<T> = ;

package/build/types/EnumStringLiteral.js

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

package/build/types/Multiple.d.ts

@@ -0,0 +1,2 @@
+export type Multiple<T> = T | T[];
+export type StrictMultiple<T> = T | [T, ...[T]];

package/build/types/Multiple.js

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

package/build/types/Tag.d.ts

@@ -0,0 +1 @@
+export type Tag = string;

package/build/types/Tag.js

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

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@rzmps/rzmps",
+  "version": "1.0.0",
+  "description": "🧅 Modular and extendable particle system for Three.js",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "files": [
+    "build/**/*"
+  ],
+  "scripts": {
+    "build": "tsc && npm run build:shaders && npm run copy:assets && npm run fix:shader-imports",
+    "build:shaders": "node scripts/build-shaders.mjs",
+    "copy:assets": "mkdir -p build && rm -rf build/assets && cp -r src/assets build/assets",
+    "fix:shader-imports": "node scripts/fix-shader-imports.mjs",
+    "dev": "concurrently -k \"tsc --watch\" \"watch 'npm run build:shaders && npm run fix:shader-imports' src/shaders\" \"watch 'npm run copy:assets' src/assets\"",
+    "prepack": "npm run build"
+  },
+  "author": "Robert May",
+  "license": "MIT",
+  "dependencies": {
+    "fast-simplex-noise": "^4.0.0",
+    "nanoid": "^3.1.23",
+    "seedrandom": "^3.0.5"
+  },
+  "peerDependencies": {
+    "three": "^0.185.1"
+  },
+  "devDependencies": {
+    "@types/seedrandom": "^3.0.8",
+    "@types/three": "^0.185.4",
+    "@typescript-eslint/eslint-plugin": "^4.23.0",
+    "concurrently": "^6.1.0",
+    "eslint": "^7.26.0",
+    "eslint-config-airbnb": "^18.2.1",
+    "three": "^0.185.1",
+    "typescript": "5.9",
+    "watch": "^0.13.0"
+  }
+}