@woosh/meep-engine 3.42.0 → 3.44.0

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode1.d.ts

@@ -0,0 +1,25 @@
+/**
+ * One BC7 mode 1 block from its partition, four endpoints and sixteen indices, as four
+ * little-endian words.
+ *
+ * The layout `bc7_write_block` states for mode 1: two mode bits — a zero and a one — then six bits
+ * of partition, then the colour endpoints by channel, red for both ends of the first subset and then
+ * both ends of the second, then green, then blue, six bits each; one parity bit per *subset*, shared
+ * by its two ends; then the indices, three bits each except the two anchors', texel 0 and the
+ * partition's second anchor, whose top bit is implied zero. Honouring that is the encoder's, by
+ * swapping a subset's ends; this drops the top bit, as the JavaScript writer drops it. Mode 1 has no
+ * alpha: it decodes opaque.
+ *
+ * Endpoints are given as the eight-bit values they decode to — six stored bits, the subset's parity
+ * bit below them, the top bit replicated below that — so the stored bits are read off them. The
+ * parity is read off each subset's first end; the encoder gives both ends the same one.
+ *
+ * Each word is composed by shifts at the fields' fixed positions, except the indices: the second
+ * anchor moves with the partition, so the three-bit fields are laid out as if none were short and
+ * the anchor's top bit is then cut out of the run.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_pack_mode1: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bc7_pack_mode1.d.ts.map

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bc7_pack_mode1.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_pack_mode1.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,mCAFU,SAAS,CA2EZ;0BAlGmB,oCAAoC"}

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode1.js

@@ -0,0 +1,99 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_bc7_partition_2 } from "./chunk_bc7_partition_2.js";
+
+/**
+ * One BC7 mode 1 block from its partition, four endpoints and sixteen indices, as four
+ * little-endian words.
+ *
+ * The layout `bc7_write_block` states for mode 1: two mode bits — a zero and a one — then six bits
+ * of partition, then the colour endpoints by channel, red for both ends of the first subset and then
+ * both ends of the second, then green, then blue, six bits each; one parity bit per *subset*, shared
+ * by its two ends; then the indices, three bits each except the two anchors', texel 0 and the
+ * partition's second anchor, whose top bit is implied zero. Honouring that is the encoder's, by
+ * swapping a subset's ends; this drops the top bit, as the JavaScript writer drops it. Mode 1 has no
+ * alpha: it decodes opaque.
+ *
+ * Endpoints are given as the eight-bit values they decode to — six stored bits, the subset's parity
+ * bit below them, the top bit replicated below that — so the stored bits are read off them. The
+ * parity is read off each subset's first end; the encoder gives both ends the same one.
+ *
+ * Each word is composed by shifts at the fields' fixed positions, except the indices: the second
+ * anchor moves with the partition, so the three-bit fields are laid out as if none were short and
+ * the anchor's top bit is then cut out of the run.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_pack_mode1 = CodeChunk.from(
+    //language=WGSL
+    `
+fn bc7_pack_mode1(
+    pattern: u32,
+    a0: vec3<u32>, a1: vec3<u32>,
+    b0: vec3<u32>, b1: vec3<u32>,
+    indices: array<u32, 16>
+) -> vec4<u32> {
+    // the six stored bits of each end's channels, and each subset's parity
+    let sa0 = a0 >> vec3<u32>(2u);
+    let sa1 = a1 >> vec3<u32>(2u);
+    let sb0 = b0 >> vec3<u32>(2u);
+    let sb1 = b1 >> vec3<u32>(2u);
+
+    let parity_a = (a0.x >> 1u) & 1u;
+    let parity_b = (b0.x >> 1u) & 1u;
+
+    // texels 1 to 15 at three bits each, as if no anchor were short: forty-five bits over two words
+    var low = 0u;
+    var high = 0u;
+
+    for (var i = 1u; i < 16u; i++) {
+        let shift = 3u * (i - 1u);
+        let index = indices[i] & 7u;
+
+        if (shift < 32u) {
+            low |= index << shift;
+        }
+
+        // texel 11's field straddles the two words, bits 30 to 32
+        if (shift == 30u) {
+            high |= index >> 2u;
+        }
+
+        if (shift > 32u) {
+            high |= index << (shift - 32u);
+        }
+    }
+
+    // cut the second anchor's top bit out of the run: the bits below it stay, the bits above it
+    // move down by one
+    let cut = 3u * (bc7_partition_2_anchor(pattern) - 1u) + 2u;
+
+    let keep_low = select(0xFFFFFFFFu, (1u << cut) - 1u, cut < 32u);
+    let keep_high = select((1u << (cut - 32u)) - 1u, 0u, cut < 32u);
+
+    let shifted_low = (low >> 1u) | (high << 31u);
+    let shifted_high = high >> 1u;
+
+    let run_low = (low & keep_low) | (shifted_low & ~keep_low);
+    let run_high = (high & keep_high) | (shifted_high & ~keep_high);
+
+    // the forty-six index bits: texel 0's two, then the run
+    let stream_low = (indices[0] & 3u) | (run_low << 2u);
+    let stream_high = (run_low >> 30u) | (run_high << 2u);
+
+    // mode 1 is signalled by a zero bit and then a one, bits 0 and 1; the partition from bit 2,
+    // red from bit 8
+    let w0 = 2u | (pattern << 2u) | (sa0.x << 8u) | (sa1.x << 14u) | (sb0.x << 20u) | (sb1.x << 26u);
+
+    // the first subset's second blue straddles bits 62 to 67
+    let w1 = sa0.y | (sa1.y << 6u) | (sb0.y << 12u) | (sb1.y << 18u) | (sa0.z << 24u) | (sa1.z << 30u);
+
+    // the parity bits at 80 and 81, the indices from 82
+    let w2 = (sa1.z >> 2u) | (sb0.z << 4u) | (sb1.z << 10u) | (parity_a << 16u) | (parity_b << 17u) | (stream_low << 18u);
+
+    let w3 = (stream_low >> 14u) | (stream_high << 18u);
+
+    return vec4<u32>(w0, w1, w2, w3);
+}
+`, [
+        chunk_bc7_partition_2,
+    ]);

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode6.d.ts

@@ -6,14 +6,16 @@
  * then blue, seven bits each; alpha likewise; one parity bit per endpoint; then the indices, four
  * bits each except texel 0's three, because its top bit is implied zero. That last rule is the
  * encoder's to honour, by swapping the ends when texel 0 lands in the upper half, and this does not
- * check it.
+ * check it: the top bit is dropped, as the JavaScript writer drops it.
  *
  * Endpoints are given as the eight-bit values they decode to — seven stored bits over the parity
  * bit — so the parity is read off them rather than passed beside them, and a caller cannot hand in
  * a pair that disagrees with itself.
  *
- * Bit by bit, as the JavaScript writer is, because the fields straddle word boundaries and a
- * hundred and twenty-eight iterations are nothing.
+ * Each word is composed by shifts at the fields' fixed positions, the two that straddle a word
+ * boundary — the second end's green, bits 28 to 34, and the second parity bit, bit 64 — split
+ * across them. The JavaScript writer goes bit by bit; here a hundred and twenty-eight iterations
+ * over two function-local arrays were 13% of a 4096² encode on a 4090.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode6.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_bc7_pack_mode6.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_pack_mode6.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,mCAFU,SAAS,CAmDhB;0BAtEuB,oCAAoC"}
+{"version":3,"file":"chunk_bc7_pack_mode6.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_pack_mode6.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,mCAFU,SAAS,CAyBhB;0BA9CuB,oCAAoC"}

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode6.js

@@ -1,71 +1,47 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-/**
- * One BC7 mode 6 block from its two endpoints and sixteen indices, as four little-endian words.
- *
- * The layout `bc7_write_block` states for mode 6, in the same order for every field: seven mode
- * bits — six zeros and a one — then the colour endpoints by channel, red for both ends, then green,
- * then blue, seven bits each; alpha likewise; one parity bit per endpoint; then the indices, four
- * bits each except texel 0's three, because its top bit is implied zero. That last rule is the
- * encoder's to honour, by swapping the ends when texel 0 lands in the upper half, and this does not
- * check it.
- *
- * Endpoints are given as the eight-bit values they decode to — seven stored bits over the parity
- * bit — so the parity is read off them rather than passed beside them, and a caller cannot hand in
- * a pair that disagrees with itself.
- *
- * Bit by bit, as the JavaScript writer is, because the fields straddle word boundaries and a
- * hundred and twenty-eight iterations are nothing.
- *
- * @type {CodeChunk}
- */
-export const chunk_bc7_pack_mode6 = CodeChunk.from(
-    //language=WGSL
-    `
-fn bc7_pack_mode6(e0: vec4<u32>, e1: vec4<u32>, indices: array<u32, 16>) -> vec4<u32> {
-    var values: array<u32, 27>;
-    var counts: array<u32, 27>;
-
-    // mode 6 is signalled by six zero bits and then a one
-    values[0] = 64u;
-    counts[0] = 7u;
-
-    for (var channel = 0u; channel < 4u; channel++) {
-        values[1u + channel * 2u] = e0[channel] >> 1u;
-        values[2u + channel * 2u] = e1[channel] >> 1u;
-        counts[1u + channel * 2u] = 7u;
-        counts[2u + channel * 2u] = 7u;
-    }
-
-    values[9] = e0.x & 1u;
-    values[10] = e1.x & 1u;
-    counts[9] = 1u;
-    counts[10] = 1u;
-
-    for (var texel = 0u; texel < 16u; texel++) {
-        values[11u + texel] = indices[texel];
-        counts[11u + texel] = select(4u, 3u, texel == 0u);
-    }
-
-    var words = array<u32, 4>(0u, 0u, 0u, 0u);
-
-    var bit = 0u;
-
-    for (var field = 0u; field < 27u; field++) {
-        let value = values[field];
-        let count = counts[field];
-
-        for (var k = 0u; k < count; k++) {
-            if (((value >> k) & 1u) != 0u) {
-                let at = bit + k;
-
-                words[at >> 5u] |= 1u << (at & 31u);
-            }
-        }
-
-        bit += count;
-    }
-
-    return vec4<u32>(words[0], words[1], words[2], words[3]);
-}
-`);
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * One BC7 mode 6 block from its two endpoints and sixteen indices, as four little-endian words.
+ *
+ * The layout `bc7_write_block` states for mode 6, in the same order for every field: seven mode
+ * bits — six zeros and a one — then the colour endpoints by channel, red for both ends, then green,
+ * then blue, seven bits each; alpha likewise; one parity bit per endpoint; then the indices, four
+ * bits each except texel 0's three, because its top bit is implied zero. That last rule is the
+ * encoder's to honour, by swapping the ends when texel 0 lands in the upper half, and this does not
+ * check it: the top bit is dropped, as the JavaScript writer drops it.
+ *
+ * Endpoints are given as the eight-bit values they decode to — seven stored bits over the parity
+ * bit — so the parity is read off them rather than passed beside them, and a caller cannot hand in
+ * a pair that disagrees with itself.
+ *
+ * Each word is composed by shifts at the fields' fixed positions, the two that straddle a word
+ * boundary — the second end's green, bits 28 to 34, and the second parity bit, bit 64 — split
+ * across them. The JavaScript writer goes bit by bit; here a hundred and twenty-eight iterations
+ * over two function-local arrays were 13% of a 4096² encode on a 4090.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_pack_mode6 = CodeChunk.from(
+    //language=WGSL
+    `
+fn bc7_pack_mode6(e0: vec4<u32>, e1: vec4<u32>, indices: array<u32, 16>) -> vec4<u32> {
+    // the seven stored bits of each end's channels
+    let s0 = e0 >> vec4<u32>(1u);
+    let s1 = e1 >> vec4<u32>(1u);
+
+    // mode 6 is signalled by six zero bits and then a one, bits 0 to 6; red from bit 7
+    let w0 = 64u | (s0.x << 7u) | (s1.x << 14u) | (s0.y << 21u) | (s1.y << 28u);
+
+    // the parity bits are the ends' low bits, the first at bit 63 and the second at bit 64
+    let w1 = (s1.y >> 4u) | (s0.z << 3u) | (s1.z << 10u) | (s0.w << 17u) | (s1.w << 24u) | ((e0.x & 1u) << 31u);
+
+    let w2 = (e1.x & 1u) | ((indices[0] & 7u) << 1u)
+        | (indices[1] << 4u) | (indices[2] << 8u) | (indices[3] << 12u) | (indices[4] << 16u)
+        | (indices[5] << 20u) | (indices[6] << 24u) | (indices[7] << 28u);
+
+    let w3 = indices[8] | (indices[9] << 4u) | (indices[10] << 8u) | (indices[11] << 12u)
+        | (indices[12] << 16u) | (indices[13] << 20u) | (indices[14] << 24u) | (indices[15] << 28u);
+
+    return vec4<u32>(w0, w1, w2, w3);
+}
+`);

