@woosh/meep-engine 3.69.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/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/scene/GPUInstancesAccelerationStructure.d.ts

@@ -1,5 +1,9 @@
 /**
- * Top-Level Acceleration Structure (TLAS)
+ * Top-Level Acceleration Structure (TLAS): a BVH8 over the scene's instances, in the layout of
+ * {@link BVH8_TREE_BUFFER_LAYOUT}. A leaf's payload is a row of the scene database's `meshes` table.
+ *
+ * A build makes a binary tree over the rows' world boxes (`graph_bvh_build_lbvh`), which lives for
+ * the length of the build, and encodes it three levels to a node (`graph_bvh8_encode_from_bvh2`).
  */
 export class GPUInstancesAccelerationStructure {
     /**
@@ -49,9 +53,9 @@ export class GPUInstancesAccelerationStructure {
      */
     invalidate(): void;
     /**
-     * The bounds of everything in the tree, read back from its root node: the box the GPU built
-     * the tree under, the union of every live row's bounds as the bounds pass derived them — the
-     * whole scene, whoever placed what. For a consumer that sizes work by the scene once, a probe
+     * The bounds of everything in the tree, read back from its header: the box the GPU built the
+     * tree under, the union of every live row's bounds as the bounds pass derived them — the whole
+     * scene, whoever placed what. For a consumer that sizes work by the scene once, a probe
      * placement or a bake; a frame-loop reader wants the scene database's readback service.
      *
      * Resolves once the copy has landed and been mapped, which is after the device has finished

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

@@ -1 +1 @@
-{"version":3,"file":"GPUInstancesAccelerationStructure.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUInstancesAccelerationStructure.js"],"names":[],"mappings":"AAoCA;;GAEG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAKzB;IA+DD;;;OAGG;IACH,sBAFW,eAAe,EAqBzB;IAzED,cAIC;IAOD;;;OAGG;IACH,wBAEC;IAmED;;;;OAIG;IACH,oBAFW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,uBAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,uBAFW,MAAM,QAOhB;IA8CD;;;;OAIG;IACH;;;OAGG;IACH,mBAEC;IAiGD;;;;;;;;;;;;OAYG;IACH,0BAHW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,GAChC,QAAQ,OAAO,CAAC,CA0C5B;IAED;;;OAGG;IACH,wDAFW,sBAAsB,QAMhC;IAED;;;;;;OAMG;IACH,mDAHW,sBAAsB,QAShC;IAED;;;OAGG;IACH,gBAKC;;CACJ;8BApaY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;uCATrB,wCAAwC"}
+{"version":3,"file":"GPUInstancesAccelerationStructure.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUInstancesAccelerationStructure.js"],"names":[],"mappings":"AAqDA;;;;;;GAMG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAMzB;IA+DD;;;OAGG;IACH,sBAFW,eAAe,EAoBzB;IAxED,cAIC;IAOD;;;OAGG;IACH,wBAEC;IAkED;;;;OAIG;IACH,oBAFW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,uBAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,uBAFW,MAAM,QAOhB;IA8CD;;;;OAIG;IACH;;;OAGG;IACH,mBAEC;IA4GD;;;;;;;;;;;;OAYG;IACH,0BAHW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,GAChC,QAAQ,OAAO,CAAC,CAqC5B;IAED;;;OAGG;IACH,wDAFW,sBAAsB,QAMhC;IAED;;;;;;OAMG;IACH,mDAHW,sBAAsB,QAShC;IAED;;;OAGG;IACH,gBAKC;;CACJ;8BAlbY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;uCAtBrB,wCAAwC"}

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

@@ -3,9 +3,22 @@ import { FrameGraph } from "../../../engine/graphics/render/frame_graph/FrameGra
 import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescriptor.js";
 import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
 import { ensure_buffer_capacity } from "../geometry/make_temp_gpu_buffer.js";
-import { BVH_HEADER_WORDS, BVH_NODE_STRIDE_WORDS, bvh_buffer_size } from "../gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js";
-import { BVH_NULL_NODE, bvh_tree_views, read_bvh_node } from "../gpu_primitive/bvh/check_bvh_structure.js";
+import { bvh_buffer_size } from "../gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js";
 import { enquire_bvh_build_lbvh_pipelines, graph_bvh_build_lbvh } from "../gpu_primitive/bvh/graph_bvh_build_lbvh.js";
+import {
+    BVH8_TREE_BOUNDS_HIGH_WORD,
+    BVH8_TREE_BOUNDS_LOW_WORD,
+    BVH8_TREE_HEADER_WORDS,
+    BVH8_TREE_LEAF_COUNT_WORD,
+    BVH8_TREE_NODE_STRIDE_WORDS,
+    BVH8_TREE_ORDER_OFFSET_WORD,
+    bvh8_tree_buffer_size
+} from "../gpu_primitive/bvh8/BVH8_TREE_BUFFER_LAYOUT.js";
+import {
+    enquire_bvh8_encode_pipelines,
+    graph_bvh8_encode_from_bvh2
+} from "../gpu_primitive/bvh8/graph_bvh8_encode_from_bvh2.js";
+import { graph_create_buffer } from "../shader/graph/graph_create_buffer.js";
 import { shader_bvh_extract_instance_leaves } from "./shader_bvh_extract_instance_leaves.js";
 
 /**
@@ -14,10 +27,14 @@ import { shader_bvh_extract_instance_leaves } from "./shader_bvh_extract_instanc
  */
 
 /**
- * `root = BVH_NULL_NODE` — an empty tree, in the four bytes every consumer already reads that way.
+ * A tree of no instances, as every walk reads it: a header that counts none, and one node with every
+ * slot empty. The payloads would start behind that node.
+ *
  * @type {Uint32Array}
  */
-const EMPTY_TREE = Uint32Array.from([0xffffffff]);
+const EMPTY_TREE = new Uint32Array(BVH8_TREE_HEADER_WORDS + BVH8_TREE_NODE_STRIDE_WORDS);
+
+EMPTY_TREE[BVH8_TREE_ORDER_OFFSET_WORD] = BVH8_TREE_HEADER_WORDS + BVH8_TREE_NODE_STRIDE_WORDS;
 
 /**
  * The scene-bounds cell before anything has been merged into it: +inf for the three minima, -inf
@@ -35,7 +52,11 @@ const SCENE_BOUNDS_SEED = Uint32Array.from([
 ]);
 
 /**
- * Top-Level Acceleration Structure (TLAS)
+ * Top-Level Acceleration Structure (TLAS): a BVH8 over the scene's instances, in the layout of
+ * {@link BVH8_TREE_BUFFER_LAYOUT}. A leaf's payload is a row of the scene database's `meshes` table.
+ *
+ * A build makes a binary tree over the rows' world boxes (`graph_bvh_build_lbvh`), which lives for
+ * the length of the build, and encodes it three levels to a node (`graph_bvh8_encode_from_bvh2`).
  */
 export class GPUInstancesAccelerationStructure {
 
@@ -47,6 +68,7 @@ export class GPUInstancesAccelerationStructure {
     static enquirePipelines(enquiry) {
         enquiry.compute.push(shader_bvh_extract_instance_leaves.pipeline);
         enquire_bvh_build_lbvh_pipelines(enquiry);
+        enquire_bvh8_encode_pipelines(enquiry);
     }
 
 
@@ -129,9 +151,8 @@ export class GPUInstancesAccelerationStructure {
             usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
         });
 
-        // A fresh buffer holds zeroes, and zero is a root word naming node 0 — a tree that was never
-        // built would read as one with a root of zero bounds. Empty, until the first build says
-        // otherwise.
+        // A fresh buffer holds zeroes, which is a tree of no instances but for where its payloads start.
+        // Empty, until the first build says otherwise.
         device.queue.writeBuffer(this.#buffer, 0, EMPTY_TREE);
     }
 
@@ -262,7 +283,7 @@ export class GPUInstancesAccelerationStructure {
         this.#buffer = ensure_buffer_capacity(
             device,
             this.#buffer,
-            bvh_buffer_size(Math.max(1, element_count)),
+            bvh8_tree_buffer_size(element_count),
             1024,
             1024,
             1.2
@@ -290,8 +311,8 @@ export class GPUInstancesAccelerationStructure {
             scene_database_buffer
         );
 
-        const nodes = graph.import_resource(
-            "tlas/nodes",
+        const tree = graph.import_resource(
+            "tlas/tree",
             BufferResourceDescriptor.fromBuffer(this.#buffer),
             this.#buffer
         );
@@ -318,13 +339,24 @@ export class GPUInstancesAccelerationStructure {
             GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
         ));
 
-        graph_bvh_build_lbvh({
+        // the binary tree is this build's alone
+        const binary = graph_bvh_build_lbvh({
             graph,
             leaf_bounds: extract_data.leaf_bounds,
             leaf_payload: extract_data.leaf_payload,
             scene_bounds: extract_data.scene_bounds,
             element_count,
-            nodes,
+            nodes: graph_create_buffer(graph, "tlas/binary tree", BufferResourceDescriptor.from(
+                bvh_buffer_size(element_count),
+                GPUBufferUsage.STORAGE
+            )),
+        });
+
+        graph_bvh8_encode_from_bvh2({
+            graph,
+            tree: binary.nodes,
+            leaf_count: element_count,
+            out: tree,
         });
 
         if (cmd_ctx !== undefined) {
@@ -340,9 +372,9 @@ export class GPUInstancesAccelerationStructure {
     }
 
     /**
-     * The bounds of everything in the tree, read back from its root node: the box the GPU built
-     * the tree under, the union of every live row's bounds as the bounds pass derived them — the
-     * whole scene, whoever placed what. For a consumer that sizes work by the scene once, a probe
+     * The bounds of everything in the tree, read back from its header: the box the GPU built the
+     * tree under, the union of every live row's bounds as the bounds pass derived them — the whole
+     * scene, whoever placed what. For a consumer that sizes work by the scene once, a probe
      * placement or a bake; a frame-loop reader wants the scene database's readback service.
      *
      * Resolves once the copy has landed and been mapped, which is after the device has finished
@@ -356,8 +388,7 @@ export class GPUInstancesAccelerationStructure {
         assert.isArrayLike(target, 'target');
         assert.greaterThanOrEqual(target.length, 6, 'target.length < 6');
 
-        // the root word and node 0 — the root by the builder's construction
-        const byte_size = (BVH_HEADER_WORDS + BVH_NODE_STRIDE_WORDS) * Uint32Array.BYTES_PER_ELEMENT;
+        const byte_size = BVH8_TREE_HEADER_WORDS * Uint32Array.BYTES_PER_ELEMENT;
 
         const allocator = this.#graphics.buffer_allocator_readback;
         const staging = allocator.get(byte_size);
@@ -369,24 +400,20 @@ export class GPUInstancesAccelerationStructure {
 
         await staging.mapAsync(GPUMapMode.READ, 0, byte_size);
 
-        const { words, floats } = bvh_tree_views(new Uint32Array(staging.getMappedRange(0, byte_size)));
-        const root = words[0];
-
-        let found = false;
-
-        if (root !== BVH_NULL_NODE) {
-            assert.equal(root, 0, 'the tree\'s root is not node 0');
+        const mapped = staging.getMappedRange(0, byte_size);
 
-            const node = read_bvh_node(words, floats, root);
+        const words = new Uint32Array(mapped);
+        const floats = new Float32Array(mapped);
 
-            target[0] = node.low[0];
-            target[1] = node.low[1];
-            target[2] = node.low[2];
-            target[3] = node.high[0];
-            target[4] = node.high[1];
-            target[5] = node.high[2];
+        const found = words[BVH8_TREE_LEAF_COUNT_WORD] !== 0;
 
-            found = true;
+        if (found) {
+            target[0] = floats[BVH8_TREE_BOUNDS_LOW_WORD];
+            target[1] = floats[BVH8_TREE_BOUNDS_LOW_WORD + 1];
+            target[2] = floats[BVH8_TREE_BOUNDS_LOW_WORD + 2];
+            target[3] = floats[BVH8_TREE_BOUNDS_HIGH_WORD];
+            target[4] = floats[BVH8_TREE_BOUNDS_HIGH_WORD + 1];
+            target[5] = floats[BVH8_TREE_BOUNDS_HIGH_WORD + 2];
         }
 
         allocator.release(staging);