@woosh/meep-engine 3.12.0 → 3.13.1

package/src/shade/renderer/buffer/util/shader_buffer_copy_storage_to_storage.js

@@ -7,10 +7,12 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 
 const resources = new ShaderResourceSetDescriptor();
 
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer holding one u32
+resources.setImmediate("size", u32);
+
 resources.createGroup()
     .addStorageBuffer("source", WebGPUArray.u32)
     .addStorageBuffer("destination", WebGPUArray.u32, true)
-    .addUniform("size", u32)
 
 const body = CodeChunk.from(
     //language=WGSL

package/src/shade/renderer/deferred/shader_tonemap_HDR.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_tonemap_HDR.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_tonemap_HDR.js"],"names":[],"mappings":"AA2DA,6CAYG;4BA/DyB,0BAA0B"}
+{"version":3,"file":"shader_tonemap_HDR.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_tonemap_HDR.js"],"names":[],"mappings":"AA8DA,6CAYG;4BAlEyB,0BAA0B"}

package/src/shade/renderer/deferred/shader_tonemap_HDR.js

@@ -16,9 +16,12 @@ const SETTINGS_STRUCT = WebGPUStruct.from({
 });
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, eight bytes, read-only: immediate data rather than a uniform buffer. exposure stays
+// bound - it is computed on the GPU, so there is no CPU value to write.
+resources.setImmediate("settings", SETTINGS_STRUCT);
 resources.createGroup()
     .addTexture("input_color", "float")
