@plasius/gpu-particles 0.1.0

package/src/effects/fire/prelude.wgsl

@@ -0,0 +1,41 @@
+// Fire effect shared WGSL definitions.
+
+struct Particle {
+  pos: vec4<f32>, // x, y, life, seed
+  vel: vec4<f32>, // vx, vy, kind, value
+};
+
+struct EffectParams {
+  time: f32,
+  dt: f32,
+  intensity: f32,
+  spawn_radius: f32,
+  bounds_min: vec2<f32>,
+  bounds_max: vec2<f32>,
+  origin: vec2<f32>,
+  drift: vec2<f32>,
+};
+
+@group(1) @binding(0) var<storage, read_write> particles: array<Particle>;
+@group(1) @binding(1) var<uniform> effect_params: EffectParams;
+
+const TWO_PI: f32 = 6.2831853;
+
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
+}
+
+fn rand01(seed: u32) -> f32 {
+  let v = hash_u32(seed) & 0x00ffffffu;
+  return f32(v) / 16777216.0;
+}
+
+fn rand_signed(seed: u32) -> f32 {
+  return rand01(seed) * 2.0 - 1.0;
+}

package/src/effects/fire/render.job.wgsl

@@ -0,0 +1,8 @@
+// Fire render job placeholder (rendering handled on the CPU in the demo).
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  let _ignore = job_index + job_type + payload_words;
+  if (_ignore == 0u) {
+    return;
+  }
+}

package/src/effects/firework/prelude.wgsl

@@ -0,0 +1,41 @@
+// Firework effect shared WGSL definitions.
+
+struct Particle {
+  pos: vec4<f32>,
+  vel: vec4<f32>,
+};
+
+struct EffectParams {
+  time: f32,
+  dt: f32,
+  intensity: f32,
+  spawn_radius: f32,
+  bounds_min: vec2<f32>,
+  bounds_max: vec2<f32>,
+  origin: vec2<f32>,
+  drift: vec2<f32>,
+};
+
+@group(1) @binding(0) var<storage, read_write> particles: array<Particle>;
+@group(1) @binding(1) var<uniform> effect_params: EffectParams;
+
+const TWO_PI: f32 = 6.2831853;
+
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
+}
+
+fn rand01(seed: u32) -> f32 {
+  let v = hash_u32(seed) & 0x00ffffffu;
+  return f32(v) / 16777216.0;
+}
+
+fn rand_signed(seed: u32) -> f32 {
+  return rand01(seed) * 2.0 - 1.0;
+}

package/src/effects/firework/render.job.wgsl

@@ -0,0 +1,8 @@
+// Firework render job placeholder.
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  let _ignore = job_index + job_type + payload_words;
+  if (_ignore == 0u) {
+    return;
+  }
+}

package/src/effects/firework/update.job.wgsl

