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

package/README.md

@@ -0,0 +1,36 @@
+# @eva/plugin-renderer-rain-puddle
+
+Rain, puddle reflection and bounded ripple effects built on Eva.js `ShaderEffect`
+and `SceneCapture`.
+
+```ts
+import {
+  RainPuddle,
+  RainPuddleSystem,
+  registerRainPuddleEffects,
+} from '@eva/plugin-renderer-rain-puddle';
+
+registerRainPuddleEffects();
+
+await game.init({
+  systems: [
+    rendererSystem,
+    new RainPuddleSystem(),
+    sceneCaptureSystem,
+    shaderEffectSystem,
+  ],
+});
+```
+
+Attach `SceneCapture` to an owner object, put `ShaderEffect` with
+`eva.rain-puddle.puddle` and `eva.rain-puddle.rain` on two full-screen surfaces,
+then add one `RainPuddle` controller. The controller owns the runtime knobs and a
+fixed ripple ring; shader sources and Pixi resources never enter serialized DSL
+data.
+
+The built-in effects currently declare WebGL support. Hosts should request
+`backendPreference: 'webgl2'` and `backendRequired: true`, or provide a fallback
+before enabling a WebGPU-only renderer.
+
+See `examples/src/rain-puddle.ts` for the complete layer order, live reflection
+proxies, pointer ripples, ground splashes and controls.

package/dist/EVA.plugin.renderer.rain.puddle.js

@@ -0,0 +1,529 @@
+globalThis.EVA = globalThis.EVA || {};
+globalThis.EVA.plugin = globalThis.EVA.plugin || {};
+globalThis.EVA.plugin.renderer = globalThis.EVA.plugin.renderer || {};
+globalThis.EVA.plugin.renderer.rain = globalThis.EVA.plugin.renderer.rain || {};
+var _EVA_IIFE_puddle = function (exports, eva_js, pluginRendererShaderEffect, pixi_js, pluginRendererSceneCapture) {
+  'use strict';
+
+  const RIPPLE_STRIDE = 4;
+  const DEFAULT_MAX_RIPPLES = 4;
+  const MAX_SHADER_RIPPLES = 8;
+  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;
+    }
+    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));
+  }
+  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;
+  }
+  let RainPuddleSystem = class RainPuddleSystem extends eva_js.System {
+    constructor() {
+      super(...arguments);
+      this.name = 'RainPuddleSystem';
+      this.bindings = new Map();
+    }
+    update() {
+      this.consumeObserverChanges();
+    }
+    consumeObserverChanges() {
+      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) {
+      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';
+  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']
+  });
+  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);
+  }
+  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;
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+  return exports;
+}({}, EVA, EVA.plugin.renderer.shader.effect, PIXI, EVA.plugin.renderer.scene.capture);
+globalThis.EVA.plugin.renderer.rain.puddle = globalThis.EVA.plugin.renderer.rain.puddle || _EVA_IIFE_puddle;

package/dist/EVA.plugin.renderer.rain.puddle.min.js

