Fluids S2 (spike): one GPU particle system on WebGPU and WebGL2

[pasquelin]

Why

Spike S2 of the fluids parent. It decides whether one particle API can serve both renderers.

To do

• Search first. Reuse any engine sprite or particle path. The open world's rain and particles (moving to pasquelin/Trillion3D-openworld) are prior art only, never imported.
• One GPU particle system
  • Fixed capacity per pool; buffers allocated once; ring-buffer emission with no CPU compaction.
  • WebGL2: position and velocity in half-float ping-pong textures (GLSL). WebGPU: a compute shader (WGSL). The emission API is the same on both.
  • Rendering with no global sort: fire is additive; smoke is premultiplied alpha with a coarse sort per emitter.
  • Soft particles (fade with depth), and flipbooks interpolated between frames with motion vectors.
  • Previous state kept for temporal antialiasing (one extra position), and a reactive mask.
• Measure capacity, cost per tier and TAA ghosting on both renderers.

Proof

A GO or NO-GO on a single API, with numbers per renderer and per tier, published as a comment on this issue.

Links

Fluids parent #417. Blocked by #395.

[pasquelin]

Split by the CTO: #420 keeps (a), one particle pool and emission API with the GPU update on both renderers, its fast tests and the bench scene. (b) drawing without a global sort → #755; (c) TAA integration and the GO/NO-GO → #756 (blocked by #755). If (a) alone passes ~500 lines, tell the CTO before the coder starts.

[pasquelin]

taken by lead physics — scope (a) of the CTO's split: pool, emission, GPU update on both renderers; drawing is #755, TAA/flipbooks #756.

[pasquelin]

Design note (lead physics), scope (a):

• Approach: one engine-internal particle pool (sdk-core: capacity, ring-buffer emission cursor, the emission record — spawn position/velocity/lifetime — written into a fixed staging buffer; no CPU compaction: a dead particle is skipped by age on the GPU). Two backends behind the same interface: WebGPU a WGSL compute pass (position, velocity, age in one storage buffer allocated once), WebGL2 half-float RGBA ping-pong textures updated by a GLSL full-screen pass (transform feedback not used). Emission and update run in the frame's existing pre-draw step of each renderer (next to the water's GPU work, webgpu/water/), timed as their own pass (passesGpu). No public API yet: object.fire/smoke is Fluids P2: GPU particles, fire, smoke flipbooks, heat distortion, wind API #423's; the bench reaches the pool through the internal entry the bench already uses for measured worlds. Search first: no engine particle path exists (sprites are page-geometry clusters); the open world's particles are not read into the code.
• Budget: capacity fixed per pool at creation (tiers: 16k / 64k / 256k particles, to be confirmed by the numbers); zero allocation per frame; no GPU→CPU read.
• Paths: WebGPU compute and WebGL2 fragment ping-pong; no CPU cut; the WebGL2 path needs EXT_color_buffer_half_float or _float (probe of Fluids S0 (spike): capabilities, budgets, refraction source, envelope method #418) and refuses the pool by name without it.
• Scenes: fast tests of the ring (wrap, cursor, emission beyond capacity overwrites the oldest) and of the shared interface on both backends' CPU halves; the bench's --scene fluids gains a particles switch (capacity per tier) and an update-only control; the measurer publishes capacity and update cost per tier on both renderers.
• Size: estimated ~530 hand-written lines; the coder stops before the review skills if it passes 600.

[pasquelin]

Scope change (lead physics, on the CTO's word): the bench's particles switch moves to #755 (it measures drawn particles there). The coder's branch measured 730 lines for (a); the WebGL2 backend is proposed to the CTO as its own issue; #420 keeps the pool, the shared backend interface, the WebGPU compute step and the world wiring.

[pasquelin]

Split again by the CTO: the WebGL2 half-float backend, its composer hook and the precision rule (emitter-relative positions) move to 759. #420 keeps the pool, the shared backend interface, the WebGPU compute step, the world wiring and their tests.