Particle updates

Author: tychedelia

Cargo.lock

@@ -212,6 +212,10 @@ path = "examples/camera_controllers.rs"
 name = "compute_readback"
 path = "examples/compute_readback.rs"
 
+[[example]]
+name = "alias_spike"
+path = "examples/alias_spike.rs"
+
 [[example]]
 name = "particles_basic"
 path = "examples/particles_basic.rs"

Cargo.toml

@@ -0,0 +1,23 @@
+struct Params {
+    scale: f32,
+}
+
+@group(0) @binding(0) var<storage, read>       density: array<f32>;
+@group(0) @binding(1) var<storage, read_write> color:   array<f32>;
+@group(0) @binding(2) var<uniform>             params:  Params;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if i >= arrayLength(&density) { return; }
+
+    let t = clamp(density[i] * params.scale, 0.0, 1.0);
+    let cool = vec3<f32>(0.10, 0.22, 0.70);
+    let warm = vec3<f32>(1.00, 0.55, 0.15);
+    let rgb = mix(cool, warm, t) * (0.35 + 1.1 * t);
+
+    color[i * 4u + 0u] = rgb.x;
+    color[i * 4u + 1u] = rgb.y;
+    color[i * 4u + 2u] = rgb.z;
+    color[i * 4u + 3u] = 1.0;
+}

assets/shaders/density_color.wesl

