@woosh/meep-engine 3.69.0 → 3.70.0

package/src/shade/renderer/wind/chunk_wind_field_sample_cascades.js

@@ -1,6 +1,7 @@
 import { chunk_clipmap_select_finest } from "../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { WIND_FIELD_BAND_WIDTH, WIND_FIELD_CASCADE_LIMIT } from "./WIND_FIELD.js";
+import { chunk_fluid_turbulence } from "./chunk_fluid_turbulence.js";
 import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
 
 /**
@@ -8,21 +9,24 @@ import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
  * `chunk_wind_field_sample` links for a field as it is ({@link WIND_FIELD_UNIFORM} `false`), any
  * number of cascades, none included.
  *
- * Reads `wind_field` ({@link WIND_FIELD_STRUCT}), `wind_field_atlas` and `wind_field_sampler`, as
- * {@link wind_field_add_resources} declares them. `wind_field_sample_in(field, position_ws)` is the
+ * Reads `wind_field` ({@link WIND_FIELD_STRUCT}), `wind_field_atlas`, `wind_field_sampler` and the
+ * turbulence tile, as {@link wind_field_add_resources} declares them. `wind_field_sample_in(field, position_ws)` is the
  * same read through any table over that atlas, the previous frame's for one.
  *
  * **The read:**
  * - the cascades' windows are walked finest first, each by `clipmap_level_select`, and the first holding
  *   the point answers, with how far into its edge band of {@link WIND_FIELD_BAND_WIDTH} cells the point is;
- * - a cascade's read is the atmosphere identity, `v_far(t) + tap · k_c`: one trilinear tap of its tile,
- *   which holds `v − v_far(t_s,c)` at cell centres, times its decay;
+ * - the far field at the point, `v_far(t, p)`: its mean, plus its turbulence's one tap when it has any
+ *   (`wind_field_far`), band-limited inside a cascade to the cascade's cell, as the cascade's own far
+ *   field is, and whole beyond every cascade;
+ * - a cascade's read is the atmosphere identity, `v_far(t, p) + tap · k_c`: one trilinear tap of its
+ *   tile, which holds `v − v_far(t_s,c)` at cell centres, times its decay;
  * - in the band, a second read blends in linearly, all of it on the window's face: the parent's
- *   identity read, or `v_far(t)` for the coarsest; deeper than the band, one read;
- * - outside every cascade, `v_far(t)`.
+ *   identity read, or `v_far(t, p)` for the coarsest; deeper than the band, one read;
+ * - outside every cascade, `v_far(t, p)`.
  *
  * The blend and the decay are taken now, at the sample, so a cascade that last stepped ticks ago reads
- * the far field's current gust and drag. Air at the far field publishes a deviation of 0 and reads
+ * the far field's current mean, turbulence and drag. Air at the far field publishes a deviation of 0 and reads
  * back `v_far(t)` exactly, on every cascade, in every band, at every instant: the blend is written as
  * `inner + (outer − inner)·w`, which leaves equal reads as they are.
  *
@@ -46,10 +50,26 @@ export const chunk_wind_field_sample_cascades = CodeChunk.from(
     `
 const WIND_FIELD_BAND_WIDTH: f32 = ${WIND_FIELD_BAND_WIDTH}.0;
 
-// cascade c's identity read at a world point its window holds
+// the far field at a world point, band-limited to what a lattice of that cell holds: its mean, and its
+// turbulence there when it has any; a cell of 0 reads the tile whole
+fn wind_field_far(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, position_ws: vec3<f32>, cell: f32) -> vec3<f32> {
+    let sigma = (*field).turbulence_sigma;
+
+    if (sigma == 0.0) {
+        return (*field).far_velocity;
+    }
+
+    let lod = fluid_turbulence_lod(cell, (*field).turbulence_inverse_texel);
+
+    return (*field).far_velocity + sigma * fluid_turbulence_at(position_ws * (*field).turbulence_scale + (*field).turbulence_origin, lod);
+}
+
+// cascade c's identity read at a world point its window holds: its far field at its own level, which is
+// what its tile is a deviation from
 fn wind_field_cascade_read(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, c: u32, position_ws: vec3<f32>) -> vec3<f32> {
     let level = (*field).levels[c];
     let cascade = (*field).cascades[c];
+    let far = wind_field_far(field, position_ws, level.cell_size);
 
     // window-local position in the cascade's cells, which is a texel offset from the tile's content
     let local = position_ws / level.cell_size - vec3<f32>(level.corner);
@@ -57,7 +77,7 @@ fn wind_field_cascade_read(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, c
 
     let deviation = textureSampleLevel(wind_field_atlas, wind_field_sampler, uvw, 0.0).xyz;
 
-    return (*field).far_velocity + deviation * cascade.decay;
+    return far + deviation * cascade.decay;
 }
 
 fn wind_field_sample_in(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, position_ws: vec3<f32>) -> vec3<f32> {
@@ -75,7 +95,7 @@ fn wind_field_sample_in(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, posi
     }
 
     if (selection.level == CLIPMAP_LEVEL_NONE) {
-        return (*field).far_velocity;
+        return wind_field_far(field, position_ws, 0.0);
     }
 
     let inner = wind_field_cascade_read(field, selection.level, position_ws);
@@ -86,10 +106,12 @@ fn wind_field_sample_in(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, posi
 
     let parent = selection.level + 1u;
 
-    var outer = (*field).far_velocity;
+    var outer: vec3<f32>;
 
     if (parent < count) {
         outer = wind_field_cascade_read(field, parent, position_ws);
+    } else {
+        outer = wind_field_far(field, position_ws, 0.0);
     }
 
     // mix's form, written so that equal reads blend to themselves exactly
@@ -102,5 +124,6 @@ fn wind_field_sample(position_ws: vec3<f32>) -> vec3<f32> {
 `, [
         WIND_FIELD_STRUCT.declaration_chunk,
         chunk_clipmap_select_finest,
+        chunk_fluid_turbulence,
     ]
 );

package/src/shade/renderer/wind/chunk_wind_field_sample_uniform.d.ts

@@ -1,7 +1,7 @@
 /**
  * `wind_field_sample(position_ws)` in a uniform field ({@link WIND_FIELD_UNIFORM} `true`): one with no
- * cascades, where the wind is `v_far(t)` at every point, which is what the cascaded read returns there,
- * exactly, having found no window that holds the point.
+ * cascades and no turbulence, where the wind is `v_far(t)` at every point, which is what the cascaded
+ * read returns there, exactly, having found no window that holds the point.
  *
  * Reads `wind_field.far_velocity` and nothing else; the atlas and its sampler stay bound and unread.
  * `wind_field_sample_in(field, position_ws)` is the same read of any table with no cascades.

package/src/shade/renderer/wind/chunk_wind_field_sample_uniform.js

@@ -3,8 +3,8 @@ import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
 
 /**
  * `wind_field_sample(position_ws)` in a uniform field ({@link WIND_FIELD_UNIFORM} `true`): one with no
- * cascades, where the wind is `v_far(t)` at every point, which is what the cascaded read returns there,
- * exactly, having found no window that holds the point.
+ * cascades and no turbulence, where the wind is `v_far(t)` at every point, which is what the cascaded
+ * read returns there, exactly, having found no window that holds the point.
  *
  * Reads `wind_field.far_velocity` and nothing else; the atlas and its sampler stay bound and unread.
  * `wind_field_sample_in(field, position_ws)` is the same read of any table with no cascades.

package/src/shade/renderer/wind/wind_field_add_resources.d.ts

@@ -3,10 +3,12 @@
  * `chunk_wind_field_sample` reads:
  * - `wind_field`: the uniform {@link WIND_FIELD_STRUCT};
  * - `wind_field_atlas`: the tiles, `texture_3d<f32>`, filterable;
- * - `wind_field_sampler`: linear and clamped, by default the field's own, so a host binds only the
- *   other two (`GPUSceneWind.bind`).
+ * - `wind_field_sampler`: linear and clamped, by default the field's own;
+ * - `fluid_turbulence`, `fluid_turbulence_sampler`: the far field's turbulence tile and its repeating
+ *   sampler (`fluid_turbulence_add_resources`), the sampler by default.
  *
- * One uniform, one texture, one sampler, and no storage buffer.
+ * A host binds the uniform and the two textures (`GPUSceneWind.bind`). One uniform, two textures, two
+ * samplers, and no storage buffer.
  *
  * @param {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
  * @returns {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
@@ -17,7 +19,7 @@ export function wind_field_add_resources(group: import("../shader/resource/Shade
  * samples both (`chunk_wind_field_sample_previous`): `wind_field_previous`, a second uniform
  * {@link WIND_FIELD_STRUCT} over the same atlas. `GPUSceneWind.bind_history` fills them.
  *
- * Two uniforms, one texture, one sampler, and no storage buffer.
+ * Two uniforms, two textures, two samplers, and no storage buffer.
  *
  * @param {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
  * @returns {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group

package/src/shade/renderer/wind/wind_field_add_resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wind_field_add_resources.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/wind_field_add_resources.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,gDAHW,OAAO,qDAAqD,EAAE,6BAA6B,GACzF,OAAO,qDAAqD,EAAE,6BAA6B,CAOvG;AAED;;;;;;;;;GASG;AACH,wDAHW,OAAO,qDAAqD,EAAE,6BAA6B,GACzF,OAAO,qDAAqD,EAAE,6BAA6B,CAKvG"}
+{"version":3,"file":"wind_field_add_resources.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/wind_field_add_resources.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,gDAHW,OAAO,qDAAqD,EAAE,6BAA6B,GACzF,OAAO,qDAAqD,EAAE,6BAA6B,CAOvG;AAED;;;;;;;;;GASG;AACH,wDAHW,OAAO,qDAAqD,EAAE,6BAA6B,GACzF,OAAO,qDAAqD,EAAE,6BAA6B,CAKvG"}

package/src/shade/renderer/wind/wind_field_add_resources.js

@@ -1,3 +1,4 @@
+import { fluid_turbulence_add_resources } from "./chunk_fluid_turbulence.js";
 import { WIND_FIELD_SAMPLER_DESCRIPTOR } from "./WIND_FIELD.js";
 import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
 
@@ -6,19 +7,21 @@ import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
  * `chunk_wind_field_sample` reads:
  * - `wind_field`: the uniform {@link WIND_FIELD_STRUCT};
  * - `wind_field_atlas`: the tiles, `texture_3d<f32>`, filterable;
- * - `wind_field_sampler`: linear and clamped, by default the field's own, so a host binds only the
- *   other two (`GPUSceneWind.bind`).
+ * - `wind_field_sampler`: linear and clamped, by default the field's own;
+ * - `fluid_turbulence`, `fluid_turbulence_sampler`: the far field's turbulence tile and its repeating
+ *   sampler (`fluid_turbulence_add_resources`), the sampler by default.
  *
- * One uniform, one texture, one sampler, and no storage buffer.
+ * A host binds the uniform and the two textures (`GPUSceneWind.bind`). One uniform, two textures, two
+ * samplers, and no storage buffer.
  *
  * @param {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
  * @returns {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
  */
 export function wind_field_add_resources(group) {
-    return group
+    return fluid_turbulence_add_resources(group
         .addUniform("wind_field", WIND_FIELD_STRUCT)
         .addTexture("wind_field_atlas", "float", "3d")
-        .addSampler("wind_field_sampler", "filtering", WIND_FIELD_SAMPLER_DESCRIPTOR);
+        .addSampler("wind_field_sampler", "filtering", WIND_FIELD_SAMPLER_DESCRIPTOR));
 }
 
 /**
@@ -26,7 +29,7 @@ export function wind_field_add_resources(group) {
  * samples both (`chunk_wind_field_sample_previous`): `wind_field_previous`, a second uniform
  * {@link WIND_FIELD_STRUCT} over the same atlas. `GPUSceneWind.bind_history` fills them.
  *
- * Two uniforms, one texture, one sampler, and no storage buffer.
+ * Two uniforms, two textures, two samplers, and no storage buffer.
  *
  * @param {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
  * @returns {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group

package/src/shade/renderer/geometry/bvh/BLAS_REFIT_TARGET_STRUCT.d.ts

@@ -1,18 +0,0 @@
-/**
- * One tree in a batched refit: where it lives, and where its arrival counters live.
- *
- * The first five fields are what {@link GPUGeometryBVHManager#get_refit_target} answers, copied
- * out at the frame the batch's tables are built. The other two are the batch's own: a tree's
- * counters sit at `counters_offset` in one buffer that holds the counters of every tree in the
- * batch — a prefix sum of node counts — and `geometry_index` is the row whose meshlets the leaf
- * payloads index, which for a skinned clone is the clone's own row, the one skinning deformed.
- *
- * Read by {@link shader_blas_refit_batch} and {@link shader_blas_refit_batch_seed} once per
- * workgroup, through their workgroup lookups;
- * written by {@link GPUBLASRefitBatch} when the set of trees or their residency changes.
- *
- * @type {WebGPUStruct}
- */
-export const BLAS_REFIT_TARGET_STRUCT: WebGPUStruct;
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-//# sourceMappingURL=BLAS_REFIT_TARGET_STRUCT.d.ts.map

