qualia_extensions/webgpu_extension/
shaders.rs1pub 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
69pub 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
103pub 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
127pub 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"#;