@@ -0,0 +1,154 @@
+// Firework update job: explosions with sparks, smoke, and ash.
+
+const KIND_SPARK: f32 = 0.0;
+const KIND_SMOKE: f32 = 1.0;
+const KIND_ASH: f32 = 2.0;
+
+const PATHS: array<vec2<f32>, 20> = array<vec2<f32>, 20>(
+  vec2<f32>(1.0, 0.0),
+  vec2<f32>(0.92, 0.38),
+  vec2<f32>(0.71, 0.71),
+  vec2<f32>(0.38, 0.92),
+  vec2<f32>(0.0, 1.0),
+  vec2<f32>(-0.38, 0.92),
+  vec2<f32>(-0.71, 0.71),
+  vec2<f32>(-0.92, 0.38),
+  vec2<f32>(-1.0, 0.0),
+  vec2<f32>(-0.92, -0.38),
+  vec2<f32>(-0.71, -0.71),
+  vec2<f32>(-0.38, -0.92),
+  vec2<f32>(0.0, -1.0),
+  vec2<f32>(0.38, -0.92),
+  vec2<f32>(0.71, -0.71),
+  vec2<f32>(0.92, -0.38),
+  vec2<f32>(0.98, 0.2),
+  vec2<f32>(0.2, 0.98),
+  vec2<f32>(-0.98, 0.2),
+  vec2<f32>(-0.2, 0.98)
+);
+
+fn respawn_firework(seed: u32, burst_seed: u32) -> Particle {
+  let r2 = rand01(seed ^ 0x9e3779b9u);
+  let radius = effect_params.spawn_radius * sqrt(r2);
+  let intensity = clamp(effect_params.intensity, 0.1, 2.0);
+  let scale = 0.2 + rand01(seed ^ 0x3c6ef372u) * 0.8;
+  let size = clamp(scale * intensity, 0.15, 0.95);
+  let raw_count = 5u + u32(floor(size * 15.0));
+  let path_count = min(20u, max(5u, raw_count));
+  let path_index = hash_u32(seed ^ burst_seed) % path_count;
+  let path_dir = normalize(PATHS[path_index]);
+  let offset = path_dir * (radius * 0.15);
+  let base = effect_params.origin + offset;
+
+  let kind_roll = rand01(seed ^ 0x85ebca6bu);
+  var kind = KIND_SPARK;
+  var life = 0.9 + rand01(seed ^ 0x27d4eb2du) * 1.1;
+  var speed = (0.8 + rand01(seed ^ 0xc2b2ae35u) * 2.2) * scale * (0.7 + intensity * 0.3);
+  var vel = path_dir * speed;
+
+  if (kind_roll > 0.78) {
+    kind = KIND_SMOKE;
+    life = 1.8 + rand01(seed ^ 0x51a3c1u) * 2.0;
+    speed = 0.08 + rand01(seed ^ 0x94d049bdu) * 0.25;
+    vel = vec2<f32>(
+      rand_signed(seed ^ 0x7f4a7c15u) * 0.06,
+      0.06 + rand01(seed ^ 0x165667b1u) * 0.18
+    );
+  } else if (kind_roll > 0.6) {
+    kind = KIND_ASH;
+    life = 1.2 + rand01(seed ^ 0x846ca68bu) * 1.4;
+    speed = 0.12 + rand01(seed ^ 0x6c8e9cf5u) * 0.35;
+    vel = vec2<f32>(
+      rand_signed(seed ^ 0x1b873593u) * 0.18,
+      0.18 + rand01(seed ^ 0x27d4eb2du) * 0.28
+    );
+  }
+
+  let perp = vec2<f32>(-path_dir.y, path_dir.x);
+  vel = vel + perp * rand_signed(seed ^ 0x632be5abu) * 0.08 * scale;
+  vel.y = vel.y + (0.45 + rand01(seed ^ 0x632be5abu) * 0.55) * scale;
+
+  let color_roll = rand01(seed ^ 0x9e3779b9u);
+  var color_index = floor(color_roll * 3.0);
+  if (color_roll > 0.92) {
+    color_index = 3.0;
+  }
+
+  return Particle(vec4<f32>(base, life, f32(seed)), vec4<f32>(vel, kind, color_index + size));
+}
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  if (payload_words == 0u) {
+    return;
+  }
+  let particle_index = payload_word(job_index, 0u);
+  if (particle_index >= arrayLength(&particles)) {
+    return;
+  }
+
+  var particle = particles[particle_index];
+  var life = particle.pos.z;
+  let seed = u32(particle.pos.w) ^ (particle_index * 173u);
+
+  let burst_id = u32(effect_params.time * 0.6);
+  let burst_seed = burst_id * 0x9e3779b9u;
+  let burst_phase = fract(effect_params.time * 0.6);
+
+  if (life <= 0.0) {
+    let chance = rand01(seed ^ burst_seed ^ 0x85ebca6bu);
+    let window = burst_phase < 0.08;
+    let threshold = select(0.995, 0.7 - effect_params.intensity * 0.2, window);
+    if (chance > threshold) {
+      particle = respawn_firework(seed + burst_seed, burst_seed);
+      particles[particle_index] = particle;
+    }
+    return;
+  }
+
+  let kind = particle.vel.z;
+  let color_index = floor(particle.vel.w);
+  let size = clamp(particle.vel.w - color_index, 0.0, 1.5);
+  var pos = particle.pos.xy;
+  var vel = particle.vel.xy;
+
+  if (kind == KIND_SPARK) {
+    var gravity = 1.1 + color_index * 0.2;
+    let drag = 0.985 - size * 0.01;
+    if (color_index >= 3.0) {
+      gravity = 0.85;
+      vel.x = vel.x + sin(effect_params.time * 3.0 + f32(seed) * 0.01) * 0.02;
+    }
+    vel.y = vel.y - gravity * effect_params.dt;
+    vel = vel * drag;
+    life = life - effect_params.dt * (1.1 + size * 0.4);
+  } else if (kind == KIND_SMOKE) {
+    let sway = rand_signed(seed ^ u32(effect_params.time * 900.0)) * 0.02;
+    vel.x = vel.x + (effect_params.drift.x * 0.15 + sway) * effect_params.dt;
+    vel.y = vel.y - 0.05 * effect_params.dt;
+    vel = vel * 0.989;
+    life = life - effect_params.dt * 0.55;
+  } else {
+    vel.y = vel.y - (0.7 + color_index * 0.05) * effect_params.dt;
+    vel.x = vel.x + effect_params.drift.x * effect_params.dt * 0.3;
+    vel = vel * 0.99;
+    life = life - effect_params.dt * 0.75;
+  }
+
+  pos = pos + vel * effect_params.dt;
+
+  if (pos.y < effect_params.bounds_min.y - 0.2 || pos.y > effect_params.bounds_max.y + 0.3 || pos.x < effect_params.bounds_min.x - 0.2 || pos.x > effect_params.bounds_max.x + 0.2) {
+    life = -1.0;
+  }
+
+  particle.pos = vec4<f32>(pos, life, f32(seed));
+  particle.vel = vec4<f32>(vel, kind, particle.vel.w);
+
+  if (life <= 0.0) {
+    let chance = rand01(seed ^ burst_seed ^ 0x27d4eb2du);
+    if (chance > 0.985) {
+      particle = respawn_firework(seed + 59u + burst_seed, burst_seed);
+    }
+  }
+
+  particles[particle_index] = particle;
+}

