@woosh/meep-engine 3.58.0 → 3.60.0

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

@@ -1,13 +1,13 @@
 /**
- * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 64 bytes a slot: where it is, when it
- * was wanted and traced, its last update's back faces, and its irradiance. Where relocation moved it
- * is the state's second word, which readers weighing it load with the state.
+ * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 48 bytes a slot: where it is, when it
+ * was wanted and traced, its last update's back faces, whose want it was, and its irradiance. Where
+ * relocation moved it is the state's second word, which readers weighing it load with the state.
  *
  * @type {WebGPUStruct}
  */
 export const PROBE_RECORD_STRUCT: WebGPUStruct;
 /**
- * A ray of a probe's update (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.6), 28 bytes, as trace writes it for
+ * A ray of a probe's update (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.6), 24 bytes, as trace writes it for
  * the passes after it.
  *
  * @type {WebGPUStruct}
@@ -64,6 +64,23 @@ export const PROBE_COUNTERS_READ_RESOURCE: ShaderResourceDescriptor;
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_FREE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * What the next frame's retire evicts (§8.3), as the frame's schedule leaves it: the oldest `buckets` of the
+ * `PROBE_AGE_BUCKETS` age buckets whole, and `remaining` probes of the bucket below them. Zero, as a new
+ * buffer holds it, evicts nothing.
+ * @type {WebGPUStruct}
+ */
+export const PROBE_EVICTION_STRUCT: WebGPUStruct;
+/**
+ * The eviction as retire reads it: plainly, every thread.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_EVICTION_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The eviction as schedule writes it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_EVICTION_WRITE_RESOURCE: ShaderResourceDescriptor;
 /**
  * The live probes' slots as retire reads them: the list the frame before wrote.
  * @type {ShaderResourceDescriptor}
@@ -84,11 +101,6 @@ export const PROBE_ACTIVE_WRITTEN_RESOURCE: ShaderResourceDescriptor;
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_WANTED_BITS_RESOURCE: ShaderResourceDescriptor;
-/**
- * The wanted bits, read plainly once want has set them.
- * @type {ShaderResourceDescriptor}
- */
-export const PROBE_WANTED_BITS_READ_RESOURCE: ShaderResourceDescriptor;
 /**
  * The probes the frame updates, as the due passes list them, at most U (§8.5).
  * @type {ShaderResourceDescriptor}
@@ -99,6 +111,12 @@ export const PROBE_TRACE_WRITE_RESOURCE: ShaderResourceDescriptor;
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_TRACE_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The probes the frame updates, as the order pass sorts them in place: the count read plainly, the
+ * entries written.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_TRACE_ORDER_RESOURCE: ShaderResourceDescriptor;
 /**
  * The keys wanted this frame, each once, as want lists them.
  * @type {ShaderResourceDescriptor}
@@ -135,6 +153,58 @@ export const PROBE_RAYS_WRITE_RESOURCE: ShaderResourceDescriptor;
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_RAYS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Each listed probe's rays this update that the budget does not scale, `{count, elements}` by its place in
+ * the trace list: a uniform update's R and a DEAD probe's fewest, zero for a guided update. The trace
+ * command writes the count, the ray counts pass the elements.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RAY_COUNTS_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Each listed probe's rays this update that the budget scales, laid out as `probe_ray_counts`: a guided
+ * update's request, zero for any other.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RAY_REQUESTS_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The inclusive sums of `probe_ray_counts`, as the scan leaves them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RAY_COUNT_SUMS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The inclusive sums of `probe_ray_requests`, as the scan leaves them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RAY_REQUEST_SUMS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The frame's rays laid out by listed probe (§8.6): inclusive sums of each listed probe's rays, so that the
+ * k-th listed probe's rays are the frame's `[sums[k − 1], sums[k])`, the first from 0, and the frame's
+ * count of rays is the last sum. The ray layout pass writes them, the trace command their count.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RAY_SUMS_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The frame's rays laid out by listed probe, as the passes after the layout read them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RAY_SUMS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A slot's ray request (§8.6), as projection writes it after each update: the rays its next guided update
+ * asks for, and what tells it the probe's light moved.
+ *
+ * @type {WebGPUStruct}
+ */
+export const PROBE_REQUEST_STRUCT: WebGPUStruct;
+/**
+ * Each slot's {@link PROBE_REQUEST_STRUCT}, as projection writes it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_REQUESTS_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Each slot's ray request, as the ray counts pass reads it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_REQUESTS_READ_RESOURCE: ShaderResourceDescriptor;
 /**
  * The listed probes' maps, as accumulation writes them for projection and publish, in list order,
  * `probe_clipmap_maps_words` a probe.
@@ -146,6 +216,14 @@ export const PROBE_MAPS_WRITE_RESOURCE: ShaderResourceDescriptor;
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_MAPS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Each slot's radiance estimators (§8.8), n_r² a slot by texel, as accumulation reads and writes them: the
+ * texel's multi-scale mean past its mean, which the radiance atlas holds. Four words of half floats: the short
+ * mean's r and g; its b and the deviation's r; the deviation's g and b; the blend reduction and the
+ * inconsistency.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ESTIMATORS_RESOURCE: ShaderResourceDescriptor;
 /**
  * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
  * @type {WebGPUStruct}
@@ -196,17 +274,37 @@ export const PROBE_DEPTH_STORE_RESOURCE: ShaderResourceDescriptor;
  * fn probe_state_kind(state: u32) -> u32 // of the state's first word
  * fn probe_state_updates(state: u32) -> u32
  * fn probe_state(kind: u32, updates: u32) -> u32
+ * fn probe_clipmap_age_bucket(age: u32) -> u32 // the bucket of frames unwanted that eviction orders by
+ * fn probe_record_flags(back_face: f32, screen: bool, cascade: u32) -> u32
+ * fn probe_record_cascade(flags: u32) -> u32
+ * fn probe_record_sh_encode(sh: MetroL1) -> vec3<u32> // held to the half float's largest, ±65,504
+ * fn probe_record_sh_decode(sh: vec3<u32>) -> MetroL1
  * fn probe_clipmap_offset_encode(offset: vec3<f32>, spacing: f32) -> u32 // the state's second word
  * fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32>
  * fn probe_clipmap_maps_words(radiance_resolution: u32, depth_resolution: u32) -> u32 // a listed probe's, in probe_maps
  * ```
  *
+ * An age's bucket is its count of binary digits: 0 frames the first, 1 the second, 2 and 3 the third, and
+ * the last everything from 2^(`PROBE_AGE_BUCKETS` − 2) frames on.
+ *
  * The offset's fields are of `PROBE_RELOCATION_LIMIT` of the spacing, 511 steps each way: under a
  * thousandth of the spacing apart, and zero at the lattice point.
  *
  * @type {CodeChunk}
  */
 export const chunk_probe_clipmap: CodeChunk;
