@woosh/meep-engine 3.40.0 → 3.41.0

package/src/shade/renderer/animation/shader_animation_pose_resolve.js

@@ -1,176 +1,187 @@
-import { atomic_u32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { chunk_scene_database_access_rw } from "../scene/chunk_scene_database_access.js";
-import { SCENE_DATABASE_SPEC } from "../scene/SCENE_DATABASE_SPEC.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_pose_accumulator } from "./chunk_pose_accumulator.js";
-
-const TRANSFORMS_TABLE = SCENE_DATABASE_SPEC.get('transforms');
-
-/**
- * Workgroup size for the resolve pass. Exported so dispatchers can pair
- * it with `transforms.dispatch_group_count(WORKGROUP_SIZE)`.
- */
-export const WORKGROUP_SIZE = 64;
-
-const PG_PREFIX = TRANSFORMS_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
-    .addStorageBuffer('pose_accumulator', WebGPUArray.from(atomic_u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(local_invocation_index) local_id: u32,
-) {
-    if !${PG_PREFIX}_setup(&scene_database, wg_id.x, local_id) {
-        return;
-    }
-
-    let slot_in_page = ${PG_PREFIX}_slot_in_page(local_id);
-
-    if slot_in_page >= ${PG_PREFIX}_ELEMENTS_PER_PAGE {
-        return;
-    }
-    if !${PG_PREFIX}_is_occupied(slot_in_page) {
-        return;
-    }
-
-    // Absolute transforms-table row index. The accumulator is laid out
-    // one slot per row at the same index, so this is also the
-    // accumulator slot.
-    let row = ${PG_PREFIX}_slot_to_index(slot_in_page);
-
-    let slot_base = pose_accumulator_slot_base(row);
-    let dirty_word = slot_base + POSE_OFFSET_DIRTY;
-
-    // Single load of the dirty mask gates the whole resolve. If
-    // nothing was contributed to this row this frame, leave local_*
-    // alone (and the accumulator slot is already zero because the
-    // previous resolve drained it).
-    let dirty = atomicLoad(&pose_accumulator[dirty_word]);
-    if dirty == 0u {
-        return;
-    }
-
-    // ── Translation ───────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_T_MASK) != 0u {
-        let t_base = slot_base + POSE_OFFSET_TRANSLATION;
-        // Per-axis: only overwrite the channels that actually had a
-        // contribution. Read the current local_translation through
-        // the rw helper and patch the dirty channels in-place — the
-        // sibling-axis race that the old direct writer already
-        // tolerated still applies (two threads writing different
-        // axes of the same node), but we now have at most one resolve
-        // thread per row, so it never triggers here.
-        var t = scene_read_node_rw(&scene_database, row).local_translation;
-        if (dirty & POSE_DIRTY_TX) != 0u {
-            t.x = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 0u]));
-            atomicStore(&pose_accumulator[t_base + 0u], 0u);
-        }
-        if (dirty & POSE_DIRTY_TY) != 0u {
-            t.y = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 1u]));
-            atomicStore(&pose_accumulator[t_base + 1u], 0u);
-        }
-        if (dirty & POSE_DIRTY_TZ) != 0u {
-            t.z = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 2u]));
-            atomicStore(&pose_accumulator[t_base + 2u], 0u);
-        }
-        scene_write_node_local_translation(&scene_database, row, t);
-    }
-
-    // ── Rotation ──────────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_R) != 0u {
-        let r_base = slot_base + POSE_OFFSET_ROTATION;
-        let r = vec4<f32>(
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 0u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 1u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 2u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 3u])),
-        );
-        atomicStore(&pose_accumulator[r_base + 0u], 0u);
-        atomicStore(&pose_accumulator[r_base + 1u], 0u);
-        atomicStore(&pose_accumulator[r_base + 2u], 0u);
-        atomicStore(&pose_accumulator[r_base + 3u], 0u);
-        // A sum of length zero carries no orientation to recover: every
-        // clip that writes this rotation is playing at weight zero, and
-        // the apply pass contributes to a bound clip whatever its
-        // weight. \`normalize\` answers NaN there, and one NaN local
-        // rotation reaches every skin matrix naming the joint, so the
-        // meshes it drives stop rasterising altogether — a rig loses a
-        // limb because a clip nobody is playing happens to be the only
-        // one that rotates it. Leaving the row alone is the rest pose,
-        // which is the answer the CPU twin gives (\`pose_evaluate_local\`)
-        // and the value the row still holds.
-        //
-        // Otherwise: the weighted-quaternion sum (\`w_i * q_i\`) is the
-        // standard nlerp blend numerator; normalise here, once, after
-        // every contributor has been folded in. The apply pass
-        // canonicalised signs at GLTF load so we don't hit the antipode
-        // case for imported clips.
-        if length(r) > 0.0 {
-            scene_write_node_local_rotation(&scene_database, row, normalize(r));
-        }
-    }
-
-    // ── Scale ─────────────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_S_MASK) != 0u {
-        let s_base = slot_base + POSE_OFFSET_SCALE;
-        var s = scene_read_node_rw(&scene_database, row).local_scale;
-        if (dirty & POSE_DIRTY_SX) != 0u {
-            s.x = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 0u]));
-            atomicStore(&pose_accumulator[s_base + 0u], 0u);
-        }
-        if (dirty & POSE_DIRTY_SY) != 0u {
-            s.y = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 1u]));
-            atomicStore(&pose_accumulator[s_base + 1u], 0u);
-        }
-        if (dirty & POSE_DIRTY_SZ) != 0u {
-            s.z = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 2u]));
-            atomicStore(&pose_accumulator[s_base + 2u], 0u);
-        }
-        scene_write_node_local_scale(&scene_database, row, s);
-    }
-
-    // Clear the dirty mask itself last, so an interrupted resolve
-    // (theoretical — these passes don't yield) would still leave the
-    // dirty bits intact to be redone.
-    atomicStore(&pose_accumulator[dirty_word], 0u);
-}
-`, [
-        TRANSFORMS_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
-        chunk_scene_database_access_rw,
-        chunk_pose_accumulator,
-    ]);
-
-/**
- * Compute shader that drains the pose accumulator into
- * `transforms_table.local_{translation,rotation,scale}`.
- *
- * Walks the transforms table via the read+write page iterator — one
- * thread per slot. For each occupied row whose accumulator slot has
- * any dirty bits set, reads the contributed components (atomic
- * loads, bitcast back to f32), writes them through the per-field
- * scene helpers, normalises rotation, and zeros the slot for next
- * frame.
- *
- * The accumulator buffer must be sized to at least
- * `transforms.dispatch_page_count * elements_per_page` rows —
- * {@link GPUAnimationManager#ensure_pose_accumulator_capacity}
- * handles that.
- *
- * Dispatch via
- * `shader_animation_pose_resolve.dispatch({ group_count_x: transforms.dispatch_group_count(WORKGROUP_SIZE), ... })`.
- */
-export const shader_animation_pose_resolve = ComputeShader.from({
-    label: "Animation/PoseResolve",
-    body,
-    resources,
-});
+import { atomic_u32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { chunk_scene_database_access_rw } from "../scene/chunk_scene_database_access.js";
+import { SCENE_DATABASE_SPEC } from "../scene/SCENE_DATABASE_SPEC.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_pose_accumulator } from "./chunk_pose_accumulator.js";
+
+const TRANSFORMS_TABLE = SCENE_DATABASE_SPEC.get('transforms');
+
+/**
+ * Workgroup size for the resolve pass. Exported so dispatchers can pair
+ * it with `transforms.dispatch_group_count(WORKGROUP_SIZE)`.
+ */
+export const WORKGROUP_SIZE = 64;
+
+const PG_PREFIX = TRANSFORMS_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
+    .addStorageBuffer('pose_accumulator', WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
+fn main(
+    @builtin(workgroup_id) wg_id: vec3<u32>,
+    @builtin(local_invocation_index) local_id: u32,
+) {
+    if !${PG_PREFIX}_setup(&scene_database, wg_id.x, local_id) {
+        return;
+    }
+
+    let slot_in_page = ${PG_PREFIX}_slot_in_page(local_id);
+
+    if slot_in_page >= ${PG_PREFIX}_ELEMENTS_PER_PAGE {
+        return;
+    }
+    if !${PG_PREFIX}_is_occupied(slot_in_page) {
+        return;
+    }
+
+    // Absolute transforms-table row index. The accumulator is laid out
+    // one slot per row at the same index, so this is also the
+    // accumulator slot.
+    let row = ${PG_PREFIX}_slot_to_index(slot_in_page);
+
+    let slot_base = pose_accumulator_slot_base(row);
+    let dirty_word = slot_base + POSE_OFFSET_DIRTY;
+
+    // Single load of the dirty mask gates the whole resolve. If
+    // nothing was contributed to this row this frame, leave local_*
+    // alone (and the accumulator slot is already zero because the
+    // previous resolve drained it).
+    let dirty = atomicLoad(&pose_accumulator[dirty_word]);
+    if dirty == 0u {
+        return;
+    }
+
+    // ── Translation ───────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_T_MASK) != 0u {
+        let t_base = slot_base + POSE_OFFSET_TRANSLATION;
+        // Per-axis: only overwrite the channels that actually had a
+        // contribution. Read the current local_translation through
+        // the rw helper and patch the dirty channels in-place — the
+        // sibling-axis race that the old direct writer already
+        // tolerated still applies (two threads writing different
+        // axes of the same node), but we now have at most one resolve
+        // thread per row, so it never triggers here.
+        var t = scene_read_node_rw(&scene_database, row).local_translation;
+        if (dirty & POSE_DIRTY_TX) != 0u {
+            t.x = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 0u]));
+            atomicStore(&pose_accumulator[t_base + 0u], 0u);
+        }
+        if (dirty & POSE_DIRTY_TY) != 0u {
+            t.y = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 1u]));
+            atomicStore(&pose_accumulator[t_base + 1u], 0u);
+        }
+        if (dirty & POSE_DIRTY_TZ) != 0u {
+            t.z = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 2u]));
+            atomicStore(&pose_accumulator[t_base + 2u], 0u);
+        }
+        scene_write_node_local_translation(&scene_database, row, t);
+    }
+
+    // ── Rotation ──────────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_R) != 0u {
+        let r_base = slot_base + POSE_OFFSET_ROTATION;
+        let r = vec4<f32>(
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 0u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 1u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 2u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 3u])),
+        );
+        atomicStore(&pose_accumulator[r_base + 0u], 0u);
+        atomicStore(&pose_accumulator[r_base + 1u], 0u);
+        atomicStore(&pose_accumulator[r_base + 2u], 0u);
+        atomicStore(&pose_accumulator[r_base + 3u], 0u);
+        // The weighted-quaternion sum (\`w_i * q_i\`) is the standard
+        // nlerp blend numerator; normalise here, once, after every
+        // contributor has been folded in. The apply pass canonicalised
+        // signs at GLTF load so we don't hit the antipode case for
+        // imported clips.
+        //
+        // A sum of length zero carries no orientation to recover: every
+        // clip that writes this rotation is playing at weight zero — a
+        // faded-out clip keeps its binding, and the apply pass
+        // contributes to a bound clip whatever its weight — or the
+        // contributions cancelled exactly. \`normalize\` answers NaN there,
+        // and one NaN local rotation reaches every skin matrix naming the
+        // joint, so the meshes it drives stop rasterising altogether. Nor
+        // can the row be left alone: once a clip has written it, it holds
+        // that clip's last pose, not the rest. The answer is the rest
+        // rotation, which every contribution carried into the slot from
+        // its binding — what the CPU twin (\`pose_evaluate_local\`) gives.
+        if length(r) > 0.0 {
+            scene_write_node_local_rotation(&scene_database, row, normalize(r));
+        } else {
+            let rest_base = slot_base + POSE_OFFSET_REST_ROTATION;
+            let rest = vec4<f32>(
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 0u])),
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 1u])),
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 2u])),
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 3u])),
+            );
+            scene_write_node_local_rotation(&scene_database, row, rest);
+        }
+    }
+
+    // ── Scale ─────────────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_S_MASK) != 0u {
+        let s_base = slot_base + POSE_OFFSET_SCALE;
+        var s = scene_read_node_rw(&scene_database, row).local_scale;
+        if (dirty & POSE_DIRTY_SX) != 0u {
+            s.x = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 0u]));
+            atomicStore(&pose_accumulator[s_base + 0u], 0u);
+        }
+        if (dirty & POSE_DIRTY_SY) != 0u {
+            s.y = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 1u]));
+            atomicStore(&pose_accumulator[s_base + 1u], 0u);
+        }
+        if (dirty & POSE_DIRTY_SZ) != 0u {
+            s.z = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 2u]));
+            atomicStore(&pose_accumulator[s_base + 2u], 0u);
+        }
+        scene_write_node_local_scale(&scene_database, row, s);
+    }
+
+    // Clear the dirty mask itself last, so an interrupted resolve
+    // (theoretical — these passes don't yield) would still leave the
+    // dirty bits intact to be redone.
+    atomicStore(&pose_accumulator[dirty_word], 0u);
+}
+`, [
+        TRANSFORMS_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
+        chunk_scene_database_access_rw,
+        chunk_pose_accumulator,
+    ]);
+
+/**
+ * Compute shader that drains the pose accumulator into
+ * `transforms_table.local_{translation,rotation,scale}`.
+ *
+ * Walks the transforms table via the read+write page iterator — one
+ * thread per slot. For each occupied row whose accumulator slot has
+ * any dirty bits set, reads the contributed components (atomic
+ * loads, bitcast back to f32), writes them through the per-field
+ * scene helpers, normalises rotation — or, for a rotation summing to
+ * nothing, writes the rest rotation the contributions carried — and
+ * zeros the sums and the dirty mask for next frame.
+ *
+ * The accumulator buffer must be sized to at least
+ * `transforms.dispatch_page_count * elements_per_page` rows —
+ * {@link GPUAnimationManager#ensure_pose_accumulator_capacity}
+ * handles that.
+ *
+ * Dispatch via
+ * `shader_animation_pose_resolve.dispatch({ group_count_x: transforms.dispatch_group_count(WORKGROUP_SIZE), ... })`.
+ */
+export const shader_animation_pose_resolve = ComputeShader.from({
+    label: "Animation/PoseResolve",
+    body,
+    resources,
+});

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#259@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#261@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/object_property/chunk_write_object_property.d.ts

