Compute Particle System (WebGPU @compute pattern)

Math essence

Per-particle update each step: vel += gravity; vel *= drag; pos += vel; pos reflected on wall; life += 1; if life >= life_max then respawn at centre with radial outward velocity and randomised hue seed. Canvas fades geometrically and each live particle splats a 5x5 weighted Gaussian point coloured by its current HSV(per-particle seed + step drift).

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/anadol_webgpu/computeParticleSystem/reference.py

"""computeParticleSystem — WebGPU compute-shader particle system.

This is the canonical "compute-to-render" pattern in WebGPU: a
@compute shader updates N particles in a storage buffer, and a
separate render pass draws them as point sprites.  Here we implement
the same algorithm in numpy as a faithful reference implementation
of the GPU loop.

Each particle has:
    pos: vec2f
    vel: vec2f
    life: f32 (in [0, life_max])
    seed: u32  (per-particle hue)

Every step the compute shader does:
    vel += gravity_and_drag(pos, vel, life, t);     // simple Verlet-ish
    pos += vel;
    vel *= drag;
    life += dt;
    if (life > life_max) reset particle to a new born state;

After the compute pass we render the live particles as glowing points
with colour = hsv(seed + life_normalised).  The numpy analogue updates
the same arrays with vectorised ops — semantically one thread per
particle.

Reference: WebGPU compute pattern as documented at
- https://www.mysimulator.uk/content/articles/webgpu-compute.html
- https://dev.to/dev48v/webgpu-i-simulated-250000-particles-entirely-on-the-gpu-in-the-browser-2o0f
- https://www.abratabia.com/webgpu/compute-shaders.php
- https://www.cg.tuwien.ac.at/research/publications/2023/PETER-2023-PSW/PETER-2023-PSW-.pdf
"""
from __future__ import annotations

from typing import ClassVar

import numpy as np


class ComputeParticleSystem:
    """WebGPU compute-shader style particle system (numpy reference).

    Parameters
    ----------
    dim : int
        Square canvas side length (px).
    num_particles : int
        Number of particles N.
    life_max : int
        Steps before a particle is "reset" (born anew at the centre
        with a random outward velocity).
    gravity : float
        Constant downward acceleration per step (per particle).
    drag : float
        Per-step velocity damping (1.0 = no damping).
    spawn_radius : float
        Radius (in pixels) inside which a respawning particle lands.
    workgroup_size : int
        For documentation only — this is the WebGPU @workgroup_size
        that an equivalent @compute shader would use.  Stored so the