@woosh/meep-engine 3.37.0 → 3.39.0

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_build_warp.js

@@ -1,3 +1,4 @@
+import { WebGPUExtensionType } from "../../../../descriptor/WebGPUExtensionType.js";
 import { u32, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
@@ -6,8 +7,10 @@ import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { AVBOIT_OCCUPANCY_WORDS, AVBOIT_VIRTUAL_SLICES_MAX } from "./AVBOIT_CONSTANTS.js";
 import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
-import { chunk_avboit_dilate_word } from "./chunk_avboit_dilate_word.js";
-import { chunk_avboit_fold_pairs } from "./chunk_avboit_fold_pairs.js";
+import { chunk_avboit_warp_level_word } from "./chunk_avboit_warp_level_word.js";
+import { chunk_avboit_warp_lut_entry } from "./chunk_avboit_warp_lut_entry.js";
+import { chunk_avboit_warp_marks } from "./chunk_avboit_warp_marks.js";
+import { chunk_avboit_warp_step_count } from "./chunk_avboit_warp_step_count.js";
 
 /**
  * Per-frame inputs of the warp build, all of which land in the warp header.
@@ -20,6 +23,8 @@ export const AVBOIT_BUILD_WARP_SETTINGS_STRUCT = WebGPUStruct.from({
     voxel_height: u32,
     /** AVBOITSettings.transmission_tint_from_base_color as 0 / 1, copied into the header */
     tint_from_base_color: u32,
+    /** AVBOITSettings.warp_steps_per_octave: virtual resolutions tried per octave, 1 for octaves alone */
+    steps_per_octave: u32,
     /** the depth curve, see avboit_build_depth_curve */
     cluster_parameters: vec3f,
 }, "AVBOITBuildWarpSettings").pack();
@@ -32,102 +37,196 @@ resources.createGroup()
     .addStorageBuffer("warp", AVBOIT_WARP_STRUCT, true)
 ;
 