+/**
+ * Where the frame's rays are, by listed probe (§8.6): the scan of each listed probe's count of rays this
+ * update, `probe_ray_sums`. A probe's rays follow one another, in the trace list's order.
+ *
+ * ```wgsl
+ * fn probe_clipmap_ray_probe(ray: u32) -> u32 // the listed probe the frame's ray is one of, by its place in the list; the list's count or more for none
+ * fn probe_clipmap_probe_rays(k: u32) -> vec2<u32> // the k-th listed probe's first ray, and how many it has
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_ray_layout: CodeChunk;
 /**
  * Which octahedral radiance texel a ray of an update is, and the way back (§8.6). An update casts R rays
  * over the n_r² texels:
@@ -226,6 +324,92 @@ export const chunk_probe_clipmap: CodeChunk;
  * @type {CodeChunk}
  */
 export const chunk_probe_clipmap_ray_texel: CodeChunk;
+/**
+ * The STBN jitter of a ray in its texel (§8.6): the noise moved by the slot's hash so that neighbouring
+ * probes do not jitter alike, and a fresh sample for each update and each round of a texel's rays. The
+ * trace aims its ray by it, and the light pass picks the probes at its hit with it (§8.7).
+ *
+ * ```wgsl
+ * fn probe_clipmap_ray_jitter(slot: u32, texel: u32, ray: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> // ray: its index among the probe's R; n: n_r
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_ray_jitter: CodeChunk;
+/**
+ * Where a ray of an update starts (§8.6): a point of the ball of `PROBE_RAY_ORIGIN_JITTER` of the spacing
+ * around the probe, uniform in its volume, as Brick4's bake jitters its probes. The point is drawn from the
+ * probe's slot and the ray's direction as its record packs it, so every pass that puts a hit back together
+ * from `t` (shade, light, want hits) draws the same one. The trace's jitter moves the direction every
+ * update, and the point with it.
+ *
+ * ```wgsl
+ * fn probe_clipmap_ray_origin(probe: vec4<f32>, slot: u32, direction: u32) -> vec3<f32> // probe: its `probe_origins` entry; direction: as the ray's record packs it
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_ray_origin: CodeChunk;
+/**
+ * The listed probes' guides, `probe_guide_words` a probe in list order, as the guide passes write them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_GUIDE_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The listed probes' guides, as trace, accumulation and projection read them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_GUIDE_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The guide's walk over a probe's octahedral texels, and the weights it walks (§8.6). A guided update
+ * gives each texel `R·(w + e)/W` rays: `w` is its weight, `e` the even share of the leftover, `W` the
+ * total. Its rays follow one another in the order of the walk. That order is the radiance map's rows,
+ * from the corner the update's count names (`updates mod 4` mirrors x, y, or both), and it is its own
+ * inverse.
+ *
+ * A probe's first n_r²/R updates are uniform, so that together they reach every texel (Enshrouded gives a new
+ * probe its most rays for the same reason): the guide would weigh a texel no ray has reached as dark.
+ *
+ * A DEAD probe's updates are all uniform. Readers weigh it at nothing, so its light is not worth guiding.
+ * Its updates exist to reclassify it, and only uniform rays do that (§8.4); guided ones would leave it
+ * dead for `PROBE_UNIFORM_PERIOD` of its already rare updates.
+ *
+ * - A texel's weight is its share of the probe's luminance in units of 1/`PROBE_GUIDE_SCALE`, held to
+ *   `(PROBE_TEXEL_RAYS − 2 − R/n_r²)/R`. With the even share added, that leaves a texel under
+ *   `PROBE_TEXEL_RAYS` rays. What the hold takes off, and what flooring the weights leaves over, is
+ *   spread evenly over every texel. A dark probe's rays are therefore an even, stratified spread.
+ * - The walk position `p` starts at ray `⌈R·Σ_{q<p}(w_q + e)/W − φ⌉`, `φ` being the update's phase in
+ *   [0, 1). That is systematic sampling: every texel takes ⌊its share⌋ or ⌈its share⌉ rays.
+ * - A guide's words (`probe_clipmap_guide_words`, by offset from the probe's): the first rays by walk
+ *   position at 0; the weights by texel at n_r²; the row luminances at 2·n_r²; the row weights at
+ *   2·n_r² + n_r; the total at 2·n_r² + 2·n_r, and the even share after it.
+ *
+ * ```wgsl
+ * fn probe_clipmap_guided(state: u32, period: u32, rays: u32, texels: u32) -> bool // the state's first word: the update's rays follow the guide
+ * fn probe_clipmap_guide_words(n: u32) -> u32
+ * fn probe_clipmap_guide_texel(position: u32, updates: u32, n: u32) -> u32 // and the other way: the walk is its own inverse
+ * fn probe_clipmap_guide_luminance(radiance: vec3<f32>) -> f32
+ * fn probe_clipmap_guide_weight(luminance: f32, total: f32, rays: u32, texels: u32) -> u32
+ * fn probe_clipmap_guide_phase(slot: u32, updates: u32) -> f32
+ * fn probe_clipmap_guide_start(before: u32, total: u32, rays: u32, phase: f32) -> u32 // before: the weight walked before
+ * fn probe_clipmap_guide_rate(expected: f32, rays: u32, texels: u32, period: u32) -> f32 // the share of updates a texel takes rays in
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_guide: CodeChunk;
+/**
+ * The jitter of a guided update's ray in its texel. The first ray takes the texel's STBN jitter
+ * (`probe_clipmap_ray_jitter` at round 0). The rest rotate it by the R2 sequence, so a texel's rays
+ * spread over it the way a lattice does.
+ *
+ * ```wgsl
+ * fn probe_clipmap_guided_ray_jitter(slot: u32, texel: u32, round: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> // round: the ray's place among its texel's
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_guided_ray_jitter: CodeChunk;
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"AAoCA;;;;;;GAMG;AACH,kCAFU,YAAY,CAcJ;AAElB;;;;;GAKG;AACH,+BAFU,YAAY,CAqBP;AAEf;;;;;;GAMG;AACH,oCAFU,wBAAwB,CAEyE;AAE3G;;;;GAIG;AACH,+CAFU,wBAAwB,CAE0G;AAE5I;;;;GAIG;AACH,0CAFU,wBAAwB,CAE+F;AAEjI;;;GAGG;AACH,yCAFU,wBAAwB,CAEwF;AAE1H;;;GAGG;AACH,2CAFU,wBAAwB,CAE+G;AAEjJ;;;GAGG;AACH,0CAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,sCAFU,wBAAwB,CAEkG;AAEpI;;;;GAIG;AACH,2CAFU,wBAAwB,CAEoF;AAEtH;;;GAGG;AACH,kCAFU,wBAAwB,CAE6E;AAE/G;;;GAGG;AACH,yCAFU,wBAAwB,CAEgG;AAElI;;;GAGG;AACH,0CAFU,wBAAwB,CAEyG;AAE3I;;;GAGG;AACH,4CAFU,wBAAwB,CAEoG;AAEtI;;;GAGG;AACH,yCAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,8CAFU,wBAAwB,CAE0F;AAE5H;;;GAGG;AACH,yCAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,wCAFU,wBAAwB,CAEyF;AAE3H;;;GAGG;AACH,0CAFU,wBAAwB,CAEmG;AAErI;;;GAGG;AACH,yCAFU,wBAAwB,CAE2F;AAE7H;;;GAGG;AACH,sCAFU,wBAAwB,CAEqF;AAEvH;;;;GAIG;AACH,2CAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,0CAFU,wBAAwB,CAE0F;AAE5H;;;GAGG;AACH,wCAFU,wBAAwB,CAEsG;AAExI;;;GAGG;AACH,uCAFU,wBAAwB,CAE+F;AAEjI;;;;GAIG;AACH,wCAFU,wBAAwB,CAEmF;AAErH;;;GAGG;AACH,uCAFU,wBAAwB,CAE4E;AAE9G;;;GAGG;AACH,0CAFU,YAAY,CAQG;AAEzB;;;GAGG;AACH,8CAFU,wBAAwB,CAE6H;AAE/J;;;GAGG;AACH,6CAFU,wBAAwB,CAEsH;AAExJ;;;;GAIG;AACH,8CAFU,wBAAwB,CAE+E;AAEjH;;;;GAIG;AACH,2CAFU,wBAAwB,CAEyE;AAE3G;;;GAGG;AACH,4CAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,yCAFU,wBAAwB,CAEgG;AAElI;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,kCAFU,SAAS,CAqFhB;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,4CAFU,SAAS,CA+BhB;6BAtb0B,sCAAsC;yCAH1B,sDAAsD;0BADrE,uCAAuC"}
+{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"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"}