package/src/effects/rain/prelude.wgsl

@@ -0,0 +1,35 @@
+// Rain effect shared WGSL definitions.
+
+struct Particle {
+  pos: vec4<f32>,
+  vel: vec4<f32>,
+};
+
+struct EffectParams {
+  time: f32,
+  dt: f32,
+  intensity: f32,
+  spawn_radius: f32,
+  bounds_min: vec2<f32>,
+  bounds_max: vec2<f32>,
+  origin: vec2<f32>,
+  drift: vec2<f32>,
+};
+
+@group(1) @binding(0) var<storage, read_write> particles: array<Particle>;
+@group(1) @binding(1) var<uniform> effect_params: EffectParams;
+
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
+}
+
+fn rand01(seed: u32) -> f32 {
+  let v = hash_u32(seed) & 0x00ffffffu;
+  return f32(v) / 16777216.0;
+}

package/src/effects/rain/render.job.wgsl

@@ -0,0 +1,8 @@
+// Rain render job placeholder.
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  let _ignore = job_index + job_type + payload_words;
+  if (_ignore == 0u) {
+    return;
+  }
+}

package/src/effects/rain/update.job.wgsl

@@ -0,0 +1,51 @@
+// Rain update job.
+
+fn rand_signed(seed: u32) -> f32 {
+  return rand01(seed) * 2.0 - 1.0;
+}
+
+fn respawn_rain(seed: u32) -> Particle {
+  let x = effect_params.origin.x + rand_signed(seed) * effect_params.spawn_radius;
+  let y = effect_params.origin.y + rand01(seed ^ 0x9e3779b9u) * 0.1;
+  let speed = 0.7 + rand01(seed ^ 0x85ebca6bu) * 1.2;
+  let vel = vec2<f32>(effect_params.drift.x * 0.2, -speed);
+  return Particle(vec4<f32>(vec2<f32>(x, y), 1.0, f32(seed)), vec4<f32>(vel, 0.0, 0.0));
+}
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  if (payload_words == 0u) {
+    return;
+  }
+  let particle_index = payload_word(job_index, 0u);
+  if (particle_index >= arrayLength(&particles)) {
+    return;
+  }
+
+  var particle = particles[particle_index];
+  var life = particle.pos.z;
+  let seed = u32(particle.pos.w) ^ (particle_index * 97u);
+
+  if (life <= 0.0) {
+    particle = respawn_rain(seed + u32(effect_params.time * 400.0));
+    particles[particle_index] = particle;
+    return;
+  }
+
+  var pos = particle.pos.xy;
+  var vel = particle.vel.xy;
+  vel.x = vel.x + effect_params.drift.x * effect_params.dt * 0.3;
+  pos = pos + vel * effect_params.dt;
+
+  if (pos.y < effect_params.bounds_min.y - 0.1) {
+    life = -1.0;
+  }
+
+  particle.pos = vec4<f32>(pos, life, f32(seed));
+  particle.vel = vec4<f32>(vel, particle.vel.z, particle.vel.w);
+
+  if (life <= 0.0) {
+    particle = respawn_rain(seed + 13u + u32(effect_params.time * 700.0));
+  }
+
+  particles[particle_index] = particle;
+}

