@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/renderer/gpu_primitive/bvh8/verify_gpu_bvh8_encode.js

@@ -0,0 +1,361 @@
+import { BVH8 } from "../../../../core/bvh8/BVH8.js";
+import { bvh8_depth } from "../../../../core/bvh8/bvh8_depth.js";
+import { FrameGraph } from "../../../../engine/graphics/render/frame_graph/FrameGraph.js";
+import { ShadeGPUCommandContext } from "../../../device/ShadeGPUCommandContext.js";
+import { GPUFrameRecorder } from "../../../device/timing/profile/GPUFrameRecorder.js";
+import { graph_inspect_gpu_buffer } from "../../buffer/graph_inspect_gpu_buffer.js";
+import { BVH8_TLAS_MAX_DEPTH } from "../../shader/chunk/bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js";
+import { graph_import_typed_buffer } from "../../shader/graph/graph_import_typed_buffer.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { bvh_buffer_size } from "../bvh/BVH_BUFFER_LAYOUT.js";
+import { graph_bvh_build_lbvh } from "../bvh/graph_bvh_build_lbvh.js";
+import {
+    BVH8_TREE_HEADER_WORDS,
+    BVH8_TREE_NODE_STRIDE_WORDS,
+    BVH8_TREE_ORDER_OFFSET_WORD,
+    bvh8_tree_buffer_size
+} from "./BVH8_TREE_BUFFER_LAYOUT.js";
+import { bvh8_encode_from_bvh2 } from "./bvh8_encode_from_bvh2.js";
+import { graph_bvh8_encode_from_bvh2 } from "./graph_bvh8_encode_from_bvh2.js";
+
+// The cases whose passes are timed: the most leaves the one-workgroup recordings take, the fewest the
+// multi-pass ones do, and a hundred thousand.
+const TIMED = ['n=1024 scattered', 'n=1025 scattered', 'n=100003 scattered'];
+
+// what the output holds before the encode, so that a word it should have written and did not shows
+const UNWRITTEN = 0xDEADBEEF;
+
+/**
+ * @param {number} seed
+ * @returns {function(): number} LCG, so a failing case is reproducible
+ */
+function make_random(seed) {
+    let state = seed >>> 0;
+
+    return () => (state = (state * 1664525 + 1013904223) >>> 0);
+}
+
+/**
+ * The leaf sets one run covers: the shapes `verify_gpu_bvh_build` builds, for what each does to the
+ * binary tree the encode is handed — an ordinary cloud, leaves no Morton code tells apart, which
+ * make the deepest trees and boxes whose centres cost every slot the same, and boxes with no volume.
+ *
+ * @returns {{name: string, count: number, make: function(function(): number, number): {low: number[], high: number[]}}[]}
+ */
+function cases() {
+    /**
+     * A box around a random point.
+     * @param {number} spread
+     * @returns {function(function(): number): {low: number[], high: number[]}}
+     */
+    function scattered(spread) {
+        return random => {
+            const unit = () => (random() / 0x100000000) * 2 - 1;
+
+            const centre = [unit() * spread, unit() * spread, unit() * spread];
+            const half = [0.5 + Math.abs(unit()), 0.5 + Math.abs(unit()), 0.5 + Math.abs(unit())];
+
+            return {
+                low: centre.map((c, a) => c - half[a]),
+                high: centre.map((c, a) => c + half[a]),
+            };
+        };
+    }
+
+    /**
+     * A box with no volume at all — a point.
+     * @param {function(): number} random
+     * @returns {{low: number[], high: number[]}}
+     */
+    function degenerate(random) {
+        const unit = () => (random() / 0x100000000) * 2 - 1;
+
+        const point = [unit() * 50, unit() * 50, unit() * 50];
+
+        return { low: point.slice(), high: point.slice() };
+    }
+
+    const shapes = [
+        ['scattered', scattered(100)],
+        ['coincident', () => ({ low: [1, 2, 3], high: [4, 5, 6] })],
+        ['clustered', scattered(0.0004)],
+        ['degenerate', degenerate],
+        ['mixed', (random, i) => (i % 2 === 0 ? { low: [0, 0, 0], high: [0, 0, 0] } : scattered(100)(random))],
+    ];
+
+    // Counts either side of every boundary the encode has: its 64-wide workgroups, the four nodes a
+    // thread of the one-workgroup encode takes, and the 1,024 leaves that encode stops at.
+    const counts = [1, 2, 3, 4, 5, 8, 9, 63, 64, 65, 66, 1023, 1024, 1025, 1026, 100003];
+
+    const result = [];
+
+    for (const count of counts) {
+        for (const [shape_name, make] of shapes) {
+            // every shape where a case costs nothing; above that an ordinary cloud and the one that
+            // makes the deepest tree
+            if (count > 200 && shape_name !== 'scattered' && shape_name !== 'coincident') {
+                continue;
+            }
+
+            result.push({ name: `n=${count} ${shape_name}`, count, make });
+        }
+    }
+
+    return result;
+}
+
+/**
+ * @param {{count: number, make: function}} test_case
+ * @returns {{bounds: Float32Array, payload: Uint32Array, scene: Float32Array}}
+ */
+function build_input(test_case) {
+    const { count, make } = test_case;
+
+    const random = make_random(0x1234567 ^ (count * 2654435761));
+
+    const bounds = new Float32Array(count * 6);
+    const payload = new Uint32Array(count);
+
+    for (let i = 0; i < count; i++) {
+        const box = make(random, i);
+
+        bounds.set([...box.low, ...box.high], i * 6);
+
+        // sparse, unordered rows — never the leaf index, so a mixed-up payload shows
+        payload[i] = 11 + i * 7;
+    }
+
+    const scene = new Float32Array(6);
+
+    scene.set([Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity]);
+
+    for (let i = 0; i < count; i++) {
+        for (let axis = 0; axis < 3; axis++) {
+            scene[axis] = Math.min(scene[axis], bounds[i * 6 + axis]);
+            scene[3 + axis] = Math.max(scene[3 + axis], bounds[i * 6 + 3 + axis]);
+        }
+    }
+
+    return { bounds, payload, scene };
+}
+
+/**
+ * Hold what the device encoded to what {@link bvh8_encode_from_bvh2} makes of the same binary tree.
+ *
+ * @param {number} count
+ * @param {Uint32Array} tree the binary tree the device built, as words
+ * @param {Uint32Array} encoded the BVH8 the device made of it, as words
+ * @returns {{problems: string[], node_count: number, depth: number}}
+ */
+function check(count, tree, encoded) {
+    const problems = [];
+
+    const expected = new Uint32Array(bvh8_tree_buffer_size(count) / Uint32Array.BYTES_PER_ELEMENT).fill(UNWRITTEN);
+
+    const node_count = bvh8_encode_from_bvh2(expected, Uint32Array.from(tree), count);
+
+    const order_offset = expected[BVH8_TREE_ORDER_OFFSET_WORD];
+
+    let differing = 0;
+
+    for (let word = 0; word < expected.length; word++) {
+        if (encoded[word] === expected[word]) {
+            continue;
+        }
+
+        differing++;
+
+        if (differing > 4) {
+            continue;
+        }
+
+        let where = `header word ${word}`;
+
+        if (word >= order_offset + count) {
+            where = `word ${word}, past the tree`;
+        } else if (word >= order_offset) {
+            where = `payload ${word - order_offset}`;
+        } else if (word >= BVH8_TREE_HEADER_WORDS) {
+            const at = word - BVH8_TREE_HEADER_WORDS;
+
+            where = `node ${Math.floor(at / BVH8_TREE_NODE_STRIDE_WORDS)} word ${at % BVH8_TREE_NODE_STRIDE_WORDS}`;
+        }
+
+        problems.push(`${where}: the device wrote 0x${(encoded[word] >>> 0).toString(16)}, the reference 0x${expected[word].toString(16)}`);
+    }
+
+    if (differing > 4) {
+        problems.push(`… ${differing} words differ in all`);
+    }
+
+    // the depth a walk's stack has to hold, of the reference: the device's tree is that tree or has failed above
+    const bvh8 = new BVH8();
+
+    bvh8.nodes.fromArrayBuffer(
+        expected.buffer.slice(BVH8_TREE_HEADER_WORDS * 4, (BVH8_TREE_HEADER_WORDS + node_count * BVH8_TREE_NODE_STRIDE_WORDS) * 4),
+        node_count
+    );
+
+    return { problems, node_count, depth: bvh8_depth(bvh8) };
+}
+
+/**
+ * On-device verification of the BVH8 encode.
+ *
+ * For each of a set of leaf sets it builds the binary tree as the scene's is built
+ * (`graph_bvh_build_lbvh`), encodes it ({@link graph_bvh8_encode_from_bvh2}), reads both back, and
+ * holds the encoded tree to {@link bvh8_encode_from_bvh2} run over the binary tree the device built:
+ * every word of the header, the nodes and the payloads, and the words past them left alone. The
+ * counts sit either side of where the encode changes recording and of its workgroups' edges.
+ *
+ * It reports each tree's depth against what a walk's stack holds, and the per-pass GPU time of the
+ * build and the encode together at three counts: one workgroup's worth of leaves, one leaf more —
+ * the same work as many dispatches — and a hundred thousand.
+ *
+ * One graph and one submission per case, as `verify_gpu_bvh_build` has it.
+ *
+ * @param {GraphicsContext} graphics
+ */
+export function verify_gpu_bvh8_encode(graphics) {
+    for (const test_case of cases()) {
+        run_case(graphics, test_case);
+    }
+}
+
+/**
+ * @param {GraphicsContext} graphics
+ * @param {{name: string, count: number, make: function}} test_case
+ */
+function run_case(graphics, test_case) {
+    const { count, name } = test_case;
+
+    const graph = new FrameGraph(`verify gpu bvh8 encode/${name}`);
+
+    const cmd = ShadeGPUCommandContext.create(graphics, `verify/gpu bvh8 encode/${name}`);
+
+    /** @type {GPUFrameRecorder|null} */
+    let recorder = null;
+
+    if (TIMED.includes(name)) {
+        recorder = new GPUFrameRecorder(0, performance.now());
+
+        recorder.enable_work_capture();
+
+        cmd.enable_profiling(recorder, 0);
+    }
+
+    const storage_usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC;
+
+    const input = build_input(test_case);
+
+    const leaf_bounds = graph_import_typed_buffer({
+        graph, type: WebGPUArray.from(f32, count * 6), value: input.bounds,
+        label: `verify bvh8 bounds ${name}`, usage: storage_usage
+    });
+
+    const leaf_payload = graph_import_typed_buffer({
+        graph, type: WebGPUArray.from(u32, count), value: input.payload,
+        label: `verify bvh8 payload ${name}`, usage: storage_usage
+    });
+
+    const scene_bounds = graph_import_typed_buffer({
+        graph, type: WebGPUArray.from(f32, 6), value: input.scene,
+        label: `verify bvh8 scene bounds ${name}`, usage: storage_usage
+    });
+
+    const tree_words = bvh_buffer_size(count) / Uint32Array.BYTES_PER_ELEMENT;
+
+    const nodes = graph_import_typed_buffer({
+        graph,
+        type: WebGPUArray.from(u32, tree_words),
+        value: new Uint32Array(tree_words),
+        label: `verify bvh8 binary tree ${name}`,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+    });
+
+    const out_words = bvh8_tree_buffer_size(count) / Uint32Array.BYTES_PER_ELEMENT;
+
+    const out = graph_import_typed_buffer({
+        graph,
+        type: WebGPUArray.from(u32, out_words),
+        value: new Uint32Array(out_words).fill(UNWRITTEN),
+        label: `verify bvh8 tree ${name}`,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+    });
+
+    const built = graph_bvh_build_lbvh({
+        graph, leaf_bounds, leaf_payload, scene_bounds, element_count: count, nodes,
+    });
+
+    const encoded_tree = graph_bvh8_encode_from_bvh2({
+        graph, tree: built.nodes, leaf_count: count, out,
+    });
+
+    /** @type {Uint32Array|undefined} */
+    let tree;
+    /** @type {Uint32Array|undefined} */
+    let encoded;
+
+    function validate() {
+        if (tree === undefined || encoded === undefined) {
+            // wait for both readbacks
+            return;
+        }
+
+        const result = check(count, tree, encoded);
+
+        const headline = `${name} — ${result.node_count} nodes, depth ${result.depth}/${BVH8_TLAS_MAX_DEPTH}`;
+
+        if (result.problems.length === 0) {
+            console.log(`%c[BVH8] PASS ${headline}`, 'color: #0c0');
+        } else {
+            console.error(`[BVH8] FAIL ${headline}\n  ${result.problems.join('\n  ')}`);
+        }
+
+        if (result.depth > BVH8_TLAS_MAX_DEPTH) {
+            console.warn(`[BVH8] ${name}: the tree is deeper than a walk's stack holds`);
+        }
+    }
+
+    graph_inspect_gpu_buffer({
+        graph, type: WebGPUArray.from(u32, tree_words), buffer: built.nodes,
+        callback([data]) {
+            tree = data;
+            validate();
+        }
+    });
+
+    graph_inspect_gpu_buffer({
+        graph, type: WebGPUArray.from(u32, out_words), buffer: encoded_tree,
+        callback([data]) {
+            encoded = data;
+            validate();
+        }
+    });
+
+    if (recorder !== null) {
+        // subscribed before the graph runs, so each pass is attributed to the node that opened it
+        recorder.attach_graph(graph);
+    }
+
+    cmd.encodeGraph(graph);
+    cmd.finish();
+
+    if (recorder !== null) {
+        const captured = recorder;
+
+        // once the timestamps have been read back, which is after the submission resolves
+        cmd.profiling_absorbed.then(() => {
+            const frame = captured.close(performance.now());
+
+            console.log(`[BVH8] GPU timings — ${name}`);
+            console.table(frame.spans.map(span => ({
+                label: span.label,
+                duration_ms: span.duration_ns * 1e-6,
+                dispatches: span.work?.dispatch_count ?? 0,
+                invocations: span.work?.invocation_count ?? 0
+            })));
+        });
+    }
+}

