@eva/plugin-renderer-rain-puddle 2.1.0-beta.14

package/dist/plugin-renderer-rain-puddle.esm.js

@@ -0,0 +1,511 @@
+import { Component, System, OBSERVER_TYPE, decorators } from '@eva/eva.js';
+import { ShaderEffect, getShaderEffect, registerShaderEffect, unregisterShaderEffect } from '@eva/plugin-renderer-shader-effect';
+import { UniformGroup, Filter, GlProgram, Texture } from 'pixi.js';
+import { getSceneCaptureTexture } from '@eva/plugin-renderer-scene-capture';
+
+const RIPPLE_STRIDE = 4;
+const DEFAULT_MAX_RIPPLES = 4;
+const MAX_SHADER_RIPPLES = 8;
+/**
+ * Runtime state shared by the rain and puddle effects.
+ *
+ * Ripples live in a fixed-size ring so pointer and footstep events never
+ * allocate per frame. Each vec4 is `(x, y, ageSeconds, strength)`; expired
+ * slots use `ageSeconds = -1`.
+ */
+class RainPuddle extends Component {
+    constructor() {
+        super(...arguments);
+        this.rainAmount = 0.65;
+        this.waterLevel = 0.5;
+        this.groundLevel = 0.545;
+        this.groundFeather = 0.02;
+        this.reflectionStrength = 0.55;
+        this.rippleDuration = 1.6;
+        this.maxRipples = DEFAULT_MAX_RIPPLES;
+        this.quality = 'high';
+        this.reflectionTexture = '';
+        this.rainSurfaceName = 'rain-surface';
+        this.puddleSurfaceName = 'puddle-surface';
+        this.rippleUniformData = new Float32Array(DEFAULT_MAX_RIPPLES * RIPPLE_STRIDE);
+        this.rippleDirectionUniformData = new Float32Array(DEFAULT_MAX_RIPPLES * 4);
+        this.clickRippleUniformData = new Float32Array([-2, -2, 99, 0]);
+        this.activeRippleCount = 0;
+        this.nextRippleIndex = 0;
+    }
+    init(params = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        this.rainAmount = clamp01((_a = params.rainAmount) !== null && _a !== void 0 ? _a : this.rainAmount);
+        this.waterLevel = clamp01((_b = params.waterLevel) !== null && _b !== void 0 ? _b : this.waterLevel);
+        this.groundLevel = clamp01((_c = params.groundLevel) !== null && _c !== void 0 ? _c : this.groundLevel);
+        this.groundFeather = clamp((_d = params.groundFeather) !== null && _d !== void 0 ? _d : this.groundFeather, 0.001, 1);
+        this.reflectionStrength = clamp01((_e = params.reflectionStrength) !== null && _e !== void 0 ? _e : this.reflectionStrength);
+        this.rippleDuration = Math.max(0.05, (_f = params.rippleDuration) !== null && _f !== void 0 ? _f : this.rippleDuration);
+        this.maxRipples = clampInteger((_g = params.maxRipples) !== null && _g !== void 0 ? _g : this.maxRipples, 1, MAX_SHADER_RIPPLES);
+        this.quality = (_h = params.quality) !== null && _h !== void 0 ? _h : this.quality;
+        this.reflectionTexture = (_j = params.reflectionTexture) !== null && _j !== void 0 ? _j : this.reflectionTexture;
+        this.rainSurfaceName = (_k = params.rainSurfaceName) !== null && _k !== void 0 ? _k : this.rainSurfaceName;
+        this.puddleSurfaceName = (_l = params.puddleSurfaceName) !== null && _l !== void 0 ? _l : this.puddleSurfaceName;
+        this.rippleUniformData = new Float32Array(this.maxRipples * RIPPLE_STRIDE);
+        this.rippleDirectionUniformData = new Float32Array(this.maxRipples * 4);
+        this.clickRippleUniformData = new Float32Array([-2, -2, 99, 0]);
+        this.resetRipples();
+    }
+    emitRipple(input) {
+        var _a;
+        const index = this.nextRippleIndex;
+        const offset = index * RIPPLE_STRIDE;
+        const wasActive = this.rippleUniformData[offset + 2] >= 0;
+        this.rippleUniformData[offset] = clamp01(input.x);
+        this.rippleUniformData[offset + 1] = clamp01(input.y);
+        this.rippleUniformData[offset + 2] = 0;
+        this.rippleUniformData[offset + 3] = clamp01((_a = input.strength) !== null && _a !== void 0 ? _a : 1);
+        const direction = normalizedDirection(input.direction);
+        const directionOffset = index * 4;
+        this.rippleDirectionUniformData[directionOffset] = direction.x;
+        this.rippleDirectionUniformData[directionOffset + 1] = direction.y;
+        if (!wasActive)
+            this.activeRippleCount += 1;
+        this.nextRippleIndex = (index + 1) % this.maxRipples;
+    }
+    /** Click ripples have an independent lifetime and never consume a footstep slot. */
+    emitClickRipple(input) {
+        var _a;
+        this.clickRippleUniformData[0] = clamp01(input.x);
+        this.clickRippleUniformData[1] = clamp01(input.y);
+        this.clickRippleUniformData[2] = 0;
+        this.clickRippleUniformData[3] = clamp01((_a = input.strength) !== null && _a !== void 0 ? _a : 1);
+    }
+    advanceRipples(deltaSeconds) {
+        if (!(deltaSeconds > 0))
+            return;
+        for (let index = 0; index < this.maxRipples; index += 1) {
+            const ageOffset = index * RIPPLE_STRIDE + 2;
+            const age = this.rippleUniformData[ageOffset];
+            if (age < 0)
+                continue;
+            const nextAge = age + deltaSeconds;
+            if (nextAge >= this.rippleDuration) {
+                this.rippleUniformData[ageOffset] = -1;
+                this.activeRippleCount -= 1;
+            }
+            else {
+                this.rippleUniformData[ageOffset] = nextAge;
+            }
+        }
+        if (this.clickRippleUniformData[2] >= 0 && this.clickRippleUniformData[2] < this.rippleDuration) {
+            this.clickRippleUniformData[2] += deltaSeconds;
+        }
+    }
+    getRippleDirection(index) {
+        var _a, _b;
+        const offset = index * 4;
+        return {
+            x: (_a = this.rippleDirectionUniformData[offset]) !== null && _a !== void 0 ? _a : 0,
+            y: (_b = this.rippleDirectionUniformData[offset + 1]) !== null && _b !== void 0 ? _b : 0,
+        };
+    }
+    resetRipples() {
+        this.rippleUniformData.fill(0);
+        for (let index = 0; index < this.maxRipples; index += 1) {
+            this.rippleUniformData[index * RIPPLE_STRIDE + 2] = -1;
+        }
+        this.rippleDirectionUniformData.fill(0);
+        this.clickRippleUniformData.set([-2, -2, 99, 0]);
+        this.nextRippleIndex = 0;
+        this.activeRippleCount = 0;
+    }
+}
+RainPuddle.componentName = 'RainPuddle';
+function normalizedDirection(direction) {
+    var _a, _b;
+    const x = typeof direction === 'number' ? direction : Number((_a = direction === null || direction === void 0 ? void 0 : direction.x) !== null && _a !== void 0 ? _a : 0);
+    const y = typeof direction === 'number' ? 0 : Number((_b = direction === null || direction === void 0 ? void 0 : direction.y) !== null && _b !== void 0 ? _b : 0);
+    const length = Math.hypot(x, y);
+    if (!(length > 0))
+        return { x: 0, y: 1 };
+    return { x: x / length, y: y / length };
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function clamp01(value) {
+    return clamp(value, 0, 1);
+}
+function clampInteger(value, min, max) {
+    return Math.round(clamp(value, min, max));
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/** Advances bounded ripples and keeps both visual passes on one shared state. */
+let RainPuddleSystem = class RainPuddleSystem extends System {
+    constructor() {
+        super(...arguments);
+        this.name = 'RainPuddleSystem';
+        this.bindings = new Map();
+    }
+    update() {
+        this.consumeObserverChanges();
+    }
+    consumeObserverChanges() {
+        // Plain Eva Systems must drain their observer queue themselves. Renderer
+        // subclasses get this behaviour from Renderer.update(), but this logic-only
+        // system deliberately extends System and therefore has to dispatch the
+        // queued ADD/REMOVE notifications explicitly.
+        for (const changed of this.componentObserver.clear()) {
+            this.componentChanged(changed);
+        }
+    }
+    componentChanged(changed) {
+        if (changed.componentName !== RainPuddle.componentName)
+            return;
+        if (changed.type === OBSERVER_TYPE.REMOVE) {
+            this.bindings.delete(changed.gameObject.id);
+            return;
+        }
+        if (changed.type === OBSERVER_TYPE.ADD) {
+            this.bindings.set(changed.gameObject.id, { component: changed.component });
+        }
+    }
+    frameStart(frame) {
+        // A physical frame may contain zero fixed simulation updates. Drain here as
+        // well so a newly-added controller can affect the very first presentation.
+        this.consumeObserverChanges();
+        const deltaSeconds = Math.min(0.1, Math.max(0, frame.rafDeltaTime / 1000));
+        for (const binding of this.bindings.values()) {
+            const component = binding.component;
+            component.advanceRipples(deltaSeconds);
+            binding.rainEffect = this.resolveEffect(binding.rainEffect, component.rainSurfaceName);
+            binding.puddleEffect = this.resolveEffect(binding.puddleEffect, component.puddleSurfaceName);
+            if (binding.rainEffect) {
+                binding.rainEffect.uniforms.rainAmount = component.rainAmount;
+                binding.rainEffect.uniforms.quality = qualityValue(component.quality);
+            }
+            if (binding.puddleEffect) {
+                binding.puddleEffect.uniforms.waterLevel = component.waterLevel;
+                binding.puddleEffect.uniforms.groundLevel = component.groundLevel;
+                binding.puddleEffect.uniforms.groundFeather = component.groundFeather;
+                binding.puddleEffect.uniforms.reflectionStrength = component.reflectionStrength;
+                binding.puddleEffect.uniforms.rippleDuration = component.rippleDuration;
+                binding.puddleEffect.uniforms.ripples = component.rippleUniformData;
+                binding.puddleEffect.uniforms.rippleDirections = component.rippleDirectionUniformData;
+                binding.puddleEffect.uniforms.clickRipple = component.clickRippleUniformData;
+                binding.puddleEffect.uniforms.reflectionTexture = component.reflectionTexture;
+            }
+        }
+    }
+    onDestroy() {
+        this.bindings.clear();
+    }
+    resolveEffect(current, name) {
+        var _a, _b, _c;
+        if ((current === null || current === void 0 ? void 0 : current.gameObject) && !current.gameObject.destroyed)
+            return current;
+        if (!name)
+            return undefined;
+        const gameObject = (_c = (_b = (_a = this.game) === null || _a === void 0 ? void 0 : _a.findAllByName) === null || _b === void 0 ? void 0 : _b.call(_a, name)) === null || _c === void 0 ? void 0 : _c[0];
+        return gameObject === null || gameObject === void 0 ? void 0 : gameObject.getComponent(ShaderEffect);
+    }
+};
+RainPuddleSystem.systemName = 'RainPuddleSystem';
+RainPuddleSystem = __decorate([
+    decorators.componentObserver({ RainPuddle: [] })
+], RainPuddleSystem);
+var RainPuddleSystem$1 = RainPuddleSystem;
+function qualityValue(quality) {
+    if (quality === 'low')
+        return 0;
+    if (quality === 'medium')
+        return 0.55;
+    return 1;
+}
+
+const RAIN_EFFECT_ID = 'eva.rain-puddle.rain';
+const PUDDLE_EFFECT_ID = 'eva.rain-puddle.puddle';
+// Pixi's default filter vertex maps vTextureCoord into the pooled input
+// texture, whose physical size may be larger than the filter frame. These
+// effects use Godot-style SCREEN_UV, so keep aPosition as the normalized
+// screen coordinate instead of inheriting the pooled-texture scale.
+const normalizedScreenFilterVert = `
+in vec2 aPosition;
+out vec2 vTextureCoord;
+
+uniform vec4 uOutputFrame;
+uniform vec4 uOutputTexture;
+
+void main() {
+  vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy;
+  position.x = position.x * (2.0 / uOutputTexture.x) - 1.0;
+  position.y = position.y * (2.0 * uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z;
+  gl_Position = vec4(position, 0.0, 1.0);
+  vTextureCoord = aPosition;
+}
+`;
+const rainFragment = `
+in vec2 vTextureCoord;
+out vec4 finalColor;
+
+uniform sampler2D uTexture;
+uniform float uTime;
+uniform float uRainAmount;
+uniform float uQuality;
+
+float hash21(vec2 p) {
+  return fract(sin(dot(p, vec2(41.31, 289.17))) * 28419.231);
+}
+
+float rainLayer(vec2 uv, float scale, float speed, float width, float length, float brightness) {
+  vec2 p = uv * vec2(150.0 * scale, 78.0 * scale);
+  p.x += p.y * 0.24;
+  // Texture coordinates grow downwards in Pixi. Subtracting time makes the
+  // streak cells travel towards increasing screen Y instead of rising upward.
+  p.y -= uTime * speed;
+  vec2 id = floor(p);
+  vec2 cell = fract(p) - 0.5;
+  float seed = hash21(id);
+  float thinLine = 1.0 - smoothstep(width, width * 2.0, abs(cell.x + seed * 0.16 - 0.08));
+  float longStreak = 1.0 - smoothstep(length, length * 1.35, abs(cell.y));
+  return thinLine * longStreak * brightness * step(1.0 - uRainAmount, seed);
+}
+
+void main() {
+  vec2 uv = vTextureCoord;
+  float detail = mix(0.78, 1.0, uQuality);
+  float rain = rainLayer(uv, 0.72 * detail, 1.15, 0.010, 0.42, 0.28);
+  rain += rainLayer(uv + vec2(0.17, 0.0), 1.28 * detail, 1.78, 0.007, 0.46, 0.62);
+  float alpha = clamp(rain, 0.0, 0.82);
+  finalColor = vec4(vec3(0.66, 0.82, 0.96) * alpha, alpha);
+}
+`;
+const puddleFragment = `
+in vec2 vTextureCoord;
+out vec4 finalColor;
+
+uniform sampler2D uTexture;
+uniform sampler2D uReflection;
+uniform float uTime;
+uniform float uWaterLevel;
+uniform float uGroundLevel;
+uniform float uGroundFeather;
+uniform float uReflectionStrength;
+uniform float uRippleDuration;
+uniform vec4 uRipples[${MAX_SHADER_RIPPLES}];
+uniform vec4 uRippleDirections[${MAX_SHADER_RIPPLES}];
+uniform vec4 uClickRipple;
+
+float puddleShape(vec2 uv, vec2 center, vec2 radii, float seed) {
+  vec2 p = (uv - center) / radii;
+  float angle = atan(p.y, p.x);
+  float edgeNoise = sin(angle * 5.0 + seed) * 0.075 + sin(angle * 9.0 - seed) * 0.035;
+  float distanceToCenter = length(p) + edgeNoise;
+  return 1.0 - smoothstep(0.72 + (1.0 - uWaterLevel) * 0.20, 1.02, distanceToCenter);
+}
+
+float ring(vec2 uv, vec2 center, float radius, float width) {
+  float distanceToCenter = length(uv - center);
+  return 1.0 - smoothstep(width, width * 2.1, abs(distanceToCenter - radius));
+}
+
+float projectedFootWave(vec2 uv, vec4 state, vec2 direction) {
+  float phase = clamp(state.z / 1.10, 0.0, 1.0);
+  float fade = (1.0 - phase) * state.w;
+  vec2 wakeCenter = state.xy - direction * phase * 0.014;
+  vec2 delta = uv - wakeCenter;
+  float projectedDistance = length(vec2(delta.x, delta.y * 3.0));
+  float radius = 0.006 + phase * 0.058;
+  float leading = 1.0 - smoothstep(0.0018, 0.0040, abs(projectedDistance - radius));
+  float secondary = 1.0 - smoothstep(0.0015, 0.0033, abs(projectedDistance - radius * 0.63));
+  vec2 trailDelta = uv - (wakeCenter - direction * 0.018 * phase);
+  float trailDistance = length(vec2(trailDelta.x, trailDelta.y * 3.0));
+  float trail = 1.0 - smoothstep(0.0020, 0.0045, abs(trailDistance - radius * 0.76));
+  return (leading + secondary * 0.34 + trail * 0.42) * fade;
+}
+
+void main() {
+  vec2 uv = vTextureCoord;
+  float mask = puddleShape(uv, vec2(0.26, 0.68), vec2(0.21, 0.12), 0.3);
+  mask = max(mask, puddleShape(uv, vec2(0.56, 0.77), vec2(0.26, 0.10), 2.2));
+  mask = max(mask, puddleShape(uv, vec2(0.82, 0.59), vec2(0.14, 0.18), 4.1));
+  mask *= smoothstep(uGroundLevel, uGroundLevel + max(uGroundFeather, 0.0001), uv.y);
+  mask *= smoothstep(0.04, 0.17, uWaterLevel);
+
+  float smallWaves = sin(uv.y * 920.0 + uTime * 2.2) + sin(uv.x * 700.0 - uTime * 1.7);
+  vec2 distortion = vec2(smallWaves * 0.00075, sin(uv.x * 510.0 + uTime * 2.0) * 0.0011);
+
+  for (int index = 0; index < 5; index++) {
+    float fi = float(index);
+    float phase = fract(uTime * (0.13 + fi * 0.023) + fi * 0.618);
+    vec2 center = vec2(fract(fi * 0.347 + 0.14), fract(fi * 0.613 + 0.52));
+    float radius = phase * 0.075;
+    float rainRipple = ring(uv, center, radius, 0.0018) * (1.0 - phase);
+    distortion += normalize(uv - center + vec2(0.0001)) * rainRipple * 0.004;
+  }
+
+  float clickPhase = clamp(uClickRipple.z / 1.55, 0.0, 1.0);
+  float clickRing = ring(uv, uClickRipple.xy, clickPhase * 0.14, 0.0025) * (1.0 - clickPhase) * uClickRipple.w;
+  distortion += normalize(uv - uClickRipple.xy + vec2(0.0001)) * clickRing * 0.012;
+
+  float footRing = 0.0;
+  vec2 footPush = vec2(0.0);
+  for (int index = 0; index < ${MAX_SHADER_RIPPLES}; index++) {
+    vec4 state = uRipples[index];
+    if (state.z < 0.0 || state.z >= uRippleDuration) continue;
+    float wave = projectedFootWave(uv, state, uRippleDirections[index].xy);
+    footRing += wave;
+    footPush += (uv - state.xy) * wave;
+  }
+  footRing = clamp(footRing, 0.0, 1.5);
+  distortion += normalize(footPush + vec2(0.0001)) * footRing * 0.0065;
+
+  vec4 reflection = texture(uReflection, clamp(uv + distortion, vec2(0.002), vec2(0.998)));
+  vec3 waterTint = vec3(0.055, 0.15, 0.23);
+  float reflectedAmount = reflection.a * uReflectionStrength;
+  vec3 color = mix(waterTint, reflection.rgb + vec3(0.03, 0.06, 0.09), reflectedAmount);
+  color += vec3(0.30, 0.48, 0.58) * (clickRing + footRing * 1.10 + 0.18 * max(0.0, smallWaves)) * 0.24;
+  float alpha = mask * (0.82 + 0.16 * uWaterLevel);
+  finalColor = vec4(color * alpha, alpha);
+}
+`;
+function numberUniform(uniforms, key, fallback) {
+    const value = uniforms[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+const rainFactory = () => {
+    const group = new UniformGroup({
+        uTime: { value: 0, type: 'f32' },
+        uRainAmount: { value: 0.65, type: 'f32' },
+        uQuality: { value: 1, type: 'f32' },
+    });
+    const filter = new Filter({
+        glProgram: GlProgram.from({ name: RAIN_EFFECT_ID, vertex: normalizedScreenFilterVert, fragment: rainFragment }),
+        resources: { rainUniforms: group },
+        antialias: 'on',
+    });
+    return {
+        filter,
+        update(frame, uniforms) {
+            const values = group.uniforms;
+            values.uTime = frame.rafTime / 1000;
+            values.uRainAmount = numberUniform(uniforms, 'rainAmount', 0.65);
+            values.uQuality = numberUniform(uniforms, 'quality', 1);
+        },
+        destroy() {
+            filter.destroy();
+        },
+    };
+};
+Object.defineProperty(rainFactory, 'backends', { value: ['webgl'] });
+const puddleFactory = () => {
+    const rippleBuffer = new Float32Array(MAX_SHADER_RIPPLES * 4);
+    const rippleDirectionBuffer = new Float32Array(MAX_SHADER_RIPPLES * 4);
+    const clickRippleBuffer = new Float32Array([-2, -2, 99, 0]);
+    for (let index = 0; index < MAX_SHADER_RIPPLES; index += 1)
+        rippleBuffer[index * 4 + 2] = -1;
+    const group = new UniformGroup({
+        uTime: { value: 0, type: 'f32' },
+        uWaterLevel: { value: 0.5, type: 'f32' },
+        uGroundLevel: { value: 0.545, type: 'f32' },
+        uGroundFeather: { value: 0.02, type: 'f32' },
+        uReflectionStrength: { value: 0.55, type: 'f32' },
+        uRippleDuration: { value: 1.6, type: 'f32' },
+        uRipples: { value: rippleBuffer, type: 'vec4<f32>', size: MAX_SHADER_RIPPLES },
+        uRippleDirections: { value: rippleDirectionBuffer, type: 'vec4<f32>', size: MAX_SHADER_RIPPLES },
+        uClickRipple: { value: clickRippleBuffer, type: 'vec4<f32>' },
+    });
+    const filter = new Filter({
+        glProgram: GlProgram.from({
+            name: PUDDLE_EFFECT_ID,
+            vertex: normalizedScreenFilterVert,
+            fragment: puddleFragment,
+        }),
+        resources: { puddleUniforms: group, uReflection: Texture.EMPTY.source },
+        antialias: 'on',
+    });
+    let boundTextureKey = '';
+    return {
+        filter,
+        update(frame, uniforms) {
+            const values = group.uniforms;
+            values.uTime = frame.rafTime / 1000;
+            values.uWaterLevel = numberUniform(uniforms, 'waterLevel', 0.5);
+            values.uGroundLevel = numberUniform(uniforms, 'groundLevel', 0.545);
+            values.uGroundFeather = numberUniform(uniforms, 'groundFeather', 0.02);
+            values.uReflectionStrength = numberUniform(uniforms, 'reflectionStrength', 0.55);
+            values.uRippleDuration = numberUniform(uniforms, 'rippleDuration', 1.6);
+            const incomingRipples = uniforms.ripples;
+            rippleBuffer.fill(0);
+            for (let index = 0; index < MAX_SHADER_RIPPLES; index += 1)
+                rippleBuffer[index * 4 + 2] = -1;
+            if (incomingRipples instanceof Float32Array) {
+                rippleBuffer.set(incomingRipples.subarray(0, rippleBuffer.length));
+            }
+            rippleDirectionBuffer.fill(0);
+            const incomingDirections = uniforms.rippleDirections;
+            if (incomingDirections instanceof Float32Array) {
+                rippleDirectionBuffer.set(incomingDirections.subarray(0, rippleDirectionBuffer.length));
+            }
+            clickRippleBuffer.set([-2, -2, 99, 0]);
+            const incomingClickRipple = uniforms.clickRipple;
+            if (incomingClickRipple instanceof Float32Array) {
+                clickRippleBuffer.set(incomingClickRipple.subarray(0, clickRippleBuffer.length));
+            }
+            const textureKey = typeof uniforms.reflectionTexture === 'string' ? uniforms.reflectionTexture : '';
+            if (textureKey && textureKey !== boundTextureKey) {
+                const texture = getSceneCaptureTexture(textureKey);
+                if (texture) {
+                    filter.resources.uReflection = texture.source;
+                    boundTextureKey = textureKey;
+                }
+            }
+        },
+        destroy() {
+            filter.destroy();
+        },
+    };
+};
+Object.defineProperty(puddleFactory, 'backends', { value: ['webgl'] });
+/** Register the built-in rain and puddle factories once for the current realm. */
+function registerRainPuddleEffects() {
+    if (!getShaderEffect(RAIN_EFFECT_ID))
+        registerShaderEffect(RAIN_EFFECT_ID, rainFactory);
+    if (!getShaderEffect(PUDDLE_EFFECT_ID))
+        registerShaderEffect(PUDDLE_EFFECT_ID, puddleFactory);
+}
+/** Primarily useful for test isolation and hosts that unload plugin bundles. */
+function unregisterRainPuddleEffects() {
+    unregisterShaderEffect(RAIN_EFFECT_ID);
+    unregisterShaderEffect(PUDDLE_EFFECT_ID);
+}
+const rainPuddleShaderSources = {
+    vertex: normalizedScreenFilterVert,
+    rainFragment,
+    puddleFragment,
+};
+
+export { DEFAULT_MAX_RIPPLES, MAX_SHADER_RIPPLES, PUDDLE_EFFECT_ID, RAIN_EFFECT_ID, RIPPLE_STRIDE, RainPuddle, RainPuddleSystem$1 as RainPuddleSystem, rainPuddleShaderSources, registerRainPuddleEffects, unregisterRainPuddleEffects };

package/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/plugin-renderer-rain-puddle.cjs.prod.js');
+} else {
+  module.exports = require('./dist/plugin-renderer-rain-puddle.cjs.js');
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@eva/plugin-renderer-rain-puddle",
+  "version": "2.1.0-beta.14",
+  "description": "Reusable rain, puddle reflection and ripple effects for Eva.js.",
+  "main": "index.js",
+  "module": "dist/plugin-renderer-rain-puddle.esm.js",
+  "bundle": "EVA.plugin.renderer.rain.puddle",
+  "unpkg": "dist/EVA.plugin.renderer.rain.puddle.min.js",
+  "types": "dist/plugin-renderer-rain-puddle.d.ts",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "keywords": [
+    "eva.js",
+    "rain",
+    "puddle"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@eva/eva.js": "2.1.0-beta.14",
+    "@eva/plugin-renderer": "2.1.0-beta.14",
+    "@eva/plugin-renderer-scene-capture": "2.1.0-beta.14",
+    "@eva/plugin-renderer-shader-effect": "2.1.0-beta.14",
+    "pixi.js": "8.19.0"
+  }
+}