@woosh/meep-engine 3.11.3 → 3.12.0

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

@@ -1,126 +1,125 @@
-import { f32, 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 { ANIMATION_DATABASE_SPEC } from "./ANIMATION_DATABASE_SPEC.js";
-import { AnimationClipFlags } from "./AnimationClipFlags.js";
-
-const CLIP_TABLE = ANIMATION_DATABASE_SPEC.get('animation_clips');
-
-/**
- * Workgroup size for the tick pass. Exported so dispatchers can pair it
- * with `animation_clips.dispatch_group_count(WORKGROUP_SIZE)` — the
- * page iterator's slot-to-workgroup mapping is computed against this
- * value, so the two must agree.
- */
-export const WORKGROUP_SIZE = 64;
-
-// rw variant — our `animation_database` binding is read_write so the
-// tick can advance `clip.time` in place. The iterator's `_setup` and
-// `_read` need matching access mode on their database parameter.
-const PG_PREFIX = CLIP_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
-
-// `dt` is a single f32 uniform — seconds elapsed since the last tick.
-// `animation_database` is read_write because the tick advances the
-// `time` field of each playing clip in place.
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform('dt', f32)
-    .addStorageBuffer('animation_database', WebGPUArray.from(u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const FLAG_PLAYING: u32 = ${AnimationClipFlags.Playing}u;
-const FLAG_LOOP:    u32 = ${AnimationClipFlags.Loop}u;
-
-@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(&animation_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;
-    }
-
-    let clip = ${PG_PREFIX}_read(&animation_database, slot_in_page);
-
-    // The Playing bit gates time advance entirely. A stopped clip
-    // doesn't even need a write — the upload-buffer dedupe would
-    // collapse it, but skipping saves the store entirely.
-    if (clip.flags & FLAG_PLAYING) == 0u {
-        return;
-    }
-
-    let clip_id = ${PG_PREFIX}_slot_to_index(slot_in_page);
-
-    let advance = dt * clip.playback_rate;
-    var new_time = clip.time + advance;
-
-    // "clip.time" is the playback offset relative to "clip.time_start",
-    // not an absolute curve-clock value — the apply shader does
-    // "effective_time = clip.time + clip.time_start" when sampling
-    // curves. So we wrap / clamp in "[0, duration]", not in
-    // "[time_start, time_end]".
-    let span = clip.time_end - clip.time_start;
-
-    if span <= 0.0 {
-        // Zero-length clip — pin to 0 and skip the wrap/clamp math.
-        // Avoids division by zero in the loop branch and gives a
-        // deterministic value the apply shader can read.
-        new_time = 0.0;
-    } else if (clip.flags & FLAG_LOOP) != 0u {
-        // Wrap into [0, duration). Uses fmod-style positive modulo
-        // so negative playback_rates wrap cleanly too.
-        new_time = new_time - floor(new_time / span) * span;
-    } else {
-        // Non-looping: clamp to the playback range. Once clamped, the
-        // clip "completes" — time stops advancing on its own (advance
-        // adds zero in subsequent frames because new_time == clip.time
-        // would already equal duration). The Playing bit is left set
-        // so the host can decide whether to stop, rewind, or flip the
-        // Loop bit on.
-        new_time = clamp(new_time, 0.0, span);
-    }
-
-    ${CLIP_TABLE.marshalling_method_write_field('time')}(&animation_database, clip_id, new_time);
-}
-`, [
-        CLIP_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
-        CLIP_TABLE.wgsl_gen_write_field_code('time'),
-    ]
-);
-
-/**
- * GPU-side animation playback driver: one thread per clip slot via the
- * page iterator. For each clip with the {@link AnimationClipFlags.Playing}
- * bit set, advances `time` by `dt * playback_rate`, then either wraps
- * modulo `[time_start, time_end]` (if {@link AnimationClipFlags.Loop} is
- * set) or clamps to that range (if not).
- *
- * Run before `shader_animation_apply` each frame — the apply pass reads
- * `clip.time` to evaluate tracks, so the tick must land first. The
- * `dt` uniform is the wall-clock seconds elapsed since the previous
- * tick; the host owns its measurement.
- *
- * Dispatch via
- * `shader_animation_tick.dispatch({ group_count_x: animation_clips.dispatch_group_count(WORKGROUP_SIZE), ... })`.
- * Skip the dispatch when `group_count_x === 0` — no clips registered
- * means no work to do.
- */
-export const shader_animation_tick = ComputeShader.from({
-    label: "Animation/Tick",
-    body,
-    resources,
-    group_size: [WORKGROUP_SIZE, 1, 1],
-});
+import { f32, 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 { ANIMATION_DATABASE_SPEC } from "./ANIMATION_DATABASE_SPEC.js";
+import { AnimationClipFlags } from "./AnimationClipFlags.js";
+
+const CLIP_TABLE = ANIMATION_DATABASE_SPEC.get('animation_clips');
+
+/**
+ * Workgroup size for the tick pass. Exported so dispatchers can pair it
+ * with `animation_clips.dispatch_group_count(WORKGROUP_SIZE)` — the
+ * page iterator's slot-to-workgroup mapping is computed against this
+ * value, so the two must agree.
+ */
+export const WORKGROUP_SIZE = 64;
+
+// rw variant — our `animation_database` binding is read_write so the
+// tick can advance `clip.time` in place. The iterator's `_setup` and
+// `_read` need matching access mode on their database parameter.
+const PG_PREFIX = CLIP_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
+
+// `dt` is a single f32 uniform — seconds elapsed since the last tick.
+// `animation_database` is read_write because the tick advances the
+// `time` field of each playing clip in place.
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addUniform('dt', f32)
+    .addStorageBuffer('animation_database', WebGPUArray.from(u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const FLAG_PLAYING: u32 = ${AnimationClipFlags.Playing}u;
+const FLAG_LOOP:    u32 = ${AnimationClipFlags.Loop}u;
+
+@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(&animation_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;
+    }
+
+    let clip = ${PG_PREFIX}_read(&animation_database, slot_in_page);
+
+    // The Playing bit gates time advance entirely. A stopped clip
+    // doesn't even need a write — the upload-buffer dedupe would
+    // collapse it, but skipping saves the store entirely.
+    if (clip.flags & FLAG_PLAYING) == 0u {
+        return;
+    }
+
+    let clip_id = ${PG_PREFIX}_slot_to_index(slot_in_page);
+
+    let advance = dt * clip.playback_rate;
+    var new_time = clip.time + advance;
+
+    // "clip.time" is the playback offset relative to "clip.time_start",
+    // not an absolute curve-clock value — the apply shader does
+    // "effective_time = clip.time + clip.time_start" when sampling
+    // curves. So we wrap / clamp in "[0, duration]", not in
+    // "[time_start, time_end]".
+    let span = clip.time_end - clip.time_start;
+
+    if span <= 0.0 {
+        // Zero-length clip — pin to 0 and skip the wrap/clamp math.
+        // Avoids division by zero in the loop branch and gives a
+        // deterministic value the apply shader can read.
+        new_time = 0.0;
+    } else if (clip.flags & FLAG_LOOP) != 0u {
+        // Wrap into [0, duration). Uses fmod-style positive modulo
+        // so negative playback_rates wrap cleanly too.
+        new_time = new_time - floor(new_time / span) * span;
+    } else {
+        // Non-looping: clamp to the playback range. Once clamped, the
+        // clip "completes" — time stops advancing on its own (advance
+        // adds zero in subsequent frames because new_time == clip.time
+        // would already equal duration). The Playing bit is left set
+        // so the host can decide whether to stop, rewind, or flip the
+        // Loop bit on.
+        new_time = clamp(new_time, 0.0, span);
+    }
+
+    ${CLIP_TABLE.marshalling_method_write_field('time')}(&animation_database, clip_id, new_time);
+}
+`, [
+        CLIP_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
+        CLIP_TABLE.wgsl_gen_write_field_code('time'),
+    ]
+);
+
+/**
+ * GPU-side animation playback driver: one thread per clip slot via the
+ * page iterator. For each clip with the {@link AnimationClipFlags.Playing}
+ * bit set, advances `time` by `dt * playback_rate`, then either wraps
+ * modulo `[time_start, time_end]` (if {@link AnimationClipFlags.Loop} is
+ * set) or clamps to that range (if not).
+ *
+ * Run before `shader_animation_apply` each frame — the apply pass reads
+ * `clip.time` to evaluate tracks, so the tick must land first. The
+ * `dt` uniform is the wall-clock seconds elapsed since the previous
+ * tick; the host owns its measurement.
+ *
+ * Dispatch via
+ * `shader_animation_tick.dispatch({ group_count_x: animation_clips.dispatch_group_count(WORKGROUP_SIZE), ... })`.
+ * Skip the dispatch when `group_count_x === 0` — no clips registered
+ * means no work to do.
+ */
+export const shader_animation_tick = ComputeShader.from({
+    label: "Animation/Tick",
+    body,
+    resources,
+});

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_geometry_sphere_derive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_geometry_sphere_derive.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_geometry_sphere_derive.js"],"names":[],"mappings":"AAQA,gCAAiC;AAsEjC;;;;;;;;;;;;;;GAcG;AACH,0DAKG;8BA9F2B,kCAAkC"}
+{"version":3,"file":"shader_geometry_sphere_derive.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_geometry_sphere_derive.js"],"names":[],"mappings":"AAQA,gCAAiC;AAsEjC;;;;;;;;;;;;;;GAcG;AACH,0DAIG;8BA7F2B,kCAAkC"}

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_geometry_sphere_derive.js

