@woosh/meep-engine 3.11.3 → 3.13.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.dispatchLinear({
-        encoder: cmd,
-        element_count: 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.dispatchLinear({
-        encoder: cmd,
-        element_count: 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,CAOpB;6BAvH0B,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"}

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

@@ -45,8 +45,12 @@ export const BLAS_LEAF_BOUNDS_SETTINGS_STRUCT = WebGPUStruct.from({
 }, "BlasLeafBoundsSettings");
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 16 bytes, read-only: immediate data rather than a uniform buffer. Runs once per
+// skinned BLAS per frame, so the buffer it used to need was allocated that often too.
+resources.setImmediate("settings", BLAS_LEAF_BOUNDS_SETTINGS_STRUCT);
+
 resources.createGroup()
-    .addUniform("settings", BLAS_LEAF_BOUNDS_SETTINGS_STRUCT)
     // node index of each leaf ordinal, as tree construction published it
     .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), false)
     .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false)
@@ -118,5 +122,4 @@ export const shader_blas_refit_leaf_bounds = ComputeShader.from({
     label: "BLAS/RefitLeafBounds",
     resources,
     body,
-    group_size: [BLAS_LEAF_BOUNDS_WORKGROUP_SIZE, 1, 1],
 });

package/src/shade/renderer/geometry/meshlet/GPUMeshletManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshletManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/GPUMeshletManager.js"],"names":[],"mappings":"AAgEA;IAoEI;;;;;OAKG;IACH,sFAiCC;IAxFD,6BAEC;IAOD,iCAEC;IA+ED,gBAKC;IAED;;;;OAIG;IACH,sBAHW,MAAM,uBACN,MAAM,QAiDhB;IA+PD;;;;;;;;;;;OAWG;IACH,qBAJW,4BAA4B,GAE1B,OAAO,CAiBnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,+BAHW,4BAA4B,GAC1B,4BAA4B,CA8BxC;IAED;;;;;;;;;;;;OAYG;IACH,8CAmHC;IAED,gBAGC;IAED;;;;OAIG;IACH,gCAFa,4BAA4B,CA6BxC;IAED,mCASC;IAED,wCAQC;IAED,+BAYC;;CACJ;AAzuBD;IACI;;OAEG;IACH,qBAAQ;IACR;;OAEG;IACH,iBAAI;IAEJ;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,0BAFU,WAAW,CAEI;IAEzB;;;OAGG;IACH,aAAsB;CACzB"}
+{"version":3,"file":"GPUMeshletManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/GPUMeshletManager.js"],"names":[],"mappings":"AA+DA;IAoEI;;;;;OAKG;IACH,sFAiCC;IAxFD,6BAEC;IAOD,iCAEC;IA+ED,gBAKC;IAED;;;;OAIG;IACH,sBAHW,MAAM,uBACN,MAAM,QAiDhB;IA+PD;;;;;;;;;;;OAWG;IACH,qBAJW,4BAA4B,GAE1B,OAAO,CAiBnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,+BAHW,4BAA4B,GAC1B,4BAA4B,CA8BxC;IAED;;;;;;;;;;;;OAYG;IACH,8CA4GC;IAED,gBAGC;IAED;;;;OAIG;IACH,gCAFa,4BAA4B,CA6BxC;IAED,mCASC;IAED,wCAQC;IAED,+BAYC;;CACJ;AAluBD;IACI;;OAEG;IACH,qBAAQ;IACR;;OAEG;IACH,iBAAI;IAEJ;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,0BAFU,WAAW,CAEI;IAEzB;;;OAGG;IACH,aAAsB;CACzB"}

package/src/shade/renderer/geometry/meshlet/GPUMeshletManager.js