package/src/shade/renderer/geometry/bvh/BLAS_REFIT_TARGET_STRUCT.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BLAS_REFIT_TARGET_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/BLAS_REFIT_TARGET_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,uCAFU,YAAY,CAiCA;6BAhDO,mCAAmC"}

package/src/shade/renderer/geometry/bvh/BLAS_REFIT_TARGET_STRUCT.js

@@ -1,50 +0,0 @@
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-
-/**
- * One tree in a batched refit: where it lives, and where its arrival counters live.
- *
- * The first five fields are what {@link GPUGeometryBVHManager#get_refit_target} answers, copied
- * out at the frame the batch's tables are built. The other two are the batch's own: a tree's
- * counters sit at `counters_offset` in one buffer that holds the counters of every tree in the
- * batch — a prefix sum of node counts — and `geometry_index` is the row whose meshlets the leaf
- * payloads index, which for a skinned clone is the clone's own row, the one skinning deformed.
- *
- * Read by {@link shader_blas_refit_batch} and {@link shader_blas_refit_batch_seed} once per
- * workgroup, through their workgroup lookups;
- * written by {@link GPUBLASRefitBatch} when the set of trees or their residency changes.
- *
- * @type {WebGPUStruct}
- */
-export const BLAS_REFIT_TARGET_STRUCT = WebGPUStruct.from({
-    /**
-     * u32 word this tree's node 0 starts at in the node arena.
-     */
-    node_word_offset: u32,
-    /**
-     * Where this tree's parents start in the parents arena.
-     */
-    parents_offset: u32,
-    /**
-     * Where this tree's leaf list starts in the leaf-node arena.
-     */
-    leaf_nodes_offset: u32,
-    /**
-     * Leaves in this tree — one triangle each, so also its triangle count.
-     */
-    leaf_count: u32,
-    /**
-     * Node slots the tree spans from `node_word_offset`, holes included — what the seeding pass
-     * covers before every refit.
-     */
-    node_count: u32,
-    /**
-     * Where this tree's arrival counters start in the batch's counters buffer, one word per node
-     * slot of the tree.
-     */
-    counters_offset: u32,
-    /**
-     * Row in the geometry table whose meshlets the leaf payloads index into.
-     */
-    geometry_index: u32,
-}, "BlasRefitTarget");

