use crate::materials::shared_passes::PassShader;
pub(crate) const UNIFORMS: &str = "FluidParams";
pub(crate) static FLUID: std::sync::LazyLock<PassShader> = std::sync::LazyLock::new(|| {
crate::passes! {
struct FluidParams {
texel_size: vec2f,
point: vec2f,
dye_texel_size: vec2f,
dt: f32,
dissipation: f32,
curl: f32,
aspect_ratio: f32,
color: vec4f,
curve: vec4f,
radius: f32,
value: f32,
flags: u32,
pad: u32,
}
const FLAG_SHADING: u32 = 1u32;
const FLAG_BLOOM: u32 = 2u32;
const FLAG_SUNRAYS: u32 = 4u32;
const FLAG_ENCODE: u32 = 8u32;
fn copy(i: Frag) -> vec4f {
return tex_a(i.uv);
}
fn clear(i: Frag) -> vec4f {
return u.value * tex_a(i.uv);
}
fn undo_srgb(c: vec3f) -> vec3f {
if ((u.flags & FLAG_ENCODE) == 0u32) {
return c;
}
let m = clamp(c, vec3f(0.0), vec3f(1.0));
let lo = m / 12.92;
let hi = pow((m + vec3f(0.055)) / 1.055, vec3f(2.4));
return select(hi, lo, m <= vec3f(0.04045));
}
fn color(i: Frag) -> vec4f {
return vec4f(undo_srgb(u.color.rgb), u.color.a);
}
fn checkerboard(i: Frag) -> vec4f {
let cell = floor(i.uv * 25.0 * vec2f(u.aspect_ratio, 1.0));
let v = 2.0 * fract((cell.x + cell.y) * 0.5) * 0.1 + 0.8;
return vec4f(undo_srgb(vec3f(v)), 1.0);
}
fn splat(i: Frag) -> vec4f {
var acc = vec3f(0.0);
var sub = vec3f(0.0);
let n = u32(u.value);
for (var k = 0u32; k < n; k += 1u32) {
let a = batch(k * 2u32);
let b = batch(k * 2u32 + 1u32);
var p = i.uv - a.xy;
p.x = p.x * u.aspect_ratio;
let d = dot(p, p);
if (d < a.z * 12.0) {
let g = exp(-d / a.z);
acc = acc + g * b.rgb * (1.0 - b.a);
sub = sub + g * abs(b.rgb) * b.a;
}
}
let out = tex_a(i.uv).rgb + acc;
return vec4f(max(out - sub, min(out, vec3f(0.0))), 1.0);
}
fn advection(i: Frag) -> vec4f {
let coord = i.uv - u.dt * tex_a(i.uv).xy * u.texel_size;
let result = tex_b(coord);
let decay = 1.0 + u.dissipation * u.dt;
return result / decay;
}
fn advect_correct(i: Frag) -> vec4f {
let v = tex_a(i.uv).xy * (u.dt * u.texel_size);
let fwd = tex_b(i.uv);
let back = tex_b(i.uv + v);
let src = tex_c(i.uv);
var corrected = fwd + 0.5 * (src - back);
let coord = i.uv - v;
let t = u.dye_texel_size;
let st = coord / t - 0.5;
let base = (floor(st) + 0.5) * t;
let s00 = tex_c(base);
let s10 = tex_c(base + vec2f(t.x, 0.0));
let s01 = tex_c(base + vec2f(0.0, t.y));
let s11 = tex_c(base + t);
let lo = min(min(s00, s10), min(s01, s11));
let hi = max(max(s00, s10), max(s01, s11));
corrected = clamp(corrected, lo, hi);
let decay = 1.0 + u.dissipation * u.dt;
return corrected / decay;
}
fn divergence(i: Frag) -> vec4f {
var l = tex_a(i.vl).x;
var r = tex_a(i.vr).x;
var t = tex_a(i.vt).y;
var b = tex_a(i.vb).y;
let c = tex_a(i.uv).xy;
if (i.vl.x < 0.0) { l = -c.x; }
if (i.vr.x > 1.0) { r = -c.x; }
if (i.vt.y > 1.0) { t = -c.y; }
if (i.vb.y < 0.0) { b = -c.y; }
return vec4f(0.5 * (r - l + t - b), 0.0, 0.0, 1.0);
}
fn curl(i: Frag) -> vec4f {
let l = tex_a(i.vl).y;
let r = tex_a(i.vr).y;
let t = tex_a(i.vt).x;
let b = tex_a(i.vb).x;
return vec4f(0.5 * (r - l - t + b), 0.0, 0.0, 1.0);
}
fn vorticity(i: Frag) -> vec4f {
let l = tex_b(i.vl).x;
let r = tex_b(i.vr).x;
let t = tex_b(i.vt).x;
let b = tex_b(i.vb).x;
let c = tex_b(i.uv).x;
var force = 0.5 * vec2f(abs(t) - abs(b), abs(r) - abs(l));
force = force / (length(force) + 0.0001);
force = force * (u.curl * c);
force.y = -force.y;
var velocity = tex_a(i.uv).xy;
velocity = velocity + force * u.dt;
velocity = clamp(velocity, vec2f(-1000.0), vec2f(1000.0));
return vec4f(velocity, 0.0, 1.0);
}
fn pressure(i: Frag) -> vec4f {
let l = tex_a(i.vl).x;
let r = tex_a(i.vr).x;
let t = tex_a(i.vt).x;
let b = tex_a(i.vb).x;
let c = tex_a(i.uv).x;
let divergence = tex_b(i.uv).x;
let jacobi = (l + r + b + t - divergence) * 0.25;
return vec4f(mix(c, jacobi, u.value), 0.0, 0.0, 1.0);
}
fn residual(i: Frag) -> vec4f {
let l = tex_a(i.vl).x;
let r = tex_a(i.vr).x;
let t = tex_a(i.vt).x;
let b = tex_a(i.vb).x;
let c = tex_a(i.uv).x;
let rhs = tex_b(i.uv).x;
return vec4f(rhs - (l + r + t + b - 4.0 * c), 0.0, 0.0, 1.0);
}
fn restriction(i: Frag) -> vec4f {
let h = u.texel_size * 0.5;
var sum = tex_a(i.uv + vec2f(-h.x, -h.y)).x;
sum = sum + tex_a(i.uv + vec2f(h.x, -h.y)).x;
sum = sum + tex_a(i.uv + vec2f(-h.x, h.y)).x;
sum = sum + tex_a(i.uv + vec2f(h.x, h.y)).x;
return vec4f(sum, 0.0, 0.0, 1.0);
}
fn prolong(i: Frag) -> vec4f {
let coarse = tex_a(i.uv).x;
let fine = tex_b(i.uv).x;
return vec4f(fine + coarse, 0.0, 0.0, 1.0);
}
fn gradient(i: Frag) -> vec4f {
let l = tex_a(i.vl).x;
let r = tex_a(i.vr).x;
let t = tex_a(i.vt).x;
let b = tex_a(i.vb).x;
var velocity = tex_b(i.uv).xy;
velocity = velocity - u.value * vec2f(r - l, t - b);
return vec4f(velocity, 0.0, 1.0);
}
fn bloom_prefilter(i: Frag) -> vec4f {
var c = tex_a(i.uv).rgb;
let br = max(c.r, max(c.g, c.b));
var rq = clamp(br - u.curve.x, 0.0, u.curve.y);
rq = u.curve.z * rq * rq;
c = c * (max(rq, br - u.curve.w) / max(br, 0.0001));
return vec4f(c, 0.0);
}
fn bloom_blur(i: Frag) -> vec4f {
var sum = tex_a(i.vl);
sum = sum + tex_a(i.vr);
sum = sum + tex_a(i.vt);
sum = sum + tex_a(i.vb);
return sum * 0.25;
}
fn bloom_final(i: Frag) -> vec4f {
var sum = tex_a(i.vl);
sum = sum + tex_a(i.vr);
sum = sum + tex_a(i.vt);
sum = sum + tex_a(i.vb);
return sum * 0.25 * u.value;
}
fn sunrays_mask(i: Frag) -> vec4f {
var c = tex_a(i.uv);
let br = max(c.r, max(c.g, c.b));
c.a = 1.0 - min(max(br * 20.0, 0.0), 0.8);
return c;
}
fn sunrays(i: Frag) -> vec4f {
let density = 0.3;
let decay = 0.95;
let exposure = 0.7;
let iterations = 16i32;
var coord = i.uv;
let dir = (i.uv - vec2f(0.5)) * (1.0 / f32(iterations) * density);
var illumination = 1.0;
var color = tex_a(i.uv).a;
for (var k = 0i32; k < iterations; k += 1i32) {
coord = coord - dir;
color = color + tex_a(coord).a * illumination * u.value;
illumination = illumination * decay;
}
return vec4f(color * exposure, 0.0, 0.0, 1.0);
}
fn blur(i: Frag) -> vec4f {
var sum = tex_a(i.uv) * 0.29411764;
sum = sum + tex_a(i.vl) * 0.35294117;
sum = sum + tex_a(i.vr) * 0.35294117;
return sum;
}
fn linear_to_gamma(c: vec3f) -> vec3f {
let m = max(c, vec3f(0.0));
return max(1.055 * pow(m, vec3f(0.416666667)) - 0.055, vec3f(0.0));
}
fn dither(p: vec2f) -> f32 {
return fract(52.9829189 * fract(0.06711056 * p.x + 0.00583715 * p.y));
}
fn display(i: Frag) -> vec4f {
var c = tex_a(i.uv).rgb;
if ((u.flags & FLAG_SHADING) != 0u32) {
let lc = tex_a(i.vl).rgb;
let rc = tex_a(i.vr).rgb;
let tc = tex_a(i.vt).rgb;
let bc = tex_a(i.vb).rgb;
let dx = length(rc) - length(lc);
let dy = length(tc) - length(bc);
let n = normalize(vec3f(dx, dy, length(u.texel_size)));
let diffuse = clamp(dot(n, vec3f(0.0, 0.0, 1.0)) + 0.7, 0.7, 1.0);
c = c * diffuse;
}
var bloom = vec3f(0.0);
let has_bloom = (u.flags & FLAG_BLOOM) != 0u32;
if (has_bloom) {
bloom = tex_b(i.uv).rgb;
}
if ((u.flags & FLAG_SUNRAYS) != 0u32) {
let rays = tex_c(i.uv).r;
c = c * rays;
bloom = bloom * rays;
}
if (has_bloom) {
bloom = bloom + vec3f((dither(i.pos.xy) * 2.0 - 1.0) / 255.0);
bloom = linear_to_gamma(bloom);
c = c + bloom;
}
let a = max(c.r, max(c.g, c.b));
return vec4f(undo_srgb(c), a);
}
}
});
#[cfg(feature = "fluid")]
const OVERLAY: &str = crate::wgsl!(
r#"
@fragment
fn fs_overlay(i : VsOut) -> @location(0) vec4<f32> {
let a = read_out(i.pos.xy, u.value);
if (a > 0.0) {
return vec4<f32>(1.0, 1.0, 1.0, a);
}
// `pass_tex_a` is the frame-time history for this pass, not the dye.
let bar = chart(i.pos.xy, pass_tex_a, u.radius, u.curl);
if (bar.a <= 0.0) {
discard;
}
return bar;
}
"#
);
#[cfg(feature = "fluid")]
pub(crate) fn wgsl() -> String {
let passes = FLUID.wgsl(UNIFORMS).expect("the fluid's passes translate");
format!("{}\n{passes}\n{OVERLAY}", super::read_out::glyphs())
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests {
#[test]
fn the_fluid_module_validates_and_translates_for_webgl2() {
use crate::materials::shared_passes::{assert_webgl2, entry_points};
let mut entries = entry_points(&super::FLUID);
entries.push((naga::ShaderStage::Fragment, "fs_overlay".into()));
assert_webgl2(&super::wgsl(), &entries);
}
}