@@ -12,7 +12,9 @@
  * `weight` is the weight `value` has already been multiplied by. Only the
  * Node3D writer wants it, and only for rotation: a rotation channel missing
  * its `w` curve defaults to the identity's 1, which has to be weighted the
- * same way the authored channels were.
+ * same way the authored channels were. `rest_rotation` is the target's
+ * rest rotation from its binding, and the same goes for it: only a Node3D
+ * rotation reads it.
  *
  * Each writer lives in its own CodeChunk and operates on whatever storage
  * buffers the importing shader has bound under the documented names —

package/src/shade/renderer/object_property/chunk_write_object_property.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_write_object_property.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,0CAFU,SAAS,CA2Bb;0BA1DoB,iCAAiC"}
+{"version":3,"file":"chunk_write_object_property.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,0CAFU,SAAS,CA4Bb;0BA7DoB,iCAAiC"}

package/src/shade/renderer/object_property/chunk_write_object_property.js

@@ -21,7 +21,9 @@ import { ObjectType } from "./ObjectType.js";
  * `weight` is the weight `value` has already been multiplied by. Only the
  * Node3D writer wants it, and only for rotation: a rotation channel missing
  * its `w` curve defaults to the identity's 1, which has to be weighted the
- * same way the authored channels were.
+ * same way the authored channels were. `rest_rotation` is the target's
+ * rest rotation from its binding, and the same goes for it: only a Node3D
+ * rotation reads it.
  *
  * Each writer lives in its own CodeChunk and operates on whatever storage
  * buffers the importing shader has bound under the documented names —
