PCG realtime

OHAO ships two samplers behind one GLSL interface, and which one runs is meant to be a property of the render profile rather than a setting a user turns. `RTRealtimeRenderer` binds `pt_raygen_realtime.rgen` and is constructed with `kRealtimeRTSettings`, and that struct names PCG:

The intent does not survive the initialisation order. `samplerType` has exactly one reader in the tree — pipeline creation, where it becomes a specialization constant — and that read happens inside `PathTracer::init`:

`RTProfileRendererBase::init` calls that first and pushes the profile's settings down afterwards:

So at the moment the constant is baked, `m_renderSettings` is still its member-initializer default:

and that default's sampler is Sobol.

`PathTracer::createRTPipeline` has exactly one call site, and neither `PathTracer::setRenderSettings` nor `PathTracer::resize` rebuilds the pipeline, so the later assignment never reaches any SPIR-V. Both profiles specialize their raygen to `SAMPLER_SOBOL`; the realtime profile's `SamplerType::PCG` is live C++ state that no shader ever sees. Everything below describes an implementation that is compiled, self-consistent, and currently unreachable on the GPU.

No example parses a `--sampler` flag; switching sampler is supposed to mean switching profile, which also switches raygen, bounce budget and denoiser. This implementation has exactly one consumer — `sampler_api.glsl` — and its constants appear nowhere else in the tree: the deferred pipeline's `rt_shadow.rgen` and `rt_gi.rgen` roll their own `hash(vec2)` and never touch this interface.

The verification log compares them at equal 16 spp on the `envlit_turntable` scene, from when PCG was still the offline default: Sobol reaches 0.002584 local 5×5 variance against PCG's 0.002863, logged as a 9.8% improvement.

That understates it, because roughly half of each figure is scene detail rather than noise — the same log's 4096-spp reference puts the signal-only floor at 0.001383, which is 48% of the PCG number and 54% of the Sobol one.

Subtracting that floor, sampling noise falls from 0.001480 to 0.001201: a 19% reduction, derived from the logged numbers rather than separately measured. Real, but not the order-of-magnitude gap "low-discrepancy" invites you to expect.

The generator is PCG-RXS-M-XS in its 32-bit form. State advance is a plain linear congruential step:

Here $s_n$ is the 32-bit state and the modulus is free — it is just uint overflow. Because $a \equiv 1 \pmod 4$ and $c$ is odd, the Hull–Dobell conditions hold, so the state cycles through all $2^{32}$ values from *any* seed. The `+ 1u` in the seed is therefore not load-bearing for period; nothing about the seed can shorten the cycle.

A raw LCG is unusable as-is: bit $k$ of the state has period $2^{k+1}$, so the low bit merely alternates. The output permutation fixes that before anything leaves the generator — with $\gg$ a logical shift and $\oplus$ xor:

The first step is the "random xorshift": the shift distance $k \in [4, 19]$ is chosen by the state's own top four bits, so mixing depth varies with the input and no fixed bit-position correlation survives. The odd multiplier propagates low bits upward, and the final fold pushes the top ten bits back down. Only then does the value become a float — which is why dividing the *output* by $2^{32}$ is legitimate while dividing the raw state would not be. Ordering matters here too: `_pcg_next` advances before it permutes, so the seed itself is never observable.

Seeding is where the cheapness shows. There is no hash — the state starts as an affine function of the pixel and the sample index:

Two invocations share their whole stream exactly when their seeds collide, so this line's quality is a lattice question. Within one frame $i$ is fixed and a collision needs $1973\,\Delta x + 9277\,\Delta y \equiv 0$. At 8K the left side is at most $1973 \cdot 7680 + 9277 \cdot 4320 \approx 5.5 \times 10^{7}$, far below $2^{32}$, so the congruence is an ordinary equality; $\gcd(1973, 9277) = 1$ then forces $9277 \mid \Delta x$, and 9277 exceeds any shipping image width. No two pixels in a frame ever share a stream.

Across the sample index it is not so clean. Solving $1973\,\Delta x + 9277\,\Delta y = -26699$ gives the minimal offset $(\Delta x, \Delta y) = (1966, -421)$, which fits inside a 2560×1440 frame: pixel $p$ at sample $i$ and pixel $p + (1966, -421)$ at sample $i+1$ would draw identical uniforms for the whole path. Neither estimate is biased by this — each still sees a well-permuted stream. It is structure that a per-pixel hash (Sobol seeds through a full Murmur-style finalizer) would not have.

