Catcrafts/Crafter.Graphics
2
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity Actions

feat(webgpu-rt): atomic pixel accumulator + raysPerPixel for >1 ray/pixel/bounce (#30)

Browse source 
wfAccum becomes array<atomic<u32>> (4 slots/pixel, f32 bit patterns — same
16 B/pixel footprint) and rtAccumulate CASes each channel, so N rays for one
pixel may resolve in the same SHADE pass without the read-modify-write
racing. GENERATE clears with atomicStore (bitcast(0.0) == 0u); RESOLVE
atomicLoads + bitcasts the vec4 it hands runResolve.

Capacity half: RTPass::raysPerPixel (default 1) scales the wavefront
ray/hit/payload buffers to raysPerPixel·W·H rays per bounce so the
per-light emits actually fit instead of being dropped by rtEmitRay's
capacity guard. The accumulator stays per-pixel.

No flag-gating: uncontended the CAS succeeds first try — RTStress SHADE
stays at its documented ~1.0 ms and master-vs-branch renders are
byte-identical, so single-ray consumers pay nothing.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
catbot 2026-06-09 22:45:25 +00:00
commit 27d7e84cb3
6 changed files with 89 additions and 19 deletions
Download patch file Download diff file Expand all files Collapse all files

47
additional/dom-webgpu.js
View file

@ -1714,7 +1714,11 @@ struct BvhNode {
@group(1) @binding(10) var<storage,read_write> wfRaysA : array<WfRay>;
@group(1) @binding(11) var<storage,read_write> wfRaysB : array<WfRay>;
@group(1) @binding(12) var<storage,read_write> wfHits : array<HitResult>;
@group(1) @binding(13) var<storage,read_write> wfAccum : array<vec4<f32>>;
// wfAccum: 4 atomic<u32> slots per pixel (RGBA as f32 bit patterns — same
// 16 B/pixel footprint as the old array<vec4<f32>>). Atomic so a SHADE
// invocation may emit N rays for the same pixel in one bounce (e.g. one
// shadow ray per light) and their rtAccumulate calls don't race (#30).
@group(1) @binding(13) var<storage,read_write> wfAccum : array<atomic<u32>>;
@group(1) @binding(14) var<storage,read_write> wfCounters : array<atomic<u32>>;
// @group(1) @binding(15) wfPayload : array<Payload> — emitted by codegen.
@ -1735,11 +1739,29 @@ fn _wfCurCount() -> u32 {
return min(raw, wfParams.rayCapacity);
}
// Add linear radiance to the pixel this SHADE/GENERATE thread owns. Safe
// without atomics: at most one ray per pixel per bounce, and bounces run
// in separate passes (implicit barrier between them).
// Atomic float add via compare-exchange on the f32 bit pattern. WGSL has
// no native atomic<f32>, so each channel CASes until its read-add-write
// wins. Uncontended (the common ≤1 ray/pixel/bounce case) the exchange
// succeeds first try; contention only occurs when several rays for the
// same pixel resolve in one SHADE pass.
fn _wfAtomicAddF32(slot: u32, v: f32) {
var old = atomicLoad(&wfAccum[slot]);
loop {
let sum = bitcast<u32>(bitcast<f32>(old) + v);
let r = atomicCompareExchangeWeak(&wfAccum[slot], old, sum);
if (r.exchanged) { break; }
old = r.old_value;
}
}
// Add linear radiance to the pixel this SHADE/GENERATE thread owns. Atomic,
// so a closest-hit may emit any number of rays for the same pixel within a
// single bounce (multi-light shadowing) and their accumulates won't race.
fn rtAccumulate(rgb: vec3<f32>) {
wfAccum[_wfPixel] = wfAccum[_wfPixel] + vec4<f32>(rgb, 0.0);
let base = _wfPixel * 4u;
_wfAtomicAddF32(base + 0u, rgb.x);
_wfAtomicAddF32(base + 1u, rgb.y);
_wfAtomicAddF32(base + 2u, rgb.z);
}
// raygen → emit the pixel's primary ray. Bounce 0's current buffer is
@ -3030,8 +3052,9 @@ function wfNextPow2(n) {
return p;
}
function ensureWavefrontBuffers(W, H) {
const cap = W * H;
function ensureWavefrontBuffers(W, H, raysPerPixel) {
const rpp = Math.max(1, raysPerPixel | 0);
const cap = W * H * rpp; // per-bounce ray capacity (= WfParams.rayCapacity)
rtState.wf = rtState.wf || { cap: 0 };
const wf = rtState.wf;
if (wf.cap === cap && wf.raysA) return wf;
@ -3041,7 +3064,8 @@ function ensureWavefrontBuffers(W, H) {
wf.raysA = device.createBuffer({ size: cap * 64, usage: S, label: "wf-raysA" });
wf.raysB = device.createBuffer({ size: cap * 64, usage: S, label: "wf-raysB" });
wf.hits = device.createBuffer({ size: cap * 112, usage: S, label: "wf-hits" });
wf.accum = device.createBuffer({ size: cap * 16, usage: S, label: "wf-accum" });
// Accumulator is per *pixel*, not per ray: 4 atomic<u32> (16 B).
wf.accum = device.createBuffer({ size: W * H * 16, usage: S, label: "wf-accum" });
wf.payload = device.createBuffer({ size: 2 * cap * WF_PAYLOAD_BYTES, usage: S, label: "wf-payload" });
wf.counters = device.createBuffer({ size: 64,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC, label: "wf-counters" });
@ -3270,7 +3294,8 @@ function wfUserBindGroups(pipe, handlesPtr, handlesCount) {
env.wgpuDispatchRT = (pipelineHandle, pushPtr, pushBytes,
tlasBufHandle, instanceCount, gx, gy,
handlesPtr, handlesCount, maxDepth, outTexHandle) => {
handlesPtr, handlesCount, maxDepth, outTexHandle,
raysPerPixel) => {
if (!state.encoder) return;
const pipe = rtPipelines.get(pipelineHandle);
const tlas = buffers.get(tlasBufHandle);
@ -3296,9 +3321,9 @@ env.wgpuDispatchRT = (pipelineHandle, pushPtr, pushBytes,
return;
}
const W = state.width, H = state.height;
const cap = W * H;
const depth = Math.max(1, maxDepth | 0);
const wf = ensureWavefrontBuffers(W, H);
const wf = ensureWavefrontBuffers(W, H, raysPerPixel);
const cap = wf.cap; // per-bounce ray capacity = raysPerPixel·W·H
// ── Per-pass WfParams ring. queue.writeBuffer lands before submit, so
// we can't mutate the uniform between passes — instead we pre-write one