package/src/shade/renderer/grass/press/shader_grass_press_mark.d.ts

@@ -17,8 +17,9 @@ export const GRASS_PRESS_MARK_WORKGROUP_SIZE: number;
  * It also writes the clock's time into the word of every tile of the window that its box comes within a
  * cell of, at the front of the field, `grass_press`: the tiles whose blades read a cell it may press.
  *
- * Two kinds of obstacle list themselves nowhere, and so press nothing. One with no box, a half-space:
- * there is no end to what it would press. And one whose row is ground of a grass surface (a member, by the
+ * Three kinds of obstacle list themselves nowhere, and so press nothing. One with no box, a half-space:
+ * there is no end to what it would press. A porous one (`drag` above 0): the air passes through it,
+ * and so does the grass. And one whose row is ground of a grass surface (a member, by the
  * scene's `mesh_ground_covers`): ground does not press what grows on it, and under everything that
  * stands on it, it would be the lowest obstacle of every cell.
  *

package/src/shade/renderer/grass/press/shader_grass_press_mark.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_grass_press_mark.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/press/shader_grass_press_mark.js"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,8CAFU,MAAM,CAEkC;AAYlD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,sCAFU,aAAa,CAyGpB;8BAlK2B,+BAA+B"}
+{"version":3,"file":"shader_grass_press_mark.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/press/shader_grass_press_mark.js"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,8CAFU,MAAM,CAEkC;AAYlD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,sCAFU,aAAa,CA0GpB;8BApK2B,+BAA+B"}

package/src/shade/renderer/grass/press/shader_grass_press_mark.js

@@ -54,8 +54,9 @@ resources.createGroup()
  * It also writes the clock's time into the word of every tile of the window that its box comes within a
  * cell of, at the front of the field, `grass_press`: the tiles whose blades read a cell it may press.
  *
- * Two kinds of obstacle list themselves nowhere, and so press nothing. One with no box, a half-space:
- * there is no end to what it would press. And one whose row is ground of a grass surface (a member, by the
+ * Three kinds of obstacle list themselves nowhere, and so press nothing. One with no box, a half-space:
+ * there is no end to what it would press. A porous one (`drag` above 0): the air passes through it,
+ * and so does the grass. And one whose row is ground of a grass surface (a member, by the
  * scene's `mesh_ground_covers`): ground does not press what grows on it, and under everything that
  * stands on it, it would be the lowest obstacle of every cell.
  *
@@ -86,7 +87,8 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let row = press_rows[i];
     let record = ${FLUID_OBSTACLE_DESCRIPTOR.marshalling_method_read}(&fluid_database, row);
 
-    if (!shape_record_local_bounded(record.shape_kind)) {
+    // a half-space, and what the air passes through, such as grass's own canopy
+    if (!shape_record_local_bounded(record.shape_kind) || record.drag != 0.0) {
         return;
     }
 

package/src/shade/renderer/grass/surface/shader_grass_surface_bake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_grass_surface_bake.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/shader_grass_surface_bake.js"],"names":[],"mappings":"AAyCA;;GAEG;AACH,uHAAsF;AAEtF;;;;;;GAMG;AACH,0CAFU,YAAY,CAIS;AAa/B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wCAFU,aAAa,CA2KpB;6BAxP0B,mCAAmC;8BAHlC,+BAA+B"}
+{"version":3,"file":"shader_grass_surface_bake.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/shader_grass_surface_bake.js"],"names":[],"mappings":"AAyCA;;GAEG;AACH,uHAAsF;AAEtF;;;;;;GAMG;AACH,0CAFU,YAAY,CAIS;AAa/B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wCAFU,aAAa,CA0KpB;6BAvP0B,mCAAmC;8BAHlC,+BAA+B"}

package/src/shade/renderer/grass/surface/shader_grass_surface_bake.js

@@ -3,7 +3,7 @@ import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_S
 import { TRANSFORMS_TABLE } from "../../scene/chunk_scene_database_access.js";
 import { MESH_GROUND_COVER_FLAG_MEMBER } from "../../scene/MESH_GROUND_COVER_STRUCT.js";
 import { SCENE_DATABASE_SPEC } from "../../scene/SCENE_DATABASE_SPEC.js";
-import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
+import { chunk_bvh8_tree_read } from "../../shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_tree_read.js";
 import { chunk_geometry_read_triangle_vertices } from "../../shader/chunk/geometry/format/chunk_geometry_read_triangle_vertices.js";
 import { chunk_compute_normal_matrix_from_m4 } from "../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
 import { chunk_offset_ray } from "../../shader/chunk/geometry/ray/chunk_offset_ray.js";
@@ -150,16 +150,15 @@ fn main(
     // the surfel's height, and how far its normal is from the frame's up axis
     var found = vec2<f32>(0.0);
 
-    if (tlas.root != BVH_NULL_NODE) {
+    if (bvh8_tree_leaf_count(&tlas) != 0u) {
         grass_bake_surface = surface;
 
         let frame = grass_surface_frame(${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, surface));
         let up = frame[1].xyz;
 
         // the scene's reach along the frame's up axis: its box's centre, and the box's half extent along it
-        let bounds = tlas.nodes[tlas.root].bounds;
-        let low = vec3<f32>(bounds[0], bounds[1], bounds[2]);
-        let high = vec3<f32>(bounds[3], bounds[4], bounds[5]);
+        let low = bvh8_tree_bounds_low(&tlas);
+        let high = bvh8_tree_bounds_high(&tlas);
         let half_reach = dot(0.5 * (high - low), abs(up));
         let top = dot(0.5 * (high + low), up) + half_reach;
 
@@ -247,7 +246,7 @@ fn main(
     }
 }
 `, [
-            BVH_NULL_NODE_DEFINITION,
+            chunk_bvh8_tree_read,
             RAY_STRUCT.declaration_chunk,
             chunk_folded_workgroup_index,
             chunk_compute_normal_matrix_from_m4,

package/src/shade/renderer/lightmap/GPULightMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightMap.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/lightmap/GPULightMap.js"],"names":[],"mappings":"AAoBA;IAgCI;;;OAGG;IACH,+BA6CC;IA/ED;;;OAGG;IACH,WAFU,iBAAiB,GAAC,IAAI,CAEf;IACjB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IACpB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IAEpB;;;OAGG;IACH,aAFU,iBAAiB,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yBAEC;IA2ED;;;;OAIG;IACH,wEAmCC;IA6BD;;OAEG;IACH,oBA+DC;IAED,iBA4EC;IAED;;;;OAIG;IACH,kEAQC;;CAEJ;kCA9ViC,iCAAiC"}
+{"version":3,"file":"GPULightMap.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/lightmap/GPULightMap.js"],"names":[],"mappings":"AAoBA;IAgCI;;;OAGG;IACH,+BA6CC;IA/ED;;;OAGG;IACH,WAFU,iBAAiB,GAAC,IAAI,CAEf;IACjB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IACpB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IAEpB;;;OAGG;IACH,aAFU,iBAAiB,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yBAEC;IA2ED;;;;OAIG;IACH,wEAmCC;IA6BD;;OAEG;IACH,oBAgEC;IAED,iBA4EC;IAED;;;;OAIG;IACH,kEAQC;;CAEJ;kCA/ViC,iCAAiC"}

package/src/shade/renderer/lightmap/GPULightMap.js

@@ -238,6 +238,7 @@ export class GPULightMap {
                 sParticipatingMediaNoise: graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
                 wind_field: scene_ctx.wind.uniform,
                 wind_field_atlas: scene_ctx.wind.atlas.texture,
+                fluid_turbulence: scene_ctx.wind.turbulence,
 
                 tlas: scene_ctx.tlas.buffer,
                 blas_lookup: scene_ctx.geometries.blas.buffer_metadata,

package/src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AccumulatingPathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;GAcG;AACH;IA8EI;;;OAGG;IACH,sBAFW,eAAe,EAkBzB;IAhGD;;;;OAIG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,wBAFU,MAAM,CAEc;IAE9B;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA+NtB;;;;;;;OAOG;IACH,+BAgBC;IAED;;;;;;;OAOG;IACH;QAJmC,IAAI,EAA5B,cAAc;QACM,KAAK,EAAzB,UAAU;QACR,MAAM,CA8JlB;;CACJ;yBA7cY,OAAO,8DAA8D,EAAE,UAAU;8BAIjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc"}
+{"version":3,"file":"AccumulatingPathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;GAcG;AACH;IA8EI;;;OAGG;IACH,sBAFW,eAAe,EAkBzB;IAhGD;;;;OAIG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,wBAFU,MAAM,CAEc;IAE9B;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA+NtB;;;;;;;OAOG;IACH,+BAgBC;IAED;;;;;;;OAOG;IACH;QAJmC,IAAI,EAA5B,cAAc;QACM,KAAK,EAAzB,UAAU;QACR,MAAM,CA+JlB;;CACJ;yBA9cY,OAAO,8DAA8D,EAAE,UAAU;8BAIjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc"}

package/src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js

@@ -429,6 +429,7 @@ export class AccumulatingPathTracer {
                     sParticipatingMediaNoise: graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
                     wind_field: scene_ctx.wind.uniform,
                     wind_field_atlas: scene_ctx.wind.atlas.texture,
+                    fluid_turbulence: scene_ctx.wind.turbulence,
 
                     settings,
                     camera: view.camera.gpu_buffer,

package/src/shade/renderer/path_tracer/graph_path_trace_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_path_trace_scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/path_tracer/graph_path_trace_scene.js"],"names":[],"mappings":"AA0GA;;;;;;GAMG;AACH;IAJ+B,KAAK;IACD,IAAI;IAC1B,MAAM,CAyFlB"}
+{"version":3,"file":"graph_path_trace_scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/path_tracer/graph_path_trace_scene.js"],"names":[],"mappings":"AA0GA;;;;;;GAMG;AACH;IAJ+B,KAAK;IACD,IAAI;IAC1B,MAAM,CA0FlB"}

package/src/shade/renderer/path_tracer/graph_path_trace_scene.js

@@ -178,6 +178,7 @@ export function graph_path_trace_scene({
                 sParticipatingMediaNoise: graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
                 wind_field: scene_ctx.wind.uniform,
                 wind_field_atlas: scene_ctx.wind.atlas.texture,
+                fluid_turbulence: scene_ctx.wind.turbulence,
 
                 common_uniforms: rt_uniforms,
                 camera: view.camera.gpu_buffer,

package/src/shade/renderer/rasterize/native/avboit/avboit_unlit_draw.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The render pipeline for an unlit draw shader: additive into the accumulators with the emission
+ * target masked off, the opaque scene's depth tested and never written, both faces.
+ *
+ * @param {object} params
+ * @param {string} params.label
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the shader's resources; must hold {@link AVBOIT_UNLIT_DRAW_PASS_GROUP}
+ * @param {string} params.source the assembled shader, with a vertex entry point named `vs_main` and
+ * {@link chunk_avboit_unlit_draw_fragment}'s `fs_main`
+ * @returns {RenderPipelineDescriptor}
+ */
+export function avboit_unlit_draw_pipeline({ label, resources, source }: {
+    label: string;
+    resources: import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor;
+    source: string;
+}): RenderPipelineDescriptor;
+/**
+ * What the unlit draw reads once per pass: the view, the warp, the integral and the fog.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_UNLIT_DRAW_PASS_GROUP: ShaderResourceGroupDescriptor;
+/**
+ * The unlit AVBOIT draw's fragment stage, `fs_main`: unlit straight-alpha geometry — a dynamic mesh, a
+ * trail — drawn at internal resolution into the four accumulators the transparent meshes and the
+ * particles draw into (`avboit_draw_fragment_body`), so it composites against both order-independently.
+ * Any vertex stage that hands it `AVBOITUnlitVaryings` (`chunk_avboit_unlit_varyings`) can be linked
+ * with it.
+ *
+ * Per fragment: nothing at all if it has faded out (the unlit splat recorded nothing for it either),
+ * then the transmittance of everything in front from the integral texture — a fragment the volume
+ * already calls extinct is discarded unshaded — the volumetric fog at its depth, and the accumulators
+ * through `avboit_premultiplied_contribution`, the routing every side channel shares.
+ *
+ * The colour is straight alpha and unlit: it is premultiplied here and never emits — a fragment that
+ * can get past the first test covers something — so {@link avboit_unlit_draw_pipeline} does not write
+ * the emission target at all rather than blend zeros into it over every covered pixel.
+ *
+ * The enclosing shader binds {@link AVBOIT_UNLIT_DRAW_PASS_GROUP} and names its vertex entry point
+ * anything but `fs_main`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_draw_fragment: CodeChunk;
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=avboit_unlit_draw.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"avboit_unlit_draw.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_unlit_draw.js"],"names":[],"mappings":"AAiHA;;;;;;;;;;;GAWG;AACH;IAP0B,KAAK,EAApB,MAAM;IACgG,SAAS,EAA/G,OAAO,yDAAyD,EAAE,2BAA2B;IAE9E,MAAM,EAArB,MAAM;IAEJ,wBAAwB,CAoBpC;AA5HD;;;;GAIG;AACH,2CAFU,6BAA6B,CAEyC;AAahF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,+CAFU,SAAS,CAuDjB;yCA7GuC,oEAAoE;8CAI/D,2DAA2D;0BAD/E,uCAAuC"}