-    .addUniform("settings", SETTINGS_STRUCT)
     .addUniform("exposure", F32_CONTAINER_STRUCT)
 
 const body = CodeChunk.from(

package/src/shade/renderer/dynamic/GPUDynamicMeshResidency.d.ts

@@ -42,12 +42,12 @@ export class GPUDynamicMeshResidency {
      */
     create_bindings(encoder: ShadeGPUCommandContext, mesh: DynamicMesh, camera: GPUBuffer): any[];
     /**
-     * @param {GPURenderPassEncoder} render_pass
+     * @param {ShadeGPURenderPassEncoder} render_pass
      * @param {GraphicsContext} graphics
      * @param {RenderPipelineDescriptor} pipeline
      * @param {Array} bindings from {@link create_bindings}
      */
-    draw(render_pass: GPURenderPassEncoder, graphics: GraphicsContext, pipeline: RenderPipelineDescriptor, bindings: any[]): void;
+    draw(render_pass: ShadeGPURenderPassEncoder, graphics: GraphicsContext, pipeline: RenderPipelineDescriptor, bindings: any[]): void;
     destroy(): void;
     #private;
 }

package/src/shade/renderer/dynamic/GPUDynamicMeshResidency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDynamicMeshResidency.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/GPUDynamicMeshResidency.js"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH;IAuBI;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,kCAJW,YAAY,sBACZ,MAAM,WACN,WAAW,QAoCrB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8FAYC;IAED;;;;;OAKG;IACH,8HAIC;IAED,gBAcC;;CACJ"}
+{"version":3,"file":"GPUDynamicMeshResidency.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/GPUDynamicMeshResidency.js"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH;IAuBI;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,kCAJW,YAAY,sBACZ,MAAM,WACN,WAAW,QAoCrB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8FAYC;IAED;;;;;OAKG;IACH,mIAIC;IAED,gBAcC;;CACJ"}

package/src/shade/renderer/dynamic/GPUDynamicMeshResidency.js

@@ -1,167 +1,167 @@
-import { round_up } from "../../../core/math/round_up.js";
-import { DYNAMIC_MESH_DRAW_STRUCT, DYNAMIC_MESH_RESOURCES } from "./shader_dynamic_mesh.js";
-
-/**
- * Growth factor for the vertex and index buffers.
- *
- * Dynamic geometry changes size constantly — a trail lengthens as it is emitted and shortens as it
- * expires — so buffers are grown with headroom and never shrunk. Sizing exactly would mean
- * reallocating on almost every frame for content whose whole purpose is to change.
- *
- * @type {number}
- */
-const GROWTH_FACTOR = 1.5;
-
-/**
- * Storage buffers are bound by size, and a binding's size has to be a multiple of 4 — so a grown
- * capacity is rounded up rather than taken as the growth factor leaves it. Without this, a buffer
- * whose contents happen to land on the wrong number of bytes is rejected at bind time: 36 bytes of
- * indices grown by 1.5 gives 54, which is not a legal binding size.
- *
- * @type {number}
- */
-const BUFFER_SIZE_ALIGNMENT = 4;
-
-/**
- * What one {@link Geometry} owns on the GPU while it is being drawn by the dynamic path.
- *
- * Keyed on the geometry rather than on the mesh or on batch membership, so an effect that is hidden
- * for a frame, or removed and re-added, does not pay for its buffers again.
- */
-export class GPUDynamicMeshResidency {
-    /**
-     * Interleaved vertices, laid out per {@link DYNAMIC_MESH_VERTEX_STRIDE}.
-     *
-     * @type {GPUBuffer|null}
-     */
-    #vertices = null;
-
-    /**
-     * @type {number} capacity in bytes
-     */
-    #vertices_capacity = 0;
-
-    /**
-     * @type {GPUBuffer|null}
-     */
-    #indices = null;
-
-    /**
-     * @type {number} capacity in bytes
-     */
-    #indices_capacity = 0;
-
-    /**
-     * How many indices to draw — the count from the last upload, not the buffer's capacity.
-     *
-     * @type {number}
-     */
-    index_count = 0;
-
-    /**
-     * The {@link Geometry.version} this was uploaded from.
-     *
-     * @type {number}
-     */
-    version = -1;
-
-    /**
-     * @param {GPUDevice} device
-     * @param {Float32Array} staging interleaved vertices, valid up to `vertex_float_count`
-     * @param {number} vertex_float_count
-     * @param {Uint32Array} indices
-     */
-    write(device, staging, vertex_float_count, indices) {
-        const vertex_bytes = vertex_float_count * 4;
-        const index_bytes = indices.length * 4;
-
-        if (this.#vertices_capacity < vertex_bytes) {
-            if (this.#vertices !== null) {
-                this.#vertices.destroy();
-            }
-
-            this.#vertices_capacity = round_up(Math.ceil(vertex_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
-            this.#vertices = device.createBuffer({
-                size: this.#vertices_capacity,
-                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-                label: "DynamicMesh/vertices",
-            });
-        }
-
-        if (this.#indices_capacity < index_bytes) {
-            if (this.#indices !== null) {
-                this.#indices.destroy();
-            }
-
-            this.#indices_capacity = round_up(Math.ceil(index_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
-            this.#indices = device.createBuffer({
-                size: this.#indices_capacity,
-                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-                label: "DynamicMesh/indices",
-            });
-        }
-
-        device.queue.writeBuffer(this.#vertices, 0, staging.buffer, staging.byteOffset, vertex_bytes);
-        device.queue.writeBuffer(this.#indices, 0, indices.buffer, indices.byteOffset, index_bytes);
-
-        this.index_count = indices.length;
-    }
-
-    /**
-     * Build this mesh's bind groups for the frame.
-     *
-     * **Must be called before the render pass is opened.** The per-draw constants are staged through
-     * a transient buffer, and staging records a copy onto the command encoder — which WebGPU locks
-     * for as long as a pass is open on it. Doing this lazily at draw time is the obvious shape and
-     * an invalid one.
-     *
-     * The constants are transient because one mesh is one draw and its transform and colour are
-     * expected to differ every frame, so there is nothing worth keeping between them.
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {DynamicMesh} mesh
-     * @param {GPUBuffer} camera
-     * @returns {Array} bind groups, for {@link draw}
-     */
-    create_bindings(encoder, mesh, camera) {
-        const draw_buffer = encoder.allocateTransientValueBuffer(DYNAMIC_MESH_DRAW_STRUCT, {
-            model: mesh.transform_global,
-            color: mesh.color,
-        });
-
-        return DYNAMIC_MESH_RESOURCES.generateBindings({
-            camera,
-            draw: draw_buffer,
-            vertices: this.#vertices,
-            indices: this.#indices,
-        }, encoder);
-    }
-
-    /**
-     * @param {GPURenderPassEncoder} render_pass
-     * @param {GraphicsContext} graphics
-     * @param {RenderPipelineDescriptor} pipeline
-     * @param {Array} bindings from {@link create_bindings}
-     */
-    draw(render_pass, graphics, pipeline, bindings) {
-        graphics.setPipelineBindings(render_pass, pipeline, bindings);
-
-        render_pass.draw(this.index_count);
-    }
-
-    destroy() {
-        if (this.#vertices !== null) {
-            this.#vertices.destroy();
-            this.#vertices = null;
-        }
-
-        if (this.#indices !== null) {
-            this.#indices.destroy();
-            this.#indices = null;
-        }
-
-        this.#vertices_capacity = 0;
-        this.#indices_capacity = 0;
-        this.index_count = 0;
-    }
-}
+import { round_up } from "../../../core/math/round_up.js";
+import { DYNAMIC_MESH_DRAW_STRUCT, DYNAMIC_MESH_RESOURCES } from "./shader_dynamic_mesh.js";
+
+/**
+ * Growth factor for the vertex and index buffers.
+ *
+ * Dynamic geometry changes size constantly — a trail lengthens as it is emitted and shortens as it
+ * expires — so buffers are grown with headroom and never shrunk. Sizing exactly would mean
+ * reallocating on almost every frame for content whose whole purpose is to change.
+ *
+ * @type {number}
+ */
+const GROWTH_FACTOR = 1.5;
+
+/**
+ * Storage buffers are bound by size, and a binding's size has to be a multiple of 4 — so a grown
+ * capacity is rounded up rather than taken as the growth factor leaves it. Without this, a buffer
+ * whose contents happen to land on the wrong number of bytes is rejected at bind time: 36 bytes of
+ * indices grown by 1.5 gives 54, which is not a legal binding size.
+ *
+ * @type {number}
+ */
+const BUFFER_SIZE_ALIGNMENT = 4;
+
+/**
+ * What one {@link Geometry} owns on the GPU while it is being drawn by the dynamic path.
+ *
+ * Keyed on the geometry rather than on the mesh or on batch membership, so an effect that is hidden
+ * for a frame, or removed and re-added, does not pay for its buffers again.
+ */
+export class GPUDynamicMeshResidency {
+    /**
+     * Interleaved vertices, laid out per {@link DYNAMIC_MESH_VERTEX_STRIDE}.
+     *
+     * @type {GPUBuffer|null}
+     */
+    #vertices = null;
+
+    /**
+     * @type {number} capacity in bytes
+     */
+    #vertices_capacity = 0;
+
+    /**
+     * @type {GPUBuffer|null}
+     */
+    #indices = null;
+
+    /**
+     * @type {number} capacity in bytes
+     */
+    #indices_capacity = 0;
+
+    /**
+     * How many indices to draw — the count from the last upload, not the buffer's capacity.
+     *
+     * @type {number}
+     */
+    index_count = 0;
+
+    /**
+     * The {@link Geometry.version} this was uploaded from.
+     *
+     * @type {number}
+     */
+    version = -1;
+
+    /**
+     * @param {GPUDevice} device
+     * @param {Float32Array} staging interleaved vertices, valid up to `vertex_float_count`
+     * @param {number} vertex_float_count
+     * @param {Uint32Array} indices
+     */
+    write(device, staging, vertex_float_count, indices) {
+        const vertex_bytes = vertex_float_count * 4;
+        const index_bytes = indices.length * 4;
+
+        if (this.#vertices_capacity < vertex_bytes) {
+            if (this.#vertices !== null) {
+                this.#vertices.destroy();
+            }
+
+            this.#vertices_capacity = round_up(Math.ceil(vertex_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
+            this.#vertices = device.createBuffer({
+                size: this.#vertices_capacity,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+                label: "DynamicMesh/vertices",
+            });
+        }
+
+        if (this.#indices_capacity < index_bytes) {
+            if (this.#indices !== null) {
+                this.#indices.destroy();
+            }
+
+            this.#indices_capacity = round_up(Math.ceil(index_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
+            this.#indices = device.createBuffer({
+                size: this.#indices_capacity,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+                label: "DynamicMesh/indices",
+            });
+        }
+
+        device.queue.writeBuffer(this.#vertices, 0, staging.buffer, staging.byteOffset, vertex_bytes);
+        device.queue.writeBuffer(this.#indices, 0, indices.buffer, indices.byteOffset, index_bytes);
+
+        this.index_count = indices.length;
+    }
+
+    /**
+     * Build this mesh's bind groups for the frame.
+     *
+     * **Must be called before the render pass is opened.** The per-draw constants are staged through
+     * a transient buffer, and staging records a copy onto the command encoder — which WebGPU locks
+     * for as long as a pass is open on it. Doing this lazily at draw time is the obvious shape and
+     * an invalid one.
+     *
+     * The constants are transient because one mesh is one draw and its transform and colour are
+     * expected to differ every frame, so there is nothing worth keeping between them.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {DynamicMesh} mesh
+     * @param {GPUBuffer} camera
+     * @returns {Array} bind groups, for {@link draw}
+     */
+    create_bindings(encoder, mesh, camera) {
+        const draw_buffer = encoder.allocateTransientValueBuffer(DYNAMIC_MESH_DRAW_STRUCT, {
+            model: mesh.transform_global,
+            color: mesh.color,
+        });
+
+        return DYNAMIC_MESH_RESOURCES.generateBindings({
+            camera,
+            draw: draw_buffer,
+            vertices: this.#vertices,
+            indices: this.#indices,
+        }, encoder);
+    }
+
+    /**
+     * @param {ShadeGPURenderPassEncoder} render_pass
+     * @param {GraphicsContext} graphics
+     * @param {RenderPipelineDescriptor} pipeline
+     * @param {Array} bindings from {@link create_bindings}
+     */
+    draw(render_pass, graphics, pipeline, bindings) {
+        graphics.setPipelineBindings(render_pass, pipeline, bindings);
+
+        render_pass.draw(this.index_count);
+    }
+
+    destroy() {
+        if (this.#vertices !== null) {
+            this.#vertices.destroy();
+            this.#vertices = null;
+        }
+
+        if (this.#indices !== null) {
+            this.#indices.destroy();
+            this.#indices = null;
+        }
+
+        this.#vertices_capacity = 0;
+        this.#indices_capacity = 0;
+        this.index_count = 0;
+    }
+}

