@woosh/meep-engine 3.37.0 → 3.39.0

package/src/shade/renderer/texture/util/single_pixel_texture_from_sampler.js

@@ -0,0 +1,34 @@
+import { ColorSpace } from "../ColorSpace.js";
+import { ShadeTexture } from "../ShadeTexture.js";
+import { ShadeTextureFlags } from "../ShadeTextureFlags.js";
+import { ShadeImage } from "../source/ShadeImage.js";
+import { TextureFilterType } from "../TextureFilterType.js";
+import { TextureWrapType } from "../TextureWrapType.js";
+
+/**
+ * A texture of one texel, which reads the same at every UV: clamped, unfiltered, no mips.
+ *
+ * The texel's format is the sampler's — its typed array and channel count, in linear space.
+ *
+ * @param {Sampler2D} sampler 1x1
+ * @returns {ShadeTexture}
+ */
+export function single_pixel_texture_from_sampler(sampler) {
+    const image = ShadeImage.fromSampler2D(sampler);
+
+    image.color_space = ColorSpace.LinearSRGB;
+
+    const texture = ShadeTexture.from(image);
+
+    texture.wrapS = TextureWrapType.ClampToEdge;
+    texture.wrapT = TextureWrapType.ClampToEdge;
+
+    texture.mipmapFilter = TextureFilterType.Nearest;
+    texture.minFilter = TextureFilterType.Nearest;
+    texture.magFilter = TextureFilterType.Nearest;
+
+    // no mip maps
+    texture.clearFlag(ShadeTextureFlags.GenerateMipMaps);
+
+    return texture;
+}

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

