@woosh/meep-engine 3.58.0 → 3.60.0

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js

@@ -0,0 +1,189 @@
+import { chunk_roughness_to_mip_ratio } from "../../../light/environment/chunk_roughness_to_mip_ratio.js";
+import { chunk_uv_octahedral_unit_encode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import { chunk_index_to_grid2d_reciprocal } from "../../../shader/chunk/grid/chunk_index_to_grid2d_reciprocal.js";
+import { chunk_probe_visibility_weight } from "../../../shader/chunk/light/probe/chunk_probe_visibility_weight.js";
+import { METRO_L1_IRRADIANCE_STRUCT } from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import {
+    chunk_resolve_irradiance_sh_to_specular
+} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_specular.js";
+import { chunk_texture_octahedral_skirt_uv } from "../../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import {
+    PROBE_LEVELS_RESOURCE,
+    PROBE_RADIANCE_HISTORY_RESOURCE,
+    PROBE_RECORDS_READ_RESOURCE,
+    PROBE_STATES_READ_RESOURCE
+} from "./chunk_probe_clipmap.js";
+import { chunk_probe_clipmap_cage } from "./chunk_probe_clipmap_cage.js";
+import {
+    chunk_probe_clipmap_pick,
+    PROBE_DEPTH_SAMPLER_RESOURCE,
+    PROBE_SAMPLING_RESOURCE
+} from "./chunk_probe_clipmap_pick.js";
+import { PROBE_RECEIVER_BIAS_VIEW } from "./PROBE_CLIPMAP.js";
+
+/**
+ * A point's specular radiance from its probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.3), before Fresnel:
+ *
+ * ```wgsl
+ * fn probe_clipmap_radiance_of(pick: ProbeClipmapPick, position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32) -> ProbeClipmapRadiance
+ * fn probe_clipmap_sample_radiance(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32, noise: vec2<f32>) -> ProbeClipmapRadiance
+ * ```
+ *
+ * - **The pick is the diffuse's** (`probe_clipmap_pick`), by the normal and the view, so a pass that does
+ *   both picks once: `probe_clipmap_radiance_of` takes a pick already made, with the point, normal and view it
+ *   was made by. Its shares are re-weighted for the lobe, as Brick4's fused pass re-weights its pair:
+ *   each probe's weight taken again with the sample vector in place of the normal, over the weight it was
+ *   picked by, at the visibility it was picked at. The trilinear part cancels.
+ * - **The sample vector** is Lagarde's dominant direction, `normalize(mix(r, n, α))` with r the
+ *   reflection of the view and α the roughness squared.
+ * - **A radiance tap** a probe, along the sample vector after a one-step sphere parallax: the reflected ray
+ *   is met with a sphere about the probe whose radius is its mean depth along the vector. The depth is held
+ *   at the cage's diagonal (§8.2), past which no parallax is taken. One bilinear tap of the tile, through
+ *   its skirt and the depth's sampler.
+ * - **The rough end** is the probes' SH, mixed by the same shares and resolved for the GGX lobe
+ *   (`resolve_irradiance_sh_to_specular`). The two are blended by `roughness_to_mip_ratio`: SH alone from
+ *   roughness 0.7.
+ * - Where no probe weighs anything, nothing is found and the fallback is the caller's.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_sample_radiance = CodeChunk.from(
+    //language=WGSL
+    `
+struct ProbeClipmapRadiance {
+    radiance: vec3<f32>,
+    found: bool,
+}
+
+struct ProbeClipmapLobe {
+    // the probe's share for the lobe, before the shares are renormalised
+    weight: f32,
+    radiance: vec3<f32>,
+    sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
+}
+
+// a slot's radiance toward a direction: one bilinear tap of its tile, through its skirt
+fn probe_clipmap_radiance(slot: u32, direction: vec3<f32>) -> vec3<f32> {
+    let side = probe_sampling.radiance_resolution + 2u;
+    let place = index_to_grid2d_reciprocal(slot, probe_sampling.radiance_tiles_per_row, probe_sampling.radiance_tiles_per_row_reciprocal);
+    let tile = vec2<f32>(place * side);
+    let in_tile = texture_octahedral_skirt_uv(uv_octahedral_unit_encode(direction), f32(side)) * f32(side);
+
+    return textureSampleLevel(probe_radiance, probe_depth_sampler, (tile + in_tile) * probe_sampling.radiance_texel, 0.0).rgb;
+}
+
+// a picked probe's share for the lobe, its radiance along it and its SH
+fn probe_clipmap_lobe(slot: u32, share: f32, position: vec3<f32>, normal: vec3<f32>, bias_direction: vec3<f32>, lobe: vec3<f32>) -> ProbeClipmapLobe {
+    let record = probe_records[slot];
+    let cascade = probe_record_cascade(record.flags);
+    let spacing = probe_levels[cascade].cell_size;
+    let probe = vec3<f32>(record.cell) * spacing + probe_clipmap_offset_decode(probe_states[slot].y, spacing);
+
+    // the visibility it was picked at: Chebyshev's from its depth toward the biased point
+    let biased = probe_clipmap_biased(cascade, position, bias_direction);
+    let to_point = biased - probe;
+    let distance = length(to_point);
+    let visibility = probe_visibility_chebyshev(probe_clipmap_depth_moments(slot, to_point / max(distance, 1e-6)), distance / spacing);
+
+    let toward = normalize(probe - position);
+
+    var out: ProbeClipmapLobe;
+    out.weight = share * probe_visibility_weight(toward, lobe, visibility) / probe_visibility_weight(toward, normal, visibility);
+    out.sh = probe_record_sh_decode(record.sh);
+
+    // the reflected ray met with a sphere about the probe, its radius the probe's mean depth along the lobe
+    let radius = probe_clipmap_depth_moments(slot, lobe).x * spacing;
+    let origin = position - probe;
+    let b = dot(lobe, origin);
+    let discriminant = b * b - (dot(origin, origin) - radius * radius);
+
+    var direction = lobe;
+
+    if (discriminant >= 0.0) {
+        let t = sqrt(discriminant) - b;
+
+        if (t > 0.0) {
+            direction = normalize(origin + t * lobe);
+        }
+    }
+
+    out.radiance = probe_clipmap_radiance(slot, direction);
+
+    return out;
+}
+
+fn probe_clipmap_radiance_of(pick: ProbeClipmapPick, position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32) -> ProbeClipmapRadiance {
+    var out: ProbeClipmapRadiance;
+
+    out.found = dot(pick.weights, vec4<f32>(1.0)) > 0.0;
+
+    if (!out.found) {
+        return out;
+    }
+
+    let alpha = roughness * roughness;
+    let lobe = normalize(mix(reflect(-view_direction, normal), normal, alpha));
+    let bias_direction = mix(normal, view_direction, ${PROBE_RECEIVER_BIAS_VIEW});
+
+    var weight = 0.0;
+    var radiance = vec3<f32>(0.0);
+    var sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
+
+    // each by name, the slots of a share of zero not read
+    if (pick.weights.x > 0.0) {
+        let probe = probe_clipmap_lobe(pick.slots.x, pick.weights.x, position, normal, bias_direction, lobe);
+        weight += probe.weight;
+        radiance += probe.weight * probe.radiance;
+        sh.Y += probe.weight * probe.sh.Y;
+        sh.CoCg += probe.weight * probe.sh.CoCg;
+    }
+    if (pick.weights.y > 0.0) {
+        let probe = probe_clipmap_lobe(pick.slots.y, pick.weights.y, position, normal, bias_direction, lobe);
+        weight += probe.weight;
+        radiance += probe.weight * probe.radiance;
+        sh.Y += probe.weight * probe.sh.Y;
+        sh.CoCg += probe.weight * probe.sh.CoCg;
+    }
+    if (pick.weights.z > 0.0) {
+        let probe = probe_clipmap_lobe(pick.slots.z, pick.weights.z, position, normal, bias_direction, lobe);
+        weight += probe.weight;
+        radiance += probe.weight * probe.radiance;
+        sh.Y += probe.weight * probe.sh.Y;
+        sh.CoCg += probe.weight * probe.sh.CoCg;
+    }
+    if (pick.weights.w > 0.0) {
+        let probe = probe_clipmap_lobe(pick.slots.w, pick.weights.w, position, normal, bias_direction, lobe);
+        weight += probe.weight;
+        radiance += probe.weight * probe.radiance;
+        sh.Y += probe.weight * probe.sh.Y;
+        sh.CoCg += probe.weight * probe.sh.CoCg;
+    }
+
+    let rough = resolve_irradiance_sh_to_specular(sh.Y / weight, sh.CoCg / weight, lobe, alpha);
+
+    out.radiance = mix(radiance / weight, rough, roughness_to_mip_ratio(roughness));
+
+    return out;
+}
+
+fn probe_clipmap_sample_radiance(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32, noise: vec2<f32>) -> ProbeClipmapRadiance {
+    return probe_clipmap_radiance_of(probe_clipmap_pick(position, normal, view_direction, noise), position, normal, view_direction, roughness);
+}
+`, [
+        chunk_probe_clipmap_pick,
+        chunk_probe_clipmap_cage,
+        chunk_probe_visibility_weight,
+        chunk_index_to_grid2d_reciprocal,
+        chunk_texture_octahedral_skirt_uv,
+        chunk_uv_octahedral_unit_encode,
+        chunk_resolve_irradiance_sh_to_specular,
+        chunk_roughness_to_mip_ratio,
+    ]);
+
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_LEVELS_RESOURCE);
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_SAMPLING_RESOURCE);
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_STATES_READ_RESOURCE);
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_RECORDS_READ_RESOURCE);
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_DEPTH_SAMPLER_RESOURCE);
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_RADIANCE_HISTORY_RESOURCE);

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_want.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Wanting the probes a receiving point's pick reads (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §9.1),
+ * for want's pixels and the hits' wants alike.
+ *
+ * ```wgsl
+ * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, key_count: u32, flag: u32)
+ * ```
+ *
+ * The cages are the pick's: the finest cascade whose cage window holds the point, the cage of the point
+ * biased along `bias_direction` by that cascade's spacing, and in the cascade's blend skirt the next
+ * cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
+ * point's bit is set, and a point whose bit was clear goes on the wanted list with `flag` over its key,
+ * so the list holds every point wanted this frame once, with its first wanter's flag.
+ *
+ * A workgroup's lanes want a few cages between them, so the first lane to want a cage claims it in the
+ * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at
+ * 1280×720 on Sponza before the claims, the bits' atomics were 140 of want's 345 µs and the appends 90.
+ *
+ * Every lane of the workgroup calls it once, wanting or not, from uniform control flow: the appends are
+ * the subgroup's.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_want: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_probe_clipmap_want.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_want.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_want.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uCAFU,SAAS,CAgFZ;0BA7HmB,uCAAuC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_want.js

@@ -0,0 +1,132 @@
+import { chunk_collection_u32_append } from "../../../gpu_primitive/chunk_collection_u32_append.js";
+import { chunk_clipmap_select_finest } from "../../../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import {
+    chunk_probe_clipmap,
+    PROBE_LEVELS_RESOURCE,
+    PROBE_WANTED_BITS_RESOURCE,
+    PROBE_WANTED_WRITE_RESOURCE
+} from "./chunk_probe_clipmap.js";
+import { chunk_probe_clipmap_cage } from "./chunk_probe_clipmap_cage.js";
+import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
+
+/**
+ * Slots of a workgroup's claim table: twice the claims its lanes make at most, a cage in each of two
+ * cascades a lane, so a probe finds a slot within a few. Sized for {@link PROBE_THREAD_WORKGROUP_SIZE}
+ * lanes: want's 8×8 tiles, and the hits' wants' 64.
+ * @type {number}
+ */
+const WANT_CLAIM_SLOTS = 2 * 2 * PROBE_THREAD_WORKGROUP_SIZE;
+
+/**
+ * Slots a claim tries before it wants its cage anyway: a bound, which a half-full table does not reach.
+ * @type {number}
+ */
+const WANT_CLAIM_PROBES = 16;
+
+/**
+ * Wanting the probes a receiving point's pick reads (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §9.1),
+ * for want's pixels and the hits' wants alike.
+ *
+ * ```wgsl
+ * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, key_count: u32, flag: u32)
+ * ```
+ *
+ * The cages are the pick's: the finest cascade whose cage window holds the point, the cage of the point
+ * biased along `bias_direction` by that cascade's spacing, and in the cascade's blend skirt the next
+ * cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
+ * point's bit is set, and a point whose bit was clear goes on the wanted list with `flag` over its key,
+ * so the list holds every point wanted this frame once, with its first wanter's flag.
+ *
+ * A workgroup's lanes want a few cages between them, so the first lane to want a cage claims it in the
+ * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at
+ * 1280×720 on Sponza before the claims, the bits' atomics were 140 of want's 345 µs and the appends 90.
+ *
+ * Every lane of the workgroup calls it once, wanting or not, from uniform control flow: the appends are
+ * the subgroup's.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_want = CodeChunk.from(
+    //language=WGSL
+    `
+// the cages the workgroup's lanes have claimed, by their key plus one; zero at the workgroup's start
+var<workgroup> probe_want_claims: array<atomic<u32>, ${WANT_CLAIM_SLOTS}>;
+
+// whether this lane is the first of its workgroup to want the cage whose least point has \`key\`; a lane
+// that finds no room in its probes wants it as well, which the bits make harmless
+fn probe_want_claim(key: u32) -> bool {
+    let tag = key + 1u;
+
+    var at = (tag * 2654435761u) >> ${32 - Math.log2(WANT_CLAIM_SLOTS)}u;
+
+    for (var probe = 0u; probe < ${WANT_CLAIM_PROBES}u; probe++) {
+        let seen = atomicCompareExchangeWeak(&probe_want_claims[at], 0u, tag);
+
+        if (seen.exchanged) {
+            return true;
+        }
+
+        if (seen.old_value == tag) {
+            return false;
+        }
+
+        // another cage's slot: the next one; an empty slot that failed spuriously is tried again
+        if (seen.old_value != 0u) {
+            at = (at + 1u) & ${WANT_CLAIM_SLOTS - 1}u;
+        }
+    }
+
+    return true;
+}
+
+fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, key_count: u32, flag: u32) {
+    let selection = clipmap_select_finest(&probe_levels, cascade_count, position, PROBE_BLEND_SKIRT);
+
+    let held = wants && selection.level != CLIPMAP_LEVEL_NONE;
+    let finest = select(0u, selection.level, held);
+    let next = min(finest + 1u, cascade_count - 1u);
+
+    var cage_finest: vec3<i32>;
+    var cage_next: vec3<i32>;
+
+    // storage wraps by the window's side, a power of two: the low bits of a point, negative ones too
+    let wrap = vec3<u32>(resolution - 1u);
+
+    let wants_finest = held && probe_clipmap_cage(finest, position, bias_direction, &cage_finest)
+        && probe_want_claim(probe_clipmap_key(finest, vec3<u32>(cage_finest) & wrap, resolution));
+    let wants_next = held && selection.edge_weight > 0.0 && finest + 1u < cascade_count
+        && probe_clipmap_cage(next, position, bias_direction, &cage_next)
+        && probe_want_claim(probe_clipmap_key(next, vec3<u32>(cage_next) & wrap, resolution));
+
+    // every lane through all sixteen corners, so that the appends stay in uniform control flow
+    for (var k = 0u; k < 16u; k++) {
+        let coarse = k >= 8u;
+        let cascade = select(finest, next, coarse);
+        let wanted = select(wants_finest, wants_next, coarse);
+        let corner = vec3<i32>(vec3<u32>(k & 1u, (k >> 1u) & 1u, (k >> 2u) & 1u));
+        let point = select(cage_finest, cage_next, coarse) + corner;
+
+        let storage = vec3<u32>(point) & wrap;
+        let key = probe_clipmap_key(cascade, storage, resolution);
+        let bit = 1u << (key & 31u);
+
+        var first = false;
+
+        if (wanted) {
+            first = (atomicOr(&probe_wanted_bits[key >> 5u], bit) & bit) == 0u;
+        }
+
+        collection_u32_append(&probe_wanted, first, key | flag, key_count);
+    }
+}
+`, [
+        chunk_probe_clipmap,
+        chunk_clipmap_select_finest,
+        chunk_probe_clipmap_cage,
+        chunk_collection_u32_append,
+    ]);
+
+chunk_probe_clipmap_want.requireResource(PROBE_LEVELS_RESOURCE);
+chunk_probe_clipmap_want.requireResource(PROBE_WANTED_BITS_RESOURCE);
+chunk_probe_clipmap_want.requireResource(PROBE_WANTED_WRITE_RESOURCE);

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.d.ts

@@ -8,19 +8,49 @@ export const PROBE_ACCUMULATE_SETTINGS: WebGPUStruct;
  * gathers its own rays and writes the texel, blended with its history, to the probe's maps in
  * `probe_maps` (`probe_clipmap_maps_words`): two words a radiance texel, rgba as half floats; then a
  * word a radiance texel, its rays this update, resolved in the low half and back faces in the high,
- * which classification sums; then a word a depth texel, its moments as half floats.
+ * which classification sums; then a word a depth texel, its moments as half floats; then a word a
+ * radiance texel, how far its sample fell from its mean in its own deviation, luminance, held to
+ * `PROBE_CHANGE_SIGNIFICANCE`, and one for its blending one, as half floats, which the probe's ray request
+ * sums (zero where no sample was blended).
  *
- * - **Radiance**: the mean of the texel's resolved rays, a back face's being zero, blended by
- *   α = max(1/(a+1), 1 − e^(−Δt·p/τ)). a is the texel's own count of the updates that reached it, held
- *   in its alpha; p the updates between a texel's rays, n_r²/R below one ray a texel. Counting a texel
- *   rather than the probe keeps α right where an update covers a subset: a texel's first ray is taken
- *   whole whenever it comes. A texel no ray reached keeps its history.
- * - **Depth**: the moments (d, d²) of the rays landing in the texel, in spacings: a miss √3, a back
- *   face 0.2·t (DDGI 2021's shortening), a hit t, every sample held to √3 (D9). Blended by the probe's
- *   α = max(1/(n+1), 1 − e^(−Δt/τ)), n its updates. At most 64 rays a texel, which the settings hold
- *   R to (R ≤ 64·n_d²).
+ * - **A texel's rays**: on a uniform update (`PROBE_UNIFORM_PERIOD`), `probe_clipmap_texel_ray`'s. On a
+ *   guided one, the run that begins at its walk position in the probe's guide, at most
+ *   `PROBE_TEXEL_RAYS` of them. A guided texel's rays are spread evenly over it however many it takes,
+ *   so their mean needs no weight for the guide's choice.
+ * - **Radiance**: the mean of the texel's resolved rays, a back face's being zero, is a sample of the
+ *   texel's multi-scale mean (`chunk_multiscale_mean`), its estimator in `probe_estimators` and its mean
+ *   in the atlas.
+ *   - Δt and τ are frames: Δt since the probe's last update, τ `response_frames`.
+ *   - The short mean blends by β = max(1/(a+1), 1 − e^(−Δt·p/τ)), its variance by the same with 2τ. a is
+ *     the texel's own count of the updates that reached it, held in its alpha; p the updates between a
+ *     texel's rays: one over the share of updates that reach it, averaged over the uniform period
+ *     (`probe_clipmap_guide_rate`), n_r²/R below one ray a texel when every update is uniform. A texel
+ *     the guide passes over thus blends what it takes as fully as its rarity asks. Counting a texel
+ *     rather than the probe keeps β right where an update covers a subset.
+ *   - The mean blends by at least 1/(a+1) until the count reaches its limit: a young texel is its running
+ *     mean, which the estimator's blend reduction, nothing at its seed, would otherwise hold back. Past it
+ *     the estimator alone, down to 1/8192 an update on a noisy texel.
+ *   - Samples are clipped once the variance's window has passed, when 1/(a+1) is no longer its blend:
+ *     before that it holds no spread to clip to.
+ *   - A texel's first sample seeds both means. A texel no ray reached keeps its history.
+ * - **Depth**: the moments (d, d²) of the rays landing in the texel, in spacings: a miss the limit, a
+ *   back face 0.2·t (DDGI 2021's shortening), a hit t, every sample held to the limit, the farthest a
+ *   cage tests a relocated probe, (1 + 0.45)·√3 (`PROBE_DEPTH_LIMIT`, D9). On a uniform update the
+ *   sample is the plain mean, blended by the probe's α = max(1/(n+1), 1 − e^(−Δt/τ)), n its updates. At
+ *   most 64 rays a texel, which the settings hold R to (R ≤ 64·n_d²).
+ *   - On a guided update the sample is a mean of means: each radiance texel inside the depth texel gives
+ *     its own mean, since the guide gives the brighter ones more rays, at most 64/f² of its rays,
+ *     evenly strided. It is taken only when every one of them took rays. The guide gives a dark one,
+ *     a back face's or a shadowed wall's, none, and the lit ones' depths are not the whole texel's: its
+ *     depth comes from the uniform updates.
+ *   - The time term's period is one over the share of updates that reach the depth texel, a uniform
+ *     update counting as reaching every one, a guided one as often as its least reached radiance texel.
  * - **A new probe's history is another probe's**, its slot's last owner: on its first update a texel
  *   no ray reached is cleared, radiance to nothing seen, depth to the moments of a miss.
+ * - **Stored rounded stochastically** onto halves (`f16_round_stochastic`), with noise fresh for each
+ *   texel and update. Rounded by the store, a blend whose step is under a ULP would stop short of its
+ *   target by up to a ULP/α, and below it, since both devices measured round toward zero: on a room
+ *   glowing evenly, 1.5% at 60 Hz and 5.9% at 240 Hz. Rounded stochastically it moves in expectation.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.js"],"names":[],"mappings":"AA4BA;;GAEG;AACH,wCAFU,YAAY,CAmBQ;AAgB9B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8CAFU,aAAa,CAgLpB;6BA9P0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.js"],"names":[],"mappings":"AA0CA;;GAEG;AACH,wCAFU,YAAY,CAqBQ;AAmB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,8CAFU,aAAa,CAmVpB;6BA3c0B,sCAAsC;8BAHrC,kCAAkC"}