package/src/effects/snow/prelude.wgsl

@@ -0,0 +1,35 @@
+// Snow effect shared WGSL definitions.
+
+struct Particle {
+  pos: vec4<f32>,
+  vel: vec4<f32>,
+};
+
+struct EffectParams {
+  time: f32,
+  dt: f32,
+  intensity: f32,
+  spawn_radius: f32,
+  bounds_min: vec2<f32>,
+  bounds_max: vec2<f32>,
+  origin: vec2<f32>,
+  drift: vec2<f32>,
+};
+
+@group(1) @binding(0) var<storage, read_write> particles: array<Particle>;
+@group(1) @binding(1) var<uniform> effect_params: EffectParams;
+
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
+}
+
+fn rand01(seed: u32) -> f32 {
+  let v = hash_u32(seed) & 0x00ffffffu;
+  return f32(v) / 16777216.0;
+}

package/src/effects/snow/render.job.wgsl

@@ -0,0 +1,8 @@
+// Snow render job placeholder.
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  let _ignore = job_index + job_type + payload_words;
+  if (_ignore == 0u) {
+    return;
+  }
+}

package/src/effects/snow/update.job.wgsl

@@ -0,0 +1,53 @@
+// Snow update job.
+
+fn rand_signed(seed: u32) -> f32 {
+  return rand01(seed) * 2.0 - 1.0;
+}
+
+fn respawn_snow(seed: u32) -> Particle {
+  let x = effect_params.origin.x + rand_signed(seed) * effect_params.spawn_radius;
+  let y = effect_params.origin.y + rand01(seed ^ 0x9e3779b9u) * 0.1;
+  let speed = 0.12 + rand01(seed ^ 0x85ebca6bu) * 0.2;
+  let drift = rand_signed(seed ^ 0x27d4eb2du) * 0.05;
+  let vel = vec2<f32>(drift + effect_params.drift.x * 0.2, -speed);
+  return Particle(vec4<f32>(vec2<f32>(x, y), 1.0, f32(seed)), vec4<f32>(vel, 0.0, 0.0));
+}
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  if (payload_words == 0u) {
+    return;
+  }
+  let particle_index = payload_word(job_index, 0u);
+  if (particle_index >= arrayLength(&particles)) {
+    return;
+  }
+
+  var particle = particles[particle_index];
+  var life = particle.pos.z;
+  let seed = u32(particle.pos.w) ^ (particle_index * 67u);
+
+  if (life <= 0.0) {
+    particle = respawn_snow(seed + u32(effect_params.time * 200.0));
+    particles[particle_index] = particle;
+    return;
+  }
+
+  var pos = particle.pos.xy;
+  var vel = particle.vel.xy;
+  let sway = sin(effect_params.time * 0.8 + f32(seed) * 0.01) * 0.02;
+  vel.x = vel.x + sway + effect_params.drift.x * effect_params.dt * 0.4;
+  pos = pos + vel * effect_params.dt;
+
+  if (pos.y < effect_params.bounds_min.y - 0.1) {
+    life = -1.0;
+  }
+
+  particle.pos = vec4<f32>(pos, life, f32(seed));
+  particle.vel = vec4<f32>(vel, particle.vel.z, particle.vel.w);
+
+  if (life <= 0.0) {
+    particle = respawn_snow(seed + 29u + u32(effect_params.time * 300.0));
+  }
+
+  particles[particle_index] = particle;
+}