package/src/shade/renderer/geometry/bvh/bvh2_derive_topology.d.ts

@@ -1,23 +0,0 @@
-/**
- * The two things a refit needs to know about a tree it did not build: who each node's parent is, and
- * which nodes are the leaves.
- *
- * Read straight off the compressed node bytes — the same bytes that go to the GPU — rather than off
- * the `BVH` object they came from. That is deliberate: the arena holds `node_capacity` slots and a
- * `BVH` allocates from a free list, so the buffer contains holes that were never part of any tree
- * and whose child words are whatever the last occupant left. Walking from the root visits exactly
- * the tree, so a hole is never mistaken for a leaf and never gets a parent.
- *
- * Topology, not geometry. Every per-instance copy of a geometry has the same answer, so this is
- * derived once per source and shared — only bounds are per-instance.
- *
- * @param {ArrayBuffer} nodes compressed BVH2 nodes, 32 bytes each, root at node 0
- * @returns {{parents: Uint32Array, leaf_nodes: Uint32Array}} `parents` is indexed by node and holds
- * `BVH_NULL_NODE` for the root and for every slot the tree does not reach; `leaf_nodes` lists the
- * leaves in pre-order, which is the ordinal the refit dispatches one thread per.
- */
-export function bvh2_derive_topology(nodes: ArrayBuffer): {
-    parents: Uint32Array;
-    leaf_nodes: Uint32Array;
-};
-//# sourceMappingURL=bvh2_derive_topology.d.ts.map