package/src/shade/renderer/fow/GPUFogOfWarRenderer.js

@@ -2,7 +2,7 @@ import { assert } from "../../../core/assert.js";
 import { TextureDescriptor } from "../../descriptor/texture/TextureDescriptor.js";
 import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
-import { FOG_OF_WAR_STRUCT, shader_fog_of_war } from "./shader_fog_of_war.js";
+import { shader_fog_of_war } from "./shader_fog_of_war.js";
 
 /**
  * Composites fog of war over the frame.
@@ -95,12 +95,12 @@ export class GPUFogOfWarRenderer {
 
         const mask = this.#obtain_mask(graphics, field);
 
-        const fog = encoder.allocateTransientValueBuffer(FOG_OF_WAR_STRUCT, {
+        const fog = {
             uv_transform: field.uv_transform,
             color: field.color,
             resolution: [field.sampler.width, field.sampler.height],
             edge_extend: field.edge_extend
-        });
+        };
 
         shader_fog_of_war.draw({
             encoder,

package/src/shade/renderer/fow/shader_fog_of_war.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_fog_of_war.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fow/shader_fog_of_war.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,6CAqBsB;AA0KtB;;;;;;;;;;;GAWG;AACH,gCAFU,WAAW,CA0BlB;AAEH;;;;GAIG;AACH,mCAFU,2BAA2B,CAES;6BAhPjB,gCAAgC;4BAJjC,0BAA0B;4CACV,mDAAmD"}
+{"version":3,"file":"shader_fog_of_war.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fow/shader_fog_of_war.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,6CAqBsB;AA4KtB;;;;;;;;;;;GAWG;AACH,gCAFU,WAAW,CA0BlB;AAEH;;;;GAIG;AACH,mCAFU,2BAA2B,CAES;6BAlPjB,gCAAgC;4BAJjC,0BAA0B;4CACV,mDAAmD"}

package/src/shade/renderer/fow/shader_fog_of_war.js

@@ -43,9 +43,11 @@ export const FOG_OF_WAR_STRUCT = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
+// per-draw, 48 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("fog", FOG_OF_WAR_STRUCT);
+
 resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addUniform("fog", FOG_OF_WAR_STRUCT)
     // as an unfilterable float and read with `.r`, which is how every depth-reading pass in the
     // engine binds the depth buffer
     .addTexture("tDepth")

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

@@ -1,102 +1,102 @@
-import { assert } from "../../../../core/assert.js";
-import { BVH_BUILD_SETTINGS_STRUCT, BVH_NO_ROOT_WORD } from "../../gpu_primitive/bvh/BVH_BUILD_SETTINGS_STRUCT.js";
-import { shader_bvh_refit } from "../../gpu_primitive/bvh/shader_bvh_refit.js";
-import { BLAS_LEAF_BOUNDS_SETTINGS_STRUCT, shader_blas_refit_leaf_bounds } from "./shader_blas_refit_leaf_bounds.js";
-
-/**
- * Bring a BLAS's bounds back in line with vertices that have moved, leaving its shape alone.
- *
- * Two dispatches. The first rewrites every leaf's box from the triangle it names, as the vertex
- * buffer holds it now; the second carries those boxes up the tree. Nothing is sorted, nothing is
- * emitted, and no node's children change — which is the entire reason this is worth having next to
- * a full build. A skinned mesh does it every frame.
- *
- * The caller supplies the *owner* rather than a tree, and this asks the manager where that owner's
- * tree lives. Nothing here knows what a clone is, or that skinning is why the vertices moved.
- *
- * Silently does nothing when the owner has no resident tree — a geometry can reach a frame before
- * its BLAS has been uploaded, and "there is nothing to refit yet" is an ordinary state rather than
- * a failure.
- *
- * @param {ShadeGPUCommandContext} cmd
- * @param {GPUGeometryBVHManager} blas tree residency — arenas for nodes, parents and leaf lists
- * @param {GPUGeometryManager} geometries geometry metadata table the leaf pass reads vertices through
- * @param {object} owner identity the tree was registered under, per {@link GPUGeometryBVHManager#obtain}
- * @param {number} geometry_index row in the geometry table whose vertices the bounds come from —
- * for a skinned mesh, the clone that skinning deformed, not the source holding the rest pose
- * @returns {boolean} whether anything was recorded
- */
-export function record_blas_refit(cmd, { blas, geometries, owner, geometry_index }) {
-    assert.defined(cmd, 'cmd');
-    assert.defined(blas, 'blas');
-    assert.defined(geometries, 'geometries');
-    assert.defined(owner, 'owner');
-    assert.isNonNegativeInteger(geometry_index, 'geometry_index');
-
-    const target = blas.get_refit_target(owner);
-
-    if (target === undefined) {
-        return false;
-    }
-
-    const { node_word_offset, node_count, leaf_count, parents_offset, leaf_nodes_offset } = target;
-
-    if (leaf_count === 0) {
-        return false;
-    }
-
-    const meshlets = geometries.meshlets;
-
-    // ── 1. Leaf bounds: one thread per leaf, straight from the vertex buffer ──
-    shader_blas_refit_leaf_bounds.dispatchThreads({
-        encoder: cmd,
-        thread_count_x: leaf_count,
-        bindings: {
-            settings: cmd.allocateTransientValueBuffer(BLAS_LEAF_BOUNDS_SETTINGS_STRUCT, {
-                leaf_count,
-                node_word_offset,
-                leaf_nodes_offset,
-                geometry_index,
-            }),
-            leaf_nodes: blas.buffer_leaf_nodes,
-            geometries: geometries.buffer_metadata,
-            meshlet_metadata: meshlets.buffer_metadata,
-            meshlet_data: meshlets.buffer_data,
-            nodes: blas.buffer_data,
-        },
-    });
-
-    // ── 2. Climb: arrival counters carry the new boxes to the root ──
-    //
-    // One counter per node of this tree, and every one of them has to start at zero: a leftover
-    // count lets a first arrival believe it is a second and fit a node from a sibling nothing has
-    // written yet. The transient allocator pools its buffers, so whatever comes back is carrying
-    // the last frame's counts and gets cleared. Sized by node rather than by leaf because the
-    // counters are indexed by node id, and a tree read off an arena has holes in that numbering.
-    const counters_size = Math.max(1, node_count) * Uint32Array.BYTES_PER_ELEMENT;
-
-    const counters = cmd.allocateTransientBuffer(GPUBufferUsage.STORAGE, counters_size);
-
-    cmd.clearBuffer(counters, 0, counters_size);
-
-    shader_bvh_refit.dispatchThreads({
-        encoder: cmd,
-        thread_count_x: leaf_count,
-        bindings: {
-            settings: cmd.allocateTransientValueBuffer(BVH_BUILD_SETTINGS_STRUCT, {
-                element_count: leaf_count,
-                node_word_offset,
-                // a BLAS has no header — its root is node 0 by convention
-                root_word_offset: BVH_NO_ROOT_WORD,
-                parents_offset,
-                leaf_nodes_offset,
-            }),
-            parents: blas.buffer_parents,
-            leaf_nodes: blas.buffer_leaf_nodes,
-            counters,
-            nodes: blas.buffer_data,
-        },
-    });
-
-    return true;
-}
+import { assert } from "../../../../core/assert.js";
+import { BVH_NO_ROOT_WORD } from "../../gpu_primitive/bvh/BVH_BUILD_SETTINGS_STRUCT.js";
+import { shader_bvh_refit } from "../../gpu_primitive/bvh/shader_bvh_refit.js";
+import { shader_blas_refit_leaf_bounds } from "./shader_blas_refit_leaf_bounds.js";
+
+/**
+ * Bring a BLAS's bounds back in line with vertices that have moved, leaving its shape alone.
+ *
+ * Two dispatches. The first rewrites every leaf's box from the triangle it names, as the vertex
+ * buffer holds it now; the second carries those boxes up the tree. Nothing is sorted, nothing is
+ * emitted, and no node's children change — which is the entire reason this is worth having next to
+ * a full build. A skinned mesh does it every frame.
+ *
+ * The caller supplies the *owner* rather than a tree, and this asks the manager where that owner's
+ * tree lives. Nothing here knows what a clone is, or that skinning is why the vertices moved.
+ *
+ * Silently does nothing when the owner has no resident tree — a geometry can reach a frame before
+ * its BLAS has been uploaded, and "there is nothing to refit yet" is an ordinary state rather than
+ * a failure.
+ *
+ * @param {ShadeGPUCommandContext} cmd
+ * @param {GPUGeometryBVHManager} blas tree residency — arenas for nodes, parents and leaf lists
+ * @param {GPUGeometryManager} geometries geometry metadata table the leaf pass reads vertices through
+ * @param {object} owner identity the tree was registered under, per {@link GPUGeometryBVHManager#obtain}
+ * @param {number} geometry_index row in the geometry table whose vertices the bounds come from —
+ * for a skinned mesh, the clone that skinning deformed, not the source holding the rest pose
+ * @returns {boolean} whether anything was recorded
+ */
+export function record_blas_refit(cmd, { blas, geometries, owner, geometry_index }) {
+    assert.defined(cmd, 'cmd');
+    assert.defined(blas, 'blas');
+    assert.defined(geometries, 'geometries');
+    assert.defined(owner, 'owner');
+    assert.isNonNegativeInteger(geometry_index, 'geometry_index');
+
+    const target = blas.get_refit_target(owner);
+
+    if (target === undefined) {
+        return false;
+    }
+
+    const { node_word_offset, node_count, leaf_count, parents_offset, leaf_nodes_offset } = target;
+
+    if (leaf_count === 0) {
+        return false;
+    }
+
+    const meshlets = geometries.meshlets;
+
+    // ── 1. Leaf bounds: one thread per leaf, straight from the vertex buffer ──
+    shader_blas_refit_leaf_bounds.dispatchThreads({
+        encoder: cmd,
+        thread_count_x: leaf_count,
+        bindings: {
+            settings: {
+                leaf_count,
+                node_word_offset,
+                leaf_nodes_offset,
+                geometry_index,
+            },
+            leaf_nodes: blas.buffer_leaf_nodes,
+            geometries: geometries.buffer_metadata,
+            meshlet_metadata: meshlets.buffer_metadata,
+            meshlet_data: meshlets.buffer_data,
+            nodes: blas.buffer_data,
+        },
+    });
+
+    // ── 2. Climb: arrival counters carry the new boxes to the root ──
+    //
+    // One counter per node of this tree, and every one of them has to start at zero: a leftover
+    // count lets a first arrival believe it is a second and fit a node from a sibling nothing has
+    // written yet. The transient allocator pools its buffers, so whatever comes back is carrying
+    // the last frame's counts and gets cleared. Sized by node rather than by leaf because the
+    // counters are indexed by node id, and a tree read off an arena has holes in that numbering.
+    const counters_size = Math.max(1, node_count) * Uint32Array.BYTES_PER_ELEMENT;
+
+    const counters = cmd.allocateTransientBuffer(GPUBufferUsage.STORAGE, counters_size);
+
+    cmd.clearBuffer(counters, 0, counters_size);
+
+    shader_bvh_refit.dispatchThreads({
+        encoder: cmd,
+        thread_count_x: leaf_count,
+        bindings: {
+            settings: {
+                element_count: leaf_count,
+                node_word_offset,
+                // a BLAS has no header — its root is node 0 by convention
+                root_word_offset: BVH_NO_ROOT_WORD,
+                parents_offset,
+                leaf_nodes_offset,
+            },
+            parents: blas.buffer_parents,
+            leaf_nodes: blas.buffer_leaf_nodes,
+            counters,
+            nodes: blas.buffer_data,
+        },
+    });
+
+    return true;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"shader_blas_refit_leaf_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/shader_blas_refit_leaf_bounds.js"],"names":[],"mappings":"AAkBA,iDAAkD;AAElD;;;;GAIG;AACH,+CAFU,YAAY,CAqBO;AAqD7B;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAFU,aAAa,CAMpB;6BAtH0B,mCAAmC;8BAElC,+BAA+B"}
+{"version":3,"file":"shader_blas_refit_leaf_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/shader_blas_refit_leaf_bounds.js"],"names":[],"mappings":"AAkBA,iDAAkD;AAElD;;;;GAIG;AACH,+CAFU,YAAY,CAqBO;AAyD7B;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAFU,aAAa,CAMpB;6BA1H0B,mCAAmC;8BAElC,+BAA+B"}