package/src/effects/sparks/prelude.wgsl

@@ -0,0 +1,41 @@
+// Sparks effect shared WGSL definitions.
+
+struct Particle {
+  pos: vec4<f32>,
+  vel: vec4<f32>,
+};
+
+struct EffectParams {
+  time: f32,
+  dt: f32,
+  intensity: f32,
+  spawn_radius: f32,
+  bounds_min: vec2<f32>,
+  bounds_max: vec2<f32>,
+  origin: vec2<f32>,
+  drift: vec2<f32>,
+};
+
+@group(1) @binding(0) var<storage, read_write> particles: array<Particle>;
+@group(1) @binding(1) var<uniform> effect_params: EffectParams;
+
+const TWO_PI: f32 = 6.2831853;
+
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
+}
+
+fn rand01(seed: u32) -> f32 {
+  let v = hash_u32(seed) & 0x00ffffffu;
+  return f32(v) / 16777216.0;
+}
+
+fn rand_signed(seed: u32) -> f32 {
+  return rand01(seed) * 2.0 - 1.0;
+}

package/src/effects/sparks/render.job.wgsl

@@ -0,0 +1,8 @@
+// Sparks render job placeholder.
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  let _ignore = job_index + job_type + payload_words;
+  if (_ignore == 0u) {
+    return;
+  }
+}

package/src/effects/sparks/update.job.wgsl

@@ -0,0 +1,53 @@
+// Sparks update job.
+
+fn respawn_spark(seed: u32) -> Particle {
+  let angle = rand01(seed) * TWO_PI;
+  let speed = 0.5 + rand01(seed ^ 0x9e3779b9u) * 1.6;
+  let radius = effect_params.spawn_radius * rand01(seed ^ 0x85ebca6bu);
+  let offset = vec2<f32>(cos(angle), sin(angle)) * radius;
+  let pos = effect_params.origin + offset;
+  let vel = vec2<f32>(cos(angle), sin(angle)) * speed;
+  let life = 0.3 + rand01(seed ^ 0x27d4eb2du) * 0.7;
+  return Particle(vec4<f32>(pos, life, f32(seed)), vec4<f32>(vel, 1.0, 0.0));
+}
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  if (payload_words == 0u) {
+    return;
+  }
+  let particle_index = payload_word(job_index, 0u);
+  if (particle_index >= arrayLength(&particles)) {
+    return;
+  }
+
+  var particle = particles[particle_index];
+  var life = particle.pos.z;
+  let seed = u32(particle.pos.w) ^ (particle_index * 131u);
+
+  if (life <= 0.0) {
+    particle = respawn_spark(seed + u32(effect_params.time * 500.0));
+    particles[particle_index] = particle;
+    return;
+  }
+
+  var vel = particle.vel.xy;
+  var pos = particle.pos.xy;
+  vel.y = vel.y - 1.4 * effect_params.dt + effect_params.drift.y * effect_params.dt;
+  vel.x = vel.x + effect_params.drift.x * effect_params.dt;
+  vel = vel * 0.985;
+  pos = pos + vel * effect_params.dt;
+  life = life - effect_params.dt * 1.5;
+
+  if (pos.y < effect_params.bounds_min.y - 0.2 || pos.y > effect_params.bounds_max.y + 0.2) {
+    life = -1.0;
+  }
+
+  particle.pos = vec4<f32>(pos, life, f32(seed));
+  particle.vel = vec4<f32>(vel, particle.vel.z, particle.vel.w);
+
+  if (life <= 0.0) {
+    particle = respawn_spark(seed + 19u + u32(effect_params.time * 700.0));
+  }
+
+  particles[particle_index] = particle;
+}

