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

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

@@ -0,0 +1,524 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var eva_js = require('@eva/eva.js');
+var pluginRendererShaderEffect = require('@eva/plugin-renderer-shader-effect');
+var pixi_js = require('pixi.js');
+var pluginRendererSceneCapture = require('@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 eva_js.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 eva_js.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 === eva_js.OBSERVER_TYPE.REMOVE) {
+            this.bindings.delete(changed.gameObject.id);
+            return;
+        }
+        if (changed.type === eva_js.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(pluginRendererShaderEffect.ShaderEffect);
+    }
+};
+RainPuddleSystem.systemName = 'RainPuddleSystem';
+RainPuddleSystem = __decorate([
+    eva_js.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 pixi_js.UniformGroup({
+        uTime: { value: 0, type: 'f32' },
+        uRainAmount: { value: 0.65, type: 'f32' },
+        uQuality: { value: 1, type: 'f32' },
+    });
+    const filter = new pixi_js.Filter({
+        glProgram: pixi_js.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 pixi_js.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 pixi_js.Filter({
+        glProgram: pixi_js.GlProgram.from({
+            name: PUDDLE_EFFECT_ID,
+            vertex: normalizedScreenFilterVert,
+            fragment: puddleFragment,
+        }),
+        resources: { puddleUniforms: group, uReflection: pixi_js.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 = pluginRendererSceneCapture.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 (!pluginRendererShaderEffect.getShaderEffect(RAIN_EFFECT_ID))
+        pluginRendererShaderEffect.registerShaderEffect(RAIN_EFFECT_ID, rainFactory);
+    if (!pluginRendererShaderEffect.getShaderEffect(PUDDLE_EFFECT_ID))
+        pluginRendererShaderEffect.registerShaderEffect(PUDDLE_EFFECT_ID, puddleFactory);
+}
+/** Primarily useful for test isolation and hosts that unload plugin bundles. */
+function unregisterRainPuddleEffects() {
+    pluginRendererShaderEffect.unregisterShaderEffect(RAIN_EFFECT_ID);
+    pluginRendererShaderEffect.unregisterShaderEffect(PUDDLE_EFFECT_ID);
+}
+const rainPuddleShaderSources = {
+    vertex: normalizedScreenFilterVert,
+    rainFragment,
+    puddleFragment,
+};
+
+exports.DEFAULT_MAX_RIPPLES = DEFAULT_MAX_RIPPLES;
+exports.MAX_SHADER_RIPPLES = MAX_SHADER_RIPPLES;
+exports.PUDDLE_EFFECT_ID = PUDDLE_EFFECT_ID;
+exports.RAIN_EFFECT_ID = RAIN_EFFECT_ID;
+exports.RIPPLE_STRIDE = RIPPLE_STRIDE;
+exports.RainPuddle = RainPuddle;
+exports.RainPuddleSystem = RainPuddleSystem$1;
+exports.rainPuddleShaderSources = rainPuddleShaderSources;
+exports.registerRainPuddleEffects = registerRainPuddleEffects;
+exports.unregisterRainPuddleEffects = unregisterRainPuddleEffects;

package/dist/plugin-renderer-rain-puddle.cjs.prod.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@eva/eva.js"),t=require("@eva/plugin-renderer-shader-effect"),n=require("pixi.js"),i=require("@eva/plugin-renderer-scene-capture");class r extends e.Component{constructor(){super(...arguments),this.rainAmount=.65,this.waterLevel=.5,this.groundLevel=.545,this.groundFeather=.02,this.reflectionStrength=.55,this.rippleDuration=1.6,this.maxRipples=4,this.quality="high",this.reflectionTexture="",this.rainSurfaceName="rain-surface",this.puddleSurfaceName="puddle-surface",this.rippleUniformData=new Float32Array(16),this.rippleDirectionUniformData=new Float32Array(16),this.clickRippleUniformData=new Float32Array([-2,-2,99,0]),this.activeRippleCount=0,this.nextRippleIndex=0}init(e={}){var t,n,i,r,l,u,s,c,p,f,d,m,v,h;this.rainAmount=o(null!==(t=e.rainAmount)&&void 0!==t?t:this.rainAmount),this.waterLevel=o(null!==(n=e.waterLevel)&&void 0!==n?n:this.waterLevel),this.groundLevel=o(null!==(i=e.groundLevel)&&void 0!==i?i:this.groundLevel),this.groundFeather=a(null!==(r=e.groundFeather)&&void 0!==r?r:this.groundFeather,.001,1),this.reflectionStrength=o(null!==(l=e.reflectionStrength)&&void 0!==l?l:this.reflectionStrength),this.rippleDuration=Math.max(.05,null!==(u=e.rippleDuration)&&void 0!==u?u:this.rippleDuration),this.maxRipples=(m=null!==(s=e.maxRipples)&&void 0!==s?s:this.maxRipples,v=1,h=8,Math.round(a(m,v,h))),this.quality=null!==(c=e.quality)&&void 0!==c?c:this.quality,this.reflectionTexture=null!==(p=e.reflectionTexture)&&void 0!==p?p:this.reflectionTexture,this.rainSurfaceName=null!==(f=e.rainSurfaceName)&&void 0!==f?f:this.rainSurfaceName,this.puddleSurfaceName=null!==(d=e.puddleSurfaceName)&&void 0!==d?d:this.puddleSurfaceName,this.rippleUniformData=new Float32Array(4*this.maxRipples),this.rippleDirectionUniformData=new Float32Array(4*this.maxRipples),this.clickRippleUniformData=new Float32Array([-2,-2,99,0]),this.resetRipples()}emitRipple(e){var t;const n=this.nextRippleIndex,i=4*n,r=this.rippleUniformData[i+2]>=0;this.rippleUniformData[i]=o(e.x),this.rippleUniformData[i+1]=o(e.y),this.rippleUniformData[i+2]=0,this.rippleUniformData[i+3]=o(null!==(t=e.strength)&&void 0!==t?t:1);const a=function(e){var t,n;const i="number"==typeof e?e:Number(null!==(t=null==e?void 0:e.x)&&void 0!==t?t:0),r="number"==typeof e?0:Number(null!==(n=null==e?void 0:e.y)&&void 0!==n?n:0),a=Math.hypot(i,r);return a>0?{x:i/a,y:r/a}:{x:0,y:1}}(e.direction),l=4*n;this.rippleDirectionUniformData[l]=a.x,this.rippleDirectionUniformData[l+1]=a.y,r||(this.activeRippleCount+=1),this.nextRippleIndex=(n+1)%this.maxRipples}emitClickRipple(e){var t;this.clickRippleUniformData[0]=o(e.x),this.clickRippleUniformData[1]=o(e.y),this.clickRippleUniformData[2]=0,this.clickRippleUniformData[3]=o(null!==(t=e.strength)&&void 0!==t?t:1)}advanceRipples(e){if(e>0){for(let t=0;t<this.maxRipples;t+=1){const n=4*t+2,i=this.rippleUniformData[n];if(i<0)continue;const r=i+e;r>=this.rippleDuration?(this.rippleUniformData[n]=-1,this.activeRippleCount-=1):this.rippleUniformData[n]=r}this.clickRippleUniformData[2]>=0&&this.clickRippleUniformData[2]<this.rippleDuration&&(this.clickRippleUniformData[2]+=e)}}getRippleDirection(e){var t,n;const i=4*e;return{x:null!==(t=this.rippleDirectionUniformData[i])&&void 0!==t?t:0,y:null!==(n=this.rippleDirectionUniformData[i+1])&&void 0!==n?n:0}}resetRipples(){this.rippleUniformData.fill(0);for(let e=0;e<this.maxRipples;e+=1)this.rippleUniformData[4*e+2]=-1;this.rippleDirectionUniformData.fill(0),this.clickRippleUniformData.set([-2,-2,99,0]),this.nextRippleIndex=0,this.activeRippleCount=0}}function a(e,t,n){return Math.min(n,Math.max(t,e))}function o(e){return a(e,0,1)}r.componentName="RainPuddle","function"==typeof SuppressedError&&SuppressedError;let l=class extends e.System{constructor(){super(...arguments),this.name="RainPuddleSystem",this.bindings=new Map}update(){this.consumeObserverChanges()}consumeObserverChanges(){for(const e of this.componentObserver.clear())this.componentChanged(e)}componentChanged(t){t.componentName===r.componentName&&(t.type!==e.OBSERVER_TYPE.REMOVE?t.type===e.OBSERVER_TYPE.ADD&&this.bindings.set(t.gameObject.id,{component:t.component}):this.bindings.delete(t.gameObject.id))}frameStart(e){this.consumeObserverChanges();const t=Math.min(.1,Math.max(0,e.rafDeltaTime/1e3));for(const e of this.bindings.values()){const n=e.component;n.advanceRipples(t),e.rainEffect=this.resolveEffect(e.rainEffect,n.rainSurfaceName),e.puddleEffect=this.resolveEffect(e.puddleEffect,n.puddleSurfaceName),e.rainEffect&&(e.rainEffect.uniforms.rainAmount=n.rainAmount,e.rainEffect.uniforms.quality=s(n.quality)),e.puddleEffect&&(e.puddleEffect.uniforms.waterLevel=n.waterLevel,e.puddleEffect.uniforms.groundLevel=n.groundLevel,e.puddleEffect.uniforms.groundFeather=n.groundFeather,e.puddleEffect.uniforms.reflectionStrength=n.reflectionStrength,e.puddleEffect.uniforms.rippleDuration=n.rippleDuration,e.puddleEffect.uniforms.ripples=n.rippleUniformData,e.puddleEffect.uniforms.rippleDirections=n.rippleDirectionUniformData,e.puddleEffect.uniforms.clickRipple=n.clickRippleUniformData,e.puddleEffect.uniforms.reflectionTexture=n.reflectionTexture)}}onDestroy(){this.bindings.clear()}resolveEffect(e,n){var i,r,a;if((null==e?void 0:e.gameObject)&&!e.gameObject.destroyed)return e;if(!n)return;const o=null===(a=null===(r=null===(i=this.game)||void 0===i?void 0:i.findAllByName)||void 0===r?void 0:r.call(i,n))||void 0===a?void 0:a[0];return null==o?void 0:o.getComponent(t.ShaderEffect)}};l.systemName="RainPuddleSystem",l=function(e,t,n,i){var r,a=arguments.length,o=a<3?t:null===i?i=Object.getOwnPropertyDescriptor(t,n):i;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)o=Reflect.decorate(e,t,n,i);else for(var l=e.length-1;l>=0;l--)(r=e[l])&&(o=(a<3?r(o):a>3?r(t,n,o):r(t,n))||o);return a>3&&o&&Object.defineProperty(t,n,o),o}([e.decorators.componentObserver({RainPuddle:[]})],l);var u=l;function s(e){return"low"===e?0:"medium"===e?.55:1}const c="eva.rain-puddle.rain",p="eva.rain-puddle.puddle",f="\nin vec2 aPosition;\nout vec2 vTextureCoord;\n\nuniform vec4 uOutputFrame;\nuniform vec4 uOutputTexture;\n\nvoid main() {\n  vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy;\n  position.x = position.x * (2.0 / uOutputTexture.x) - 1.0;\n  position.y = position.y * (2.0 * uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z;\n  gl_Position = vec4(position, 0.0, 1.0);\n  vTextureCoord = aPosition;\n}\n",d="\nin vec2 vTextureCoord;\nout vec4 finalColor;\n\nuniform sampler2D uTexture;\nuniform float uTime;\nuniform float uRainAmount;\nuniform float uQuality;\n\nfloat hash21(vec2 p) {\n  return fract(sin(dot(p, vec2(41.31, 289.17))) * 28419.231);\n}\n\nfloat rainLayer(vec2 uv, float scale, float speed, float width, float length, float brightness) {\n  vec2 p = uv * vec2(150.0 * scale, 78.0 * scale);\n  p.x += p.y * 0.24;\n  // Texture coordinates grow downwards in Pixi. Subtracting time makes the\n  // streak cells travel towards increasing screen Y instead of rising upward.\n  p.y -= uTime * speed;\n  vec2 id = floor(p);\n  vec2 cell = fract(p) - 0.5;\n  float seed = hash21(id);\n  float thinLine = 1.0 - smoothstep(width, width * 2.0, abs(cell.x + seed * 0.16 - 0.08));\n  float longStreak = 1.0 - smoothstep(length, length * 1.35, abs(cell.y));\n  return thinLine * longStreak * brightness * step(1.0 - uRainAmount, seed);\n}\n\nvoid main() {\n  vec2 uv = vTextureCoord;\n  float detail = mix(0.78, 1.0, uQuality);\n  float rain = rainLayer(uv, 0.72 * detail, 1.15, 0.010, 0.42, 0.28);\n  rain += rainLayer(uv + vec2(0.17, 0.0), 1.28 * detail, 1.78, 0.007, 0.46, 0.62);\n  float alpha = clamp(rain, 0.0, 0.82);\n  finalColor = vec4(vec3(0.66, 0.82, 0.96) * alpha, alpha);\n}\n",m="\nin vec2 vTextureCoord;\nout vec4 finalColor;\n\nuniform sampler2D uTexture;\nuniform sampler2D uReflection;\nuniform float uTime;\nuniform float uWaterLevel;\nuniform float uGroundLevel;\nuniform float uGroundFeather;\nuniform float uReflectionStrength;\nuniform float uRippleDuration;\nuniform vec4 uRipples[8];\nuniform vec4 uRippleDirections[8];\nuniform vec4 uClickRipple;\n\nfloat puddleShape(vec2 uv, vec2 center, vec2 radii, float seed) {\n  vec2 p = (uv - center) / radii;\n  float angle = atan(p.y, p.x);\n  float edgeNoise = sin(angle * 5.0 + seed) * 0.075 + sin(angle * 9.0 - seed) * 0.035;\n  float distanceToCenter = length(p) + edgeNoise;\n  return 1.0 - smoothstep(0.72 + (1.0 - uWaterLevel) * 0.20, 1.02, distanceToCenter);\n}\n\nfloat ring(vec2 uv, vec2 center, float radius, float width) {\n  float distanceToCenter = length(uv - center);\n  return 1.0 - smoothstep(width, width * 2.1, abs(distanceToCenter - radius));\n}\n\nfloat projectedFootWave(vec2 uv, vec4 state, vec2 direction) {\n  float phase = clamp(state.z / 1.10, 0.0, 1.0);\n  float fade = (1.0 - phase) * state.w;\n  vec2 wakeCenter = state.xy - direction * phase * 0.014;\n  vec2 delta = uv - wakeCenter;\n  float projectedDistance = length(vec2(delta.x, delta.y * 3.0));\n  float radius = 0.006 + phase * 0.058;\n  float leading = 1.0 - smoothstep(0.0018, 0.0040, abs(projectedDistance - radius));\n  float secondary = 1.0 - smoothstep(0.0015, 0.0033, abs(projectedDistance - radius * 0.63));\n  vec2 trailDelta = uv - (wakeCenter - direction * 0.018 * phase);\n  float trailDistance = length(vec2(trailDelta.x, trailDelta.y * 3.0));\n  float trail = 1.0 - smoothstep(0.0020, 0.0045, abs(trailDistance - radius * 0.76));\n  return (leading + secondary * 0.34 + trail * 0.42) * fade;\n}\n\nvoid main() {\n  vec2 uv = vTextureCoord;\n  float mask = puddleShape(uv, vec2(0.26, 0.68), vec2(0.21, 0.12), 0.3);\n  mask = max(mask, puddleShape(uv, vec2(0.56, 0.77), vec2(0.26, 0.10), 2.2));\n  mask = max(mask, puddleShape(uv, vec2(0.82, 0.59), vec2(0.14, 0.18), 4.1));\n  mask *= smoothstep(uGroundLevel, uGroundLevel + max(uGroundFeather, 0.0001), uv.y);\n  mask *= smoothstep(0.04, 0.17, uWaterLevel);\n\n  float smallWaves = sin(uv.y * 920.0 + uTime * 2.2) + sin(uv.x * 700.0 - uTime * 1.7);\n  vec2 distortion = vec2(smallWaves * 0.00075, sin(uv.x * 510.0 + uTime * 2.0) * 0.0011);\n\n  for (int index = 0; index < 5; index++) {\n    float fi = float(index);\n    float phase = fract(uTime * (0.13 + fi * 0.023) + fi * 0.618);\n    vec2 center = vec2(fract(fi * 0.347 + 0.14), fract(fi * 0.613 + 0.52));\n    float radius = phase * 0.075;\n    float rainRipple = ring(uv, center, radius, 0.0018) * (1.0 - phase);\n    distortion += normalize(uv - center + vec2(0.0001)) * rainRipple * 0.004;\n  }\n\n  float clickPhase = clamp(uClickRipple.z / 1.55, 0.0, 1.0);\n  float clickRing = ring(uv, uClickRipple.xy, clickPhase * 0.14, 0.0025) * (1.0 - clickPhase) * uClickRipple.w;\n  distortion += normalize(uv - uClickRipple.xy + vec2(0.0001)) * clickRing * 0.012;\n\n  float footRing = 0.0;\n  vec2 footPush = vec2(0.0);\n  for (int index = 0; index < 8; index++) {\n    vec4 state = uRipples[index];\n    if (state.z < 0.0 || state.z >= uRippleDuration) continue;\n    float wave = projectedFootWave(uv, state, uRippleDirections[index].xy);\n    footRing += wave;\n    footPush += (uv - state.xy) * wave;\n  }\n  footRing = clamp(footRing, 0.0, 1.5);\n  distortion += normalize(footPush + vec2(0.0001)) * footRing * 0.0065;\n\n  vec4 reflection = texture(uReflection, clamp(uv + distortion, vec2(0.002), vec2(0.998)));\n  vec3 waterTint = vec3(0.055, 0.15, 0.23);\n  float reflectedAmount = reflection.a * uReflectionStrength;\n  vec3 color = mix(waterTint, reflection.rgb + vec3(0.03, 0.06, 0.09), reflectedAmount);\n  color += vec3(0.30, 0.48, 0.58) * (clickRing + footRing * 1.10 + 0.18 * max(0.0, smallWaves)) * 0.24;\n  float alpha = mask * (0.82 + 0.16 * uWaterLevel);\n  finalColor = vec4(color * alpha, alpha);\n}\n";function v(e,t,n){const i=e[t];return"number"==typeof i&&Number.isFinite(i)?i:n}const h=()=>{const e=new n.UniformGroup({uTime:{value:0,type:"f32"},uRainAmount:{value:.65,type:"f32"},uQuality:{value:1,type:"f32"}}),t=new n.Filter({glProgram:n.GlProgram.from({name:c,vertex:f,fragment:d}),resources:{rainUniforms:e},antialias:"on"});return{filter:t,update(t,n){const i=e.uniforms;i.uTime=t.rafTime/1e3,i.uRainAmount=v(n,"rainAmount",.65),i.uQuality=v(n,"quality",1)},destroy(){t.destroy()}}};Object.defineProperty(h,"backends",{value:["webgl"]});const g=()=>{const e=new Float32Array(32),t=new Float32Array(32),r=new Float32Array([-2,-2,99,0]);for(let t=0;t<8;t+=1)e[4*t+2]=-1;const a=new n.UniformGroup({uTime:{value:0,type:"f32"},uWaterLevel:{value:.5,type:"f32"},uGroundLevel:{value:.545,type:"f32"},uGroundFeather:{value:.02,type:"f32"},uReflectionStrength:{value:.55,type:"f32"},uRippleDuration:{value:1.6,type:"f32"},uRipples:{value:e,type:"vec4<f32>",size:8},uRippleDirections:{value:t,type:"vec4<f32>",size:8},uClickRipple:{value:r,type:"vec4<f32>"}}),o=new n.Filter({glProgram:n.GlProgram.from({name:p,vertex:f,fragment:m}),resources:{puddleUniforms:a,uReflection:n.Texture.EMPTY.source},antialias:"on"});let l="";return{filter:o,update(n,u){const s=a.uniforms;s.uTime=n.rafTime/1e3,s.uWaterLevel=v(u,"waterLevel",.5),s.uGroundLevel=v(u,"groundLevel",.545),s.uGroundFeather=v(u,"groundFeather",.02),s.uReflectionStrength=v(u,"reflectionStrength",.55),s.uRippleDuration=v(u,"rippleDuration",1.6);const c=u.ripples;e.fill(0);for(let t=0;t<8;t+=1)e[4*t+2]=-1;c instanceof Float32Array&&e.set(c.subarray(0,e.length)),t.fill(0);const p=u.rippleDirections;p instanceof Float32Array&&t.set(p.subarray(0,t.length)),r.set([-2,-2,99,0]);const f=u.clickRipple;f instanceof Float32Array&&r.set(f.subarray(0,r.length));const d="string"==typeof u.reflectionTexture?u.reflectionTexture:"";if(d&&d!==l){const e=i.getSceneCaptureTexture(d);e&&(o.resources.uReflection=e.source,l=d)}},destroy(){o.destroy()}}};Object.defineProperty(g,"backends",{value:["webgl"]});const x={vertex:f,rainFragment:d,puddleFragment:m};exports.DEFAULT_MAX_RIPPLES=4,exports.MAX_SHADER_RIPPLES=8,exports.PUDDLE_EFFECT_ID=p,exports.RAIN_EFFECT_ID=c,exports.RIPPLE_STRIDE=4,exports.RainPuddle=r,exports.RainPuddleSystem=u,exports.rainPuddleShaderSources=x,exports.registerRainPuddleEffects=function(){t.getShaderEffect(c)||t.registerShaderEffect(c,h),t.getShaderEffect(p)||t.registerShaderEffect(p,g)},exports.unregisterRainPuddleEffects=function(){t.unregisterShaderEffect(c),t.unregisterShaderEffect(p)};

package/dist/plugin-renderer-rain-puddle.d.ts

@@ -0,0 +1,116 @@
+import { Component } from '@eva/eva.js';
+import { ComponentChanged } from '@eva/eva.js';
+import { FrameParams } from '@eva/eva.js';
+import { System } from '@eva/eva.js';
+
+declare interface ClickRippleInput {
+    x: number;
+    y: number;
+    strength?: number;
+}
+
+export declare const DEFAULT_MAX_RIPPLES = 4;
+
+export declare const MAX_SHADER_RIPPLES = 8;
+
+export declare const PUDDLE_EFFECT_ID = "eva.rain-puddle.puddle";
+
+export declare const RAIN_EFFECT_ID = "eva.rain-puddle.rain";
+
+/**
+ * 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`.
+ */
+export declare class RainPuddle extends Component<RainPuddleParams> {
+    static componentName: string;
+    rainAmount: number;
+    waterLevel: number;
+    groundLevel: number;
+    groundFeather: number;
+    reflectionStrength: number;
+    rippleDuration: number;
+    maxRipples: number;
+    quality: RainPuddleQuality;
+    reflectionTexture: string;
+    rainSurfaceName: string;
+    puddleSurfaceName: string;
+    rippleUniformData: Float32Array;
+    rippleDirectionUniformData: Float32Array;
+    clickRippleUniformData: Float32Array;
+    activeRippleCount: number;
+    private nextRippleIndex;
+    init(params?: RainPuddleParams): void;
+    emitRipple(input: RippleInput): void;
+    /** Click ripples have an independent lifetime and never consume a footstep slot. */
+    emitClickRipple(input: ClickRippleInput): void;
+    advanceRipples(deltaSeconds: number): void;
+    getRippleDirection(index: number): {
+        x: number;
+        y: number;
+    };
+    resetRipples(): void;
+}
+
+export declare interface RainPuddleParams {
+    rainAmount?: number;
+    waterLevel?: number;
+    /** Normalized screen Y where the ground plane begins. */
+    groundLevel?: number;
+    /** Normalized vertical distance used to soften the ground-plane edge. */
+    groundFeather?: number;
+    reflectionStrength?: number;
+    rippleDuration?: number;
+    maxRipples?: number;
+    quality?: RainPuddleQuality;
+    reflectionTexture?: string;
+    rainSurfaceName?: string;
+    puddleSurfaceName?: string;
+}
+
+export declare type RainPuddleQuality = 'low' | 'medium' | 'high';
+
+export declare const rainPuddleShaderSources: {
+    readonly vertex: "\nin vec2 aPosition;\nout vec2 vTextureCoord;\n\nuniform vec4 uOutputFrame;\nuniform vec4 uOutputTexture;\n\nvoid main() {\n  vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy;\n  position.x = position.x * (2.0 / uOutputTexture.x) - 1.0;\n  position.y = position.y * (2.0 * uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z;\n  gl_Position = vec4(position, 0.0, 1.0);\n  vTextureCoord = aPosition;\n}\n";
+    readonly rainFragment: "\nin vec2 vTextureCoord;\nout vec4 finalColor;\n\nuniform sampler2D uTexture;\nuniform float uTime;\nuniform float uRainAmount;\nuniform float uQuality;\n\nfloat hash21(vec2 p) {\n  return fract(sin(dot(p, vec2(41.31, 289.17))) * 28419.231);\n}\n\nfloat rainLayer(vec2 uv, float scale, float speed, float width, float length, float brightness) {\n  vec2 p = uv * vec2(150.0 * scale, 78.0 * scale);\n  p.x += p.y * 0.24;\n  // Texture coordinates grow downwards in Pixi. Subtracting time makes the\n  // streak cells travel towards increasing screen Y instead of rising upward.\n  p.y -= uTime * speed;\n  vec2 id = floor(p);\n  vec2 cell = fract(p) - 0.5;\n  float seed = hash21(id);\n  float thinLine = 1.0 - smoothstep(width, width * 2.0, abs(cell.x + seed * 0.16 - 0.08));\n  float longStreak = 1.0 - smoothstep(length, length * 1.35, abs(cell.y));\n  return thinLine * longStreak * brightness * step(1.0 - uRainAmount, seed);\n}\n\nvoid main() {\n  vec2 uv = vTextureCoord;\n  float detail = mix(0.78, 1.0, uQuality);\n  float rain = rainLayer(uv, 0.72 * detail, 1.15, 0.010, 0.42, 0.28);\n  rain += rainLayer(uv + vec2(0.17, 0.0), 1.28 * detail, 1.78, 0.007, 0.46, 0.62);\n  float alpha = clamp(rain, 0.0, 0.82);\n  finalColor = vec4(vec3(0.66, 0.82, 0.96) * alpha, alpha);\n}\n";
+    readonly puddleFragment: string;
+};
+
+/** Advances bounded ripples and keeps both visual passes on one shared state. */
+export declare class RainPuddleSystem extends System {
+    static systemName: string;
+    name: string;
+    private readonly bindings;
+    update(): void;
+    private consumeObserverChanges;
+    componentChanged(changed: ComponentChanged): void;
+    frameStart(frame: FrameParams): void;
+    onDestroy(): void;
+    private resolveEffect;
+}
+
+/** Register the built-in rain and puddle factories once for the current realm. */
+export declare function registerRainPuddleEffects(): void;
+
+export declare const RIPPLE_STRIDE = 4;
+
+export declare interface RippleInput {
+    /** Horizontal position in normalized screen coordinates. */
+    x: number;
+    /** Vertical position in normalized screen coordinates. */
+    y: number;
+    /** Ripple amplitude, normalized to 0..1. */
+    strength?: number;
+    /** Optional ground-plane direction used by projected footstep wakes. */
+    direction?: number | {
+        x: number;
+        y: number;
+    };
+}
+
+/** Primarily useful for test isolation and hosts that unload plugin bundles. */
+export declare function unregisterRainPuddleEffects(): void;
+
+export { }