@@ -0,0 +1 @@
+globalThis.EVA=globalThis.EVA||{},globalThis.EVA.plugin=globalThis.EVA.plugin||{},globalThis.EVA.plugin.renderer=globalThis.EVA.plugin.renderer||{},globalThis.EVA.plugin.renderer.rain=globalThis.EVA.plugin.renderer.rain||{};var _EVA_IIFE_puddle=function(e,t,n,i,r){"use strict";class a extends t.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,a,u,s,c,p,f,d,m,h,v;this.rainAmount=l(null!==(t=e.rainAmount)&&void 0!==t?t:this.rainAmount),this.waterLevel=l(null!==(n=e.waterLevel)&&void 0!==n?n:this.waterLevel),this.groundLevel=l(null!==(i=e.groundLevel)&&void 0!==i?i:this.groundLevel),this.groundFeather=o(null!==(r=e.groundFeather)&&void 0!==r?r:this.groundFeather,.001,1),this.reflectionStrength=l(null!==(a=e.reflectionStrength)&&void 0!==a?a: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,h=1,v=8,Math.round(o(m,h,v))),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]=l(e.x),this.rippleUniformData[i+1]=l(e.y),this.rippleUniformData[i+2]=0,this.rippleUniformData[i+3]=l(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),o=4*n;this.rippleDirectionUniformData[o]=a.x,this.rippleDirectionUniformData[o+1]=a.y,r||(this.activeRippleCount+=1),this.nextRippleIndex=(n+1)%this.maxRipples}emitClickRipple(e){var t;this.clickRippleUniformData[0]=l(e.x),this.clickRippleUniformData[1]=l(e.y),this.clickRippleUniformData[2]=0,this.clickRippleUniformData[3]=l(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 o(e,t,n){return Math.min(n,Math.max(t,e))}function l(e){return o(e,0,1)}a.componentName="RainPuddle";let u=class extends t.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(e){e.componentName===a.componentName&&(e.type!==t.OBSERVER_TYPE.REMOVE?e.type===t.OBSERVER_TYPE.ADD&&this.bindings.set(e.gameObject.id,{component:e.component}):this.bindings.delete(e.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=c(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,t){var i,r,a;if((null==e?void 0:e.gameObject)&&!e.gameObject.destroyed)return e;if(!t)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,t))||void 0===a?void 0:a[0];return null==o?void 0:o.getComponent(n.ShaderEffect)}};u.systemName="RainPuddleSystem",u=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}([t.decorators.componentObserver({RainPuddle:[]})],u);var s=u;function c(e){return"low"===e?0:"medium"===e?.55:1}const p="eva.rain-puddle.rain",f="eva.rain-puddle.puddle",d="\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",m="\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",h="\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 g=()=>{const e=new i.UniformGroup({uTime:{value:0,type:"f32"},uRainAmount:{value:.65,type:"f32"},uQuality:{value:1,type:"f32"}}),t=new i.Filter({glProgram:i.GlProgram.from({name:p,vertex:d,fragment:m}),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(g,"backends",{value:["webgl"]});const R=()=>{const e=new Float32Array(32),t=new Float32Array(32),n=new Float32Array([-2,-2,99,0]);for(let t=0;t<8;t+=1)e[4*t+2]=-1;const a=new i.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:n,type:"vec4<f32>"}}),o=new i.Filter({glProgram:i.GlProgram.from({name:f,vertex:d,fragment:h}),resources:{puddleUniforms:a,uReflection:i.Texture.EMPTY.source},antialias:"on"});let l="";return{filter:o,update(i,u){const s=a.uniforms;s.uTime=i.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)),n.set([-2,-2,99,0]);const f=u.clickRipple;f instanceof Float32Array&&n.set(f.subarray(0,n.length));const d="string"==typeof u.reflectionTexture?u.reflectionTexture:"";if(d&&d!==l){const e=r.getSceneCaptureTexture(d);e&&(o.resources.uReflection=e.source,l=d)}},destroy(){o.destroy()}}};Object.defineProperty(R,"backends",{value:["webgl"]});const y={vertex:d,rainFragment:m,puddleFragment:h};return e.DEFAULT_MAX_RIPPLES=4,e.MAX_SHADER_RIPPLES=8,e.PUDDLE_EFFECT_ID=f,e.RAIN_EFFECT_ID=p,e.RIPPLE_STRIDE=4,e.RainPuddle=a,e.RainPuddleSystem=s,e.rainPuddleShaderSources=y,e.registerRainPuddleEffects=function(){n.getShaderEffect(p)||n.registerShaderEffect(p,g),n.getShaderEffect(f)||n.registerShaderEffect(f,R)},e.unregisterRainPuddleEffects=function(){n.unregisterShaderEffect(p),n.unregisterShaderEffect(f)},Object.defineProperty(e,"__esModule",{value:!0}),e}({},EVA,EVA.plugin.renderer.shader.effect,PIXI,EVA.plugin.renderer.scene.capture);globalThis.EVA.plugin.renderer.rain.puddle=globalThis.EVA.plugin.renderer.rain.puddle||_EVA_IIFE_puddle;