@woosh/meep-engine 3.57.0 → 3.59.0

package/src/shade/renderer/view/GPUViewContext.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { array_copy } from "../../../core/collection/array/array_copy.js";
-import { compose_matrix4_array } from "../../../core/geom/3d/mat4/compose_matrix4_array.js";
+import { m4_compose } from "../../../core/geom/3d/mat4/m4_compose.js";
 import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import Vector3 from "../../../core/geom/Vector3.js";
@@ -313,7 +313,7 @@ export class GPUViewContext {
 
         // make screen mapping matrix
         const mapping = new Float64Array(16);
-        compose_matrix4_array(mapping, new Vector3(viewport_size[0] * 0.5, viewport_size[1] * 0.5, 0), Quaternion.identity, new Vector3(viewport_size[0] * 0.5, -viewport_size[1] * 0.5, 1))
+        m4_compose(mapping, new Vector3(viewport_size[0] * 0.5, viewport_size[1] * 0.5, 0), Quaternion.identity, new Vector3(viewport_size[0] * 0.5, -viewport_size[1] * 0.5, 1))
 
         m4_multiply(reprojection_matrix, mapping, reprojection_matrix);
 

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

@@ -22,8 +22,8 @@ export class GPUViewVolumetrics {
     set tile_size(v: number);
     /**
      * Size of one froxel in XY, in screen pixels. Smaller is finer fog detail at a cost that grows
-     * with the inverse square. The grid is resized on the next update and the TAA history dropped,
-     * so the frame after a change starts its accumulation over.
+     * with the inverse square. The grid is resized on the next update and the TAA history carries
+     * over: it spans the same screen uv at any froxel count.
      *
      * The grid's XY extent, `ceil(view resolution / tile_size)`, must stay within the device's
      * `maxTextureDimension3D`.
@@ -37,7 +37,8 @@ export class GPUViewVolumetrics {
     set resolution_z(v: number);
     /**
      * Number of froxel slices between the camera near and {@link froxel_far}. Cost grows linearly.
-     * The grid is resized on the next update and the TAA history dropped, as for {@link tile_size}.
+     * The grid is resized on the next update and the TAA history dropped, because the depth curve
+     * is built for the slice count.
      * @returns {number}
      */
     get resolution_z(): number;
@@ -73,9 +74,11 @@ export class GPUViewVolumetrics {
      * @param {ShaderSwitchSet} [options.shader_switches]
      * @param {import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4]
      * @param {import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv]
+     * @param {import("../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} options.probes
+     *   the renderer's probe clipmap GI, whose probes the irradiance clipmap binds in every mode
      * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number, uniform: number}}}
      */
-    graph_update({ graph, view, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, shader_switches, brick4, lpv, }: {
+    graph_update({ graph, view, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, shader_switches, brick4, lpv, probes, }: {
         graph: FrameGraph;
         view: GPUViewContext;
         light_cluster_data: number;
@@ -85,6 +88,7 @@ export class GPUViewVolumetrics {
         shader_switches?: ShaderSwitchSet;
         brick4?: import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap;
         lpv?: import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume;
+        probes: import("../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI;
     }): {
         resolved: number;
         metadata: number;

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":"AAuBA;;;GAGG;AAEH;IA0MI;;;OAGG;IACH,+BAuCC;IA/MD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAuCD;;OAEG;IACH,yBAIC;IApBD;;;;;;;;OAQG;IACH,wBAEC;IAoBD;;;OAGG;IACH,4BAMC;IAnBD;;;;OAIG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAwHD;;OAEG;IACH,+CAEC;IAED;;;;OAIG;IACH,sBAEC;IAED,gBAcC;IAsOD;;;;;;;;;;;;;;OAcG;IACH;QAZ+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QAEE,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QACoE,MAAM,GAAzF,OAAO,iDAAiD,EAAE,cAAc;QACkB,GAAG,GAA7F,OAAO,mDAAmD,EAAE,mBAAmB;QAC7E;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CA6GxG;;CAEJ;yBA3nBY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc;qCAX1B,8CAA8C;gCAXnD,uCAAuC"}
+{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAuBA;;;GAGG;AAEH;IAkNI;;;OAGG;IACH,+BAuCC;IAvND;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IA8CD;;OAEG;IACH,yBAIC;IApBD;;;;;;;;OAQG;IACH,wBAEC;IAqBD;;;OAGG;IACH,4BAMC;IApBD;;;;;OAKG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAwHD;;OAEG;IACH,+CAEC;IAED;;;;OAIG;IACH,sBAEC;IAED,gBAcC;IA+MD;;;;;;;;;;;;;;;;OAgBG;IACH;QAd+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QAEE,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QACoE,MAAM,GAAzF,OAAO,iDAAiD,EAAE,cAAc;QACkB,GAAG,GAA7F,OAAO,mDAAmD,EAAE,mBAAmB;QACgB,MAAM,EAArG,OAAO,2DAA2D,EAAE,iBAAiB;QAEnF;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CA0HxG;;CAEJ;yBA3nBY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc;qCAX1B,8CAA8C;gCAXnD,uCAAuC"}

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

@@ -37,7 +37,7 @@ export class GPUViewVolumetrics {
     /**
      * Should we perform temporal integration, or not?
      * If set to true - the next update will discard history.
-     * Useful for significant scene transitions and screen resizing.
+     * Useful for significant scene transitions.
      * @type {boolean}
      */
     #reset_history = true;
@@ -82,6 +82,13 @@ export class GPUViewVolumetrics {
      */
     #tile_size = 16;
 
+    /**
+     * Froxel counts of this frame's grid. The TAA output is sized to it when it is written; the
+     * history keeps the size it was written at, see {@link graph_update}.
+     * @type {number[]}
+     */
+    #resolution = [1, 1, 1];
+
     /**
      * Number of froxel slices along the view.
      * @type {number}
@@ -90,8 +97,8 @@ export class GPUViewVolumetrics {
 
     /**
      * Size of one froxel in XY, in screen pixels. Smaller is finer fog detail at a cost that grows
-     * with the inverse square. The grid is resized on the next update and the TAA history dropped,
-     * so the frame after a change starts its accumulation over.
+     * with the inverse square. The grid is resized on the next update and the TAA history carries
+     * over: it spans the same screen uv at any froxel count.
      *
      * The grid's XY extent, `ceil(view resolution / tile_size)`, must stay within the device's
      * `maxTextureDimension3D`.
@@ -112,7 +119,8 @@ export class GPUViewVolumetrics {
 
     /**
      * Number of froxel slices between the camera near and {@link froxel_far}. Cost grows linearly.
-     * The grid is resized on the next update and the TAA history dropped, as for {@link tile_size}.
+     * The grid is resized on the next update and the TAA history dropped, because the depth curve
+     * is built for the slice count.
      * @returns {number}
      */
     get resolution_z() {
@@ -309,35 +317,12 @@ export class GPUViewVolumetrics {
      * @param {GPUViewContext} view
      */
     #update_resolution(view) {
-
         const screen_resolution = view.resolution;
+        const resolution = this.#resolution;
 
-        const output_resolution_x = Math.ceil(screen_resolution[0] / this.#tile_size);
-        const output_resolution_y = Math.ceil(screen_resolution[1] / this.#tile_size);
-        const output_resolution_z = this.#resolution_z;
-
-        const t_first = this.#volumetrics_textures[0];
-
-        if (t_first.width === output_resolution_x
-            && t_first.height === output_resolution_y
-            && t_first.depth === output_resolution_z
-        ) {
-            // already at the right resolution
-            return;
-        }
-
-        for (let i = 0; i < 2; i++) {
-
-            this.#volumetrics_textures[i].resize(
-                output_resolution_x,
-                output_resolution_y,
-                output_resolution_z
-            );
-
-        }
-
-        // drop history
-        this.#reset_history = true;
+        resolution[0] = Math.ceil(screen_resolution[0] / this.#tile_size);
+        resolution[1] = Math.ceil(screen_resolution[1] / this.#tile_size);
+        resolution[2] = this.#resolution_z;
     }
 
     /**
@@ -452,8 +437,8 @@ export class GPUViewVolumetrics {
     #update_metadata(view) {
         const camera = view.camera;
 
-        const resolution = this.#volumetrics_textures[0].size;
-        // the grid as allocated, so the curve always spans the slices the textures actually have
+        const resolution = this.#resolution;
+        // the grid this frame writes, so the curve always spans the slices its output has
         const resolution_z = resolution[2];
 
         this.#sun_shadow_light_index = this.#update_sun_shadow(view);
@@ -546,6 +531,8 @@ export class GPUViewVolumetrics {
      * @param {ShaderSwitchSet} [options.shader_switches]
      * @param {import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4]
      * @param {import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv]
+     * @param {import("../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} options.probes
+     *   the renderer's probe clipmap GI, whose probes the irradiance clipmap binds in every mode
      * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number, uniform: number}}}
      */
     graph_update({
@@ -558,6 +545,7 @@ export class GPUViewVolumetrics {
                      shader_switches = ShaderSwitchSet.EMPTY,
                      brick4,
                      lpv,
+                     probes,
                  }) {
 
         assert.defined(view, 'view');
@@ -587,7 +575,7 @@ export class GPUViewVolumetrics {
 
         const gr_metadata = graph_import_buffer(graph, this.#metadata.buffer, "volumetrics metadata");
 
-        const resolution = this.#volumetrics_textures[0].size;
+        const resolution = this.#resolution;
 
         // World-space irradiance clipmap for particle lighting.
         // Culled by the frame graph when no lit particles read it.
@@ -599,6 +587,8 @@ export class GPUViewVolumetrics {
             shader_switches,
             brick4,
             lpv,
+            probes,
+            view_uniform: view.uniform_buffer.buffer,
         });
 
         if (view.scene.volumetrics.source.volumes.length === 0) {
@@ -619,8 +609,18 @@ export class GPUViewVolumetrics {
 
         if (this.#taa_enabled) {
             const parity = view.frame_index & 1;
-            taa_history = graph_import_texture(graph, this.#volumetrics_textures[parity ^ 1], "volumetrics taa history");
-            taa_output = graph_import_texture(graph, this.#volumetrics_textures[parity], "volumetrics taa output");
+
+            const history = this.#volumetrics_textures[parity ^ 1];
+            const output = this.#volumetrics_textures[parity];
+
+            // Only the output follows the grid. The history keeps the size it was written at: the
+            // grid spans screen uv [0, 1] at any froxel count and the TAA fetches the history by uvw
+            // through a filtering sampler, so a resolution step resamples it once rather than
+            // throwing it away. It is resized in turn on the next frame, when it is the output.
+            output.resize(resolution[0], resolution[1], resolution[2]);
+
+            taa_history = graph_import_texture(graph, history, "volumetrics taa history");
+            taa_output = graph_import_texture(graph, output, "volumetrics taa output");
         }
 
         const sky = view.scene.sky;

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

@@ -0,0 +1,59 @@
+/**
+ * Which cascade a sun-shadow build dispatch is operating on.
+ *
+ * Per-dispatch, uniform, read-only and eight bytes, which is the shape immediate data exists for:
+ * no pooled buffer, no staging copy, no bind group.
+ *
+ * @type {WebGPUStruct}
+ */
+export const VOLUMETRICS_SUN_SHADOW_BUILD_SETTINGS: WebGPUStruct;
+/**
+ * Which cascade and cascade voxel resolution a sun-shadow cull or brick-bin dispatch is operating on.
+ * Packed into 16 bytes of immediate data (`vec3<u32>` + `u32`).
+ *
+ * @type {WebGPUStruct}
+ */
+export const VOLUMETRICS_SUN_SHADOW_BIN_SETTINGS: WebGPUStruct;
+/**
+ * Depth of one 3D brick of a sun optical-depth cascade along the sun axis, in voxels.
+ *
+ * Paired with {@link VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION} (`[8, 8]` in xy), each brick is an
+ * `8x8x8` cube of cascade voxels. The bin pre-culls the cascade's participating-media volumes into a
+ * bitmask per brick, and the column scan walks its column stack brick by brick: an empty brick skips
+ * all eight slices in O(1), and a populated brick amortizes each volume's `scene_database` load,
+ * local-basis projection and 4-ray slab setup across all eight slices.
+ *
+ * @type {number}
+ */
+export const VOLUMETRICS_SUN_SHADOW_BRICK_Z: number;
+/**
+ * Maximum integer-lattice slices immediately upwind of the outermost cascade's `w = 0` entry face
+ * (`s in [-VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES, 0)`) integrated at the cascade's own voxel
+ * step. Because these slices sit on the exact same world-space voxel lattice as the interior slices
+ * `s >= 0`, snapping the cascade origin by whole voxels moves a slice across `s = 0` (`s = 0` <->
+ * `s = -1`) without changing its coverage, fade or noise sample point. Any volume extending further
+ * upwind (`s < -16`) integrates its deep upwind tail in at most
+ * `VOLUMETRICS_SUN_SHADOW_UPWIND_TAIL_STEPS` steps.
+ *
+ * @type {number}
+ */
+export const VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES: number;
+/**
+ * Quadrature steps for the deep upwind tail (`s < -VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES`)
+ * ahead of the outermost cascade.
+ *
+ * @type {number}
+ */
+export const VOLUMETRICS_SUN_SHADOW_UPWIND_TAIL_STEPS: number;
+/**
+ * Brick-grid addressing and 6-axis OBB-vs-cascade-box culling for the sun optical-depth cascades,
+ * shared by {@link shader_volumetrics_cull_sun_shadow_media},
+ * {@link shader_volumetrics_bin_sun_shadow_media} and
+ * {@link shader_volumetrics_build_sun_shadow_volume_outermost}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_sun_shadow_group_list: CodeChunk;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_volumetrics_sun_shadow_group_list.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_volumetrics_sun_shadow_group_list.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_volumetrics_sun_shadow_group_list.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,oDAFU,YAAY,CAKkB;AAExC;;;;;GAKG;AACH,kDAFU,YAAY,CAKgB;AAEtC;;;;;;;;;;GAUG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;;;;;;;GAUG;AACH,2DAFU,MAAM,CAE+C;AAE/D;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AAE1D;;;;;;;GAOG;AACH,sDAFU,SAAS,CA8EjB;6BAnJ2B,gCAAgC;0BAFnC,iCAAiC"}

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

@@ -0,0 +1,152 @@
+import { chunk_grid3d_to_index } from "../shader/chunk/grid/chunk_grid3d_to_index.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { u32, vec3u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+import { VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET } from "./chunk_volumetrics_media_group_list.js";
+import { VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION } from "./VOLUMETRICS_SUN_SHADOW_RESOLUTION.js";
+
+/**
+ * Which cascade a sun-shadow build dispatch is operating on.
+ *
+ * Per-dispatch, uniform, read-only and eight bytes, which is the shape immediate data exists for:
+ * no pooled buffer, no staging copy, no bind group.
+ *
+ * @type {WebGPUStruct}
+ */
+export const VOLUMETRICS_SUN_SHADOW_BUILD_SETTINGS = WebGPUStruct.from({
+    cascade: u32,
+    sub_steps: u32,
+}, "VolumetricsSunShadowBuildSettings");
+
+/**
+ * Which cascade and cascade voxel resolution a sun-shadow cull or brick-bin dispatch is operating on.
+ * Packed into 16 bytes of immediate data (`vec3<u32>` + `u32`).
+ *
+ * @type {WebGPUStruct}
+ */
+export const VOLUMETRICS_SUN_SHADOW_BIN_SETTINGS = WebGPUStruct.from({
+    resolution: vec3u,
+    cascade: u32,
+}, "VolumetricsSunShadowBinSettings");
+
+/**
+ * Depth of one 3D brick of a sun optical-depth cascade along the sun axis, in voxels.
+ *
+ * Paired with {@link VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION} (`[8, 8]` in xy), each brick is an
+ * `8x8x8` cube of cascade voxels. The bin pre-culls the cascade's participating-media volumes into a
+ * bitmask per brick, and the column scan walks its column stack brick by brick: an empty brick skips
+ * all eight slices in O(1), and a populated brick amortizes each volume's `scene_database` load,
+ * local-basis projection and 4-ray slab setup across all eight slices.
+ *
+ * @type {number}
+ */
+export const VOLUMETRICS_SUN_SHADOW_BRICK_Z = 8;
+
+/**
+ * Maximum integer-lattice slices immediately upwind of the outermost cascade's `w = 0` entry face
+ * (`s in [-VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES, 0)`) integrated at the cascade's own voxel
+ * step. Because these slices sit on the exact same world-space voxel lattice as the interior slices
+ * `s >= 0`, snapping the cascade origin by whole voxels moves a slice across `s = 0` (`s = 0` <->
+ * `s = -1`) without changing its coverage, fade or noise sample point. Any volume extending further
+ * upwind (`s < -16`) integrates its deep upwind tail in at most
+ * `VOLUMETRICS_SUN_SHADOW_UPWIND_TAIL_STEPS` steps.
+ *
+ * @type {number}
+ */
+export const VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES = 16;
+
+/**
+ * Quadrature steps for the deep upwind tail (`s < -VOLUMETRICS_SUN_SHADOW_UPWIND_LATTICE_SLICES`)
+ * ahead of the outermost cascade.
+ *
+ * @type {number}
+ */
+export const VOLUMETRICS_SUN_SHADOW_UPWIND_TAIL_STEPS = 8;
+
+/**
+ * Brick-grid addressing and 6-axis OBB-vs-cascade-box culling for the sun optical-depth cascades,
+ * shared by {@link shader_volumetrics_cull_sun_shadow_media},
+ * {@link shader_volumetrics_bin_sun_shadow_media} and
+ * {@link shader_volumetrics_build_sun_shadow_volume_outermost}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_sun_shadow_group_list = CodeChunk.from(
+    //language=WGSL
+    `
+const VOLUMETRICS_SUN_SHADOW_GROUP_XY = vec2<u32>(${VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION[0]}u, ${VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION[1]}u);
+const VOLUMETRICS_SUN_SHADOW_BRICK_Z: u32 = ${VOLUMETRICS_SUN_SHADOW_BRICK_Z}u;
+const VOLUMETRICS_SUN_SHADOW_VOLUME_BUDGET: u32 = ${VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET}u;
+
+fn volumetrics_sun_shadow_interior_bricks_z(resolution_z: u32) -> u32 {
+    return (resolution_z + VOLUMETRICS_SUN_SHADOW_BRICK_Z - 1u) / VOLUMETRICS_SUN_SHADOW_BRICK_Z;
+}
+
+// Brick grid of one cascade: interior bricks in 0 .. interior_z - 1, plus one upwind layer at
+// z = interior_z for volumes between the sun and the outermost cascade's w = 0 entry face.
+fn volumetrics_sun_shadow_groups(resolution: vec3<u32>) -> vec3<u32> {
+    let xy = (resolution.xy + VOLUMETRICS_SUN_SHADOW_GROUP_XY - vec2<u32>(1u)) / VOLUMETRICS_SUN_SHADOW_GROUP_XY;
+    let z = volumetrics_sun_shadow_interior_bricks_z(resolution.z) + 1u;
+    return vec3<u32>(xy, z);
+}
+
+fn volumetrics_sun_shadow_list_words(volume_count: u32, buffer_words: u32, groups: vec3<u32>) -> u32 {
+    let total_groups = max(1u, groups.x * groups.y * groups.z);
+    return min((volume_count + 31u) / 32u, buffer_words / total_groups);
+}
+
+fn volumetrics_sun_shadow_list_offset(group: vec3<u32>, groups: vec3<u32>, list_words: u32) -> u32 {
+    return grid3d_to_index(group, groups.xy) * list_words;
+}
+
+// 6-axis separating-axis test between an axis-aligned box [uvw_min, uvw_max] in sun-cascade UVW
+// space and a volume's unit box [-0.5, +0.5]^3 in its own local space.
+//
+// First projects the volume's unit box into cascade UVW space to test the 3 sun-cascade axes and
+// clamp [uvw_min, uvw_max] to the volume's own UVW bounds [vol_uvw_min, vol_uvw_max]. That clamp is
+// what keeps a semi-infinite upwind prism (uvw_min.z = -F32_MAX) finite and tight before mapping the
+// intersection box into volume-local space to test the volume's 3 OBB face axes.
+fn volumetrics_volume_in_sun_box(
+    uvw_min: vec3<f32>,
+    uvw_max: vec3<f32>,
+    ws_to_uvw: mat4x4<f32>,
+    uvw_to_ws: mat4x4<f32>,
+    volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref},
+) -> bool {
+    let local_to_uvw = ws_to_uvw * volume.transform;
+    let vol_uvw_center = local_to_uvw[3].xyz;
+    let vol_uvw_half = 0.5 * (
+        abs(local_to_uvw[0].xyz) +
+        abs(local_to_uvw[1].xyz) +
+        abs(local_to_uvw[2].xyz)
+    );
+
+    let vol_uvw_min = vol_uvw_center - vol_uvw_half;
+    let vol_uvw_max = vol_uvw_center + vol_uvw_half;
+
+    let b_min = max(uvw_min, vol_uvw_min);
+    let b_max = min(uvw_max, vol_uvw_max);
+
+    if (any(b_max < b_min)) {
+        return false;
+    }
+
+    let uvw_to_local = volume.transform_inverse * uvw_to_ws;
+    let b_center = (b_min + b_max) * 0.5;
+    let b_half = (b_max - b_min) * 0.5;
+
+    let local_center = (uvw_to_local * vec4<f32>(b_center, 1.0)).xyz;
+    let local_half = abs(uvw_to_local[0].xyz) * b_half.x
+                   + abs(uvw_to_local[1].xyz) * b_half.y
+                   + abs(uvw_to_local[2].xyz) * b_half.z;
+
+    return all(abs(local_center) <= vec3<f32>(0.5005) + local_half);
+}
+    `,
+    [
+        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
+        chunk_grid3d_to_index,
+    ]
+);
+

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

@@ -1 +1 @@
-{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AA+aA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAtB+B,KAAK;IACC,MAAM;IACJ,MAAM;IACV,IAAI;IACZ,GAAG;IAIH,kBAAkB,EAAlC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACU,eAAe,EAA/B,MAAM;IACY,qBAAqB,EAAvC,MAAM,EAAE;IACU,qBAAqB,EAAvC,MAAM,EAAE;IAGQ,oBAAoB,EAApC,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe;IAChB,eAAe,GAAzC,eAAe;;;;;;EAsLzB;gCA3nB+B,uCAAuC"}
+{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AAkhBA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAtB+B,KAAK;IACC,MAAM;IACJ,MAAM;IACV,IAAI;IACZ,GAAG;IAIH,kBAAkB,EAAlC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACU,eAAe,EAA/B,MAAM;IACY,qBAAqB,EAAvC,MAAM,EAAE;IACU,qBAAqB,EAAvC,MAAM,EAAE;IAGQ,oBAAoB,EAApC,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe;IAChB,eAAe,GAAzC,eAAe;;;;;;EAsLzB;gCA9tB+B,uCAAuC"}