package/src/shade/renderer/geometry/bvh/bvh2_derive_topology.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bvh2_derive_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/bvh2_derive_topology.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH,4CALW,WAAW,GACT;IAAC,OAAO,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,WAAW,CAAA;CAAC,CA4D3D"}

package/src/shade/renderer/geometry/bvh/bvh2_derive_topology.js

@@ -1,87 +0,0 @@
-import { assert } from "../../../../core/assert.js";
-import {
-    BVH_NODE_CHILD_1_WORD,
-    BVH_NODE_CHILD_2_WORD,
-    BVH_NODE_STRIDE_WORDS
-} from "../../gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js";
-
-/**
- * @type {number}
- */
-const BVH_NULL_NODE = 0xffffffff;
-
-/**
- * The two things a refit needs to know about a tree it did not build: who each node's parent is, and
- * which nodes are the leaves.
- *
- * Read straight off the compressed node bytes — the same bytes that go to the GPU — rather than off
- * the `BVH` object they came from. That is deliberate: the arena holds `node_capacity` slots and a
- * `BVH` allocates from a free list, so the buffer contains holes that were never part of any tree
- * and whose child words are whatever the last occupant left. Walking from the root visits exactly
- * the tree, so a hole is never mistaken for a leaf and never gets a parent.
- *
- * Topology, not geometry. Every per-instance copy of a geometry has the same answer, so this is
- * derived once per source and shared — only bounds are per-instance.
- *
- * @param {ArrayBuffer} nodes compressed BVH2 nodes, 32 bytes each, root at node 0
- * @returns {{parents: Uint32Array, leaf_nodes: Uint32Array}} `parents` is indexed by node and holds
- * `BVH_NULL_NODE` for the root and for every slot the tree does not reach; `leaf_nodes` lists the
- * leaves in pre-order, which is the ordinal the refit dispatches one thread per.
- */
-export function bvh2_derive_topology(nodes) {
-    assert.defined(nodes, 'nodes');
-
-    const words = new Uint32Array(nodes);
-
-    const node_count = Math.floor(words.length / BVH_NODE_STRIDE_WORDS);
-
-    assert.greaterThan(node_count, 0, 'node_count');
-
-    const parents = new Uint32Array(node_count).fill(BVH_NULL_NODE);
-
-    const leaf_nodes = [];
-
-    const stack = [0];
-
-    let visited = 0;
-
-    while (stack.length > 0) {
-        const node = stack.pop();
-
-        visited += 1;
-
-        assert.lessThanOrEqual(visited, node_count, 'walk visited more nodes than the buffer holds — the tree is not a tree');
-
-        const base = node * BVH_NODE_STRIDE_WORDS;
-
-        const child_1 = words[base + BVH_NODE_CHILD_1_WORD];
-
-        if (child_1 === BVH_NULL_NODE) {
-            leaf_nodes.push(node);
-
-            continue;
-        }
-
-        const child_2 = words[base + BVH_NODE_CHILD_2_WORD];
-
-        assert.greaterThan(child_1, 0, 'child_1 must be a non-root node');
-        assert.greaterThan(child_2, 0, 'child_2 must be a non-root node');
-        assert.lessThan(child_1, node_count, 'child_1 out of range');
-        assert.lessThan(child_2, node_count, 'child_2 out of range');
-        assert.notEqual(child_1, child_2, 'internal node children must be distinct');
-        assert.equal(parents[child_1], BVH_NULL_NODE, 'child_1 already has a parent');
-        assert.equal(parents[child_2], BVH_NULL_NODE, 'child_2 already has a parent');
-
-        parents[child_1] = node;
-        parents[child_2] = node;
-
-        // child_1 first out, so the leaf order is a pre-order walk rather than an artefact of
-        // which way the stack happens to run
-        stack.push(child_2, child_1);
-    }
-
-    return {
-        parents,
-        leaf_nodes: Uint32Array.from(leaf_nodes),
-    };
-}