+/**
+ * Invocations of the warp build: one per occupancy word.
+ * @type {number}
+ */
+const WARP_THREADS = AVBOIT_OCCUPANCY_WORDS;
+
 /**
  * AVBOIT warp build: turns the finest-level occupancy bits into the depth-warp LUT (plan §3.4).
  *
- * One invocation does the whole thing. Per level: dilate by one slice each side at that level,
- * count; if the count fits the physical budget, or the level is already down at the physical count,
- * stop — otherwise halve the *undilated* bits by OR-ing adjacent pairs and go again. Dilation is
- * applied fresh at each level rather than once at the finest, because a one-slice margin at 1024
- * slices is a quarter of a slice at 256 and rounds away; the margin is what keeps a fragment on the
- * edge of a meshlet's bounds from linear-splatting into a neighbouring run.
+ * Per octave: dilate by one slice each side at that level, count; if the count fits the physical
+ * budget, or the level is already down at the physical count, stop — otherwise halve and go again.
+ * Each level is marked afresh from the finest bits ({@link chunk_avboit_warp_marks}), so halving is not
+ * a fold of the level above but the same rule every resolution uses: a slice is occupied when a finest
+ * slice it overlaps is.
+ *
+ * **Steps between octaves** (`steps_per_octave > 1`). Halving lands the occupied count anywhere from
+ * about half the budget to all of it, so up to half the precision the budget allows goes unused. Between
+ * the octave that fits and the one above it that did not, the build tries
+ * `2 L · 2^(-i / steps)` virtual slices, finest first, and takes the first that fits. Those do not nest
+ * in the finest slices; the overlap rule is conservative for them, and consumers take any virtual count
+ * — the coordinate is the finest one scaled by `V / V_max` — so nothing past this shader changes.
  *
  * The LUT is then an exclusive prefix count of the dilated bits, with the bit itself in the low
  * position — see `AVBOIT_WARP_STRUCT`.
  *
- * Single-lane by design, not as a fallback: 32 words and at most three halvings is a few thousand
- * bit operations, and staying single-lane is what lets the WGSL emulator run this shader as-is.
+ * One workgroup, an invocation per occupancy word, each holding its finest word for the whole build.
+ * A resolution tried is every invocation marking the virtual slices its runs touch — two words at most,
+ * OR-ed into workgroup memory, so all of them work at every resolution — then every word of that
+ * resolution dilated by its own invocation and a subgroup reduction of their counts. The LUT is a
+ * subgroup scan of the chosen words' counts and `V_max / WARP_THREADS` coalesced writes per invocation. Every decision is made on a count read
+ * back through `workgroupUniformLoad`, so the workgroup takes the same path through the loops. The
+ * emulator cannot run a workgroup that cooperates through barriers, so the pure parts are chunks with
+ * their own specs and the whole is verified on a device (AVBOIT ledger entry 28).
  */
 const body = CodeChunk.from(
     //language=WGSL
     `
-const AVBOIT_OCCUPANCY_WORDS: u32 = ${AVBOIT_OCCUPANCY_WORDS}u;
-
-@compute @workgroup_size(1)
-fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
-
-    if (global_id.x != 0u) {
-        return;
+const AVBOIT_VIRTUAL_SLICES_MAX_U: u32 = ${AVBOIT_VIRTUAL_SLICES_MAX}u;
+const AVBOIT_WARP_THREADS: u32 = ${WARP_THREADS}u;
+const AVBOIT_WARP_SLICES_SHIFT: u32 = ${Math.log2(AVBOIT_VIRTUAL_SLICES_MAX)}u;
+// halvings from the finest resolution to a single slice, the most the octave loop can take
+const AVBOIT_WARP_OCTAVES: u32 = ${Math.log2(AVBOIT_VIRTUAL_SLICES_MAX) + 1}u;
+// LUT entries each invocation writes before the closing one
+const AVBOIT_WARP_LUT_ROUNDS: u32 = ${AVBOIT_VIRTUAL_SLICES_MAX / WARP_THREADS}u;
+const AVBOIT_WARP_MIN_SUBGROUP_SIZE: u32 = 4u;
+
+// the virtual slices the finest runs touch, undilated; alternate tries use alternate halves, each try
+// zeroing the half the next will mark
+var<workgroup> wg_marked: array<array<atomic<u32>, AVBOIT_WARP_THREADS>, 2>;
+// [0]: the octave's words, [1]: the step being tried; every word of the workgroup, 0 past the resolution
+var<workgroup> wg_words: array<array<u32, AVBOIT_WARP_THREADS>, 2>;
+// occupied slices in the chosen words before each one
+var<workgroup> wg_words_below: array<u32, AVBOIT_WARP_THREADS>;
+var<workgroup> wg_partials: array<u32, AVBOIT_WARP_THREADS / AVBOIT_WARP_MIN_SUBGROUP_SIZE>;
+var<workgroup> wg_broadcast: u32;
+
+// \`value\` summed over the workgroup, the same for every invocation
+fn avboit_warp_sum(value: u32, thread: u32, lane: u32, lane_count: u32) -> u32 {
+    let subgroup_total = subgroupAdd(value);
+    if (lane == 0u) {
+        wg_partials[thread / lane_count] = subgroup_total;
     }
+    workgroupBarrier();
+    if (thread == 0u) {
+        var total = 0u;
+        for (var s = 0u; s < AVBOIT_WARP_THREADS / lane_count; s++) {
+            total += wg_partials[s];
+        }
+        wg_broadcast = total;
+    }
+    return workgroupUniformLoad(&wg_broadcast);
+}
 
-    let physical = settings.physical_count;
-
-    var words: array<u32, AVBOIT_OCCUPANCY_WORDS>;
-    var dilated: array<u32, AVBOIT_OCCUPANCY_WORDS>;
+// \`value\` summed over the invocations before this one
+fn avboit_warp_sum_below(value: u32, thread: u32, lane: u32, lane_count: u32) -> u32 {
+    let subgroup = thread / lane_count;
+    let below_in_subgroup = subgroupExclusiveAdd(value);
+    let subgroup_total = subgroupAdd(value);
+    if (lane == 0u) {
+        wg_partials[subgroup] = subgroup_total;
+    }
+    workgroupBarrier();
+    var below = below_in_subgroup;
+    for (var s = 0u; s < subgroup; s++) {
+        below += wg_partials[s];
+    }
+    return below;
+}
 
-    for (var w = 0u; w < AVBOIT_OCCUPANCY_WORDS; w++) {
-        words[w] = occupancy[w];
-        dilated[w] = 0u;
+// every word of the slicing into \`virtual_count\` virtual slices into wg_words[slot]; its occupied count
+fn avboit_warp_try(virtual_count: u32, slot: u32, parity: u32, finest: u32, thread: u32, lane: u32, lane_count: u32) -> u32 {
+    let marks = avboit_warp_marks(finest, thread, virtual_count);
+    // a second word is marked only where that word holds a slice below virtual_count, so it exists
+    let first_word = (thread * virtual_count) >> AVBOIT_WARP_SLICES_SHIFT;
+    if (marks.x != 0u) {
+        atomicOr(&wg_marked[parity][first_word], marks.x);
     }
+    if (marks.y != 0u) {
+        atomicOr(&wg_marked[parity][first_word + 1u], marks.y);
+    }
+    workgroupBarrier();
 
-    var level_count = ${AVBOIT_VIRTUAL_SLICES_MAX}u;
-    var word_count = AVBOIT_OCCUPANCY_WORDS;
+    let marked_below = select(0u, atomicLoad(&wg_marked[parity][max(thread, 1u) - 1u]), thread > 0u);
+    let marked = atomicLoad(&wg_marked[parity][thread]);
+    let marked_above = select(0u, atomicLoad(&wg_marked[parity][min(thread + 1u, AVBOIT_WARP_THREADS - 1u)]), thread + 1u < AVBOIT_WARP_THREADS);
+    let word = avboit_warp_level_word(marked_below, marked, marked_above, thread, virtual_count);
+    wg_words[slot][thread] = word;
+    atomicStore(&wg_marked[1u - parity][thread], 0u);
 
-    loop {
-        var occupied = 0u;
+    return avboit_warp_sum(countOneBits(word), thread, lane, lane_count);
+}
 
-        for (var w = 0u; w < word_count; w++) {
-            var below = 0u;
-            if (w > 0u) {
-                below = words[w - 1u] >> 31u;
-            }
-            var above = 0u;
-            if (w + 1u < word_count) {
-                above = (words[w + 1u] & 1u) << 31u;
-            }
-            let d = avboit_dilate_word(words[w], below, above);
-            dilated[w] = d;
-            occupied += countOneBits(d);
-        }
+@compute @workgroup_size(AVBOIT_WARP_THREADS)
+fn main(
+    @builtin(local_invocation_index) thread: u32,
+    @builtin(subgroup_invocation_id) lane: u32,
+    @builtin(subgroup_size) lane_count: u32,
+) {
+    let physical = settings.physical_count;
+    let finest = occupancy[thread];
+    var tries = 0u;
+
+    var level = AVBOIT_VIRTUAL_SLICES_MAX_U;
 
-        if (occupied <= physical || level_count <= physical) {
+    for (var octave = 0u; octave < AVBOIT_WARP_OCTAVES; octave++) {
+        let occupied = avboit_warp_try(level, 0u, tries & 1u, finest, thread, lane, lane_count);
+        tries++;
+        if (occupied <= physical || level <= physical) {
             break;
         }
+        level = level / 2u;
+    }
 
-        // halve: two old words become one new word
-        let half_words = word_count / 2u;
-        for (var nw = 0u; nw < half_words; nw++) {
-            words[nw] = avboit_fold_pairs(words[2u * nw]) | (avboit_fold_pairs(words[2u * nw + 1u]) << 16u);
+    // between the octave that fits and the one above it, the finest step that fits as well
+    var slot = 0u;
+    let steps = max(settings.steps_per_octave, 1u);
+
+    if (steps > 1u && level < AVBOIT_VIRTUAL_SLICES_MAX_U) {
+        let octave = level;
+
+        for (var i = 1u; i < steps; i++) {
+            let candidate = avboit_warp_step_count(octave, steps, i);
+            let occupied = avboit_warp_try(candidate, 1u, tries & 1u, finest, thread, lane, lane_count);
+            tries++;
+            if (occupied <= physical) {
+                level = candidate;
+                slot = 1u;
+                break;
+            }
         }
+    }
 
-        word_count = half_words;
-        level_count = level_count / 2u;
+    // the chosen words were written behind the barriers of the count that chose them
+    let count = countOneBits(wg_words[slot][thread]);
+    let below = avboit_warp_sum_below(count, thread, lane, lane_count);
+    wg_words_below[thread] = below;
+    workgroupBarrier();
+
+    for (var i = 0u; i < AVBOIT_WARP_LUT_ROUNDS; i++) {
+        let v = i * AVBOIT_WARP_THREADS + thread;
+        if (v < level) {
+            let w = v >> 5u;
+            warp.lut[v] = avboit_warp_lut_entry(wg_words[slot][w], v & 31u, wg_words_below[w]);
+        }
     }
 
-    warp.virtual_count = level_count;
-    warp.physical_count = physical;
-    warp.voxel_width = settings.voxel_width;
-    warp.voxel_height = settings.voxel_height;
-    warp.tint_from_base_color = settings.tint_from_base_color;
-    warp.cluster_parameters = settings.cluster_parameters;
+    if (thread == AVBOIT_WARP_THREADS - 1u) {
+        let total = below + count;
 
-    var prefix = 0u;
+        warp.lut[level] = total << 1u;
+        warp.occupied_count = total;
 
-    for (var v = 0u; v < level_count; v++) {
-        let bit = (dilated[v >> 5u] >> (v & 31u)) & 1u;
-        warp.lut[v] = (prefix << 1u) | bit;
-        prefix += bit;
+        warp.virtual_count = level;
+        warp.physical_count = physical;
+        warp.voxel_width = settings.voxel_width;
+        warp.voxel_height = settings.voxel_height;
+        warp.tint_from_base_color = settings.tint_from_base_color;
+        warp.cluster_parameters = settings.cluster_parameters;
     }
-
-    warp.lut[level_count] = prefix << 1u;
-    warp.occupied_count = prefix;
 }
     `, [
-        chunk_avboit_dilate_word,
-        chunk_avboit_fold_pairs,
+        chunk_avboit_warp_level_word,
+        chunk_avboit_warp_lut_entry,
+        chunk_avboit_warp_marks,
+        chunk_avboit_warp_step_count,
     ]
 );
 