@@ -1,24 +1,34 @@
 /**
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  * @typedef {import("./SceneVolumetrics.js").SceneVolumetrics} SceneVolumetrics
+ * @typedef {import("../buffer/table/GPUTypedTable.js").GPUTypedTable} GPUTypedTable
  */
 /**
- * Represents participating media and volumetric lighting.
- * View-dependent.
+ * Keeps a scene's participating-media volumes in the scene database, as rows of its
+ * `participating_media_volumes` table: the froxel volumetrics read them there, and so do the ray
+ * passes, which already bind the scene database and have no storage binding to spare for a table
+ * of their own.
+ *
+ * The table is written whole whenever {@link SceneVolumetrics#version} moves — cleared and refilled
+ * in the scene's volume order — and not at all otherwise; the scene database's own update, later in
+ * the same frame, takes the rows to the GPU. The rows are dense from 0, which the passes' walk over
+ * `[0, participating_media_volumes_count)` relies on. A volume whose transform has no inverse —
+ * scaled to nothing on an axis — gets no row.
  */
 export class GPUSceneVolumetrics {
     /**
      *
-     * @param {GPUDevice} device
+     * @param {GPUTypedTable} table the scene database's `participating_media_volumes` table
      * @param {SceneVolumetrics} volumetrics
      */
-    constructor(device: GPUDevice, volumetrics: SceneVolumetrics);
+    constructor(table: import("../buffer/table/GPUTypedTable.js").GPUTypedTable<any>, volumetrics: SceneVolumetrics);
     /**
      * @type {SceneVolumetrics}
      */
     source: SceneVolumetrics;
-    get table(): GPUSingleTypeTable;
-    get metadata_buffer(): GPUTypedBuffer;
+    /**
+     * Nothing to release: the rows belong to the scene database.
+     */
     destroy(): void;
     /**
      *
@@ -30,6 +40,5 @@ export class GPUSceneVolumetrics {
 }
 export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
 export type SceneVolumetrics = import("./SceneVolumetrics.js").SceneVolumetrics;
-import { GPUSingleTypeTable } from "../buffer/table/single/GPUSingleTypeTable.js";
-import { GPUTypedBuffer } from "../buffer/GPUTypedBuffer.js";
+export type GPUTypedTable = import("../buffer/table/GPUTypedTable.js").GPUTypedTable<any>;
 //# sourceMappingURL=GPUSceneVolumetrics.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUSceneVolumetrics.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;;;GAGG;AACH;IAkCI;;;;OAIG;IACH,4CAFW,gBAAgB,EAkB1B;IArDD;;OAEG;IACH,QAFU,gBAAgB,CAEpB;IAWN,gCAEC;IAOD,sCAEC;IA8BD,gBAGC;IAED;;;;OAIG;IACH,YAHW,eAAe,gBACf,MAAM,QA+ChB;;CAEJ;8BA1HY,OAAO,uBAAuB,EAAE,eAAe;+BAC/C,OAAO,uBAAuB,EAAE,gBAAgB;mCAN1B,8CAA8C;+BADlD,6BAA6B"}
+{"version":3,"file":"GPUSceneVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUSceneVolumetrics.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;GAWG;AACH;IAeI;;;;OAIG;IACH,+FAFW,gBAAgB,EAM1B;IAtBD;;OAEG;IACH,QAFU,gBAAgB,CAEpB;IAqBN;;OAEG;IACH,gBACC;IAED;;;;OAIG;IACH,YAHW,eAAe,gBACf,MAAM,QA4ChB;;CAEJ;8BAlGY,OAAO,uBAAuB,EAAE,eAAe;+BAC/C,OAAO,uBAAuB,EAAE,gBAAgB"}

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

@@ -1,18 +1,22 @@
 import { m4_invert } from "../../../core/geom/3d/mat4/m4_invert.js";
-import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
-import { GPUTypedBuffer } from "../buffer/GPUTypedBuffer.js";
-import { GPUSingleTypeTable } from "../buffer/table/single/GPUSingleTypeTable.js";
-import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
-import { SCENE_VOLUMETRICS_METADATA_STRUCT } from "./SCENE_VOLUMETRICS_METADATA_STRUCT.js";
 
 /**
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  * @typedef {import("./SceneVolumetrics.js").SceneVolumetrics} SceneVolumetrics
+ * @typedef {import("../buffer/table/GPUTypedTable.js").GPUTypedTable} GPUTypedTable
  */
 
 /**
- * Represents participating media and volumetric lighting.
- * View-dependent.
+ * Keeps a scene's participating-media volumes in the scene database, as rows of its
+ * `participating_media_volumes` table: the froxel volumetrics read them there, and so do the ray
+ * passes, which already bind the scene database and have no storage binding to spare for a table
+ * of their own.
+ *
+ * The table is written whole whenever {@link SceneVolumetrics#version} moves — cleared and refilled
+ * in the scene's volume order — and not at all otherwise; the scene database's own update, later in
+ * the same frame, takes the rows to the GPU. The rows are dense from 0, which the passes' walk over
+ * `[0, participating_media_volumes_count)` relies on. A volume whose transform has no inverse —
+ * scaled to nothing on an axis — gets no row.
  */
 export class GPUSceneVolumetrics {
 
@@ -21,59 +25,29 @@ export class GPUSceneVolumetrics {
      */
     source
 
-
     #version = -1;
 
     /**
-     *
-     * @type {GPUSingleTypeTable}
+     * The scene database's `participating_media_volumes` table; owned by the database.
+     * @type {GPUTypedTable}
      */
     #table;
 
-    get table() {
-        return this.#table;
-    }
-
-    /**
-     * @type {GPUTypedBuffer}
-     */
-    #metadata_buffer;
-
-    get metadata_buffer() {
-        return this.#metadata_buffer;
-    }
-
-    /**
-     * @type {GPUDevice}
-     */
-    #device;
-
     /**
      *
-     * @param {GPUDevice} device
+     * @param {GPUTypedTable} table the scene database's `participating_media_volumes` table
      * @param {SceneVolumetrics} volumetrics
      */
-    constructor(device, volumetrics) {
-        this.#device = device;
-
-        this.#table = new GPUSingleTypeTable({
-            device,
-            type: PARTICIPATING_MEDIA_VOLUME_STRUCT,
-        });
-
-        this.#metadata_buffer = GPUTypedBuffer.create({
-            label: "scene volumetrics metadata buffer",
-            device,
-            type: SCENE_VOLUMETRICS_METADATA_STRUCT,
-            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-        })
+    constructor(table, volumetrics) {
+        this.#table = table;
 
         this.source = volumetrics;
     }
 