@@ -0,0 +1,65 @@
+struct Params {
+    nx: u32,
+    ny: u32,
+    time: f32,
+    extent: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> color:    array<f32>;
+@group(0) @binding(2) var<storage, read_write> normal:   array<f32>;
+@group(0) @binding(3) var<storage, read_write> indices:  array<u32>;
+@group(0) @binding(4) var<uniform>             params:   Params;
+
+fn height(x: f32, z: f32, t: f32) -> f32 {
+    let r = sqrt(x * x + z * z);
+    return sin(r * 0.8 - t * 2.0) * 1.6 * exp(-r * 0.10)
+         + sin(x * 0.5 + t) * 0.4
+         + cos(z * 0.6 - t * 1.3) * 0.3;
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let nx = params.nx;
+    let ny = params.ny;
+    if i >= nx * ny { return; }
+
+    let gx = i % nx;
+    let gy = i / nx;
+    let x = (f32(gx) / f32(nx - 1u) - 0.5) * params.extent;
+    let z = (f32(gy) / f32(ny - 1u) - 0.5) * params.extent;
+    let t = params.time;
+
+    let h = height(x, z, t);
+    position[i * 3u + 0u] = x;
+    position[i * 3u + 1u] = h;
+    position[i * 3u + 2u] = z;
+
+    let e = 0.12;
+    let hl = height(x - e, z, t);
+    let hr = height(x + e, z, t);
+    let hd = height(x, z - e, t);
+    let hu = height(x, z + e, t);
+    let n = normalize(vec3<f32>(hl - hr, 2.0 * e, hd - hu));
+    normal[i * 3u + 0u] = n.x;
+    normal[i * 3u + 1u] = n.y;
+    normal[i * 3u + 2u] = n.z;
+
+    let c = clamp(h * 0.35 + 0.5, 0.0, 1.0);
+    color[i * 4u + 0u] = 0.15 + 0.75 * c;
+    color[i * 4u + 1u] = 0.30 + 0.45 * (1.0 - abs(c - 0.5) * 2.0);
+    color[i * 4u + 2u] = 0.95 - 0.65 * c;
+    color[i * 4u + 3u] = 1.0;
+
+    if gx + 1u < nx && gy + 1u < ny {
+        let cell = gy * (nx - 1u) + gx;
+        let base = cell * 6u;
+        indices[base + 0u] = i;
+        indices[base + 1u] = i + 1u;
+        indices[base + 2u] = i + nx + 1u;
+        indices[base + 3u] = i;
+        indices[base + 4u] = i + nx + 1u;
+        indices[base + 5u] = i + nx;
+    }
+}

assets/shaders/gen_colored_surface.wesl

@@ -0,0 +1,60 @@
+struct Params {
+    nx: u32,
+    ny: u32,
+    time: f32,
+    extent: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> indices: array<u32>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+fn wave(p: vec2<f32>, dir: vec2<f32>, freq: f32, speed: f32, t: f32) -> f32 {
+    return sin(dot(p, normalize(dir)) * freq + t * speed);
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let nx = params.nx;
+    let ny = params.ny;
+    if i >= nx * ny { return; }
+
+    let gx = i % nx;
+    let gy = i / nx;
+
+    let u = f32(gx) / f32(nx - 1u);
+    let v = f32(gy) / f32(ny - 1u);
+    let x = (u - 0.5) * params.extent;
+    let z = (v - 0.5) * params.extent;
+
+    let t = params.time;
+    let p = vec2(x, z);
+
+    let w1 = wave(p, vec2(1.0, 0.3),  0.6, 0.7, t) * 1.0;
+    let w2 = wave(p, vec2(0.4, 1.0),  0.9, 0.9, t) * 0.6;
+    let w3 = wave(p, vec2(-0.7, 0.6), 1.7, 1.4, t) * 0.3;
+    let w4 = wave(p, vec2(0.9, -0.5), 2.3, 1.8, t) * 0.18;
+    let w5 = wave(p, vec2(-0.2, -1.0), 4.1, 2.6, t) * 0.08;
+    var h = w1 + w2 + w3 + w4 + w5;
+    h = h + 0.25 * h * abs(h);
+
+    position[i * 3u + 0u] = x;
+    position[i * 3u + 1u] = h;
+    position[i * 3u + 2u] = z;
+
+    if gx + 1u < nx && gy + 1u < ny {
+        let cell = gy * (nx - 1u) + gx;
+        let base = cell * 6u;
+        let v00 = i;
+        let v10 = i + 1u;
+        let v01 = i + nx;
+        let v11 = i + nx + 1u;
+        indices[base + 0u] = v00;
+        indices[base + 1u] = v10;
+        indices[base + 2u] = v11;
+        indices[base + 3u] = v00;
+        indices[base + 4u] = v11;
+        indices[base + 5u] = v01;
+    }
+}

assets/shaders/gen_surface.wesl

@@ -0,0 +1,42 @@
+import { lygia::color::space::hsv2rgb::hsv2rgb };
+
+struct Params {
+    count: u32,
+    time: f32,
+    fx: f32,        // frequency ratios
+    fy: f32,
+    fz: f32,
+    loops: f32,     // parameter spans loops * TAU
+    scale: f32,
+    hue_mix: f32,   // 0 = grayscale (black), 1 = rainbow
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<storage, read_write> color:    array<f32>;
+@group(0) @binding(2) var<uniform>             params:   Params;
+
+const TAU: f32 = 6.28318530718;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if i >= params.count { return; }
+
+    let u = f32(i) / f32(params.count);
+    let t = u * TAU * params.loops;
+    let world = vec3<f32>(
+        sin(params.fx * t + params.time * 0.30),
+        sin(params.fy * t + params.time * 0.47),
+        sin(params.fz * t + params.time * 0.23),
+    ) * params.scale;
+    position[i * 3u + 0u] = world.x;
+    position[i * 3u + 1u] = world.y;
+    position[i * 3u + 2u] = world.z;
+
+    let rainbow = hsv2rgb(vec3<f32>(fract(u + params.time * 0.03), 0.75, 1.0));
+    let rgb = mix(vec3<f32>(0.0), rainbow, params.hue_mix);
+    color[i * 4u + 0u] = rgb.x;
+    color[i * 4u + 1u] = rgb.y;
+    color[i * 4u + 2u] = rgb.z;
+    color[i * 4u + 3u] = 1.0;
+}

assets/shaders/plexus_curve.wesl

@@ -0,0 +1,114 @@
+struct GridParams {
+    grid_min: vec3<f32>,
+    cell_size: f32,
+    dims_x: u32,
+    dims_y: u32,
+    dims_z: u32,
+    _pad: u32,
+}
+
+struct Params {
+    connection_radius: f32,
+    connection_ramp: f32,  // falloff exponent
+    line_alpha: f32,       // opacity scale
+    max_links: u32,        // per-particle edge cap
+}
+
+// Auto-bound by apply(): names must be position/color.
+@group(0) @binding(0) var<storage, read>       position:  array<f32>;
+@group(0) @binding(1) var<storage, read>       color:     array<f32>;
+@group(0) @binding(2) var<storage, read_write> edge_pos:  array<f32>;
+@group(0) @binding(3) var<storage, read_write> edge_col:  array<f32>;
+@group(0) @binding(4) var<storage, read_write> indices:   array<u32>;
+@group(0) @binding(5) var<storage, read_write> draw_args: array<atomic<u32>>;
+// Bound by grid.bind().
+@group(0) @binding(6) var<storage, read>       offsets:   array<u32>;
+@group(0) @binding(7) var<storage, read>       sorted:    array<u32>;
+@group(0) @binding(8) var<uniform>             params:    Params;
+@group(0) @binding(9) var<uniform>             gp:        GridParams;
+
+fn cell_coords(p: vec3<f32>, grid_min: vec3<f32>, cell_size: f32, dims: vec3<u32>) -> vec3<i32> {
+    let rel = (p - grid_min) / cell_size;
+    return vec3<i32>(
+        clamp(i32(floor(rel.x)), 0, i32(dims.x) - 1),
+        clamp(i32(floor(rel.y)), 0, i32(dims.y) - 1),
+        clamp(i32(floor(rel.z)), 0, i32(dims.z) - 1),
+    );
+}
+
+fn cell_index(c: vec3<u32>, dims: vec3<u32>) -> u32 {
+    return c.x + c.y * dims.x + c.z * dims.x * dims.y;
+}
+
+fn load_pos(i: u32) -> vec3<f32> {
+    return vec3<f32>(position[i * 3u], position[i * 3u + 1u], position[i * 3u + 2u]);
+}
+
+fn load_rgb(i: u32) -> vec3<f32> {
+    return vec3<f32>(color[i * 4u], color[i * 4u + 1u], color[i * 4u + 2u]);
+}
+
+fn emit_vertex(slot: u32, p: vec3<f32>, rgb: vec3<f32>, a: f32) {
+    edge_pos[slot * 3u + 0u] = p.x;
+    edge_pos[slot * 3u + 1u] = p.y;
+    edge_pos[slot * 3u + 2u] = p.z;
+    edge_col[slot * 4u + 0u] = rgb.x;
+    edge_col[slot * 4u + 1u] = rgb.y;
+    edge_col[slot * 4u + 2u] = rgb.z;
+    edge_col[slot * 4u + 3u] = a;
+    indices[slot] = slot;
+}
+
+@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 cap = arrayLength(&indices);
+    let pos = load_pos(i);
+    let rgb = load_rgb(i);
+    let radius = params.connection_radius;
+    let r2 = radius * radius;
+    let dims = vec3<u32>(gp.dims_x, gp.dims_y, gp.dims_z);
+    let base = cell_coords(pos, gp.grid_min, gp.cell_size, dims);
+
+    let reach = max(1, i32(ceil(radius / gp.cell_size)));
+    let z0 = max(base.z - reach, 0);
+    let z1 = min(base.z + reach, i32(gp.dims_z) - 1);
+    let y0 = max(base.y - reach, 0);
+    let y1 = min(base.y + reach, i32(gp.dims_y) - 1);
+    let x0 = max(base.x - reach, 0);
+    let x1 = min(base.x + reach, i32(gp.dims_x) - 1);
+
+    var emitted = 0u;
+    for (var cz = z0; cz <= z1; cz++) {
+        for (var cy = y0; cy <= y1; cy++) {
+            for (var cx = x0; cx <= x1; cx++) {
+                let cell = cell_index(vec3<u32>(u32(cx), u32(cy), u32(cz)), dims);
+                let start = offsets[cell];
+                let end = offsets[cell + 1u];
+                for (var s = start; s < end; s++) {
+                    let j = sorted[s];
+                    if j <= i { continue; }              // one direction per edge
+                    let pj = load_pos(j);
+                    let diff = pos - pj;
+                    let d2 = dot(diff, diff);
+                    if d2 > r2 { continue; }
+
+                    if emitted >= params.max_links { return; }
+                    emitted += 1u;
+
+                    let d = sqrt(d2);
+                    let a = pow(1.0 / (d / radius + 1.0), params.connection_ramp) * params.line_alpha;
+
+                    let slot = atomicAdd(&draw_args[0], 2u);
+                    if slot + 1u < cap {
+                        emit_vertex(slot, pos, rgb, a);
+                        emit_vertex(slot + 1u, pj, load_rgb(j), a);
+                    }
+                }
+            }
+        }
+    }
+}

assets/shaders/plexus_link.wesl

@@ -55,6 +55,68 @@ pub const LAB: &str = "lab";
 pub const LCH: &str = "lch";
 pub const XYZ: &str = "xyz";
 
+pub const MAP: &str = "map";
+pub const COMBINE: &str = "combine";
+pub const MIX: &str = "mix";
+pub const LOOKUP: &str = "lookup";
+pub const REDUCE: &str = "reduce";
+pub const EXTRACT: &str = "extract";
+pub const PACK: &str = "pack";
+pub const GENERATE: &str = "generate";
+pub const NEIGHBOR: &str = "neighbor";
+
+pub const COUNT: &str = "count";
+pub const DENSITY: &str = "density";
+
+pub const CONSTANT: &str = "constant";
+pub const SMOOTHSTEP: &str = "smoothstep";
+pub const QUADRATIC: &str = "quadratic";
+pub const CUBIC: &str = "cubic";
+pub const INVERSE: &str = "inverse";
+
+pub const AFFINE: &str = "affine";
+pub const ABS: &str = "abs";
+pub const NEGATE: &str = "negate";
+pub const FLOOR: &str = "floor";
+pub const SQRT: &str = "sqrt";
+pub const GREATER: &str = "greater";
+pub const LESS: &str = "less";
+pub const GEQ: &str = "geq";
+pub const LEQ: &str = "leq";
+pub const EQ: &str = "eq";
+pub const NEQ: &str = "neq";
+
+pub const ADD: &str = "add";
+pub const SUB: &str = "sub";
+pub const MUL: &str = "mul";
+pub const DIV: &str = "div";
+pub const POW: &str = "pow";
+
+pub const LENGTH: &str = "length";
+pub const SUM: &str = "sum";
+pub const SUMSQ: &str = "sumsq";
+pub const MEAN: &str = "mean";
+pub const MIN: &str = "min";
+pub const MAX: &str = "max";
+
+pub const UNIFORM: &str = "uniform";
+pub const SIGNED: &str = "signed";
+pub const GAUSSIAN: &str = "gaussian";
+
+pub const NOISE: &str = "noise";
+pub const TRANSFORM: &str = "transform";
+pub const ATTRACT: &str = "attract";
+pub const DRAG: &str = "drag";
+pub const VORTEX: &str = "vortex";
+pub const FORCE: &str = "force";
+pub const INTEGRATE: &str = "integrate";
+pub const AGE: &str = "age";
+pub const IMPULSE: &str = "impulse";
+pub const ORIENT: &str = "orient";
+pub const FIELD: &str = "field";
+pub const BOUNDS_SPHERE: &str = "bounds_sphere";
+pub const BOUNDS_BOX: &str = "bounds_box";
+
 pub const PI: f32 = std::f32::consts::PI;
 pub const TWO_PI: f32 = std::f32::consts::TAU;
 pub const HALF_PI: f32 = std::f32::consts::FRAC_PI_2;