+body.addExtension(WebGPUExtensionType.Subgroups);
+
 export const shader_avboit_build_warp = ComputeShader.from({
     label: 'AVBOIT / build warp',
     resources,

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js"],"names":[],"mappings":"AA4EA,gDAUE;4BApF0B,gCAAgC"}
+{"version":3,"file":"shader_avboit_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js"],"names":[],"mappings":"AAwEA,gDAUE;4BAhF0B,gCAAgC"}

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js

@@ -3,6 +3,7 @@ import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { chunk_avboit_renormalization } from "./chunk_avboit_renormalization.js";
 
 const resources = new ShaderResourceSetDescriptor();
 resources.createGroup()
@@ -19,7 +20,7 @@ resources.createGroup()
  *
  * ```
  * T_total = exp(-Σ extinction)
- * norm    = Σ norm > ε ? (1 - T_total) / Σ norm : 0
+ * norm    = Σ norm > 0 ? stable_lost_throughput(Σ extinction) / Σ norm : 0
  * out     = scene × T_total + Σ color × norm + Σ emission
  * ```
  *
@@ -58,19 +59,14 @@ fn main(
     let total_transmittance = exp(-accum_extinction);
 
     // sum of (1 - T_self) * T at each fragment; zero where nothing transparent was drawn
-    let safe = accum_norm > vec3<f32>(1e-4);
-    let renormalization = select(
-        vec3<f32>(0.0),
-        (vec3<f32>(1.0) - total_transmittance) / max(accum_norm, vec3<f32>(1e-4)),
-        safe
-    );
+    let renormalization = avboit_renormalization(accum_extinction, accum_norm);
 
     let transparent = accum_color * renormalization;
 
     return vec4<f32>(scene.rgb * total_transmittance + transparent + accum_emission, scene.a);
 }
     `, [
-        chunk_is_nan
+        chunk_is_nan, chunk_avboit_renormalization
     ]
 )
 

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IA5KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2HD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAiBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAtuBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAoCf;IA/KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA8HD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAiBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAzuBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -248,7 +248,10 @@ export class GPUSceneContext {
 
         this.volumetric_light_map = new Brick4LightMap(device);
 
-        this.#volumetrics = new GPUSceneVolumetrics(device, scene.volumetrics);
+        this.#volumetrics = new GPUSceneVolumetrics(
+            this.#scene_database.get('participating_media_volumes'),
+            scene.volumetrics
+        );
 
         this.#animation_manager = new GPUAnimationManager(device, `GPUSceneContext[${this.id}]/Animation`, this);
     }

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wDAGG;sCAbmC,0CAA0C"}
+{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wDAOG;sCAlBmC,0CAA0C"}

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.js

@@ -1,6 +1,7 @@
 import { GPUDatabaseDefinition } from "../buffer/table/GPUDatabaseDefinition.js";
 import { MESH_INSTANCE_METADATA_STRUCT } from "./MESH_INSTANCE_METADATA_STRUCT.js";
 import { NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "../volumetrics/PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
 
 /**
  * Schema for the scene's GPU-resident records — meshes and the
@@ -11,6 +12,10 @@ import { NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
 export const SCENE_DATABASE_SPEC = GPUDatabaseDefinition.from({
     meshes: MESH_INSTANCE_METADATA_STRUCT,
     transforms: NODE3D_STRUCT,
+    // the scene's fog, smoke and cloud volumes (SceneVolumetrics), written whole by
+    // GPUSceneVolumetrics whenever their version moves; read by the froxel volumetrics and by the
+    // ray passes through chunk_participating_media_volumes_iterate
+    participating_media_volumes: PARTICIPATING_MEDIA_VOLUME_STRUCT,
 });
 
 // A mesh's transform. A mesh row and its transforms row are the same row — the entity's, one on —

package/src/shade/renderer/scene/shader_bvh_extract_instance_leaves.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_extract_instance_leaves.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/shader_bvh_extract_instance_leaves.js"],"names":[],"mappings":"AAUA,4CAA6C;AAkH7C;;;;;;;;;;;;;;;;;GAiBG;AACH,iDAFU,aAAa,CAMpB;8BA7I2B,4BAA4B"}
+{"version":3,"file":"shader_bvh_extract_instance_leaves.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/shader_bvh_extract_instance_leaves.js"],"names":[],"mappings":"AAWA,4CAA6C;AAmH7C;;;;;;;;;;;;;;;;;GAiBG;AACH,iDAFU,aAAa,CAMpB;8BA9I2B,4BAA4B"}

package/src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.d.ts

@@ -4,7 +4,18 @@
  */
 export const C_MIE_SCATTERING_DECLARATION: CodeChunk;
 /**
- * Mie absorption
+ * Mie extinction: scattering plus absorption. Hillaire's Earth authors this and the scattering,
+ * not the absorption -- 0.004440 and 0.003996 per km.
+ *
+ * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Application/SkyAtmosphereCommon.cpp#L40
+ */
+export const C_MIE_EXTINCTION_DECLARATION: CodeChunk;
+/**
+ * Mie absorption, derived the way Hillaire does: extinction less scattering, 0.444e-6 per metre,
+ * a tenth of the extinction. The shadertoy port wrote the 4.4 extinction here as the absorption,
+ * which put the extinction at 8.396e-6.
+ *
+ * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Application/Game.cpp#L707
  */
 export const C_MIE_ABSORPTION_DECLARATION: CodeChunk;
 import { CodeChunk } from "../../compiler/CodeChunk.js";

package/src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"C_MIE_SCATTERING_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qDAGE;AAEF;;GAEG;AACH,qDAGE;0BAjBwB,6BAA6B"}
+{"version":3,"file":"C_MIE_SCATTERING_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qDAGE;AAEF;;;;;GAKG;AACH,qDAGE;AAEF;;;;;;GAMG;AACH,qDAOE;0BApCwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.js

@@ -10,9 +10,28 @@ export const C_MIE_SCATTERING_DECLARATION = CodeChunk.from(
 );
 
 /**
- * Mie absorption
+ * Mie extinction: scattering plus absorption. Hillaire's Earth authors this and the scattering,
+ * not the absorption -- 0.004440 and 0.003996 per km.
+ *
+ * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Application/SkyAtmosphereCommon.cpp#L40
+ */
+export const C_MIE_EXTINCTION_DECLARATION = CodeChunk.from(
+    //language=WGSL
+    "const C_MIE_EXTINCTION = vec3(4.44) * 1e-6;"
+);
+
+/**
+ * Mie absorption, derived the way Hillaire does: extinction less scattering, 0.444e-6 per metre,
+ * a tenth of the extinction. The shadertoy port wrote the 4.4 extinction here as the absorption,
+ * which put the extinction at 8.396e-6.
+ *
+ * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Application/Game.cpp#L707
  */
 export const C_MIE_ABSORPTION_DECLARATION = CodeChunk.from(
     //language=WGSL
-    "const C_MIE_ABSORPTION = vec3(4.4) * 1e-6;"
-);
+    "const C_MIE_ABSORPTION = C_MIE_EXTINCTION - C_MIE_SCATTERING;",
+    [
+        C_MIE_EXTINCTION_DECLARATION,
+        C_MIE_SCATTERING_DECLARATION,
+    ]
+);

package/src/shade/renderer/shader/chunk/atmosphere/phase/chunk_sample_henyey_greenstein_cos.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Inverse CDF of the Henyey-Greenstein phase function: the cosine of the scattering angle, in the
+ * convention of `phase_mie` (`chunk_phase_mie_henyey_greenstein`) — +1 is straight on — for a
+ * uniform `xi` in [0, 1].
+ *
+ * The textbook inverse, `(1 + g² - ((1 - g²) / (1 - g + 2 g xi))²) / (2 g)`, cancels to O(g) in the
+ * numerator and divides by `g`, so it loses digits as g shrinks and needs an isotropic special case
+ * at g = 0. With `w = 2 xi - 1` the same function is
+ *
+ *      mu = (w + g) / (1 + g w) + g (1 - g²) (1 - w²) / (2 (1 + g w)²)
+ *
+ * which needs no special case (mu = w at g = 0), and lands exactly on -1 and +1 at the ends of the
+ * interval for every g in (-1, 1): there the second term is zero and the first is a ratio of two
+ * exact differences. `1 - w²` is formed as `4 xi (1 - xi)` so it does not cancel near the ends.
+ */
+export const chunk_sample_henyey_greenstein_cos: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sample_henyey_greenstein_cos.d.ts.map

package/src/shade/renderer/shader/chunk/atmosphere/phase/chunk_sample_henyey_greenstein_cos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sample_henyey_greenstein_cos.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/chunk_sample_henyey_greenstein_cos.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,2DAaE;0BA9BwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/atmosphere/phase/chunk_sample_henyey_greenstein_cos.js

@@ -0,0 +1,31 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Inverse CDF of the Henyey-Greenstein phase function: the cosine of the scattering angle, in the
+ * convention of `phase_mie` (`chunk_phase_mie_henyey_greenstein`) — +1 is straight on — for a
+ * uniform `xi` in [0, 1].
+ *
+ * The textbook inverse, `(1 + g² - ((1 - g²) / (1 - g + 2 g xi))²) / (2 g)`, cancels to O(g) in the
+ * numerator and divides by `g`, so it loses digits as g shrinks and needs an isotropic special case
+ * at g = 0. With `w = 2 xi - 1` the same function is
+ *
+ *      mu = (w + g) / (1 + g w) + g (1 - g²) (1 - w²) / (2 (1 + g w)²)
+ *
+ * which needs no special case (mu = w at g = 0), and lands exactly on -1 and +1 at the ends of the
+ * interval for every g in (-1, 1): there the second term is zero and the first is a ratio of two
+ * exact differences. `1 - w²` is formed as `4 xi (1 - xi)` so it does not cancel near the ends.
+ */
+export const chunk_sample_henyey_greenstein_cos = CodeChunk.from(
+    //language=WGSL
+    `
+fn sample_henyey_greenstein_cos(xi: f32, g: f32) -> f32 {
+    let w = 2.0 * xi - 1.0;
+    let denominator = 1.0 + g * w;
+
+    let mobius = (w + g) / denominator;
+    let correction = g * (1.0 - g * g) * (4.0 * xi * (1.0 - xi)) / (2.0 * denominator * denominator);
+
+    return clamp(mobius + correction, -1.0, 1.0);
+}
+    `
+);

package/src/shade/renderer/shader/chunk/atmosphere/phase/ff/chunk_phase_fournier_forand.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The Fournier-Forand phase function: scattering by a Junge (power-law) population of particles,
+ * the analytic form fitted to measured ocean phase functions. Parameterized by
+ *
+ *  - `nu` = (3 - junge_slope) / 2, in (-1, 0)
+ *  - `kappa` = 4 / (3 (n - 1)²), the value of FF's delta at 180 degrees
+ *
+ * which `fournier_forand_parameters_from_backscatter` derives from a backscatter fraction.
+ *
+ * Everything here takes `sin2_half` = sin²(psi / 2) = (1 - cos psi) / 2 rather than the cosine:
+ * the forward peak is so narrow that most of its mass sits at angles an f32 cosine rounds to
+ * exactly 1. A caller holding two unit directions gets it without cancellation as
+ * |a - b|² / 4. `phase_fournier_forand` takes a cosine for callers that only have one.
+ *
+ * With delta = kappa sin2_half, the density and the cumulative (fraction scattered into angles
+ * below psi) are
+ *
+ *      p(psi) = [ r - s / sin2_half ] / (4 pi delta^nu) + C' (3 cos² psi - 1)
+ *      F(psi) = [ 1 + delta q (1 - 1 / kappa) ] / delta^nu + (C / 8) cos psi sin² psi
+ *
+ *      q = (1 - delta^nu) / (1 - delta),   r = (nu - q) / (1 - delta),   s = r + q = (nu - delta q) / (1 - delta)
+ *      C = (1 - kappa^nu) / ((kappa - 1) kappa^nu),   C' = C / (16 pi)
+ *
+ * which is Mobley et al.'s form regrouped so that its removable singularities at delta = 1
+ * (psi of about 10 to 14 degrees for natural water) sit inside q and r. Within |e| < 0.25 of it,
+ * e = delta - 1, those are evaluated by their binomial series, q = sum_{k>=1} C(nu, k) e^(k-1) and
+ * r = sum_{k>=2} C(nu, k) e^(k-2); outside it directly. s is formed directly outside the band
+ * because r and q there are two large terms of opposite sign at small delta, deep in the forward
+ * peak, and their sum would lose every digit.
+ *
+ * Transcriptions of FF differ between sources, so this one is pinned by its specs rather than by
+ * any citation: it integrates to one, its cumulative is the integral of its density, and its
+ * backscatter is the fraction it was solved for. The sign of the cos psi sin² psi term is the one
+ * that makes the cumulative the integral of Mobley's density, whose last term is
+ * +C' (3 cos² psi - 1); it is invisible to normalization and to the backscatter fraction, because it
+ * vanishes at 0, 90 and 180 degrees.
+ *
+ * @see Fournier, Forand, "Analytic phase function for ocean water", Proc. SPIE 2258, 1994
+ * @see Mobley, Sundman, Boss, "Phase function effects on oceanic light fields", Applied Optics 41(6), 2002
+ */
+export const chunk_phase_fournier_forand: CodeChunk;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_phase_fournier_forand.d.ts.map

package/src/shade/renderer/shader/chunk/atmosphere/phase/ff/chunk_phase_fournier_forand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_phase_fournier_forand.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/ff/chunk_phase_fournier_forand.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,oDA6GE;0BAxJwB,mCAAmC"}