package/src/shade/renderer/geometry/bvh/shader_blas_refit_batch.d.ts

@@ -1,42 +0,0 @@
-/**
- * Leaves per workgroup. A workgroup serves one tree and one aligned run of this many of its leaves,
- * which is what the lookup's `leaf_base` counts in.
- *
- * @type {number}
- */
-export const BLAS_REFIT_BATCH_WORKGROUP_SIZE: number;
-/**
- * Refit every tree in a batch, from one dispatch.
- *
- * One lane per leaf, across every tree the batch lists: the lane finds its tree and its leaf through
- * the workgroup lookup, rewrites that leaf's box from the triangle it names as the vertex buffer
- * holds it *now*, and climbs — {@link chunk_bvh_refit_climb}, the same arrival-counter climb the
- * LBVH build ends with, at this tree's positions in the shared arenas. Topology is untouched:
- * nothing is sorted, nothing is emitted, no node's children change.
- *
- * Batched rather than per tree because a refit's cost is not the refit. A tree's climb is a chain
- * of dependent atomics as long as the tree is deep, with half the live lanes exiting at every
- * level; on its own it is a long tail of a nearly idle GPU, and a dispatch per tree serialises
- * `N` such tails behind `2N` pass boundaries. In one dispatch a small tree's climb overlaps the
- * next tree's, and the command count is the same for one skinned mesh as for three hundred.
- *
- * Fused rather than two passes: the leaf box is stored through the same atomic words the climb
- * reads, before the lane's first arrival, so the second arrival at its parent reads it exactly as
- * it reads an internal node's — including when it has not arrived yet. Arriving second does not
- * order the sibling's stores (R1 in GPU_BVH_BUILD_PLAN.md), so every bound word is seeded with
- * {@link BVH_UNFITTED} a dispatch earlier ({@link shader_blas_refit_batch_seed}), the climb defers
- * the nodes it cannot see whole to the list in `refit_deferred`, and
- * {@link shader_bvh_refit_repair} grows them a dispatch later — the build's own repair, over every
- * tree in the batch at once.
- *
- * For a skinned mesh this runs against the per-instance clone, after the skinning pass has deformed
- * its vertex region; `geometry_index` on the row is the clone's, and reading the source instead
- * would produce the rest pose.
- *
- * Recorded by {@link GPUBLASRefitBatch}, which builds the tables and paginates the dispatch.
- *
- * @type {ComputeShader}
- */
-export const shader_blas_refit_batch: ComputeShader;
-import { ComputeShader } from "../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_blas_refit_batch.d.ts.map