package/src/effects/text/layout.job.wgsl

@@ -0,0 +1,57 @@
+// Text layout job.
+
+fn respawn_text(seed: u32) -> Particle {
+  let x = effect_params.origin.x + rand_signed(seed) * effect_params.spawn_radius;
+  let y = effect_params.origin.y + rand01(seed ^ 0x9e3779b9u) * 0.05;
+  let value = f32(hash_u32(seed) % 10000u);
+  let lateral = rand_signed(seed ^ 0x85ebca6bu) * 0.12;
+  let upward = 0.55 + rand01(seed ^ 0x27d4eb2du) * 0.45;
+  let vel = vec2<f32>(lateral, upward);
+  let life = 2.2 + rand01(seed ^ 0x51a3c1u) * 1.2;
+  return Particle(vec4<f32>(vec2<f32>(x, y), life, f32(seed)), vec4<f32>(vel, 0.0, value));
+}
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  if (payload_words == 0u) {
+    return;
+  }
+  let particle_index = payload_word(job_index, 0u);
+  if (particle_index >= arrayLength(&particles)) {
+    return;
+  }
+
+  var particle = particles[particle_index];
+  var life = particle.pos.z;
+  let seed = u32(particle.pos.w) ^ (particle_index * 113u);
+
+  if (life <= 0.0) {
+    let burst = rand01(seed ^ u32(effect_params.time * 120.0));
+    if (burst > 0.985) {
+      particle = respawn_text(seed + u32(effect_params.time * 600.0));
+      particles[particle_index] = particle;
+    }
+    return;
+  }
+
+  var pos = particle.pos.xy;
+  var vel = particle.vel.xy;
+  let dir = select(-1.0, 1.0, pos.x >= effect_params.origin.x);
+  vel.x = vel.x + dir * 0.18 * effect_params.dt;
+  vel.x = vel.x + effect_params.drift.x * effect_params.dt * 0.05;
+  vel.y = vel.y - 0.95 * effect_params.dt;
+  vel = vel * 0.995;
+  pos = pos + vel * effect_params.dt;
+
+  if (pos.y < effect_params.bounds_min.y - 0.1 || pos.x < effect_params.bounds_min.x - 0.1 || pos.x > effect_params.bounds_max.x + 0.1) {
+    life = -1.0;
+  }
+
+  particle.pos = vec4<f32>(pos, life, f32(seed));
+  particle.vel = vec4<f32>(vel, particle.vel.z, particle.vel.w);
+
+  if (life <= 0.0) {
+    particle = respawn_text(seed + 37u + u32(effect_params.time * 500.0));
+  }
+
+  particles[particle_index] = particle;
+}

package/src/effects/text/prelude.wgsl

@@ -0,0 +1,39 @@
+// Text overlay effect shared WGSL definitions.
+
+struct Particle {
+  pos: vec4<f32>,
+  vel: vec4<f32>,
+};
+
+struct EffectParams {
+  time: f32,
+  dt: f32,
+  intensity: f32,
+  spawn_radius: f32,
+  bounds_min: vec2<f32>,
+  bounds_max: vec2<f32>,
+  origin: vec2<f32>,
+  drift: vec2<f32>,
+};
+
+@group(1) @binding(0) var<storage, read_write> particles: array<Particle>;
+@group(1) @binding(1) var<uniform> effect_params: EffectParams;
+
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
+}
+
+fn rand01(seed: u32) -> f32 {
+  let v = hash_u32(seed) & 0x00ffffffu;
+  return f32(v) / 16777216.0;
+}
+
+fn rand_signed(seed: u32) -> f32 {
+  return rand01(seed) * 2.0 - 1.0;
+}

package/src/effects/text/render.job.wgsl

@@ -0,0 +1,8 @@
+// Text render job placeholder.
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  let _ignore = job_index + job_type + payload_words;
+  if (_ignore == 0u) {
+    return;
+  }
+}