Skip to main content

qualia_extensions/webgpu_extension/
shaders.rs

1//! WGSL **kernel specs** mirroring the CPU reference solvers.
2//!
3//! These are the GPU dispatch kernels for the physics in this module. They are
4//! provided as the authoritative description of the per-cell update; the CPU
5//! solvers in the sibling files are the verifiable reference (analytic-solution
6//! tested) and are what runs when no GPU is present. A GPU run routes through
7//! the core engine's shared `wgpu` device rather than a second device here.
8
9/// 2D incompressible Navier–Stokes — advection + viscous diffusion + pressure
10/// gradient (the projection/Poisson pass runs as a separate Jacobi kernel).
11/// Stencils use the true grid spacing `dx`/`dy` (`1/h²`), unlike the old mock.
12pub const NAVIER_STOKES_2D: &str = r#"
13struct SimParams {
14    dt: f32,
15    viscosity: f32,
16    dx: f32,
17    dy: f32,
18    nx: u32,
19    ny: u32,
20    _pad0: u32,
21    _pad1: u32,
22};
23
24@group(0) @binding(0) var<storage, read>        vel_in:  array<vec2<f32>>;
25@group(0) @binding(1) var<storage, read>        p_in:    array<f32>;
26@group(0) @binding(2) var<storage, read_write>  vel_out: array<vec2<f32>>;
27@group(0) @binding(3) var<uniform>              params:  SimParams;
28
29fn widx(ix: i32, iy: i32) -> u32 {
30    let nx = i32(params.nx);
31    let ny = i32(params.ny);
32    let x = ((ix % nx) + nx) % nx;
33    let y = ((iy % ny) + ny) % ny;
34    return u32(y * nx + x);
35}
36
37@compute @workgroup_size(16, 16, 1)
38fn navier_stokes(@builtin(global_invocation_id) gid: vec3<u32>) {
39    if (gid.x >= params.nx || gid.y >= params.ny) { return; }
40    let ix = i32(gid.x);
41    let iy = i32(gid.y);
42    let c = widx(ix, iy);
43
44    let v  = vel_in[c];
45    let vE = vel_in[widx(ix + 1, iy)];
46    let vW = vel_in[widx(ix - 1, iy)];
47    let vN = vel_in[widx(ix, iy + 1)];
48    let vS = vel_in[widx(ix, iy - 1)];
49
50    let inv_dx2 = 1.0 / (params.dx * params.dx);
51    let inv_dy2 = 1.0 / (params.dy * params.dy);
52
53    let lap = (vE + vW - 2.0 * v) * inv_dx2 + (vN + vS - 2.0 * v) * inv_dy2;
54
55    let dudx = (vE - vW) / (2.0 * params.dx);
56    let dudy = (vN - vS) / (2.0 * params.dy);
57    let adv  = vec2<f32>(v.x * dudx.x + v.y * dudy.x, v.x * dudx.y + v.y * dudy.y);
58
59    let pE = p_in[widx(ix + 1, iy)];
60    let pW = p_in[widx(ix - 1, iy)];
61    let pN = p_in[widx(ix, iy + 1)];
62    let pS = p_in[widx(ix, iy - 1)];
63    let grad_p = vec2<f32>((pE - pW) / (2.0 * params.dx), (pN - pS) / (2.0 * params.dy));
64
65    vel_out[c] = v + params.dt * (-adv + params.viscosity * lap - grad_p);
66}
67"#;
68
69/// 1D electromagnetics — the Yee FDTD leap-frog (Ey/Hz). One workgroup pass
70/// advances Hz, the next advances Ey; the host alternates them per step.
71pub const MAXWELL_FDTD_1D: &str = r#"
72struct EmParams {
73    dt: f32,
74    dx: f32,
75    eps: f32,
76    mu: f32,
77    sigma: f32,
78    n: u32,
79    stage: u32,   // 0 = update Hz, 1 = update Ey
80    _pad: u32,
81};
82
83@group(0) @binding(0) var<storage, read_write> ey: array<f32>;
84@group(0) @binding(1) var<storage, read_write> hz: array<f32>;
85@group(0) @binding(2) var<uniform>             p:  EmParams;
86
87@compute @workgroup_size(64, 1, 1)
88fn maxwell_fdtd(@builtin(global_invocation_id) gid: vec3<u32>) {
89    let i = gid.x;
90    if (i >= p.n) { return; }
91    let n = p.n;
92    if (p.stage == 0u) {
93        let ip1 = select(i + 1u, 0u, i + 1u >= n);
94        hz[i] = hz[i] - (p.dt / (p.mu * p.dx)) * (ey[ip1] - ey[i]);
95    } else {
96        let im1 = select(i - 1u, n - 1u, i == 0u);
97        ey[i] = ey[i] - (p.dt / (p.eps * p.dx)) * (hz[i] - hz[im1])
98                      - (p.dt * p.sigma / p.eps) * ey[i];
99    }
100}
101"#;
102
103/// 2D heat diffusion — explicit forward-Euler 5-point Laplacian.
104pub const HEAT_DIFFUSION_2D: &str = r#"
105struct HeatParams { dt: f32, alpha: f32, dx: f32, dy: f32, nx: u32, ny: u32, _p0: u32, _p1: u32, };
106@group(0) @binding(0) var<storage, read>       u_in:  array<f32>;
107@group(0) @binding(1) var<storage, read_write> u_out: array<f32>;
108@group(0) @binding(2) var<uniform>             params: HeatParams;
109
110fn hidx(ix: i32, iy: i32) -> u32 {
111    let nx = i32(params.nx); let ny = i32(params.ny);
112    let x = ((ix % nx) + nx) % nx; let y = ((iy % ny) + ny) % ny;
113    return u32(y * nx + x);
114}
115
116@compute @workgroup_size(16, 16, 1)
117fn heat(@builtin(global_invocation_id) gid: vec3<u32>) {
118    if (gid.x >= params.nx || gid.y >= params.ny) { return; }
119    let ix = i32(gid.x); let iy = i32(gid.y);
120    let c = hidx(ix, iy);
121    let lap = (u_in[hidx(ix + 1, iy)] + u_in[hidx(ix - 1, iy)] - 2.0 * u_in[c]) / (params.dx * params.dx)
122            + (u_in[hidx(ix, iy + 1)] + u_in[hidx(ix, iy - 1)] - 2.0 * u_in[c]) / (params.dy * params.dy);
123    u_out[c] = u_in[c] + params.dt * params.alpha * lap;
124}
125"#;
126
127/// 2D wave equation — explicit leap-frog (u_old / u / u_new triple buffer).
128pub const WAVE_EQUATION_2D: &str = r#"
129struct WaveParams { c: f32, dt: f32, dx: f32, dy: f32, nx: u32, ny: u32, _p0: u32, _p1: u32, };
130@group(0) @binding(0) var<storage, read>       u_old: array<f32>;
131@group(0) @binding(1) var<storage, read>       u_cur: array<f32>;
132@group(0) @binding(2) var<storage, read_write> u_new: array<f32>;
133@group(0) @binding(3) var<uniform>             params: WaveParams;
134
135fn vwidx(ix: i32, iy: i32) -> u32 {
136    let nx = i32(params.nx); let ny = i32(params.ny);
137    let x = ((ix % nx) + nx) % nx; let y = ((iy % ny) + ny) % ny;
138    return u32(y * nx + x);
139}
140
141@compute @workgroup_size(16, 16, 1)
142fn wave(@builtin(global_invocation_id) gid: vec3<u32>) {
143    if (gid.x >= params.nx || gid.y >= params.ny) { return; }
144    let ix = i32(gid.x); let iy = i32(gid.y);
145    let c = vwidx(ix, iy);
146    let lap = (u_cur[vwidx(ix + 1, iy)] + u_cur[vwidx(ix - 1, iy)] - 2.0 * u_cur[c]) / (params.dx * params.dx)
147            + (u_cur[vwidx(ix, iy + 1)] + u_cur[vwidx(ix, iy - 1)] - 2.0 * u_cur[c]) / (params.dy * params.dy);
148    let coef = params.c * params.dt * params.c * params.dt;
149    u_new[c] = 2.0 * u_cur[c] - u_old[c] + coef * lap;
150}
151"#;