package/src/shade/renderer/geometry/bvh/shader_blas_refit_batch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_blas_refit_batch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/shader_blas_refit_batch.js"],"names":[],"mappings":"AAeA;;;;;GAKG;AACH,8CAFU,MAAM,CAEkC;AAmFlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,sCAFU,aAAa,CAMpB;8BAzI2B,+BAA+B"}

package/src/shade/renderer/geometry/bvh/shader_blas_refit_batch.js

@@ -1,141 +0,0 @@
-import { atomic_u32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { BVH_NODE_LAYOUT_DEFINITION } from "../../gpu_primitive/bvh/BVH_NODE_LAYOUT_DEFINITION.js";
-import { chunk_bvh_refit_climb } from "../../gpu_primitive/bvh/chunk_bvh_refit_climb.js";
-import {
-    chunk_geometry_read_triangle_bounds
-} from "../../shader/chunk/geometry/format/chunk_geometry_read_triangle_bounds.js";
-import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
-import { GEOMETRY_METADATA_STRUCT } from "../GEOMETRY_METADATA_STRUCT.js";
-import { MESHLET_METADATA_STRUCT } from "../meshlet/encoding/MESHLET_METADATA_STRUCT.js";
-import { BLAS_REFIT_TARGET_STRUCT } from "./BLAS_REFIT_TARGET_STRUCT.js";
-
-/**
- * Leaves per workgroup. A workgroup serves one tree and one aligned run of this many of its leaves,
- * which is what the lookup's `leaf_base` counts in.
- *
- * @type {number}
- */
-export const BLAS_REFIT_BATCH_WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-
-// Workgroups already covered by earlier sub-dispatches of the same batch, for a batch larger than
-// the device's per-dimension cap. Four bytes, per dispatch: immediate data.
-resources.setImmediate("dispatch_offset", u32);
-
-resources.createGroup()
-    // one row per tree in the batch — where it lives, and where its counters live
-    .addStorageBuffer("targets", WebGPUArray.from(BLAS_REFIT_TARGET_STRUCT), false)
-    // `(target_index, leaf_base)` per workgroup, flat
-    .addStorageBuffer("lookup", WebGPUArray.from(u32), false)
-    // node index of each leaf ordinal, per tree, at the tree's `leaf_nodes_offset`
-    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), false)
-    // parent of every node, per tree, at the tree's `parents_offset`
-    .addStorageBuffer("parents", WebGPUArray.from(u32), false)
-    // one arrival counter per node slot of every tree, at each tree's `counters_offset`; zero at
-    // the start of every batch
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    // The node arena, flat and atomic. Every word this kernel writes is communicated between
-    // invocations — a leaf box to the second arrival at its parent, a node box to the next — so
-    // every access to it is an atomic one. Its bound words arrive seeded by
-    // shader_blas_refit_batch_seed.
-    .addStorageBuffer("nodes", WebGPUArray.from(atomic_u32), true)
-    // the nodes whose children had not all reached their second arrival, every tree's, for the
-    // repair; header zero at the start of every batch
-    .addStorageBuffer("refit_deferred", WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false)
-    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT), false)
-    .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE, false);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${BLAS_REFIT_BATCH_WORKGROUP_SIZE}, 1, 1)
-fn main(
-    @builtin(workgroup_id) wg: vec3<u32>,
-    @builtin(local_invocation_id) lid: vec3<u32>,
-) {
-    // Which tree, and which run of its leaves: one lookup pair per workgroup, so the row read below
-    // is uniform across the workgroup and the leaf list read is one contiguous run.
-    let pair = (wg.x + dispatch_offset) * 2u;
-
-    // ("target" is a reserved word in WGSL)
-    let tree = targets[lookup[pair]];
-
-    let leaf = lookup[pair + 1u] + lid.x;
-
-    if (leaf >= tree.leaf_count) {
-        // the tail of a tree's last run; the next workgroup is another tree's
-        return;
-    }
-
-    let leaf_node = leaf_nodes[tree.leaf_nodes_offset + leaf];
-
-    let leaf_word = tree.node_word_offset + leaf_node * BVH_NODE_STRIDE;
-
-    // The leaf already says which triangle it holds — its payload is what the ray query hands to
-    // the triangle test. Reading it back means no side table has to agree with the tree about
-    // which leaf is which.
-    let payload = atomicLoad(&nodes[leaf_word + BVH_NODE_CHILD_2]);
-
-    let box = geometry_read_triangle_bounds(geometries[tree.geometry_index], payload);
-
-    // This leaf's box, then the climb from it. The box is written before this lane's first arrival
-    // at the parent, through the same atomic words the climb reads every other box through, so the
-    // second arrival at the parent finds it exactly as it finds an internal node's.
-    bvh_node_store_bounds(leaf_word, box.min, box.max);
-
-    bvh_refit_climb(
-        tree.node_word_offset,
-        tree.parents_offset,
-        tree.counters_offset,
-        leaf_node
-    );
-}
-`, [
-    BVH_NODE_LAYOUT_DEFINITION,
-    chunk_bvh_refit_climb,
-    chunk_geometry_read_triangle_bounds,
-]);
-
-/**
- * Refit every tree in a batch, from one dispatch.
- *
- * One lane per leaf, across every tree the batch lists: the lane finds its tree and its leaf through
- * the workgroup lookup, rewrites that leaf's box from the triangle it names as the vertex buffer
- * holds it *now*, and climbs — {@link chunk_bvh_refit_climb}, the same arrival-counter climb the
- * LBVH build ends with, at this tree's positions in the shared arenas. Topology is untouched:
- * nothing is sorted, nothing is emitted, no node's children change.
- *
- * Batched rather than per tree because a refit's cost is not the refit. A tree's climb is a chain
- * of dependent atomics as long as the tree is deep, with half the live lanes exiting at every
- * level; on its own it is a long tail of a nearly idle GPU, and a dispatch per tree serialises
- * `N` such tails behind `2N` pass boundaries. In one dispatch a small tree's climb overlaps the
- * next tree's, and the command count is the same for one skinned mesh as for three hundred.
- *
- * Fused rather than two passes: the leaf box is stored through the same atomic words the climb
- * reads, before the lane's first arrival, so the second arrival at its parent reads it exactly as
- * it reads an internal node's — including when it has not arrived yet. Arriving second does not
- * order the sibling's stores (R1 in GPU_BVH_BUILD_PLAN.md), so every bound word is seeded with
- * {@link BVH_UNFITTED} a dispatch earlier ({@link shader_blas_refit_batch_seed}), the climb defers
- * the nodes it cannot see whole to the list in `refit_deferred`, and
- * {@link shader_bvh_refit_repair} grows them a dispatch later — the build's own repair, over every
- * tree in the batch at once.
- *
- * For a skinned mesh this runs against the per-instance clone, after the skinning pass has deformed
- * its vertex region; `geometry_index` on the row is the clone's, and reading the source instead
- * would produce the rest pose.
- *
- * Recorded by {@link GPUBLASRefitBatch}, which builds the tables and paginates the dispatch.
- *
- * @type {ComputeShader}
- */
-export const shader_blas_refit_batch = ComputeShader.from({
-    label: "BLAS/RefitBatch",
-    resources,
-    body,
-});

package/src/shade/renderer/geometry/bvh/shader_blas_refit_batch_seed.d.ts

@@ -1,21 +0,0 @@
-/**
- * Seed every bound word of every tree in a batch with {@link BVH_UNFITTED}, a dispatch ahead of
- * {@link shader_blas_refit_batch}.
- *
- * The batch refit hands boxes between invocations through relaxed atomics — leaf boxes included,
- * since it writes them in the same dispatch — and a store need not reach the reader before the
- * dispatch ends. What this leaves behind is what such a read returns, so the climb can see a box
- * that has not arrived instead of taking last frame's for it. For a skinned mesh last frame's box
- * is close to this frame's, so taking it would go unnoticed.
- *
- * One lane per node slot, holes included: the arena's trees keep the slots their builder allocated,
- * and seeding a hole costs six stores where telling it apart would cost a walk. The bounds words are
- * all it touches; children and payloads are the tree's topology and stay as they are.
- *
- * Recorded by {@link GPUBLASRefitBatch}, paginated as the refit is.
- *
- * @type {ComputeShader}
- */
-export const shader_blas_refit_batch_seed: ComputeShader;
-import { ComputeShader } from "../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_blas_refit_batch_seed.d.ts.map

package/src/shade/renderer/geometry/bvh/shader_blas_refit_batch_seed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_blas_refit_batch_seed.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/shader_blas_refit_batch_seed.js"],"names":[],"mappings":"AAoDA;;;;;;;;;;;;;;;;;GAiBG;AACH,2CAFU,aAAa,CAMpB;8BAvE2B,+BAA+B"}