The interface takes a dimension index. PCG ignores it and returns the next value in its stream:

For Sobol that argument is load-bearing — `getSample1D_sobol(dim)` is a pure function of (sample index, dimension, pixel seed), with `dim >> 2` selecting an independently-scrambled 4D pad. For PCG only call *order and count* matter, and the realtime raygen is laid out as though that were not so. It consumes the sub-pixel jitter at dimensions 0–1, then re-seeds inside its per-sample loop and resumes bookkeeping at dimension 2:

With the default `samplesPerFrame = 1` that re-seed computes `frameIdx * 1 + 0` — the same seed used for the jitter a few lines earlier. Sobol is untouched, because dimension 2 is a different function evaluation. PCG would restart the stream: `dimIdx = 2u` buys it nothing, and the frame's first path uniform comes out numerically equal to `jitter.x + 0.5`. On a primary hit with a non-empty light SSBO that uniform is the one that selects the NEE light, so the light chosen at a pixel would become a function of where inside the pixel the camera ray landed. The jitter partitioned here is the sub-pixel *x* offset, so with $L$ lights, light $k$ is only ever paired with one $1/L$-wide band of $x$ — a vertical strip of the pixel footprint rather than a point drawn from all of it.

None of that happens in any shipping configuration, because the ordering above leaves this raygen specialized to Sobol. It is exactly the dimension reuse the padded-Sobol accounting exists to prevent, waiting behind a one-line fix to the initialisation order.

Sobol shifts right by 8 and scales by $2^{-24}$, capping at $1 - 2^{-24}$, and says so:

PCG's 31 lines make no claim about their range at all. They divide the full 32-bit output by $2^{32}$ in `float` precision:

Near $2^{32}$ the spacing of `float32` is 256, so the 128 largest uint outputs round up to exactly $2^{32}$ and the quotient is exactly 1.0 — probability $2^{-25}$, one sample in 33.5 million. Nothing downstream would break if that value were ever produced, because the three kinds of site that turn a uniform into an index are all bounded: every light-selection site in all three raygen shaders follows `uint(u * lightCount)` with a `min(..., lightCount - 1u)` clamp; the environment CDF lookup is a binary search with a pre-clamped upper bound; and ReSTIR-GI's spatial-reuse tap clamps its neighbour offset to the framebuffer.

Selection happens at pipeline creation, not per ray: `sampler_api.glsl` declares the sampler as a specialization constant and branches on it.

The CPU writes `m_renderSettings.samplerType` into a `VkSpecializationInfo` attached to exactly one stage.

Stage 0 is the raygen, which is currently sufficient: `sampler_api.glsl` is included by exactly three files — `pt_raygen.rgen`, `pt_raygen_offline.rgen`, `pt_raygen_realtime.rgen` — and by no closest-hit, miss or any-hit shader. Note also that the GLSL default is `SAMPLER_SOBOL` while the C++ enum gives PCG the value 0: an *absent* specialization yields Sobol, a *zero-filled* one yields PCG. The specialization written here is never absent — it is simply always read one step too early.

• `PathTracer::createRTPipeline` reads `m_renderSettings.samplerType` at build time and has exactly one call site, inside `PathTracer::init`. A profile that wants a non-default sampler must push its settings down *before* `init`; none does, so every RT pipeline in the tree is specialized from the `kOfflineRTSettings` member initializer.
• The sampler specialization reaches the raygen stage only. If a closest-hit or miss shader ever includes `sampler_api.glsl`, it compiles with the declared default `SAMPLER_SOBOL` regardless of profile, and the two stages silently draw from different samplers.
• `_pcg_state` is a single module-scope uint: one stream per invocation, and only one. A second decorrelated stream can only be had by re-seeding, which discards the first — so any `dimIdx` reservation scheme built around a re-seed protects Sobol and not PCG.
• `getSample1D` may return exactly 1.0 under PCG and never under Sobol. Consumers must clamp indices or use bounded searches; light selection, the environment CDF lookup and ReSTIR-GI's spatial tap all do.
• Neither sampler's GLSL is value-tested. `sobol_test.cpp` asserts against the C++ `SobolGenerator::sample1D` and `owenScramble` only; the GLSL's claim to mirror them byte-for-byte is a source comment, not an assertion. PCG has no CPU-side reference implementation at all, and the only PCG assertion in the suite is the `isQmcSampler` trait predicate. A typo in either permutation's constants would not fail the test build.