Externalize all example shaders.

Author: tychedelia

assets/shaders/flocking_duck_flock.wesl

@@ -0,0 +1,82 @@
+struct Params {
+    neighbor_dist: f32,
+    separation_dist: f32,
+    max_speed: f32,
+    max_force: f32,
+    home_radius: f32,
+    _pad0: f32,
+    _pad1: f32,
+    _pad2: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> velocity: array<f32>;
+@group(0) @binding(2) var<storage, read_write> home: array<f32>;
+@group(0) @binding(3) var<storage, read_write> steer: array<f32>;
+@group(0) @binding(4) var<uniform> params: Params;
+
+fn limit(v: vec3<f32>, max_len: f32) -> vec3<f32> {
+    let len = length(v);
+    if len > max_len { return v * (max_len / len); }
+    return v;
+}
+
+// Reynolds: steering = desired - velocity
+fn steer_toward(desired: vec3<f32>, vel: vec3<f32>) -> vec3<f32> {
+    let len = length(desired);
+    if len < 1e-6 { return vec3<f32>(0.0); }
+    return limit(desired * (params.max_speed / len) - vel, params.max_force);
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let count = arrayLength(&position) / 3u;
+    if i >= count { return; }
+
+    let pos = vec3<f32>(position[i * 3u], position[i * 3u + 1u], position[i * 3u + 2u]);
+    let vel = vec3<f32>(velocity[i * 3u], velocity[i * 3u + 1u], velocity[i * 3u + 2u]);
+
+    var separation = vec3<f32>(0.0);
+    var alignment = vec3<f32>(0.0);
+    var cohesion = vec3<f32>(0.0);
+    var separation_count = 0u;
+    var neighbor_count = 0u;
+
+    for (var j = 0u; j < count; j = j + 1u) {
+        if j == i { continue; }
+        let other = vec3<f32>(position[j * 3u], position[j * 3u + 1u], position[j * 3u + 2u]);
+        let d = distance(pos, other);
+        if d > 0.0 && d < params.separation_dist {
+            // Point away from the neighbor, weighted by closeness
+            separation = separation + normalize(pos - other) / d;
+            separation_count = separation_count + 1u;
+        }
+        if d < params.neighbor_dist {
+            alignment = alignment
+                + vec3<f32>(velocity[j * 3u], velocity[j * 3u + 1u], velocity[j * 3u + 2u]);
+            cohesion = cohesion + other;
+            neighbor_count = neighbor_count + 1u;
+        }
+    }
+
+    var force = vec3<f32>(0.0);
+    if separation_count > 0u {
+        force = force + steer_toward(separation / f32(separation_count), vel) * 1.5;
+    }
+    if neighbor_count > 0u {
+        force = force + steer_toward(alignment, vel);
+        force = force + steer_toward(cohesion / f32(neighbor_count) - pos, vel);
+    }
+
+    // The tether: inside home_radius the weight is < 1 and flocking wins;
+    // past it the pull grows quadratically until it dominates everything.
+    let home_pos = vec3<f32>(home[i * 3u], home[i * 3u + 1u], home[i * 3u + 2u]);
+    let to_home = home_pos - pos;
+    let w = length(to_home) / params.home_radius;
+    force = force + steer_toward(to_home, vel) * min(w * w, 8.0);
+
+    steer[i * 3u] = force.x;
+    steer[i * 3u + 1u] = force.y;
+    steer[i * 3u + 2u] = force.z;
+}

assets/shaders/flocking_duck_integrate.wesl

@@ -0,0 +1,51 @@
+struct Params {
+    dt: f32,
+    max_speed: f32,
+    _pad0: f32,
+    _pad1: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> velocity: array<f32>;
+@group(0) @binding(2) var<storage, read_write> steer: array<f32>;
+@group(0) @binding(3) var<storage, read_write> rotation: array<f32>;
+@group(0) @binding(4) var<uniform> params: Params;
+
+// shortest-arc quaternion rotating the mesh's +Z axis onto dir
+fn quat_z_to(dir: vec3<f32>) -> vec4<f32> {
+    let z = vec3<f32>(0.0, 0.0, 1.0);
+    let d = dot(z, dir);
+    if d < -0.9999 { return vec4<f32>(0.0, 1.0, 0.0, 0.0); }
+    return normalize(vec4<f32>(cross(z, dir), 1.0 + d));
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let count = arrayLength(&position) / 3u;
+    if i >= count { return; }
+
+    var pos = vec3<f32>(position[i * 3u], position[i * 3u + 1u], position[i * 3u + 2u]);
+    var vel = vec3<f32>(velocity[i * 3u], velocity[i * 3u + 1u], velocity[i * 3u + 2u]);
+    let force = vec3<f32>(steer[i * 3u], steer[i * 3u + 1u], steer[i * 3u + 2u]);
+
+    vel = vel + force * params.dt;
+    let speed = length(vel);
+    if speed > params.max_speed { vel = vel * (params.max_speed / speed); }
+    pos = pos + vel * params.dt;
+
+    position[i * 3u] = pos.x;
+    position[i * 3u + 1u] = pos.y;
+    position[i * 3u + 2u] = pos.z;
+    velocity[i * 3u] = vel.x;
+    velocity[i * 3u + 1u] = vel.y;
+    velocity[i * 3u + 2u] = vel.z;
+
+    if speed > 1e-6 {
+        let q = quat_z_to(vel / speed);
+        rotation[i * 4u] = q.x;
+        rotation[i * 4u + 1u] = q.y;
+        rotation[i * 4u + 2u] = q.z;
+        rotation[i * 4u + 3u] = q.w;
+    }
+}

assets/shaders/flocking_gpu_flock.wesl

@@ -0,0 +1,70 @@
+struct Params {
+    neighbor_dist: f32,
+    separation_dist: f32,
+    max_speed: f32,
+    max_force: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> velocity: array<f32>;
+@group(0) @binding(2) var<storage, read_write> steer: array<f32>;
+@group(0) @binding(3) var<uniform> params: Params;
+
+fn limit(v: vec3<f32>, max_len: f32) -> vec3<f32> {
+    let len = length(v);
+    if len > max_len { return v * (max_len / len); }
+    return v;
+}
+
+// Reynolds: steering = desired - velocity
+fn steer_toward(desired: vec3<f32>, vel: vec3<f32>) -> vec3<f32> {
+    let len = length(desired);
+    if len < 1e-6 { return vec3<f32>(0.0); }
+    return limit(desired * (params.max_speed / len) - vel, params.max_force);
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let count = arrayLength(&position) / 3u;
+    if i >= count { return; }
+
+    let pos = vec3<f32>(position[i * 3u], position[i * 3u + 1u], position[i * 3u + 2u]);
+    let vel = vec3<f32>(velocity[i * 3u], velocity[i * 3u + 1u], velocity[i * 3u + 2u]);
+
+    var separation = vec3<f32>(0.0);
+    var alignment = vec3<f32>(0.0);
+    var cohesion = vec3<f32>(0.0);
+    var separation_count = 0u;
+    var neighbor_count = 0u;
+
+    for (var j = 0u; j < count; j = j + 1u) {
+        if j == i { continue; }
+        let other = vec3<f32>(position[j * 3u], position[j * 3u + 1u], position[j * 3u + 2u]);
+        let d = distance(pos, other);
+        if d > 0.0 && d < params.separation_dist {
+            // Point away from the neighbor, weighted by closeness
+            separation = separation + normalize(pos - other) / d;
+            separation_count = separation_count + 1u;
+        }
+        if d < params.neighbor_dist {
+            alignment = alignment
+                + vec3<f32>(velocity[j * 3u], velocity[j * 3u + 1u], velocity[j * 3u + 2u]);
+            cohesion = cohesion + other;
+            neighbor_count = neighbor_count + 1u;
+        }
+    }
+
+    var force = vec3<f32>(0.0);
+    if separation_count > 0u {
+        force = force + steer_toward(separation / f32(separation_count), vel) * 1.5;
+    }
+    if neighbor_count > 0u {
+        force = force + steer_toward(alignment, vel);
+        force = force + steer_toward(cohesion / f32(neighbor_count) - pos, vel);
+    }
+
+    steer[i * 3u] = force.x;
+    steer[i * 3u + 1u] = force.y;
+    steer[i * 3u + 2u] = force.z;
+}

assets/shaders/flocking_gpu_integrate.wesl

@@ -0,0 +1,55 @@
+struct Params {
+    dt: f32,
+    max_speed: f32,
+    bound: f32,
+    _pad: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> velocity: array<f32>;
+@group(0) @binding(2) var<storage, read_write> steer: array<f32>;
+@group(0) @binding(3) var<storage, read_write> rotation: array<f32>;
+@group(0) @binding(4) var<uniform> params: Params;
+
+// shortest-arc quaternion rotating the mesh's +Z axis onto dir
+fn quat_z_to(dir: vec3<f32>) -> vec4<f32> {
+    let z = vec3<f32>(0.0, 0.0, 1.0);
+    let d = dot(z, dir);
+    if d < -0.9999 { return vec4<f32>(0.0, 1.0, 0.0, 0.0); }
+    return normalize(vec4<f32>(cross(z, dir), 1.0 + d));
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let count = arrayLength(&position) / 3u;
+    if i >= count { return; }
+
+    var pos = vec3<f32>(position[i * 3u], position[i * 3u + 1u], position[i * 3u + 2u]);
+    var vel = vec3<f32>(velocity[i * 3u], velocity[i * 3u + 1u], velocity[i * 3u + 2u]);
+    let force = vec3<f32>(steer[i * 3u], steer[i * 3u + 1u], steer[i * 3u + 2u]);
+
+    vel = vel + force * params.dt;
+    let speed = length(vel);
+    if speed > params.max_speed { vel = vel * (params.max_speed / speed); }
+    pos = pos + vel * params.dt;
+
+    // wrap into [-bound, bound]: ((p + b) mod 2b + 2b) mod 2b - b
+    let span = 2.0 * params.bound;
+    pos = ((pos + params.bound) % span + span) % span - params.bound;
+
+    position[i * 3u] = pos.x;
+    position[i * 3u + 1u] = pos.y;
+    position[i * 3u + 2u] = pos.z;
+    velocity[i * 3u] = vel.x;
+    velocity[i * 3u + 1u] = vel.y;
+    velocity[i * 3u + 2u] = vel.z;
+
+    if speed > 1e-6 {
+        let q = quat_z_to(vel / speed);
+        rotation[i * 4u] = q.x;
+        rotation[i * 4u + 1u] = q.y;
+        rotation[i * 4u + 2u] = q.z;
+        rotation[i * 4u + 3u] = q.w;
+    }
+}

assets/shaders/particles_animated_spin.wesl

@@ -0,0 +1,21 @@
+struct Params {
+    dt: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<uniform> params: Params;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let count = arrayLength(&position) / 3u;
+    if i >= count {
+        return;
+    }
+    let cs = cos(params.dt);
+    let sn = sin(params.dt);
+    let x = position[i * 3u + 0u];
+    let z = position[i * 3u + 2u];
+    position[i * 3u + 0u] = x * cs - z * sn;
+    position[i * 3u + 2u] = x * sn + z * cs;
+}

assets/shaders/particles_emit_gpu_motion.wesl

@@ -0,0 +1,37 @@
+struct Params {
+    dt: f32,
+    ttl: f32,
+    gravity: f32,
+    _pad: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> velocity: array<f32>;
+@group(0) @binding(2) var<storage, read_write> scale: array<f32>;
+@group(0) @binding(3) var<storage, read_write> age: array<f32>;
+@group(0) @binding(4) var<storage, read_write> life: array<f32>;
+@group(0) @binding(5) var<uniform> params: Params;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let count = arrayLength(&age);
+    if i >= count { return; }
+    if life[i] <= 0.0 { return; }
+
+    age[i] = age[i] + params.dt;
+
+    velocity[i * 3u + 1u] = velocity[i * 3u + 1u] - params.gravity * params.dt;
+
+    position[i * 3u + 0u] = position[i * 3u + 0u] + velocity[i * 3u + 0u] * params.dt;
+    position[i * 3u + 1u] = position[i * 3u + 1u] + velocity[i * 3u + 1u] * params.dt;
+    position[i * 3u + 2u] = position[i * 3u + 2u] + velocity[i * 3u + 2u] * params.dt;
+
+    let remaining = clamp(1.0 - age[i] / params.ttl, 0.0, 1.0);
+    let s = remaining * remaining;
+    scale[i * 3u + 0u] = s;
+    scale[i * 3u + 1u] = s;
+    scale[i * 3u + 2u] = s;
+
+    if age[i] > params.ttl { life[i] = 0.0; }
+}

assets/shaders/particles_emit_gpu_spawn.wesl

@@ -0,0 +1,65 @@
+struct Spawn {
+    pos: vec4<f32>,
+    speed: vec4<f32>,
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> velocity: array<f32>;
+@group(0) @binding(2) var<storage, read_write> color: array<f32>;
+@group(0) @binding(3) var<storage, read_write> scale: array<f32>;
+@group(0) @binding(4) var<storage, read_write> age: array<f32>;
+@group(0) @binding(5) var<storage, read_write> life: array<f32>;
+@group(0) @binding(6) var<uniform> spawn: Spawn;
+@group(0) @binding(7) var<uniform> emit_base: u32;
+@group(0) @binding(8) var<uniform> emit_count: u32;
+@group(0) @binding(9) var<uniform> emit_capacity: u32;
+
+fn hash(n: u32) -> u32 {
+    var x = n;
+    x = (x ^ 61u) ^ (x >> 16u);
+    x = x + (x << 3u);
+    x = x ^ (x >> 4u);
+    x = x * 0x27d4eb2du;
+    x = x ^ (x >> 15u);
+    return x;
+}
+
+fn hash_unit(n: u32) -> f32 {
+    return f32(hash(n)) / f32(0xffffffffu);
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let local_i = gid.x;
+    if local_i >= emit_count { return; }
+    let slot = (emit_base + local_i) % emit_capacity;
+
+    let seed = emit_base + local_i;
+
+    let theta = hash_unit(seed) * 6.2831853;
+    let r     = sqrt(hash_unit(seed * 2u + 1u));
+    let dirxz = vec2<f32>(cos(theta), sin(theta)) * r;
+    let dy    = 0.7 + 0.3 * hash_unit(seed * 3u + 7u);
+    let v     = vec3<f32>(dirxz.x, dy, dirxz.y) * spawn.speed.x;
+
+    position[slot * 3u + 0u] = spawn.pos.x;
+    position[slot * 3u + 1u] = spawn.pos.y;
+    position[slot * 3u + 2u] = spawn.pos.z;
+
+    velocity[slot * 3u + 0u] = v.x;
+    velocity[slot * 3u + 1u] = v.y;
+    velocity[slot * 3u + 2u] = v.z;
+
+    let h = fract(hash_unit(seed * 5u + 11u));
+    color[slot * 4u + 0u] = 0.5 + 0.5 * sin(h * 6.28);
+    color[slot * 4u + 1u] = 0.5 + 0.5 * sin(h * 6.28 + 2.094);
+    color[slot * 4u + 2u] = 0.5 + 0.5 * sin(h * 6.28 + 4.189);
+    color[slot * 4u + 3u] = 1.0;
+
+    scale[slot * 3u + 0u] = 1.0;
+    scale[slot * 3u + 1u] = 1.0;
+    scale[slot * 3u + 2u] = 1.0;
+
+    age[slot]  = 0.0;
+    life[slot] = 1.0;
+}