@@ -6,7 +6,6 @@ import Signal from "../../../../core/events/signal/Signal.js";
 import { MEGABYTE } from "../../../../core/science/units/memory/MEGABYTE.js";
 import { read_wgsl_type_value } from "../../shader/type/serde/read_gpu_typed_buffer.js";
 import { write_wgsl_type_value } from "../../shader/type/serde/write_gpu_typed_buffer.js";
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { inspect_gpu_buffer_typed } from "../../buffer/inspect_gpu_buffer_typed.js";
 import {
     BUFFER_INTRA_COPY_REGION_STRUCT,
@@ -679,20 +678,13 @@ export class GPUMeshletManager {
             GPUBufferUsage.STORAGE,
         );
 
-        // patch_count uniform is a bare u32 — see
-        // shader_meshlet_metadata_address_patch.
-        const patch_count_buffer = cmd_ctx.allocateTransientValueBuffer(
-            u32,
-            total_records,
-        );
-
-        shader_meshlet_metadata_address_patch.dispatchLinear({
+        shader_meshlet_metadata_address_patch.dispatchThreads({
             encoder: cmd_ctx,
-            element_count: total_records,
+            thread_count_x: total_records,
             bindings: {
                 meshlet_metadata: metadata_buffer,
                 patches: patches_buffer,
-                patch_count: patch_count_buffer,
+                patch_count: total_records,
             },
         });
 

package/src/shade/renderer/geometry/meshlet/shader_meshlet_metadata_address_patch.d.ts

@@ -12,7 +12,7 @@
  * clones being flushed in this dispatch. `patch_count` is the number of
  * pairs (i.e. half the array length).
  *
- * Dispatch via `dispatchLinear({ element_count: patch_count, ... })`.
+ * Dispatch via `dispatchThreads({ thread_count_x: patch_count, ... })`.
  */
 export const shader_meshlet_metadata_address_patch: ComputeShader;
 import { ComputeShader } from "../../shader/ComputeShader.js";

package/src/shade/renderer/geometry/meshlet/shader_meshlet_metadata_address_patch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_metadata_address_patch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/shader_meshlet_metadata_address_patch.js"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;GAeG;AACH,kEAKG;8BAlE2B,+BAA+B"}
+{"version":3,"file":"shader_meshlet_metadata_address_patch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/shader_meshlet_metadata_address_patch.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;GAeG;AACH,kEAIG;8BApE2B,+BAA+B"}

package/src/shade/renderer/geometry/meshlet/shader_meshlet_metadata_address_patch.js

@@ -15,10 +15,13 @@ const WORKGROUP_SIZE = 64;
 // in aggregate) flushes through one dispatch over M_total threads, no
 // per-clone dispatch overhead.
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer holding one u32
+resources.setImmediate("patch_count", u32);
+
 resources.createGroup()
     .addStorageBuffer('meshlet_metadata', WebGPUArray.from(MESHLET_METADATA_STRUCT), true)
-    .addStorageBuffer('patches', WebGPUArray.from(u32), false)
-    .addUniform('patch_count', u32);
+    .addStorageBuffer('patches', WebGPUArray.from(u32), false);
 
 const body = CodeChunk.from(
     //language=WGSL
@@ -60,11 +63,10 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
  * clones being flushed in this dispatch. `patch_count` is the number of
  * pairs (i.e. half the array length).
  *
- * Dispatch via `dispatchLinear({ element_count: patch_count, ... })`.
+ * Dispatch via `dispatchThreads({ thread_count_x: patch_count, ... })`.
  */
 export const shader_meshlet_metadata_address_patch = ComputeShader.from({
     label: "Meshlet/MetadataAddressPatch",
     body,
     resources,
-    group_size: [WORKGROUP_SIZE, 1, 1],
 });

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometrySDFManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js"],"names":[],"mappings":"AAoBA;IAoKI;;;OAGG;IACH,+BAqBC;IAhLD;;;OAGG;IACH,iCAEC;IAQD;;;OAGG;IACH,8BAEC;IAQD,0CAEC;IAED;;;OAGG;IACH,+BAFY,MAAM,CAMjB;IAED;;;OAGG;IACH,sBAFY,MAAM,CA6BjB;IAED;;;OAGG;IACH,6BAFW,MAAM,QAoChB;IAED,uBAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QA4BhB;IA6BD,gBAEC;IAGD;;;;;OAKG;IACH,+DAHW,MAAM,EAAE,wCA4DlB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACL,MAAM,EAAE,CAgBnB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACL,QAAQ,YAAY,CAAC,CAiBhC;;CACJ;kCAjUiC,oCAAoC"}
+{"version":3,"file":"GPUGeometrySDFManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js"],"names":[],"mappings":"AAmBA;IAoKI;;;OAGG;IACH,+BAqBC;IAhLD;;;OAGG;IACH,iCAEC;IAQD;;;OAGG;IACH,8BAEC;IAQD,0CAEC;IAED;;;OAGG;IACH,+BAFY,MAAM,CAMjB;IAED;;;OAGG;IACH,sBAFY,MAAM,CA6BjB;IAED;;;OAGG;IACH,6BAFW,MAAM,QAoChB;IAED,uBAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QA4BhB;IA6BD,gBAEC;IAGD;;;;;OAKG;IACH,+DAHW,MAAM,EAAE,wCAwDlB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACL,MAAM,EAAE,CAgBnB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACL,QAAQ,YAAY,CAAC,CAiBhC;;CACJ;kCA5TiC,oCAAoC"}

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js

@@ -2,7 +2,6 @@ import { assert } from "../../../../core/assert.js";
 import { array_compute_max } from "../../../../core/collection/array/array_compute_max.js";
 import { download_texture_data } from "../../texture/download_texture_data.js";
 import { GPUTextureContext } from "../../texture/GPUTextureContext.js";
-import { SDF_BUILD_SETTINGS_STRUCT } from "./SDF_BUILD_SETTINGS_STRUCT.js";
 import { SFD_BUILD_WORKGROUP_SIZE } from "./SFD_BUILD_WORKGROUP_SIZE.js";
 import { shader_build_sdf } from "./shader_build_sdf.js";
 
@@ -241,15 +240,11 @@ export class GPUGeometrySDFManager {
         for (let i = 0; i < slot_indices.length; i++) {
             const slot_index = slot_indices[i];
 
-            const buffer_settings = command_ctx.allocateTransientValueBuffer(
-                SDF_BUILD_SETTINGS_STRUCT,
-                {
-                    slot_index,
-                    slot_resolution,
-                    atlas_resolution_in_slots: this.#atlas_resolution_in_tiles,
-                },
-                GPUBufferUsage.UNIFORM
-            );
+            const buffer_settings = {
+                slot_index,
+                slot_resolution,
+                atlas_resolution_in_slots: this.#atlas_resolution_in_tiles,
+            };
 
 
             const wgx = Math.ceil(slot_resolution / SFD_BUILD_WORKGROUP_SIZE[0]);