ReSTIR GI reservoirs

A one-sample diffuse bounce does not fail as pixel grain. It *boils*: every frame the cosine ray lands somewhere else, the wall's indirect term jumps, and accumulation smears it into a crawling stain. Averaging cannot help — an averaged colour is welded to the shading point that produced it.

ReSTIR (Ouyang et al. 2021) carries the **sample** instead: the vertex the bounce ray hit, its normal, the radiance leaving it, and enough bookkeeping to re-weight it for the surface the pixel is shading now. A sample can be re-evaluated at a new shading point; a colour cannot. Hence six full-resolution images and a block of the descriptor set.

Six fields: the secondary vertex `x_s`, its normal `n_s`, the outgoing radiance `L_o` toward the primary hit, the RIS weight sum `wSum`, a confidence count `M`, and the contribution weight `W`.

Only five are persisted. Three RGBA32F planes give twelve floats: three `vec3`s in RGB, and in the alphas `M`, `W`, and a validity flag set only where the primary ray hit geometry. `wSum` is dropped — a stored reservoir re-enters the stream with weight `p̂ · W · M`, reconstructible from the rest.

The planes are allocated twice — read as *prev*, written as *curr* — so a single raygen dispatch can read-modify-write without aliasing itself:

They occupy a contiguous six-binding block in the path tracer's set 0: 29–31 prev, 32–34 curr.

The price is unconditional: six `R32G32B32A32_SFLOAT` images at render resolution — 96 bytes per pixel, roughly 190 MiB at 1920×1080.

Resampled importance sampling draws $M$ cheap candidates $x_i$ from a source pdf $p$, then keeps one survivor $y$ in proportion to a *target* $\hat p$ closer to the integrand than $p$ is:

$f$ is the diffuse GI at the primary hit $x_1$ — $(\rho/\pi)\,L_o\cos\theta$, for $\rho$ the diffuse albedo (zero on metals) and $\theta$ the angle between the normal and the direction to $x_s$; $p$ is the cosine-hemisphere pdf $\cos\theta/\pi$ the bounce was drawn from; $\hat p$ is a scalar stand-in for $f$, its luminance:

Everything right of $f(y)$ collapses into the number stored as $W = (\sum w_i) / (M\,\hat p(y))$, so shading is just $f(y)\cdot W$:

`M` counts candidates, not frames: the N-samples-per-frame loop streams each initial bounce into one reservoir before any reuse —

— but only the bounces that *hit* something. That call is the sole `r.M += 1.0` and sits in the else-branch; a cosine ray escaping to the environment goes straight into the shaded result:

So `M = N` in a closed box, and less under an HDRI.

The stored reservoir re-enters the stream with weight $\hat p'(y)\cdot W\cdot M$, where $\hat p'$ is the target **re-computed at the current shading point** — not the $\hat p$ in force when it was taken:

Two guards sit on top. The reprojected pixel must clear the geometry gate the beauty accumulation uses — position within `max(0.03, 0.02·d)`, normal dot ≥ 0.9, roughness delta ≤ 0.12 — so a disocclusion cannot inherit a stranger's sample. And a shadow ray from $x_1$ to $x_s$ zeroes $\hat p'$ when the reused vertex has become occluded, stopping light bleeding through a wall that closed between frames:

Inherited confidence is then clamped to twenty times the current frame's:

That clamp also bounds the bias, because both combiners are M-weighted, not MIS-weighted: a candidate enters carrying $\hat p\cdot W\cdot M$, no balance term. The shader calls the temporal one biased — unbiased only in the limit, and only because that reuse is same-domain —

— and repeats the label for the spatial fold, where the sample crosses to a different primary hit and that argument lapses:

GRIS pairwise or generalized-balance weights would remove it; none are computed here.

Phase 2 folds in K = 4 neighbours from a screen-space disk whose radius shrinks 15 % per tap — 20, 17, 14, 11 px:

Its centre is not this pixel but the primary hit reprojected into the *previous* frame's screen space — the frame those reservoirs belong to — or `pixel` if that reprojection leaves the frame:

A neighbour's sample was integrated over *its* solid angle at *its* primary hit, so reuse needs the change-of-measure Jacobian (Ouyang et al. Eq. 11):

$x_{1r}$ is this pixel's primary hit, $x_{1q}$ the neighbour's; each $\phi$ is the angle at $x_s$ between $n_s$ and the direction back to the corresponding primary hit. Without $J$, samples reused across a depth or grazing-angle discontinuity are weighted as if they subtended the same solid angle at both receivers — silhouettes band light or dark. The ratio is then clamped to $[10^{-3},10^{3}]$ as numerical insurance:

Both paths carry the same `!viewChanged` gate:

`viewChanged` is `pc.control.z`, from `m_viewChangedThisFrame`: `notifyViewChanged()` raises it, `render` clears it each frame, `interactive` sets it whenever the camera moved. A continuously moving camera therefore runs neither pass; what surfaces is a noisy single-frame RIS estimate, not stale-neighbour lag.

Only the *temporal* reservoir goes back to the ping-pong planes, captured before any neighbour is folded in; the spatial result is shading-only:

Everything above is live GLSL and the layout still reserves 29–34, but the host code that joined them is gone: the descriptor update in `PathTracer::render` builds a 29-entry write array and stops at binding 28, and no `dstBinding` above 28 exists anywhere in the tree.

`m_giReservoirViews` appears only at image creation and destruction, no barrier moves those images to `VK_IMAGE_LAYOUT_GENERAL`, and `m_giReservoirWriteIndex` is assigned `0` in three places and incremented in none — the ping-pong cannot alternate. The shader's four `PT_FLAG_RESTIRGI_*` bits, 5–8 of `pc.control.x`, are set by nothing.

No commit deleted this. The merge `c894ebf` took `path_tracer_render.cpp` from a branch forked at `1910fd9`, two hours before ReSTIR landed in `cd87dea`: parent `a726db3` still holds `writes[40]` and a live `m_giReservoirWriteIndex = 1u - m_giReservoirWriteIndex`; the merge result holds neither, and `cornell_box` drops from nine `restir` matches to one, `restir_probe` with it.

Bindings 29–34 carry no `PARTIALLY_BOUND` flag — that is on binding 12 alone — so this is not a legal "optional descriptor" configuration. A statically-used descriptor that is never written is undefined behaviour; what a driver does with it is not characterised here.

The storage-image pool is sized to exactly the 25 storage-image bindings, six of them reservoir planes:

No slack: a 26th storage image added without editing that literal fails `vkAllocateDescriptorSets` with `VK_ERROR_OUT_OF_POOL_MEMORY` at startup, nowhere near the cause.

The second edge predates ReSTIR but the reservoir block widened it. Vulkan requires `VARIABLE_DESCRIPTOR_COUNT` on the set's highest-numbered binding; here it sits on the bindless texture array at 12, with 23 higher-numbered bindings above:

The comment directly above that line still claims the flag is on "the LAST binding only".

• $\hat p$ must be re-evaluated at the current primary hit before the held sample is shaded. Reusing the stored $\hat p$, or a stale `W`, distorts the GI while still looking smooth.
• The spatial pass must not write back into the ping-pong planes; persisting it compounds sample correlation until the GI bakes.
• Bindings 29–34 must be written every frame with prev/curr swapped and the images in `VK_IMAGE_LAYOUT_GENERAL` before the raygen runs. Neither happens in HEAD.
• The `{STORAGE_IMAGE, 25}` entry is exact: bump it with `bindings[36]`, `flagsInfo.bindingCount` and `layoutInfo.bindingCount`. The `29..34` loop assumes array index equals binding number.