@@ -1,99 +1,98 @@
-import { atomic_u32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { GEOMETRY_METADATA_STRUCT } from "../../../geometry/GEOMETRY_METADATA_STRUCT.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { SKINNING_BINDING_STRUCT } from "../SKINNING_BINDING_STRUCT.js";
-
-export const WORKGROUP_SIZE = 64;
-
-const GEOMETRY_BBOX_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_box').offset / 4;
-const GEOMETRY_SPHERE_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_sphere').offset / 4;
-const GEOMETRY_STRIDE_WORDS = GEOMETRY_METADATA_STRUCT.size / 4;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    // Number of active skinning bindings. Threads past `binding_count`
-    // early-out (the dispatch is sized to `ceil(binding_count/64)`
-    // workgroups, so the tail can have up to 63 idle threads).
-    .addUniform('binding_count', u32)
-    .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
-    // Same buffer the rasterizer reads as a typed struct array; we
-    // atomicLoad the freshly-merged `bounding_box` cells and
-    // atomicStore the derived sphere into `bounding_sphere`. Atomic
-    // store is the simplest way to write through an atomic-typed
-    // view; only one thread (this binding's) writes its geometry's
-    // sphere, so there's no contention.
-    .addStorageBuffer('geometry_metadata_atomic', WebGPUArray.from(atomic_u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const GEOMETRY_BBOX_OFFSET: u32   = ${GEOMETRY_BBOX_OFFSET_WORDS}u;
-const GEOMETRY_SPHERE_OFFSET: u32 = ${GEOMETRY_SPHERE_OFFSET_WORDS}u;
-const GEOMETRY_STRIDE: u32        = ${GEOMETRY_STRIDE_WORDS}u;
-
-@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let binding_index = gid.x;
-    if binding_index >= binding_count {
-        return;
-    }
-
-    let binding = skinning_bindings[binding_index];
-    let g_base = binding.clone_geometry_index * GEOMETRY_STRIDE;
-
-    // Read the freshly-merged bounding box. The reduce pass wrote
-    // these atomically; by the time this dispatch runs (after the
-    // reduce pass's barrier), they're stable. atomicLoad is the
-    // correct read through an atomic-typed binding.
-    let bbox_base = g_base + GEOMETRY_BBOX_OFFSET;
-    let min_x = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 0u]));
-    let min_y = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 1u]));
-    let min_z = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 2u]));
-    let max_x = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 3u]));
-    let max_y = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 4u]));
-    let max_z = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 5u]));
-
-    let min_v = vec3<f32>(min_x, min_y, min_z);
-    let max_v = vec3<f32>(max_x, max_y, max_z);
-
-    // Conservative sphere from the AABB: center at the box midpoint,
-    // radius = half the box diagonal. Slightly larger than the
-    // minimum enclosing sphere (which would need a Miniball-style
-    // iterative solver), but cheap and tight enough for culling.
-    // Same convention as "computeBoundingSphereFromBox" on the CPU
-    // side.
-    let center = (min_v + max_v) * 0.5;
-    let radius = length(max_v - min_v) * 0.5;
-
-    let sphere_base = g_base + GEOMETRY_SPHERE_OFFSET;
-    atomicStore(&geometry_metadata_atomic[sphere_base + 0u], bitcast<u32>(center.x));
-    atomicStore(&geometry_metadata_atomic[sphere_base + 1u], bitcast<u32>(center.y));
-    atomicStore(&geometry_metadata_atomic[sphere_base + 2u], bitcast<u32>(center.z));
-    atomicStore(&geometry_metadata_atomic[sphere_base + 3u], bitcast<u32>(radius));
-}
-`);
-
-/**
- * Compute shader that derives each active clone geometry's
- * `bounding_sphere` from its freshly-merged `bounding_box`.
- *
- * One thread per active skinning binding (= one per clone geometry).
- * Reads the 6 box cells, computes center = (min+max)/2 and radius =
- * length(max-min)/2 — the box-derived conservative sphere — and
- * writes the 4 sphere cells. No cross-thread contention since each
- * binding owns its own geometry row.
- *
- * Must run AFTER `shader_meshlet_bounds_reduce` (which finalizes the
- * `bounding_box` cells this pass reads) and BEFORE the mesh-instance
- * bounds-refresh pass (which reads `bounding_sphere` to project into
- * world space).
- */
-export const shader_geometry_sphere_derive = ComputeShader.from({
-    label: "Skinning/GeometrySphereDerive",
-    resources,
-    body,
-    group_size: [WORKGROUP_SIZE, 1, 1],
-});
+import { atomic_u32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { SKINNING_BINDING_STRUCT } from "../SKINNING_BINDING_STRUCT.js";
+
+export const WORKGROUP_SIZE = 64;
+
+const GEOMETRY_BBOX_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_box').offset / 4;
+const GEOMETRY_SPHERE_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_sphere').offset / 4;
+const GEOMETRY_STRIDE_WORDS = GEOMETRY_METADATA_STRUCT.size / 4;
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    // Number of active skinning bindings. Threads past `binding_count`
+    // early-out (the dispatch is sized to `ceil(binding_count/64)`
+    // workgroups, so the tail can have up to 63 idle threads).
+    .addUniform('binding_count', u32)
+    .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
+    // Same buffer the rasterizer reads as a typed struct array; we
+    // atomicLoad the freshly-merged `bounding_box` cells and
+    // atomicStore the derived sphere into `bounding_sphere`. Atomic
+    // store is the simplest way to write through an atomic-typed
+    // view; only one thread (this binding's) writes its geometry's
+    // sphere, so there's no contention.
+    .addStorageBuffer('geometry_metadata_atomic', WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const GEOMETRY_BBOX_OFFSET: u32   = ${GEOMETRY_BBOX_OFFSET_WORDS}u;
+const GEOMETRY_SPHERE_OFFSET: u32 = ${GEOMETRY_SPHERE_OFFSET_WORDS}u;
+const GEOMETRY_STRIDE: u32        = ${GEOMETRY_STRIDE_WORDS}u;
+
+@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let binding_index = gid.x;
+    if binding_index >= binding_count {
+        return;
+    }
+
+    let binding = skinning_bindings[binding_index];
+    let g_base = binding.clone_geometry_index * GEOMETRY_STRIDE;
+
+    // Read the freshly-merged bounding box. The reduce pass wrote
+    // these atomically; by the time this dispatch runs (after the
+    // reduce pass's barrier), they're stable. atomicLoad is the
+    // correct read through an atomic-typed binding.
+    let bbox_base = g_base + GEOMETRY_BBOX_OFFSET;
+    let min_x = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 0u]));
+    let min_y = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 1u]));
+    let min_z = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 2u]));
+    let max_x = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 3u]));
+    let max_y = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 4u]));
+    let max_z = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 5u]));
+
+    let min_v = vec3<f32>(min_x, min_y, min_z);
+    let max_v = vec3<f32>(max_x, max_y, max_z);
+
+    // Conservative sphere from the AABB: center at the box midpoint,
+    // radius = half the box diagonal. Slightly larger than the
+    // minimum enclosing sphere (which would need a Miniball-style
+    // iterative solver), but cheap and tight enough for culling.
+    // Same convention as "computeBoundingSphereFromBox" on the CPU
+    // side.
+    let center = (min_v + max_v) * 0.5;
+    let radius = length(max_v - min_v) * 0.5;
+
+    let sphere_base = g_base + GEOMETRY_SPHERE_OFFSET;
+    atomicStore(&geometry_metadata_atomic[sphere_base + 0u], bitcast<u32>(center.x));
+    atomicStore(&geometry_metadata_atomic[sphere_base + 1u], bitcast<u32>(center.y));
+    atomicStore(&geometry_metadata_atomic[sphere_base + 2u], bitcast<u32>(center.z));
+    atomicStore(&geometry_metadata_atomic[sphere_base + 3u], bitcast<u32>(radius));
+}
+`);
+
+/**
+ * Compute shader that derives each active clone geometry's
+ * `bounding_sphere` from its freshly-merged `bounding_box`.
+ *
+ * One thread per active skinning binding (= one per clone geometry).
+ * Reads the 6 box cells, computes center = (min+max)/2 and radius =
+ * length(max-min)/2 — the box-derived conservative sphere — and
+ * writes the 4 sphere cells. No cross-thread contention since each
+ * binding owns its own geometry row.
+ *
+ * Must run AFTER `shader_meshlet_bounds_reduce` (which finalizes the
+ * `bounding_box` cells this pass reads) and BEFORE the mesh-instance
+ * bounds-refresh pass (which reads `bounding_sphere` to project into
+ * world space).
+ */
+export const shader_geometry_sphere_derive = ComputeShader.from({
+    label: "Skinning/GeometrySphereDerive",
+    resources,
+    body,
+});

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_bounds_reduce.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,gCAAiC;AAmKjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yDAKG;8BA/M2B,kCAAkC"}
+{"version":3,"file":"shader_meshlet_bounds_reduce.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,gCAAiC;AAmKjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yDAIG;8BA9M2B,kCAAkC"}