+    /**
+     * Nothing to release: the rows belong to the scene database.
+     */
     destroy() {
-        this.#table.destroy();
-        this.#metadata_buffer.destroy();
     }
 
     /**
@@ -90,14 +64,24 @@ export class GPUSceneVolumetrics {
             return;
         }
 
-        const cmd = ShadeGPUCommandContext.create(gfx, 'volumetrics update');
+        const table = this.#table;
+
+        table.clear();
 
         const m4_transform_inverse = new Float32Array(16);
-        this.source.volumes.forEach((v,index) => {
 
-            m4_invert(m4_transform_inverse, v.transform.matrix);
+        const volumes = this.source.volumes;
+
+        for (let i = 0; i < volumes.length; i++) {
+            const v = volumes[i];
 
-            this.#table.set(index, {
+            if (!m4_invert(m4_transform_inverse, v.transform.matrix)) {
+                // scaled to nothing on an axis: it encloses nothing, and without an inverse every
+                // pass would place it wrong — an all-zero matrix puts the whole world inside it
+                continue;
+            }
+
+            table.add({
                 particle_spec: {
                     scattering: v.particle_spec.scattering,
                     extinction: v.particle_spec.extinction,
@@ -110,22 +94,9 @@ export class GPUSceneVolumetrics {
                 fade_distance: v.fade_distance,
                 density: v.density,
             });
-
-        })
-
-        this.#table.update(cmd);
-
-        this.#metadata_buffer.upload({
-            instance_count: this.source.volumes.length,
-        }, this.#device.queue);
-
-
-        cmd.finish();
-
-        // this.#table.debug_dump().then(console.warn); // DEBUG
+        }
 
         this.#version = this.source.version;
-
     }
 
-}
+}

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

@@ -0,0 +1,21 @@
+/**
+ * A participating-media volume at a point and along a ray, exactly: what the ray passes trace
+ * through, where the froxel volumetrics discretize.
+ *
+ * - `participating_media_volume_density_at` is the volume's particle density at a world position:
+ *   `density` times its edge fade, zero outside its box. The fade is the per-axis smoothstep over
+ *   `fade_distance` (in world units, unaffected by scale) that `compute_volume_fade_factor` evaluates
+ *   at a froxel's midpoint; here it is the field itself. Bounded above by `density`, so
+ *   `density * extinction` majorizes the volume anywhere in it.
+ * - `participating_media_volume_span` is where a ray is inside the box, as distances along it,
+ *   clipped to `[0, t_max]`; empty (`y <= x`) when it misses. The direction need not be unit
+ *   length, and the distances are in its units: the local direction is not renormalized.
+ *
+ * The coefficients at a point are `density_at * particle_spec.{scattering, extinction}`, scattered
+ * by Henyey-Greenstein with `particle_spec.g`, as the froxels scatter it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_volume_sample: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_participating_media_volume_sample.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_participating_media_volume_sample.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_participating_media_volume_sample.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,sDAFU,SAAS,CAgDjB;0BAnEwB,iCAAiC"}

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

@@ -0,0 +1,70 @@
+import { chunk_aabb3_slab_span } from "../shader/chunk/geometry/aabb3/chunk_aabb3_slab_span.js";
+import { chunk_mat4_extract_scale } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_scale.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+
+/**
+ * A participating-media volume at a point and along a ray, exactly: what the ray passes trace
+ * through, where the froxel volumetrics discretize.
+ *
+ * - `participating_media_volume_density_at` is the volume's particle density at a world position:
+ *   `density` times its edge fade, zero outside its box. The fade is the per-axis smoothstep over
+ *   `fade_distance` (in world units, unaffected by scale) that `compute_volume_fade_factor` evaluates
+ *   at a froxel's midpoint; here it is the field itself. Bounded above by `density`, so
+ *   `density * extinction` majorizes the volume anywhere in it.
+ * - `participating_media_volume_span` is where a ray is inside the box, as distances along it,
+ *   clipped to `[0, t_max]`; empty (`y <= x`) when it misses. The direction need not be unit
+ *   length, and the distances are in its units: the local direction is not renormalized.
+ *
+ * The coefficients at a point are `density_at * particle_spec.{scattering, extinction}`, scattered
+ * by Henyey-Greenstein with `particle_spec.g`, as the froxels scatter it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_volume_sample = CodeChunk.from(
+    //language=WGSL
+    `
+fn participating_media_volume_density_at(volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref}, position: vec3<f32>) -> f32 {
+    let local = (volume.transform_inverse * vec4<f32>(position, 1.0)).xyz;
+    let to_edge_local = vec3<f32>(0.5) - abs(local);
+
+    if (any(to_edge_local < vec3<f32>(0.0))) {
+        return 0.0;
+    }
+
+    if (volume.fade_distance <= 0.001) {
+        return volume.density;
+    }
+
+    let to_edge_world = to_edge_local * mat4_extract_scale(volume.transform);
+    let fade = smoothstep(vec3<f32>(0.0), vec3<f32>(volume.fade_distance), to_edge_world);
+
+    return volume.density * fade.x * fade.y * fade.z;
+}
+
+fn participating_media_volume_span(
+    volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref},
+    origin: vec3<f32>,
+    direction: vec3<f32>,
+    t_max: f32,
+) -> vec2<f32> {
+    let local_origin = (volume.transform_inverse * vec4<f32>(origin, 1.0)).xyz;
+    let local_direction = (volume.transform_inverse * vec4<f32>(direction, 0.0)).xyz;
+    let inverse_direction = 1.0 / local_direction;
+
+    let x = aabb3_slab_span(-0.5 - local_origin.x, 0.5 - local_origin.x, inverse_direction.x);
+    let y = aabb3_slab_span(-0.5 - local_origin.y, 0.5 - local_origin.y, inverse_direction.y);
+    let z = aabb3_slab_span(-0.5 - local_origin.z, 0.5 - local_origin.z, inverse_direction.z);
+
+    let near = max(max(x.x, y.x), max(z.x, 0.0));
+    let far = min(min(x.y, y.y), min(z.y, t_max));
+
+    return vec2<f32>(near, far);
+}
+    `,
+    [
+        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
+        chunk_aabb3_slab_span,
+        chunk_mat4_extract_scale,
+    ]
+);

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

@@ -0,0 +1,31 @@
+/**
+ * The scene's participating-media volumes, as rows of the scene database.
+ * @type {import("../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor}
+ */
+export const PARTICIPATING_MEDIA_VOLUMES_TABLE: import("../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+/**
+ * Per-thread iteration over the scene's participating-media volumes, read from the scene database
+ * the importing shader binds as `scene_database` (`var<storage, read>`, `array<u32>`). No workgroup
+ * memory, so it serves the froxel passes and the ray passes alike.
+ *
+ * The table is written whole from row 0 — `GPUSceneVolumetrics` clears it and adds every volume in
+ * the scene's order — so its rows are `[0, count)`, its pages run from page 0 without a hole, and
+ * only the last of them is partly full. `participating_media_volumes_count` reads the count off the
+ * pages' live counts, stopping at the first page that is missing or not full: one page for up to
+ * {@link PARTICIPATING_MEDIA_VOLUMES_TABLE}'s `elements_per_page` volumes. A walk is then over rows,
+ * never over the table's page capacity:
+ *
+ *     let volume_count = participating_media_volumes_count(&scene_database);
+ *
+ *     for (var v = 0u; v < volume_count; v++) {
+ *         let volume = participating_media_volume_read(&scene_database, v);
+ *         // ...
+ *     }
+ *
+ * The page accessors stay for readers that walk the occupancy bitmap.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_volumes_iterate: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_participating_media_volumes_iterate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_participating_media_volumes_iterate.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_participating_media_volumes_iterate.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,gDAFU,OAAO,4CAA4C,EAAE,uBAAuB,CAEkB;AAExG;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wDAFU,SAAS,CAsDjB;0BApFwB,iCAAiC"}

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

@@ -0,0 +1,86 @@
+import { SCENE_DATABASE_SPEC } from "../scene/SCENE_DATABASE_SPEC.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+
+/**
+ * The scene's participating-media volumes, as rows of the scene database.
+ * @type {import("../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor}
+ */
+export const PARTICIPATING_MEDIA_VOLUMES_TABLE = SCENE_DATABASE_SPEC.get('participating_media_volumes');
+
+/**
+ * Per-thread iteration over the scene's participating-media volumes, read from the scene database
+ * the importing shader binds as `scene_database` (`var<storage, read>`, `array<u32>`). No workgroup
+ * memory, so it serves the froxel passes and the ray passes alike.
+ *
+ * The table is written whole from row 0 — `GPUSceneVolumetrics` clears it and adds every volume in
+ * the scene's order — so its rows are `[0, count)`, its pages run from page 0 without a hole, and
+ * only the last of them is partly full. `participating_media_volumes_count` reads the count off the
+ * pages' live counts, stopping at the first page that is missing or not full: one page for up to
+ * {@link PARTICIPATING_MEDIA_VOLUMES_TABLE}'s `elements_per_page` volumes. A walk is then over rows,
+ * never over the table's page capacity:
+ *
+ *     let volume_count = participating_media_volumes_count(&scene_database);
+ *
+ *     for (var v = 0u; v < volume_count; v++) {
+ *         let volume = participating_media_volume_read(&scene_database, v);
+ *         // ...
+ *     }
+ *
+ * The page accessors stay for readers that walk the occupancy bitmap.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_volumes_iterate = CodeChunk.from(
+    //language=WGSL
+    `
+const PARTICIPATING_MEDIA_VOLUMES_PAGE_LIMIT: u32 = ${PARTICIPATING_MEDIA_VOLUMES_TABLE.page_limit}u;
+const PARTICIPATING_MEDIA_VOLUMES_OCCUPANCY_BITMAP_WORDS: u32 = ${PARTICIPATING_MEDIA_VOLUMES_TABLE.occupancy_bitmap_words}u;
+const PARTICIPATING_MEDIA_VOLUMES_ELEMENTS_PER_PAGE: u32 = ${PARTICIPATING_MEDIA_VOLUMES_TABLE.elements_per_page}u;
+
+fn participating_media_volumes_page_address(database: ptr<storage, array<u32>, read>, page_index: u32) -> u32 {
+    return database[page_index + ${PARTICIPATING_MEDIA_VOLUMES_TABLE.page_lookup_address}u];
+}
+
+fn participating_media_volumes_page_bitmap_word(database: ptr<storage, array<u32>, read>, page_address: u32, word_index: u32) -> u32 {
+    // page header: [u32 live_count][u32 bitmap[OCCUPANCY_BITMAP_WORDS]]
+    return database[page_address + 1u + word_index];
+}
+
+fn participating_media_volumes_slot_to_index(page_index: u32, in_page_slot: u32) -> u32 {
+    return page_index * PARTICIPATING_MEDIA_VOLUMES_ELEMENTS_PER_PAGE + in_page_slot;
+}
+
+fn participating_media_volume_read(database: ptr<storage, array<u32>, read>, index: u32) -> ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref} {
+    return ${PARTICIPATING_MEDIA_VOLUMES_TABLE.marshalling_method_read}(database, index);
+}
+
+// how many volumes the scene has, as rows [0, count)
+fn participating_media_volumes_count(database: ptr<storage, array<u32>, read>) -> u32 {
+    var count = 0u;
+
+    for (var page = 0u; page < PARTICIPATING_MEDIA_VOLUMES_PAGE_LIMIT; page++) {
+        let page_address = participating_media_volumes_page_address(database, page);
+
+        if (page_address == ~0u) {
+            break;
+        }
+
+        // page header: [u32 live_count]...
+        let live = database[page_address];
+
+        count += live;
+
+        if (live < PARTICIPATING_MEDIA_VOLUMES_ELEMENTS_PER_PAGE) {
+            break;
+        }
+    }
+
+    return count;
+}
+    `,
+    [
+        PARTICIPATING_MEDIA_VOLUMES_TABLE.chunk_read,
+        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
+    ]
+);

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":"AA0BA;;;;;;;;GAQG;AACH;IAH+B,KAAK;IACvB;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CA8DjE;AAqVD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAnB+B,KAAK;IACC,MAAM;IACJ,MAAM;IACV,IAAI;IACZ,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;IACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;IAElD,WAAW,GAA5B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe;;;;;;WAjKH,MAAM;cAAQ,MAAM;;;EA0VrE"}
+{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AA0BA;;;;;;;;GAQG;AACH;IAH+B,KAAK;IACvB;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CA8DjE;AAoVD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAnB+B,KAAK;IACC,MAAM;IACJ,MAAM;IACV,IAAI;IACZ,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;IACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;IAElD,WAAW,GAA5B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe;;;;;;WAjKH,MAAM;cAAQ,MAAM;;;EAyVrE"}

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

@@ -151,8 +151,7 @@ function graph_integrate_participating_media({
                     camera: camera.buffer.buffer,
                     view: view.uniform_buffer.buffer,
                     volumetrics_metadata,
-                    scene_volumetrics_metadata: scene.volumetrics.metadata_buffer.buffer,
-                    scene_volumes: scene.volumetrics.table.buffer,
+                    scene_database: scene.scene_database_buffer,
                     tOutput0: output0.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
                     tOutput1: output1.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
                 }
@@ -600,8 +599,7 @@ export function graph_build_volumetrics({
                 tParticipatingMedia1: participating_media1.obtainView(),
 
                 // RDR2-style far-field march inputs (used beyond froxel_far)
-                scene_volumetrics_metadata: view.scene.volumetrics.metadata_buffer.buffer,
-                scene_volumes: view.scene.volumetrics.table.buffer,
+                scene_database: view.scene.scene_database_buffer,
                 light_data: lights.buffer_data,
                 tSunTransmittance: sun_transmittance_lut.obtainView(),
 

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

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AAsMA,yEAIE;8BArL4B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AAqMA,yEAIE;8BApL4B,4BAA4B"}

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

@@ -26,8 +26,7 @@ import { chunk_cluster_depth_from_z_slice } from "../light/cluster/chunk_cluster
 import { chunk_compute_volume_fade_factor } from "./chunk_compute_volume_fade_factor.js";
 import { chunk_frustum_unit_box_coverage_multisample } from "./chunk_frustum_unit_box_coverage_multisample.js";
 import { chunk_volumetrics_column_jitter } from "./chunk_volumetrics_column_jitter.js";
-import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
-import { SCENE_VOLUMETRICS_METADATA_STRUCT } from "./SCENE_VOLUMETRICS_METADATA_STRUCT.js";
+import { chunk_participating_media_volumes_iterate } from "./chunk_participating_media_volumes_iterate.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
 
 const resources = new ShaderResourceSetDescriptor();
@@ -36,8 +35,7 @@ resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addUniform("view", VIEW_UNIFORM_STRUCT)
     .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
-    .addUniform("scene_volumetrics_metadata", SCENE_VOLUMETRICS_METADATA_STRUCT)
-    .addStorageBuffer("scene_volumes", WebGPUArray.from(PARTICIPATING_MEDIA_VOLUME_STRUCT))
+    .addStorageBuffer("scene_database", WebGPUArray.u32)
     .addStorageTexture("tOutput0", "rgba16float", "3d", "write-only")
     .addStorageTexture("tOutput1", "rgba16float", "3d", "write-only")
 
@@ -104,9 +102,10 @@ fn main(
     var scattering_luma_sum = 0.0;
     var anisotropic_g = 0.0;
 
-    for(var i=0u; i < scene_volumetrics_metadata.instance_count; i++){
+    let volume_count = participating_media_volumes_count(&scene_database);
 
-        let volume = scene_volumes[i];
+    for (var v = 0u; v < volume_count; v++) {
+        let volume = participating_media_volume_read(&scene_database, v);
 
         // Transform froxel into volume's coordinate space. Points go world -> local through
         // transform_inverse, so planes go by the transpose of *its* inverse, which is just
@@ -165,7 +164,6 @@ fn main(
         anisotropic_g += volume.particle_spec.g * volume_scattering_luma;
         
         scattering_luma_sum += volume_scattering_luma;
-        
     }
     
     if(scattering_luma_sum != 0.0){
@@ -193,6 +191,7 @@ fn main(
         chunk_compute_volume_fade_factor,
         chunk_mat4_extract_scale,
         chunk_volumetrics_column_jitter,
+        chunk_participating_media_volumes_iterate,
     ]
 )
 

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

@@ -20,8 +20,7 @@ import { chunk_get_directional_light_info_by_index } from "../shader/chunk/light
 import { chunk_sky_lut_compute_uv } from "../atmosphere/chunk_sky_lut_compute_uv.js";
 import { chunk_calculate_multiscattering } from "./chunk_calculate_multiscattering.js";
 import { chunk_camera_ray_planar_depth_scale } from "./chunk_camera_ray_planar_depth_scale.js";
-import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
-import { SCENE_VOLUMETRICS_METADATA_STRUCT } from "./SCENE_VOLUMETRICS_METADATA_STRUCT.js";
+import { chunk_participating_media_volumes_iterate } from "./chunk_participating_media_volumes_iterate.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
@@ -35,8 +34,7 @@ resources.createGroup()
     .addTexture("tVolumeLighting", "float", "3d") // pre-integrated volumetric light scattering
     // RDR2-style far field: beyond froxel_far the pass ray-marches the scene volumes directly,
     // lit by the directional sun + atmosphere (single scattering, no self-shadow).
-    .addUniform("scene_volumetrics_metadata", SCENE_VOLUMETRICS_METADATA_STRUCT)
-    .addStorageBuffer("scene_volumes", WebGPUArray.from(PARTICIPATING_MEDIA_VOLUME_STRUCT))
+    .addStorageBuffer("scene_database", WebGPUArray.u32)
     .addStorageBuffer("light_data", WebGPUArray.u32)
     .addTexture("tSunTransmittance", "float", "2d")
     .addSampler("sLinear")
@@ -65,9 +63,10 @@ fn far_sample_volumes(world_pos: vec3<f32>) -> FarVolumeSample {
     var g_weighted = 0.0;
     var scattering_luma = 0.0;
 
-    let count = scene_volumetrics_metadata.instance_count;
-    for (var i = 0u; i < count; i++) {
-        let volume = scene_volumes[i];
+    let volume_count = participating_media_volumes_count(&scene_database);
+
+    for (var v = 0u; v < volume_count; v++) {
+        let volume = participating_media_volume_read(&scene_database, v);
         let local = (volume.transform_inverse * vec4<f32>(world_pos, 1.0)).xyz;
         if (any(abs(local) > vec3<f32>(0.5))) {
             continue;
@@ -263,6 +262,7 @@ fn main(
         chunk_get_directional_light_info_by_index,
         chunk_sky_lut_compute_uv,
         chunk_calculate_multiscattering,
+        chunk_participating_media_volumes_iterate,
     ]
 )