@@ -40,12 +42,13 @@ fn write_object_property(
     mask: u32,
     value: vec4f,
     weight: f32,
+    rest_rotation: vec4f,
 ) {
     let object_type = instance >> 24u;
 
     switch(object_type){
         case ${ObjectType.Node3D}u: {
-            write_object_property_node3d(instance, property, mask, value, weight);
+            write_object_property_node3d(instance, property, mask, value, weight, rest_rotation);
         }
         case ${ObjectType.Material}u: {
             write_object_property_material(instance, property, mask, value);

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.d.ts

@@ -35,6 +35,10 @@
  * channel has to carry the same weight as the channels that were
  * authored; nothing else here does.
  *
+ * `rest_rotation` is the target's rest rotation, from its binding. Only
+ * Rotation reads it: it rides into the slot with the contribution, for
+ * the resolve to write when the rotations summed to nothing.
+ *
  * @type {CodeChunk}
  */
 export const chunk_write_object_property_node3d: CodeChunk;

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_write_object_property_node3d.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property_node3d.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,iDAFU,SAAS,CA6Bb;0BArEoB,iCAAiC"}
+{"version":3,"file":"chunk_write_object_property_node3d.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property_node3d.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,iDAFU,SAAS,CA8Bb;0BA1EoB,iCAAiC"}

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.js

@@ -39,6 +39,10 @@ import { Node3DProperty } from "./Node3DProperty.js";
  * channel has to carry the same weight as the channels that were
  * authored; nothing else here does.
  *
+ * `rest_rotation` is the target's rest rotation, from its binding. Only
+ * Rotation reads it: it rides into the slot with the contribution, for
+ * the resolve to write when the rotations summed to nothing.
+ *
  * @type {CodeChunk}
  */
 export const chunk_write_object_property_node3d = CodeChunk.from(
@@ -50,6 +54,7 @@ fn write_object_property_node3d(
     mask: u32,
     value: vec4f,
     weight: f32,
+    rest_rotation: vec4f,
 ) {
     let node_index = instance & 0x00FFFFFFu;
 
@@ -58,7 +63,7 @@ fn write_object_property_node3d(
             pose_accumulator_add_translation(node_index, value.xyz, mask);
         }
         case ${Node3DProperty.Rotation}u: {
-            pose_accumulator_add_rotation(node_index, value, mask, weight);
+            pose_accumulator_add_rotation(node_index, value, mask, weight, rest_rotation);
         }
         case ${Node3DProperty.Scale}u: {
             pose_accumulator_add_scale(node_index, value.xyz, mask);

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#190@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#192@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.d.ts

@@ -37,7 +37,7 @@ export type GeometryDeduplicateOptions = {
      */
     position_epsilon?: number;
     /**
-     * Max occurrences kept per rolling-hash bucket
+     * Max triangles kept per neighbourhood hash
      */
     seed_budget?: number;
 };

package/src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_deduplicate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;GAUG;AACH,qGAHW,0BAA0B,GACxB,cAAc,CAAC,WAAW,WAAW,EAAE,CAAC,CAqNpD;;;;;gBA8Ea,MAAM;gBACN,MAAM;gBACN,MAAM;;;;YACN,MAAM;;;gBA1UN,UAAU;;;;qBACV,MAAM;;;;;;;;uBACN,MAAM;;;;kBAKN,MAAM;;4BArBQ,oDAAoD"}
+{"version":3,"file":"geometry_deduplicate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.js"],"names":[],"mappings":"AAyDA;;;;;;;;;;GAUG;AACH,qGAHW,0BAA0B,GACxB,cAAc,CAAC,WAAW,WAAW,EAAE,CAAC,CA4LpD;;;;;gBAoJa,MAAM;gBACN,MAAM;gBACN,MAAM;;;;YACN,MAAM;;;gBAlYN,UAAU;;;;qBACV,MAAM;;;;;;;;uBACN,MAAM;;;;kBAKN,MAAM;;4BAtBQ,oDAAoD"}