package/src/shade/renderer/texture/encode/chunk_bc7_partition_2.d.ts

@@ -0,0 +1,10 @@
+/**
+ * BC7's two-subset partitions as a shader reads them: which texels a pattern puts in the second
+ * subset, and that subset's anchor — the texel whose index is stored a bit short. The first
+ * subset's anchor is always texel 0, which every pattern puts in the first subset.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_partition_2: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bc7_partition_2.d.ts.map

package/src/shade/renderer/texture/encode/chunk_bc7_partition_2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bc7_partition_2.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_partition_2.js"],"names":[],"mappings":"AA4BA;;;;;;GAMG;AACH,oCAFU,SAAS,CAgBhB;0BAhDuB,oCAAoC"}

package/src/shade/renderer/texture/encode/chunk_bc7_partition_2.js

@@ -0,0 +1,50 @@
+import { BC7_ANCHOR_2, BC7_PARTITIONS_2 } from "../../../../format/texture/basis/uastc/bc7_tables.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * BC7's sixty-four two-subset partitions, one word each: bit `i` set where texel `i` is in the
+ * second subset, and the second subset's anchor texel from bit 16.
+ *
+ * Built from the tables the UASTC transcoder uses rather than transcribed again, so the encoder and
+ * the transcoders cannot disagree about a shape.
+ *
+ * @returns {string} sixty-four WGSL `u32` literals
+ */
+function partition_words() {
+    const words = [];
+
+    for (let partition = 0; partition < 64; partition++) {
+        let mask = 0;
+
+        for (let texel = 0; texel < 16; texel++) {
+            mask |= BC7_PARTITIONS_2[partition * 16 + texel] << texel;
+        }
+
+        words.push(`${(mask | (BC7_ANCHOR_2[partition] << 16)) >>> 0}u`);
+    }
+
+    return words.join(', ');
+}
+
+/**
+ * BC7's two-subset partitions as a shader reads them: which texels a pattern puts in the second
+ * subset, and that subset's anchor — the texel whose index is stored a bit short. The first
+ * subset's anchor is always texel 0, which every pattern puts in the first subset.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_partition_2 = CodeChunk.from(
+    //language=WGSL
+    `
+const BC7_PARTITION_2 = array<u32, 64>(${partition_words()});
+
+// the texels a two-subset partition puts in its second subset, bit i for texel i
+fn bc7_partition_2_mask(pattern: u32) -> u32 {
+    return BC7_PARTITION_2[pattern] & 0xFFFFu;
+}
+
+// the second subset's anchor texel
+fn bc7_partition_2_anchor(pattern: u32) -> u32 {
+    return BC7_PARTITION_2[pattern] >> 16u;
+}
+`);

package/src/shade/renderer/texture/encode/shader_texture_encode_bc7.d.ts

@@ -1,11 +1,10 @@
 /**
  * Every level of a texture to `bc7-rgba-unorm` or its sRGB twin, one invocation per block.
  *
- * **Mode 6 only**, today: the single-subset mode with the finest indices, fitted by
- * {@link chunk_bc7_encode_block_mode6} over all four channels. A mode search across the
- * partitioned modes is a later quality step, and a separate chunk — this shader would call it
- * instead, and nothing about the format or the bytes it produces changes. The dispatch shape is
- * {@link shader_texture_encode_bc4}'s; a block is four words.
+ * Each block in mode 6 or mode 1, whichever {@link chunk_bc7_encode_block} estimates loses less:
+ * one line through all four channels with sixteen levels, or two lines through the colour over one
+ * of the sixty-four partitions. The dispatch shape is {@link shader_texture_encode_bc4}'s; a block is
+ * four words.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/texture/encode/shader_texture_encode_bc7.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_texture_encode_bc7.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/shader_texture_encode_bc7.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,wCAFU,aAAa,CA2CpB;8BA1D2B,+BAA+B"}
+{"version":3,"file":"shader_texture_encode_bc7.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/shader_texture_encode_bc7.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,wCAFU,aAAa,CA2CpB;8BAzD2B,+BAA+B"}

package/src/shade/renderer/texture/encode/shader_texture_encode_bc7.js

@@ -1,7 +1,7 @@
 import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
-import { chunk_bc7_encode_block_mode6 } from "./chunk_bc7_encode_block_mode6.js";
+import { chunk_bc7_encode_block } from "./chunk_bc7_encode_block.js";
 import { chunk_texture_encode_load_block } from "./chunk_texture_encode_load_block.js";
 import { TEXTURE_ENCODE_WORKGROUP_SIZE } from "./shader_texture_encode_bc4.js";
 import { texture_encode_resources } from "./texture_encode_resources.js";
@@ -9,11 +9,10 @@ import { texture_encode_resources } from "./texture_encode_resources.js";
 /**
  * Every level of a texture to `bc7-rgba-unorm` or its sRGB twin, one invocation per block.
  *
- * **Mode 6 only**, today: the single-subset mode with the finest indices, fitted by
- * {@link chunk_bc7_encode_block_mode6} over all four channels. A mode search across the
- * partitioned modes is a later quality step, and a separate chunk — this shader would call it
- * instead, and nothing about the format or the bytes it produces changes. The dispatch shape is
- * {@link shader_texture_encode_bc4}'s; a block is four words.
+ * Each block in mode 6 or mode 1, whichever {@link chunk_bc7_encode_block} estimates loses less:
+ * one line through all four channels with sixteen levels, or two lines through the colour over one
+ * of the sixty-four partitions. The dispatch shape is {@link shader_texture_encode_bc4}'s; a block is
+ * four words.
  *
  * @type {ComputeShader}
  */
