@mkbabb/glass-ui 4.0.0 → 4.1.0

package/dist/dot-flow-field.js

@@ -0,0 +1,894 @@
+import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
+import { t } from "./usePointerVelocityField-QLsy3_kv.js";
+import { n, o as r, r as i, s as a } from "./procedural-color.wgsl-m7Zgv35j.js";
+import { a as o, t as s } from "./useGpuSubstrate-4pTcp6mX.js";
+import { c } from "./color-Cs0-oxYL.js";
+import { computed as l, createElementBlock as u, createElementVNode as d, defineComponent as f, normalizeStyle as p, onScopeDispose as m, openBlock as h, useTemplateRef as g, watch as _ } from "vue";
+//#region src/components/custom/dot-flow-field/shaders/flow-field.compute.wgsl.ts
+var v = "\nconst MAX_WAVE_COMPONENTS: i32 = 8;\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst FLOW_GRAVITY: f32 = 9.81;\nconst CURL_EPS: f32 = 0.012;\nconst FBM_ROT: mat2x2<f32> = mat2x2<f32>(0.8, 0.6, -0.6, 0.8);\n\nstruct Particle {\n  // (pos.x, pos.y, height, |disp|) — the anchored-lattice live state\n  data: vec4<f32>,\n};\n\n// ── Uniforms (the typed-struct source-of-truth — see uniformBridgeWGPU.ts) ──\nstruct FlowUniforms {\n  // p0: (uTime, uDt, uWindSpeed, uCurlStrength)\n  p0: vec4<f32>,\n  // p1: (uGridPitch, uDisplaceAmp, uSpringK, uGridCols)  — the lattice geometry\n  p1: vec4<f32>,\n  // ints: (uWaveCount, uParticleCount, uGridColsI, _pad)\n  ints: vec4<i32>,\n  // each wave row: (amplitude, wavelength, directionDeg, phase)\n  waves: array<vec4<f32>, 8>,\n};\n\n@group(0) @binding(0) var<uniform> u: FlowUniforms;\n@group(0) @binding(1) var<storage, read_write> particles: array<Particle>;\n\n// ── The deterministic lattice origin (transcribes flowField.ts gridOrigin) ──\nfn gridOrigin(index: u32, cols: i32, pitch: f32) -> vec2<f32> {\n  let c = max(cols, 1);\n  let col = i32(index) % c;\n  let row = i32(index) / c;\n  let half = f32(c - 1) * pitch * 0.5;\n  return vec2<f32>(f32(col) * pitch - half, f32(row) * pitch - half);\n}\n\n// ── The Gerstner-sum analytic ∇⊥h velocity (transcribes flowField.ts gerstnerVelocity) ──\nfn gerstnerVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {\n  var dhdx = 0.0;\n  var dhdy = 0.0;\n  let windSpeed = u.p0.z;\n  let waveCount = u.ints.x;\n  for (var i = 0; i < MAX_WAVE_COMPONENTS; i = i + 1) {\n    if (i >= waveCount) { break; }\n    let w = u.waves[i];\n    let amplitude = w.x;\n    let wavelength = max(w.y, 1e-4);\n    let dirRad = w.z * PI / 180.0;\n    let phase = w.w;\n    let k = TAU / wavelength;\n    let d = vec2<f32>(cos(dirRad), sin(dirRad));\n    let omega = sqrt(FLOW_GRAVITY * k) * windSpeed;\n    let theta = k * (d.x * p.x + d.y * p.y) - omega * t + phase;\n    let akc = amplitude * k * cos(theta);\n    dhdx = dhdx + akc * d.x;\n    dhdy = dhdy + akc * d.y;\n  }\n  // v = ∇⊥h = (∂h/∂y, −∂h/∂x).\n  return vec2<f32>(dhdy, -dhdx);\n}\n\n// ── The scalar Gerstner HEIGHT (transcribes flowField.ts sampleHeight — the brightness\n//    driver, normalized to ≈[-1,1] by the total amplitude so the band thresholds are\n//    wave-table-independent). ──\nfn sampleHeight(o: vec2<f32>, t: f32) -> f32 {\n  var h = 0.0;\n  var ampSum = 0.0;\n  let windSpeed = u.p0.z;\n  let waveCount = u.ints.x;\n  for (var i = 0; i < MAX_WAVE_COMPONENTS; i = i + 1) {\n    if (i >= waveCount) { break; }\n    let w = u.waves[i];\n    let k = TAU / max(w.y, 1e-4);\n    let dirRad = w.z * PI / 180.0;\n    let d = vec2<f32>(cos(dirRad), sin(dirRad));\n    let omega = sqrt(FLOW_GRAVITY * k) * windSpeed;\n    let theta = k * (d.x * o.x + d.y * o.y) - omega * t + w.w;\n    h = h + w.x * sin(theta);\n    ampSum = ampSum + abs(w.x);\n  }\n  return h / max(ampSum, 1e-4);\n}\n\n// ── Shared curl-noise basis (the WGSL twin of flow.glsl.ts curlFBM) ──\nfn hash21(p: vec2<f32>) -> f32 {\n  var p3 = fract(vec3<f32>(p.x, p.y, p.x) * 0.1031);\n  p3 = p3 + dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\n\nfn valueNoise(p: vec2<f32>) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u2 = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n  let a = hash21(i + vec2<f32>(0.0, 0.0));\n  let b = hash21(i + vec2<f32>(1.0, 0.0));\n  let c = hash21(i + vec2<f32>(0.0, 1.0));\n  let d = hash21(i + vec2<f32>(1.0, 1.0));\n  return mix(mix(a, b, u2.x), mix(c, d, u2.x), u2.y);\n}\n\nfn potentialFBM(p0: vec2<f32>) -> f32 {\n  var v = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var p = p0;\n  for (var i = 0; i < 3; i = i + 1) {\n    v = v + amp * valueNoise(p * freq);\n    p = FBM_ROT * p;\n    freq = freq * 2.0;\n    amp = amp * 0.5;\n  }\n  return v;\n}\n\nfn curlFBM(p: vec2<f32>) -> vec2<f32> {\n  let dx = potentialFBM(p + vec2<f32>(CURL_EPS, 0.0)) - potentialFBM(p - vec2<f32>(CURL_EPS, 0.0));\n  let dy = potentialFBM(p + vec2<f32>(0.0, CURL_EPS)) - potentialFBM(p - vec2<f32>(0.0, CURL_EPS));\n  let g = vec2<f32>(dx, dy) / (2.0 * CURL_EPS);\n  return vec2<f32>(g.y, -g.x);\n}\n\n// The composite flow velocity (transcribes flowField.ts sampleVelocity EXACTLY — the\n// coarse ×0.55 curl domain-scale, the §3.2 inversion).\nfn sampleVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {\n  let curlStrength = u.p0.w;\n  var v = gerstnerVelocity(p, t);\n  if (curlStrength > 0.0) {\n    let c = curlFBM(vec2<f32>(p.x * 0.55 + t * 0.15, p.y * 0.55));\n    v = v + c * curlStrength;\n  }\n  return v;\n}\n\n// The sub-cell DISPLACEMENT (transcribes flowField.ts sampleDisplacement — ∇⊥h + the\n// coarse curl break, soft-clamped through tanh so the magnitude rides into [0,1)).\nfn sampleDisplacement(o: vec2<f32>, t: f32) -> vec2<f32> {\n  let v = sampleVelocity(o, t);\n  let mag = length(v);\n  if (mag < 1e-5) { return vec2<f32>(0.0, 0.0); }\n  let bounded = tanh(mag);\n  return v * (bounded / mag);\n}\n\n@compute @workgroup_size(64)\nfn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  let count = u32(u.ints.y);\n  if (idx >= count) { return; } // bounds-guard the dispatch tail\n\n  let t = u.p0.x;\n  let dt = u.p0.y;\n  let pitch = u.p1.x;\n  let displaceAmp = u.p1.y;\n  let springK = u.p1.z;\n  let cols = u.ints.z;\n\n  // The PERMANENT anchor — no wrap, no re-seed (the coherence fix).\n  let o = gridOrigin(idx, cols, pitch);\n  let disp = sampleDisplacement(o, t);\n  let anchorTarget = o + disp * (displaceAmp * pitch);\n\n  var pr = particles[idx];\n  var pos = pr.data.xy;\n  // Framerate-independent critically-damped pull-to-anchor:\n  //   p ← mix(p, anchorTarget, 1 - exp(-springK·dt))  (the GPGPU influence-pull pattern).\n  let k = 1.0 - exp(-springK * dt);\n  pos = mix(pos, anchorTarget, k);\n\n  let h = sampleHeight(o, t);\n  particles[idx] = Particle(vec4<f32>(pos, h, length(disp)));\n}\n", y = `
+const PI: f32 = 3.141592653589793;
+const TAU: f32 = 6.283185307179586;
+const MAX_FLOW_STOPS: i32 = 4;
+
+struct Particle {
+  // (pos.x, pos.y, height, |disp|)
+  data: vec4<f32>,
+};
+
+// ── Render uniforms (the typed-struct source-of-truth — see uniformBridgeWGPU.ts) ──
+struct RenderUniforms {
+  // r0: (uTime, uContrast, uBaseBright, uDomainHalf)
+  r0: vec4<f32>,
+  // r1: (uDotSize, uSizePulse, uAspect, uGridPitch)
+  r1: vec4<f32>,
+  // r2: (uWaveBandCenter, uWaveBandWidth, uGlobeMask, _pad)
+  r2: vec4<f32>,
+  // ints: (uStopCount, uParticleCount, _pad, _pad)
+  ints: vec4<i32>,
+  // bg: (background.rgb, hasBackground)
+  bg: vec4<f32>,
+  // each palette stop: linear-sRGB rgb + _pad
+  palette: array<vec4<f32>, 4>,
+};
+
+@group(0) @binding(0) var<uniform> u: RenderUniforms;
+@group(0) @binding(1) var<storage, read> particles: array<Particle>;
+
+${n}
+${i}
+
+// The sweeping bright-stripe band (transcribes flowField.ts waveBand): a soft two-sided
+// ridge over the normalized height — 1 at the band center, falling to 0 at ±width.
+fn waveBand(h: f32, center: f32, width: f32) -> f32 {
+  let w = max(width, 1e-3);
+  let d = abs(h - center);
+  return 1.0 - smoothstep(0.0, w, d);
+}
+
+// The optional soft-disc globe mask — a slow Lissajous-drifting radial field (the
+// reference's two-sphere composition). OFF when uGlobeMask <= 0.5 (returns 1).
+fn globeMask(o: vec2<f32>, t: f32, on: f32) -> f32 {
+  if (on <= 0.5) { return 1.0; }
+  // a slow Lissajous center drift within the domain
+  let cx = 0.35 * sin(t * 0.13);
+  let cy = 0.28 * cos(t * 0.11);
+  let d = length(o - vec2<f32>(cx, cy));
+  // a soft disc of radius ~0.6 with a feathered edge
+  return 1.0 - smoothstep(0.45, 0.75, d);
+}
+
+// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].
+fn samplePaletteLin(t: f32) -> vec3<f32> {
+  let stopCount = u.ints.x;
+  if (stopCount <= 1) { return u.palette[0].rgb; }
+  let n = f32(stopCount);
+  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);
+  let i0 = i32(floor(ft));
+  let i1 = min(i0 + 1, stopCount - 1);
+  let f = ft - f32(i0);
+  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);
+  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);
+  return oklabToLinearSrgb(mix(labA, labB, f));
+}
+
+struct VSOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) local: vec2<f32>,   // [-1,1] billboard-local coords for the soft circle
+  @location(1) bright: f32,        // band-driven brightness [0, ~1.6]
+};
+
+@vertex
+fn vs_main(
+  @builtin(vertex_index) vi: u32,
+  @builtin(instance_index) ii: u32,
+) -> VSOut {
+  // Two-triangle quad corners in billboard-local space.
+  var corners = array<vec2<f32>, 6>(
+    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(-1.0, 1.0),
+    vec2<f32>(-1.0, 1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0, 1.0),
+  );
+  let local = corners[vi];
+
+  let pr = particles[ii].data;
+  let p = pr.xy;
+  let h = pr.z;
+  let dispMag = pr.w;
+  let half = u.r0.w;
+
+  // Brightness = base + band·contrast, masked by the optional globe (read at the live
+  // position — close enough to the anchor at the sub-cell cap). The band SWEEPS as h
+  // translates across the lattice.
+  let band = waveBand(h, u.r2.x, u.r2.y);
+  var bright = u.r0.z + band * u.r0.y;
+  bright = bright * globeMask(p, u.r0.x, u.r2.z);
+
+  // A subtle drift-driven size pulse (never a re-seed — the dot only breathes).
+  let sizePulse = u.r1.y;
+  let sizeWorld = u.r1.x * (1.0 + dispMag * sizePulse);
+
+  // Position the quad at the dot in clip space. Domain [-half,half] → NDC [-1,1];
+  // the quad half-extent rides sizeWorld (in domain units, aspect-corrected x).
+  let aspect = u.r1.z;
+  let ndc = p / half;
+  let off = local * sizeWorld / half;
+  let offX = off.x / max(aspect, 1e-4);
+
+  var out: VSOut;
+  out.pos = vec4<f32>(ndc.x + offX, ndc.y + off.y, 0.0, 1.0);
+  out.local = local;
+  out.bright = bright;
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
+  // Soft circle — radial smoothstep over the billboard-local radius.
+  let r = length(in.local);
+  let feather = 0.4;
+  let mask = 1.0 - smoothstep(1.0 - feather, 1.0, r);
+  if (mask < 0.002) { return vec4<f32>(0.0); }
+
+  // The brightness lights the dot core; the palette tints it (the warm-cream identity).
+  let bright = clamp(in.bright, 0.0, 1.6);
+  let tone = clamp(bright, 0.0, 1.0);
+  let lin = samplePaletteLin(tone) * bright;
+  // A floor alpha so even an off-band dot stays a faint lattice point (the calm grid).
+  let alpha = mask * clamp(bright * 0.8 + 0.12, 0.0, 1.0);
+  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));
+  // Premultiplied-alpha output.
+  return vec4<f32>(rgb * alpha, alpha);
+}
+`, b = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition;            // [-1,1]² domain\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}", x = `#version 300 es
+precision highp float;
+
+#define PI 3.141592653589793
+#define TAU 6.283185307179586
+#define FLOW_GRAVITY 9.81
+#define CURL_EPS 0.012
+#define MAX_WAVE_COMPONENTS 8
+#define MAX_FLOW_STOPS 4
+
+in vec2 vUv;
+out vec4 fragColor;
+
+uniform float uTime;
+uniform float uWindSpeed;
+uniform float uCurlStrength;
+uniform float uDomainHalf;
+uniform float uAspect;
+uniform float uGridPitchDomain;  // lattice pitch in DOMAIN units
+uniform float uDotRadiusDomain;  // dot radius in DOMAIN units
+uniform float uDisplaceAmp;      // sub-cell drift in pitch fractions
+uniform float uContrast;
+uniform float uBaseBright;
+uniform float uWaveBandCenter;
+uniform float uWaveBandWidth;
+uniform float uGlobeMask;
+uniform int   uWaveCount;
+uniform int   uStopCount;
+uniform float uHasBackground;
+uniform vec3  uBg;
+uniform vec4  uWaves[MAX_WAVE_COMPONENTS];   // (amplitude, wavelength, directionDeg, phase)
+uniform vec3  uPalette[MAX_FLOW_STOPS];      // linear-sRGB stops
+
+const mat2 FBM_ROT = mat2(0.8, 0.6, -0.6, 0.8);
+
+${r}
+${a}
+
+// ── The Gerstner-sum analytic ∇⊥h velocity (transcribes flowField.ts gerstnerVelocity) ──
+vec2 gerstnerVelocity(vec2 p, float t) {
+  float dhdx = 0.0;
+  float dhdy = 0.0;
+  for (int i = 0; i < MAX_WAVE_COMPONENTS; i++) {
+    if (i >= uWaveCount) break;
+    vec4 w = uWaves[i];
+    float k = TAU / max(w.y, 1e-4);
+    float dirRad = w.z * PI / 180.0;
+    vec2 d = vec2(cos(dirRad), sin(dirRad));
+    float omega = sqrt(FLOW_GRAVITY * k) * uWindSpeed;
+    float theta = k * (d.x * p.x + d.y * p.y) - omega * t + w.w;
+    float akc = w.x * k * cos(theta);
+    dhdx += akc * d.x;
+    dhdy += akc * d.y;
+  }
+  return vec2(dhdy, -dhdx);
+}
+
+// ── The scalar Gerstner HEIGHT (transcribes flowField.ts sampleHeight) ──
+float sampleHeight(vec2 o, float t) {
+  float h = 0.0;
+  float ampSum = 0.0;
+  for (int i = 0; i < MAX_WAVE_COMPONENTS; i++) {
+    if (i >= uWaveCount) break;
+    vec4 w = uWaves[i];
+    float k = TAU / max(w.y, 1e-4);
+    float dirRad = w.z * PI / 180.0;
+    vec2 d = vec2(cos(dirRad), sin(dirRad));
+    float omega = sqrt(FLOW_GRAVITY * k) * uWindSpeed;
+    float theta = k * (d.x * o.x + d.y * o.y) - omega * t + w.w;
+    h += w.x * sin(theta);
+    ampSum += abs(w.x);
+  }
+  return h / max(ampSum, 1e-4);
+}
+
+// ── Shared curl-noise basis (the GLSL twin of flow.glsl.ts curlFBM) ──
+float hash21(vec2 p) {
+  vec3 p3 = fract(vec3(p.x, p.y, p.x) * 0.1031);
+  p3 += dot(p3, p3.yzx + 33.33);
+  return fract((p3.x + p3.y) * p3.z);
+}
+float valueNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u2 = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
+  float a = hash21(i + vec2(0.0, 0.0));
+  float b = hash21(i + vec2(1.0, 0.0));
+  float c = hash21(i + vec2(0.0, 1.0));
+  float d = hash21(i + vec2(1.0, 1.0));
+  return mix(mix(a, b, u2.x), mix(c, d, u2.x), u2.y);
+}
+float potentialFBM(vec2 p0) {
+  float v = 0.0;
+  float amp = 0.5;
+  float freq = 1.0;
+  vec2 p = p0;
+  for (int i = 0; i < 3; i++) {
+    v += amp * valueNoise(p * freq);
+    p = FBM_ROT * p;
+    freq *= 2.0;
+    amp *= 0.5;
+  }
+  return v;
+}
+vec2 curlFBM(vec2 p) {
+  float dx = potentialFBM(p + vec2(CURL_EPS, 0.0)) - potentialFBM(p - vec2(CURL_EPS, 0.0));
+  float dy = potentialFBM(p + vec2(0.0, CURL_EPS)) - potentialFBM(p - vec2(0.0, CURL_EPS));
+  vec2 g = vec2(dx, dy) / (2.0 * CURL_EPS);
+  return vec2(g.y, -g.x);
+}
+vec2 sampleVelocity(vec2 p, float t) {
+  vec2 v = gerstnerVelocity(p, t);
+  if (uCurlStrength > 0.0) {
+    vec2 c = curlFBM(vec2(p.x * 0.55 + t * 0.15, p.y * 0.55));
+    v += c * uCurlStrength;
+  }
+  return v;
+}
+// sub-cell displacement (transcribes flowField.ts sampleDisplacement — tanh soft-clamp).
+vec2 sampleDisplacement(vec2 o, float t) {
+  vec2 v = sampleVelocity(o, t);
+  float mag = length(v);
+  if (mag < 1e-5) return vec2(0.0);
+  return v * (tanh(mag) / mag);
+}
+
+// The sweeping bright-stripe band (transcribes flowField.ts waveBand).
+float waveBand(float h, float center, float width) {
+  float w = max(width, 1e-3);
+  float d = abs(h - center);
+  return 1.0 - smoothstep(0.0, w, d);
+}
+
+// The optional soft-disc globe mask (the reference's two-sphere composition).
+float globeMask(vec2 o, float t, float on) {
+  if (on <= 0.5) return 1.0;
+  float cx = 0.35 * sin(t * 0.13);
+  float cy = 0.28 * cos(t * 0.11);
+  float d = length(o - vec2(cx, cy));
+  return 1.0 - smoothstep(0.45, 0.75, d);
+}
+
+vec3 samplePaletteLin(float t) {
+  if (uStopCount <= 1) return uPalette[0];
+  float n = float(uStopCount);
+  float ft = clamp(t, 0.0, 1.0) * (n - 1.0);
+  int i0 = int(floor(ft));
+  int i1 = min(i0 + 1, uStopCount - 1);
+  float f = ft - float(i0);
+  vec3 lmsA = LINEAR_SRGB_TO_LMS * uPalette[i0];
+  vec3 lmsB = LINEAR_SRGB_TO_LMS * uPalette[i1];
+  vec3 labA = LMS_TO_OKLAB * (sign(lmsA) * pow(abs(lmsA), vec3(1.0 / 3.0)));
+  vec3 labB = LMS_TO_OKLAB * (sign(lmsB) * pow(abs(lmsB), vec3(1.0 / 3.0)));
+  return oklabToLinearSrgb(mix(labA, labB, f));
+}
+
+void main() {
+  float aspect = max(uAspect, 1e-4);
+  // Domain-space pixel (aspect-corrected x so the lattice stays square).
+  vec2 p = vec2(vUv.x * aspect, vUv.y);
+  float pitch = max(uGridPitchDomain, 1e-3);
+
+  // The nearest lattice cell ORIGIN (the anchored grid — the deterministic gridOrigin
+  // mapping, evaluated per-pixel: round p/pitch to the nearest cell center).
+  vec2 cell = floor(p / pitch + 0.5);
+  vec2 o = cell * pitch;
+
+  // The dot DRIFTS toward o + disp·displaceAmp·pitch (the same sub-cell offset the
+  // compute kernel writes — here evaluated analytically per pixel).
+  vec2 disp = sampleDisplacement(o, uTime);
+  vec2 dotCenter = o + disp * (uDisplaceAmp * pitch);
+
+  // The soft circle around the (drifted) dot center.
+  float dist = length(p - dotCenter);
+  float radius = max(uDotRadiusDomain, 1e-4);
+  float mask = 1.0 - smoothstep(radius * 0.6, radius, dist);
+  if (mask < 0.002) {
+    if (uHasBackground > 0.5) {
+      fragColor = vec4(clamp(linearToSrgb(uBg), vec3(0.0), vec3(1.0)), 1.0);
+    } else {
+      fragColor = vec4(0.0);
+    }
+    return;
+  }
+
+  // The brightness lights the dot — the SWEEPING band over the height at the anchor.
+  float h = sampleHeight(o, uTime);
+  float band = waveBand(h, uWaveBandCenter, uWaveBandWidth);
+  float bright = (uBaseBright + band * uContrast) * globeMask(o, uTime, uGlobeMask);
+  bright = clamp(bright, 0.0, 1.6);
+
+  float tone = clamp(bright, 0.0, 1.0);
+  vec3 lin = samplePaletteLin(tone) * bright;
+  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));
+  float alpha = mask * clamp(bright * 0.8 + 0.12, 0.0, 1.0);
+
+  if (uHasBackground > 0.5) {
+    vec3 bg = clamp(linearToSrgb(uBg), vec3(0.0), vec3(1.0));
+    fragColor = vec4(mix(bg, rgb, alpha), 1.0);
+    return;
+  }
+  fragColor = vec4(rgb * alpha, alpha);
+}`, S = 9.81, C = Math.PI * 2;
+function w(e) {
+	let t = e * Math.PI / 180;
+	return {
+		x: Math.cos(t),
+		y: Math.sin(t)
+	};
+}
+function T(e, t, n, r) {
+	let i = 0, a = 0;
+	for (let o of n) {
+		let n = C / Math.max(o.wavelength, 1e-4), s = w(o.direction), c = Math.sqrt(S * n) * r, l = n * (s.x * e.x + s.y * e.y) - c * t + o.phase, u = Math.cos(l), d = o.amplitude * n * u;
+		i += d * s.x, a += d * s.y;
+	}
+	return {
+		x: a,
+		y: -i
+	};
+}
+var E = .012;
+function D(e, t) {
+	let n = e * .1031 % 1, r = t * .1031 % 1, i = e * .1031 % 1;
+	n < 0 && (n += 1), r < 0 && (r += 1), i < 0 && (i += 1);
+	let a = n * (r + 33.33) + r * (i + 33.33) + i * (n + 33.33);
+	n += a, r += a, i += a;
+	let o = (n + r) * i % 1;
+	return o < 0 && (o += 1), o;
+}
+function O(e, t, n) {
+	return e + (t - e) * n;
+}
+function k(e, t) {
+	let n = Math.floor(e), r = Math.floor(t), i = e - n, a = t - r, o = i * i * i * (i * (i * 6 - 15) + 10), s = a * a * a * (a * (a * 6 - 15) + 10), c = D(n, r), l = D(n + 1, r), u = D(n, r + 1), d = D(n + 1, r + 1);
+	return O(O(c, l, o), O(u, d, o), s);
+}
+function A(e, t) {
+	let n = 0, r = .5, i = 1, a = e, o = t;
+	for (let e = 0; e < 3; e++) {
+		n += r * k(a * i, o * i);
+		let e = .8 * a - .6 * o, t = .6 * a + .8 * o;
+		a = e, o = t, i *= 2, r *= .5;
+	}
+	return n;
+}
+function j(e) {
+	let t = A(e.x + E, e.y) - A(e.x - E, e.y), n = A(e.x, e.y + E) - A(e.x, e.y - E), r = t / (2 * E);
+	return {
+		x: n / (2 * E),
+		y: -r
+	};
+}
+function M(e, t, n, r, i) {
+	let a = T(e, t, n, r);
+	if (i <= 0) return a;
+	let o = j({
+		x: e.x * .55 + t * .15,
+		y: e.y * .55
+	});
+	return {
+		x: a.x + o.x * i,
+		y: a.y + o.y * i
+	};
+}
+var N = .85;
+function P(e, t, n) {
+	let r = Math.max(t, 1), i = e % r, a = Math.floor(e / r), o = (r - 1) * n / 2;
+	return {
+		x: i * n - o,
+		y: a * n - o
+	};
+}
+function F(e, t, n, r) {
+	let i = 0, a = 0;
+	for (let o of n) {
+		let n = C / Math.max(o.wavelength, 1e-4), s = w(o.direction), c = Math.sqrt(S * n) * r, l = n * (s.x * e.x + s.y * e.y) - c * t + o.phase;
+		i += o.amplitude * Math.sin(l), a += Math.abs(o.amplitude);
+	}
+	return i / Math.max(a, 1e-4);
+}
+function I(e, t, n, r, i) {
+	let a = M(e, t, n, r, i), o = Math.hypot(a.x, a.y);
+	if (o < 1e-5) return {
+		x: 0,
+		y: 0
+	};
+	let s = Math.tanh(o) / o;
+	return {
+		x: a.x * s,
+		y: a.y * s
+	};
+}
+function L(e, t, n) {
+	return 1 - ee(0, Math.max(n, .001), Math.abs(e - t));
+}
+function ee(e, t, n) {
+	let r = Math.min(Math.max((n - e) / Math.max(t - e, 1e-6), 0), 1);
+	return r * r * (3 - 2 * r);
+}
+function R(e, t = 3, n = 2.5) {
+	let r = 2 * N, i = Math.max(n, .5) * r, a = i / C, o = r / 3, s = Math.max(1, Math.min(Math.round(t), 3)), c = [], l = i, u = 1;
+	for (let t = 0; t < s; t++) {
+		let n = Math.max(l, o), r = C / n, i = Math.exp(-1 / (r * a) ** 2) / (r * r), s = (t % 2 == 0 ? 1 : -1) * (8 + t * 4);
+		c.push({
+			amplitude: i * u,
+			wavelength: n,
+			direction: e + s,
+			phase: t * 1.618033 % C
+		}), l *= .58, u *= .38;
+	}
+	return c;
+}
+//#endregion
+//#region src/components/custom/dot-flow-field/constants.ts
+var te = 16384, ne = 8, re = 4, z = [{
+	L: .92,
+	C: .03,
+	h: 78
+}, {
+	L: .84,
+	C: .07,
+	h: 62
+}], B = R(35, 3, 2.5), V = {
+	waveComponents: B,
+	windSpeed: .3,
+	curlStrength: .12,
+	gridPitch: 26,
+	dotSize: 2,
+	displaceAmp: .18,
+	springK: 6,
+	waveBandCenter: 0,
+	waveBandWidth: .55,
+	contrast: .6,
+	coherence: .8,
+	globeMask: !1,
+	palette: z,
+	background: "transparent",
+	interactive: !1,
+	respectReducedMotion: !0
+}, H = N, ie = 16384;
+function U(e, t) {
+	let n = Math.min(Math.max(Math.ceil((t || 320) / Math.max(e, 4)) + 2, 4), 128);
+	return {
+		cols: n,
+		count: Math.min(n * n, ie),
+		pitchDomain: 2 * H / Math.max(n, 1)
+	};
+}
+var ae = 176, W = {
+	p0: 0,
+	p1: 4,
+	ints: 8,
+	waves: 12
+};
+function G() {
+	let e = new ArrayBuffer(ae);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+function oe(e, t, n, r, i) {
+	let { f32: a, i32: o } = e;
+	a[W.p0 + 0] = n, a[W.p0 + 1] = r, a[W.p0 + 2] = t.windSpeed, a[W.p0 + 3] = t.curlStrength, a[W.p1 + 0] = i.pitchDomain, a[W.p1 + 1] = t.displaceAmp, a[W.p1 + 2] = t.springK, a[W.p1 + 3] = i.cols;
+	let s = Math.min(t.waveComponents.length, 8);
+	return o[W.ints + 0] = s, o[W.ints + 1] = i.count, o[W.ints + 2] = i.cols, o[W.ints + 3] = 0, de(a, W.waves, t.waveComponents), e;
+}
+var se = 144, K = {
+	r0: 0,
+	r1: 4,
+	r2: 8,
+	ints: 12,
+	bg: 16,
+	palette: 20
+};
+function q() {
+	let e = new ArrayBuffer(se);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+var J = .22, ce = .4;
+function le(e, t) {
+	let n = (t || 320) / (2 * H);
+	return e / Math.max(n, 1e-4);
+}
+function ue(e, t, n, r, i, a, o) {
+	let { f32: s, i32: l } = e;
+	s[K.r0 + 0] = n, s[K.r0 + 1] = t.contrast, s[K.r0 + 2] = J, s[K.r0 + 3] = H, s[K.r1 + 0] = le(t.dotSize, i), s[K.r1 + 1] = ce, s[K.r1 + 2] = r, s[K.r1 + 3] = a.pitchDomain, s[K.r2 + 0] = t.waveBandCenter, s[K.r2 + 1] = t.waveBandWidth, s[K.r2 + 2] = +!!t.globeMask, s[K.r2 + 3] = 0;
+	let u = Math.min(o.length, 4);
+	if (l[K.ints + 0] = u, l[K.ints + 1] = a.count, l[K.ints + 2] = 0, l[K.ints + 3] = 0, t.background === "transparent") s[K.bg + 0] = 0, s[K.bg + 1] = 0, s[K.bg + 2] = 0, s[K.bg + 3] = 0;
+	else {
+		let e = c(t.background);
+		s[K.bg + 0] = e[0], s[K.bg + 1] = e[1], s[K.bg + 2] = e[2], s[K.bg + 3] = 1;
+	}
+	for (let e = 0; e < 4; e++) {
+		let t = K.palette + e * 4, n = c(o[Math.min(e, u - 1)] ?? o[0]);
+		s[t + 0] = n[0], s[t + 1] = n[1], s[t + 2] = n[2], s[t + 3] = 0;
+	}
+	return e;
+}
+function de(e, t, n) {
+	for (let r = 0; r < 8; r++) {
+		let i = t + r * 4, a = n[r];
+		a ? (e[i + 0] = a.amplitude, e[i + 1] = a.wavelength, e[i + 2] = a.direction, e[i + 3] = a.phase) : (e[i + 0] = 0, e[i + 1] = 1, e[i + 2] = 0, e[i + 3] = 0);
+	}
+}
+function fe(e) {
+	let { cols: t, count: n, pitchDomain: r } = e, i = new Float32Array(n * 4), a = (t - 1) * r / 2;
+	for (let e = 0; e < n; e++) {
+		let n = e % t, o = Math.floor(e / t), s = e * 4;
+		i[s + 0] = n * r - a, i[s + 1] = o * r - a, i[s + 2] = 0, i[s + 3] = 0;
+	}
+	return i;
+}
+//#endregion
+//#region src/components/custom/dot-flow-field/composables/useFlowParticles.ts
+var Y = 64, pe = 128, X = 8, Z = 1, me = 2, Q = 4, he = 64;
+function $(e) {
+	return Math.min(e.clientWidth || 320, e.clientHeight || 320);
+}
+function ge(e) {
+	let { canvas: t, config: n, getPalette: r, shouldContinue: i, onFrame: a } = e;
+	return function(e, s, c) {
+		let l = U(n.gridPitch, $(t)), u = e.createShaderModule({
+			label: "[DotFlowField] flow-field.compute.wgsl",
+			code: v
+		}), d = e.createShaderModule({
+			label: "[DotFlowField] flow-field.render.wgsl",
+			code: y
+		}), f = fe(l), p = e.createBuffer({
+			label: "[DotFlowField] lattice",
+			size: l.count * 16,
+			usage: pe | X,
+			mappedAtCreation: !0
+		});
+		new Float32Array(p.getMappedRange()).set(f), p.unmap();
+		let m = e.createBuffer({
+			label: "[DotFlowField] compute-uniforms",
+			size: G().buffer.byteLength,
+			usage: Y | X
+		}), h = e.createBuffer({
+			label: "[DotFlowField] render-uniforms",
+			size: q().buffer.byteLength,
+			usage: Y | X
+		}), g = e.createBindGroupLayout({
+			label: "[DotFlowField] compute-bgl",
+			entries: [{
+				binding: 0,
+				visibility: Q,
+				buffer: { type: "uniform" }
+			}, {
+				binding: 1,
+				visibility: Q,
+				buffer: { type: "storage" }
+			}]
+		}), _ = e.createComputePipeline({
+			label: "[DotFlowField] compute-pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [g] }),
+			compute: {
+				module: u,
+				entryPoint: "cs_main"
+			}
+		}), b = e.createBindGroup({
+			label: "[DotFlowField] compute-bg",
+			layout: g,
+			entries: [{
+				binding: 0,
+				resource: { buffer: m }
+			}, {
+				binding: 1,
+				resource: { buffer: p }
+			}]
+		}), x = e.createBindGroupLayout({
+			label: "[DotFlowField] render-bgl",
+			entries: [{
+				binding: 0,
+				visibility: Z | me,
+				buffer: { type: "uniform" }
+			}, {
+				binding: 1,
+				visibility: Z,
+				buffer: { type: "read-only-storage" }
+			}]
+		}), S = e.createRenderPipeline({
+			label: "[DotFlowField] render-pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [x] }),
+			vertex: {
+				module: d,
+				entryPoint: "vs_main"
+			},
+			fragment: {
+				module: d,
+				entryPoint: "fs_main",
+				targets: [{
+					format: c,
+					blend: {
+						color: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						},
+						alpha: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						}
+					}
+				}]
+			},
+			primitive: { topology: "triangle-list" }
+		}), C = e.createBindGroup({
+			label: "[DotFlowField] render-bg",
+			layout: x,
+			entries: [{
+				binding: 0,
+				resource: { buffer: h }
+			}, {
+				binding: 1,
+				resource: { buffer: p }
+			}]
+		}), w = G(), T = q(), E = -1;
+		function D() {
+			let e = o(), r = t.clientWidth || 320, i = t.clientHeight || 320, a = Math.max(1, Math.round(r * e)), s = Math.max(1, Math.round(i * e));
+			(t.width !== a || t.height !== s) && (t.width = a, t.height = s);
+			let c = U(n.gridPitch, $(t));
+			l = {
+				...c,
+				count: Math.min(c.count, f.length / 4)
+			};
+		}
+		function O(i) {
+			a?.(i);
+			let o = E < 0 ? 0 : Math.min(Math.max(i - E, 0), .05);
+			E = i;
+			let c = (t.clientWidth || 320) / Math.max(t.clientHeight || 320, 1);
+			oe(w, n, i, o, l), e.queue.writeBuffer(m, 0, w.buffer), ue(T, n, i, c, $(t), l, r()), e.queue.writeBuffer(h, 0, T.buffer);
+			let u = Math.ceil(l.count / he), d = e.createCommandEncoder({ label: "[DotFlowField] frame" }), f = d.beginComputePass();
+			f.setPipeline(_), f.setBindGroup(0, b), f.dispatchWorkgroups(u), f.end();
+			let p = s.getCurrentTexture().createView(), g = d.beginRenderPass({ colorAttachments: [{
+				view: p,
+				clearValue: {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				},
+				loadOp: "clear",
+				storeOp: "store"
+			}] });
+			g.setPipeline(S), g.setBindGroup(0, C), g.draw(6, l.count, 0, 0), g.end(), e.queue.submit([d.finish()]);
+		}
+		return {
+			frame: O,
+			shouldContinue: i,
+			resize: D,
+			teardown: () => {
+				p.destroy(), m.destroy(), h.destroy();
+			}
+		};
+	};
+}
+function _e(e, t, n) {
+	let r = e.createShader(t);
+	if (e.shaderSource(r, n), e.compileShader(r), !e.getShaderParameter(r, e.COMPILE_STATUS)) {
+		let t = e.getShaderInfoLog(r);
+		throw e.deleteShader(r), Error(`[DotFlowField] shader compile failed: ${t}`);
+	}
+	return r;
+}
+function ve(e) {
+	let { canvas: t, config: n, getPalette: r, shouldContinue: i, onFrame: a } = e;
+	return function(e) {
+		let s = _e(e, e.VERTEX_SHADER, b), l = _e(e, e.FRAGMENT_SHADER, x), u = e.createProgram();
+		if (e.attachShader(u, s), e.attachShader(u, l), e.linkProgram(u), !e.getProgramParameter(u, e.LINK_STATUS)) throw Error(`[DotFlowField] link failed: ${e.getProgramInfoLog(u)}`);
+		e.deleteShader(s), e.deleteShader(l);
+		let d = e.createVertexArray();
+		e.bindVertexArray(d);
+		let f = e.createBuffer();
+		e.bindBuffer(e.ARRAY_BUFFER, f), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+			-1,
+			-1,
+			3,
+			-1,
+			-1,
+			3
+		]), e.STATIC_DRAW);
+		let p = e.getAttribLocation(u, "aPosition");
+		e.enableVertexAttribArray(p), e.vertexAttribPointer(p, 2, e.FLOAT, !1, 0, 0), e.bindVertexArray(null);
+		let m = (t) => e.getUniformLocation(u, t), h = m("uTime"), g = m("uWindSpeed"), _ = m("uCurlStrength"), v = m("uDomainHalf"), y = m("uAspect"), S = m("uGridPitchDomain"), C = m("uDotRadiusDomain"), w = m("uDisplaceAmp"), T = m("uContrast"), E = m("uBaseBright"), D = m("uWaveBandCenter"), O = m("uWaveBandWidth"), k = m("uGlobeMask"), A = m("uWaveCount"), j = m("uStopCount"), M = m("uHasBackground"), N = m("uBg"), P = m("uWaves[0]"), F = m("uPalette[0]");
+		function I() {
+			let n = o(), r = t.clientWidth || 320, i = t.clientHeight || 320, a = Math.max(1, Math.round(r * n)), s = Math.max(1, Math.round(i * n));
+			(t.width !== a || t.height !== s) && (t.width = a, t.height = s), e.viewport(0, 0, t.width, t.height);
+		}
+		function L(i) {
+			a?.(i);
+			let o = $(t), s = (t.clientWidth || 320) / Math.max(t.clientHeight || 320, 1), l = U(n.gridPitch, o), f = o / (2 * H), p = n.dotSize / Math.max(f, 1e-4);
+			e.useProgram(u), e.bindVertexArray(d), e.enable(e.BLEND), e.blendFunc(e.ONE, e.ONE_MINUS_SRC_ALPHA), e.clearColor(0, 0, 0, 0), e.clear(e.COLOR_BUFFER_BIT), e.uniform1f(h, i), e.uniform1f(g, n.windSpeed), e.uniform1f(_, n.curlStrength), e.uniform1f(v, H), e.uniform1f(y, s), e.uniform1f(S, l.pitchDomain), e.uniform1f(C, p), e.uniform1f(w, n.displaceAmp), e.uniform1f(T, n.contrast), e.uniform1f(E, J), e.uniform1f(D, n.waveBandCenter), e.uniform1f(O, n.waveBandWidth), e.uniform1f(k, +!!n.globeMask);
+			let m = Math.min(n.waveComponents.length, 8), b = r(), x = Math.min(b.length, 4);
+			if (e.uniform1i(A, m), e.uniform1i(j, x), n.background === "transparent") e.uniform1f(M, 0), e.uniform3f(N, 0, 0, 0);
+			else {
+				e.uniform1f(M, 1);
+				let t = c(n.background);
+				e.uniform3f(N, t[0], t[1], t[2]);
+			}
+			let I = new Float32Array(32);
+			for (let e = 0; e < 8; e++) {
+				let t = n.waveComponents[e];
+				I[e * 4 + 0] = t?.amplitude ?? 0, I[e * 4 + 1] = t?.wavelength ?? 1, I[e * 4 + 2] = t?.direction ?? 0, I[e * 4 + 3] = t?.phase ?? 0;
+			}
+			e.uniform4fv(P, I);
+			let L = new Float32Array(12);
+			for (let e = 0; e < 4; e++) {
+				let t = c(b[Math.min(e, x - 1)] ?? b[0]);
+				L[e * 3 + 0] = t[0], L[e * 3 + 1] = t[1], L[e * 3 + 2] = t[2];
+			}
+			e.uniform3fv(F, L), e.drawArrays(e.TRIANGLES, 0, 3), e.bindVertexArray(null);
+		}
+		return {
+			frame: L,
+			shouldContinue: i,
+			resize: I,
+			teardown: () => {
+				e.deleteProgram(u), e.deleteVertexArray(d), e.deleteBuffer(f);
+			}
+		};
+	};
+}
+//#endregion
+//#region src/components/custom/dot-flow-field/composables/useDotFlowField.ts
+function ye(e, n) {
+	let { config: r, getPalette: i } = n, a = n.mode ?? "live", o = t({ respectReducedMotion: r.respectReducedMotion }), c = {
+		displaceBoost: 1,
+		bloom: 0
+	}, l = { ...r }, u = () => (Object.assign(l, r), l.displaceAmp = r.displaceAmp * c.displaceBoost, l.contrast = r.contrast * (1 + c.bloom * .8), l), d = null, f = 0;
+	function p(e) {
+		let t = f > 0 ? (e - f) * 1e3 : 16.7;
+		if (f = e, o.tick(t), !r.interactive || !o.active.value) {
+			c.displaceBoost += (1 - c.displaceBoost) * .1, c.bloom *= .9;
+			return;
+		}
+		let n = o.speed.value, i = 1 + Math.min(2.5, n * 3);
+		c.displaceBoost += (i - c.displaceBoost) * .2, c.bloom = Math.max(c.bloom * .9, o.burst.value);
+	}
+	let h = () => {
+		o.onPointerEnter(), r.interactive && d?.wake();
+	}, g = (e) => {
+		o.onPointerMove(e), r.interactive && d?.wake();
+	}, _ = (e) => e.parentElement ?? e;
+	function v(e) {
+		let t = _(e);
+		t.addEventListener("pointermove", g), t.addEventListener("pointerenter", h), t.addEventListener("pointerleave", o.onPointerLeave);
+	}
+	function y(e) {
+		let t = _(e);
+		t.removeEventListener("pointermove", g), t.removeEventListener("pointerenter", h), t.removeEventListener("pointerleave", o.onPointerLeave);
+	}
+	let b = () => {
+		let t = e.value;
+		if (!t) return null;
+		if (!d) {
+			v(t);
+			let e = {
+				canvas: t,
+				config: u(),
+				getPalette: i,
+				shouldContinue: () => !0,
+				onFrame: p
+			};
+			d = s(t, {
+				mode: a,
+				respectReducedMotion: r.respectReducedMotion,
+				setupWGPU: ge({
+					...e,
+					config: l,
+					onFrame: (e) => {
+						p(e), u();
+					}
+				}),
+				setupGL: ve({
+					...e,
+					config: l,
+					onFrame: (e) => {
+						p(e), u();
+					}
+				})
+			}), d.armAsync();
+		}
+		return d;
+	};
+	queueMicrotask(() => b());
+	let x = {
+		get backend() {
+			return b()?.backend ?? "webgpu";
+		},
+		pause: () => b()?.suspend("manual"),
+		resume: () => b()?.resume("manual"),
+		wake: () => b()?.wake(),
+		renderAt: (e) => b()?.renderAt(e),
+		get reducedMotion() {
+			return d?.reducedMotion ?? !1;
+		},
+		dispose: () => {
+			let t = e.value;
+			t && y(t), o.dispose(), d?.dispose();
+		}
+	};
+	return m(() => x.dispose()), x;
+}
+//#endregion
+//#region src/components/custom/dot-flow-field/DotFlowField.vue
+var be = /* @__PURE__ */ e(/* @__PURE__ */ f({
+	__name: "DotFlowField",
+	props: {
+		config: { default: () => V },
+		paused: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["update:paused"],
+	setup(e, { expose: t }) {
+		let n = g("canvasRef"), r = ye(n, {
+			config: e.config,
+			getPalette: () => e.config.palette
+		});
+		_(() => e.paused, (e) => e ? r.pause() : r.resume(), { immediate: !0 });
+		let i = l(() => {
+			let t = e.config.background;
+			if (t !== "transparent") return `oklch(${t.L} ${t.C} ${t.h})`;
+		});
+		return t({
+			pause: r.pause,
+			resume: r.resume,
+			wake: r.wake,
+			renderAt: r.renderAt
+		}), (e, t) => (h(), u("div", {
+			class: "dot-flow-field-wrapper",
+			style: p(i.value ? { background: i.value } : void 0)
+		}, [d("canvas", {
+			ref_key: "canvasRef",
+			ref: n,
+			class: "dot-flow-field-canvas",
+			"aria-hidden": "true",
+			"data-testid": "dot-flow-field-canvas"
+		}, null, 512)], 4));
+	}
+}), [["__scopeId", "data-v-01c7721a"]]);
+//#endregion
+export { V as DEFAULT_FLOW_CONFIG, B as DEFAULT_WAVE_COMPONENTS, be as DotFlowField, N as FLOW_DOMAIN_HALF, S as FLOW_GRAVITY, re as MAX_FLOW_STOPS, te as MAX_PARTICLES, ne as MAX_WAVE_COMPONENTS, z as WARM_IDENTITY_PALETTE, R as buildWaveLadder, j as curlFBM, T as gerstnerVelocity, P as gridOrigin, I as sampleDisplacement, F as sampleHeight, M as sampleVelocity, ye as useDotFlowField, L as waveBand };