@@ -44,7 +43,7 @@ fn main(
 
     let texels = texture_encode_load_block(level, block_x, block_y);
 
-    let packed = bc7_encode_block_mode6(texels);
+    let packed = bc7_encode_block(texels);
 
     let word = level.word_offset + block_y * level.row_stride_words + block_x * 4u;
 
@@ -56,6 +55,6 @@ fn main(
 `, [
             chunk_grid3d_to_index,
             chunk_texture_encode_load_block,
-            chunk_bc7_encode_block_mode6,
+            chunk_bc7_encode_block,
         ]),
 });

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts

@@ -34,7 +34,10 @@ export class GPUViewVolumetrics {
      *   module that starts the froxel irradiance volume
      * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number}}} the
      *   integrated aerial LUT, the metadata buffer, and the froxel irradiance volume
-     *   (chunk_volumetrics_irradiance_sh) for the transparent surfaces the lighting pass cannot see
+     *   (chunk_volumetrics_irradiance_sh) that lit particles are lit by. The two do not depend on
+     *   each other, and a pass building only one of them is culled when nothing reads it. A scene
+     *   with no participating-media volume records no fog at all, and `resolved` is then a constant:
+     *   no in-scatter, full transmittance.
      */
     graph_update({ graph, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, indirect_lighting_mode, }: {
         graph: FrameGraph;

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAiCA;IAkII;;;;OAIG;IACH,kBAHW,cAAc,qBAwBxB;IAxHD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IA6ND;;;;;;;;;;;;;OAaG;IACH;QAX+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;QAEjE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAyFvF;;CAEJ;yBApfY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc"}
+{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAkCA;IA2II;;;;OAIG;IACH,kBAHW,cAAc,qBAyCxB;IAlJD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAkHD,gBAaC;IA6ND;;;;;;;;;;;;;;;;OAgBG;IACH;QAd+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;QAEjE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAmIvF;;CAEJ;yBA1jBY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc"}

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.js

@@ -10,6 +10,7 @@ import {
     build_volumetrics_sun_shadow_transform,
     volumetrics_sun_shadow_cascade_far
 } from "./build_volumetrics_sun_shadow_transform.js";
+import { graph_build_froxel_irradiance } from "./graph_build_froxel_irradiance.js";
 import { graph_build_volumetrics } from "./graph_build_volumetrics.js";
 import {
     VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT,
@@ -151,6 +152,15 @@ export class GPUViewVolumetrics {
      */
     #sun_shadow_cascade_far = new Float32Array(4);
 
+    /**
+     * What the fog integrates to through no medium: nothing in-scattered (.rgb 0), everything
+     * transmitted (.a 1). Handed out in place of the aerial LUT on a frame whose scene has no
+     * participating-media volume, so every surface that samples the fog keeps doing so and reads
+     * it as none, for one texel and no pass. Written once, at construction.
+     * @type {GPUTextureContext}
+     */
+    #no_medium;
+
     /**
      * @type {GPUTypedBuffer}
      */
@@ -181,6 +191,23 @@ export class GPUViewVolumetrics {
             this.#volumetrics_textures[i] = texture;
         }
 
+        const no_medium = new GPUTextureContext(device);
+        no_medium.descriptor.label = "volumetrics/no medium";
+        no_medium.descriptor.format = "rgba16float";
+        no_medium.descriptor.dimension = "3d";
+        no_medium.descriptor.size = [1, 1, 1];
+        no_medium.descriptor.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST;
+
+        device.queue.writeTexture(
+            { texture: no_medium.gpu_texture },
+            new Float16Array([0, 0, 0, 1]),
+            { bytesPerRow: 8, rowsPerImage: 1 },
+            [1, 1, 1]
+        );
+        no_medium.incrementVersion();
+
+        this.#no_medium = no_medium;
+
         this.#metadata = GPUTypedBuffer.create({
             type: VOLUMETRICS_METADATA_STRUCT,
             device,
@@ -200,6 +227,8 @@ export class GPUViewVolumetrics {
             textures[i] = null;
         }
 
+        this.#no_medium.destroy();
+
     }
 
     #update_resolution() {
@@ -433,7 +462,10 @@ export class GPUViewVolumetrics {
      *   module that starts the froxel irradiance volume
      * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number}}} the
      *   integrated aerial LUT, the metadata buffer, and the froxel irradiance volume
-     *   (chunk_volumetrics_irradiance_sh) for the transparent surfaces the lighting pass cannot see
+     *   (chunk_volumetrics_irradiance_sh) that lit particles are lit by. The two do not depend on
+     *   each other, and a pass building only one of them is culled when nothing reads it. A scene
+     *   with no participating-media volume records no fog at all, and `resolved` is then a constant:
+     *   no in-scatter, full transmittance.
      */
     graph_update({
                      graph,
@@ -479,6 +511,35 @@ export class GPUViewVolumetrics {
 
         const resolution = this.#volumetrics_textures[0].size;
 
+        // Particle lighting first, and on its own: it reads no medium. The frame graph culls it when
+        // nothing reads it.
+        const irradiance = graph_build_froxel_irradiance({
+            graph,
+            camera,
+            view,
+            lights,
+            light_cluster_data,
+            light_cluster_lookup,
+            light_cluster_parameters,
+            shadowmap_atlas,
+            volumetrics_metadata: gr_metadata,
+            resolution,
+            indirect_lighting_mode,
+        });
+
+        if (view.scene.volumetrics.source.volumes.length === 0) {
+            // No medium: nothing scatters and nothing absorbs, so the fog is the identity everywhere
+            // and the passes that would integrate it to that are not recorded. Nothing accumulates
+            // either, which leaves the history stale for whenever a volume arrives.
+            this.#reset_history = true;
+
+            return {
+                resolved: graph_import_texture(graph, this.#no_medium, "volumetrics no medium"),
+                metadata: gr_metadata,
+                irradiance,
+            };
+        }
+
         // Ping-pong the two persistent froxel textures: this frame writes [parity] and reads the
         // previous frame's accumulation from [parity ^ 1]. On the first frame / after a resize the
         // history is invalid, which #update_metadata signals via history_reset (the TAA then emits
@@ -493,16 +554,26 @@ export class GPUViewVolumetrics {
             taa_output = graph_import_texture(graph, this.#volumetrics_textures[parity], "volumetrics taa output");
         }
 
-        const { lut_aerial, irradiance } = graph_build_volumetrics({
+        /*
+         The sun's transmittance and the multiple scattering are the scene sky's, built once and
+         read from here on. Brought current now rather than in a pass: the sky submits commands of
+         its own, which land ahead of this frame's -- recorded into the frame graph they would be
+         paid every frame, which is what they used to be. A no-op after the first call.
+        */
+        const sky = view.scene.sky;
+
+        sky.update();
+
+        const { lut_aerial } = graph_build_volumetrics({
             graph,
             camera,
             lights,
             view,
+            sky,
             light_cluster_data,
             light_cluster_lookup,
             light_cluster_parameters,
             shadowmap_atlas,
-            indirect_lighting_mode,
 
             volumetrics_metadata: gr_metadata,
             volumetric_resolution: resolution,