@woosh/meep-engine 3.12.0 → 3.13.1

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

@@ -1,120 +1,135 @@
-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 { MESHLET_METADATA_STRUCT } from "../../../geometry/meshlet/encoding/MESHLET_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;
-
-// Struct field offsets resolved at module-load time and baked into the
-// shader as constants. The structs use `.pack()` for minimum-size
-// layout, so the field positions depend on the packing heuristic —
-// reading `.get(field).offset` after the build phase is the only
-// reliable way to know where bounds_box / bounding_box actually sit.
-const MESHLET_BOUNDS_OFFSET_WORDS = MESHLET_METADATA_STRUCT.get('bounds_box').offset / 4;
-const MESHLET_STRIDE_WORDS = MESHLET_METADATA_STRUCT.size / 4;
-
-const GEOMETRY_BBOX_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_box').offset / 4;
-const GEOMETRY_STRIDE_WORDS = GEOMETRY_METADATA_STRUCT.size / 4;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    // Sub-dispatch first-pair offset, in pair units. The host
-    // paginates if `total_pair_count > maxComputeWorkgroupsPerDimension
-    // * WORKGROUP_SIZE`; under typical stress-test scale (~71k pairs)
-    // a single sub-dispatch suffices and `dispatch_offset` is zero.
-    .addUniform('dispatch_offset', u32)
-    .addUniform('total_pair_count', u32)
-    .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
-    .addStorageBuffer('dispatch_lookup', WebGPUArray.from(u32), false)
-    // Same buffers the rasterizer reads as typed structs, bound here
-    // as flat `atomic<u32>` arrays so we can do per-cell atomic
-    // stores at known field offsets (resolved above at module-load).
-    .addStorageBuffer('meshlet_metadata_atomic', WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer('geometry_metadata_atomic', WebGPUArray.from(atomic_u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const PLUS_INF: u32  = 0x7F800000u;  // bitcast f32(+inf)
-const MINUS_INF: u32 = 0xFF800000u;  // bitcast f32(-inf)
-
-const MESHLET_BOUNDS_OFFSET: u32  = ${MESHLET_BOUNDS_OFFSET_WORDS}u;
-const MESHLET_STRIDE: u32         = ${MESHLET_STRIDE_WORDS}u;
-const GEOMETRY_BBOX_OFFSET: u32   = ${GEOMETRY_BBOX_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 pair_index = gid.x + dispatch_offset;
-    if pair_index >= total_pair_count {
-        return;
-    }
-
-    let lookup_base = pair_index * 2u;
-    let binding_index = dispatch_lookup[lookup_base];
-    let meshlet_local = dispatch_lookup[lookup_base + 1u];
-
-    let binding = skinning_bindings[binding_index];
-    let clone_meshlet_abs = binding.clone_meshlet_metadata_offset + meshlet_local;
-
-    // Meshlet bounds reset: +inf for the 3 min slots, -inf for the
-    // 3 max slots. Each meshlet has exactly one (binding, meshlet)
-    // pair that touches it, so there's no cross-thread race on these
-    // slots — atomicStore is technically overkill, but the buffer is
-    // bound atomic-typed for the reduce pass and atomicStore is the
-    // way to write through that view.
-    let m_base = clone_meshlet_abs * MESHLET_STRIDE + MESHLET_BOUNDS_OFFSET;
-    atomicStore(&meshlet_metadata_atomic[m_base + 0u], PLUS_INF);
-    atomicStore(&meshlet_metadata_atomic[m_base + 1u], PLUS_INF);
-    atomicStore(&meshlet_metadata_atomic[m_base + 2u], PLUS_INF);
-    atomicStore(&meshlet_metadata_atomic[m_base + 3u], MINUS_INF);
-    atomicStore(&meshlet_metadata_atomic[m_base + 4u], MINUS_INF);
-    atomicStore(&meshlet_metadata_atomic[m_base + 5u], MINUS_INF);
-
-    // Geometry bounds reset gate: the first meshlet of each binding
-    // (meshlet_local == 0) does the reset for the binding's clone
-    // geometry. Every clone has at least one meshlet, so this fires
-    // exactly once per active binding. Multiple bindings could in
-    // principle target the same clone — the skinning context allocates
-    // one clone per SkinnedMesh, so in practice each binding owns its
-    // own geometry — but even if they didn't, the writes here are
-    // idempotent (same sentinels).
-    if meshlet_local == 0u {
-        let g_base = binding.clone_geometry_index * GEOMETRY_STRIDE + GEOMETRY_BBOX_OFFSET;
-        atomicStore(&geometry_metadata_atomic[g_base + 0u], PLUS_INF);
-        atomicStore(&geometry_metadata_atomic[g_base + 1u], PLUS_INF);
-        atomicStore(&geometry_metadata_atomic[g_base + 2u], PLUS_INF);
-        atomicStore(&geometry_metadata_atomic[g_base + 3u], MINUS_INF);
-        atomicStore(&geometry_metadata_atomic[g_base + 4u], MINUS_INF);
-        atomicStore(&geometry_metadata_atomic[g_base + 5u], MINUS_INF);
-    }
-}
-`);
-
-/**
- * Compute shader that resets per-meshlet `bounds_box` (clone meshlets
- * only) and per-clone-geometry `bounding_box` to ±inf sentinels —
- * the prerequisite for the reduce / merge passes that follow.
- *
- * Linear-thread dispatch: one thread per (binding, meshlet) pair in
- * the skinning context's `dispatch_lookup`. With workgroup size 64,
- * `ceil(total_pair_count / 64)` workgroups cover everything; the
- * `dispatch_offset` uniform lets the host paginate when
- * `total_pair_count > maxComputeWorkgroupsPerDimension * 64`
- * (currently won't trigger — 65535 * 64 ≈ 4M pairs).
- *
- * The geometry bounds reset is gated to `meshlet_local == 0` so each
- * clone geometry is reset exactly once. The clone's bounding_sphere
- * is NOT reset here — the derive-sphere pass at the end of the
- * refresh chain overwrites it wholesale from the box, so no
- * transient state matters.
- */
-export const shader_meshlet_bounds_scatter = ComputeShader.from({
-    label: "Skinning/MeshletBoundsScatter",
-    resources,
-    body,
-});
+import { atomic_u32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_METADATA_STRUCT } from "../../../geometry/meshlet/encoding/MESHLET_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;
+
+// Struct field offsets resolved at module-load time and baked into the
+// shader as constants. The structs use `.pack()` for minimum-size
+// layout, so the field positions depend on the packing heuristic —
+// reading `.get(field).offset` after the build phase is the only
+// reliable way to know where bounds_box / bounding_box actually sit.
+const MESHLET_BOUNDS_OFFSET_WORDS = MESHLET_METADATA_STRUCT.get('bounds_box').offset / 4;
+const MESHLET_STRIDE_WORDS = MESHLET_METADATA_STRUCT.size / 4;
+
+const GEOMETRY_BBOX_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_box').offset / 4;
+const GEOMETRY_STRIDE_WORDS = GEOMETRY_METADATA_STRUCT.size / 4;
+
+/**
+ * Per-dispatch, eight bytes, read-only.
+ *
+ * `dispatch_offset` is the sub-dispatch's first-pair offset, in pair units. The host paginates if
+ * `total_pair_count > maxComputeWorkgroupsPerDimension * WORKGROUP_SIZE`; under typical stress-test
+ * scale (~71k pairs) a single sub-dispatch suffices and `dispatch_offset` is zero.
+ *
+ * The two were separate u32 uniforms, so two transient buffers per sub-dispatch. WGSL allows one
+ * immediate per entry point, so carrying them as immediate data means carrying them together.
+ *
+ * @type {WebGPUStruct}
+ */
+const SCATTER_SETTINGS = WebGPUStruct.from({
+    dispatch_offset: u32,
+    total_pair_count: u32,
+}, 'MeshletBoundsScatterSettings');
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate('settings', SCATTER_SETTINGS);
+
+resources.createGroup()
+    .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
+    .addStorageBuffer('dispatch_lookup', WebGPUArray.from(u32), false)
+    // Same buffers the rasterizer reads as typed structs, bound here
+    // as flat `atomic<u32>` arrays so we can do per-cell atomic
+    // stores at known field offsets (resolved above at module-load).
+    .addStorageBuffer('meshlet_metadata_atomic', WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer('geometry_metadata_atomic', WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const PLUS_INF: u32  = 0x7F800000u;  // bitcast f32(+inf)
+const MINUS_INF: u32 = 0xFF800000u;  // bitcast f32(-inf)
+
+const MESHLET_BOUNDS_OFFSET: u32  = ${MESHLET_BOUNDS_OFFSET_WORDS}u;
+const MESHLET_STRIDE: u32         = ${MESHLET_STRIDE_WORDS}u;
+const GEOMETRY_BBOX_OFFSET: u32   = ${GEOMETRY_BBOX_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 pair_index = gid.x + settings.dispatch_offset;
+    if pair_index >= settings.total_pair_count {
+        return;
+    }
+
+    let lookup_base = pair_index * 2u;
+    let binding_index = dispatch_lookup[lookup_base];
+    let meshlet_local = dispatch_lookup[lookup_base + 1u];
+
+    let binding = skinning_bindings[binding_index];
+    let clone_meshlet_abs = binding.clone_meshlet_metadata_offset + meshlet_local;
+
+    // Meshlet bounds reset: +inf for the 3 min slots, -inf for the
+    // 3 max slots. Each meshlet has exactly one (binding, meshlet)
+    // pair that touches it, so there's no cross-thread race on these
+    // slots — atomicStore is technically overkill, but the buffer is
+    // bound atomic-typed for the reduce pass and atomicStore is the
+    // way to write through that view.
+    let m_base = clone_meshlet_abs * MESHLET_STRIDE + MESHLET_BOUNDS_OFFSET;
+    atomicStore(&meshlet_metadata_atomic[m_base + 0u], PLUS_INF);
+    atomicStore(&meshlet_metadata_atomic[m_base + 1u], PLUS_INF);
+    atomicStore(&meshlet_metadata_atomic[m_base + 2u], PLUS_INF);
+    atomicStore(&meshlet_metadata_atomic[m_base + 3u], MINUS_INF);
+    atomicStore(&meshlet_metadata_atomic[m_base + 4u], MINUS_INF);
+    atomicStore(&meshlet_metadata_atomic[m_base + 5u], MINUS_INF);
+
+    // Geometry bounds reset gate: the first meshlet of each binding
+    // (meshlet_local == 0) does the reset for the binding's clone
+    // geometry. Every clone has at least one meshlet, so this fires
+    // exactly once per active binding. Multiple bindings could in
+    // principle target the same clone — the skinning context allocates
+    // one clone per SkinnedMesh, so in practice each binding owns its
+    // own geometry — but even if they didn't, the writes here are
+    // idempotent (same sentinels).
+    if meshlet_local == 0u {
+        let g_base = binding.clone_geometry_index * GEOMETRY_STRIDE + GEOMETRY_BBOX_OFFSET;
+        atomicStore(&geometry_metadata_atomic[g_base + 0u], PLUS_INF);
+        atomicStore(&geometry_metadata_atomic[g_base + 1u], PLUS_INF);
+        atomicStore(&geometry_metadata_atomic[g_base + 2u], PLUS_INF);
+        atomicStore(&geometry_metadata_atomic[g_base + 3u], MINUS_INF);
+        atomicStore(&geometry_metadata_atomic[g_base + 4u], MINUS_INF);
+        atomicStore(&geometry_metadata_atomic[g_base + 5u], MINUS_INF);
+    }
+}
+`);
+
+/**
+ * Compute shader that resets per-meshlet `bounds_box` (clone meshlets
+ * only) and per-clone-geometry `bounding_box` to ±inf sentinels —
+ * the prerequisite for the reduce / merge passes that follow.
+ *
+ * Linear-thread dispatch: one thread per (binding, meshlet) pair in
+ * the skinning context's `dispatch_lookup`. With workgroup size 64,
+ * `ceil(total_pair_count / 64)` workgroups cover everything; the
+ * `settings.dispatch_offset` immediate lets the host paginate when
+ * `total_pair_count > maxComputeWorkgroupsPerDimension * 64`
+ * (currently won't trigger — 65535 * 64 ≈ 4M pairs).
+ *
+ * The geometry bounds reset is gated to `meshlet_local == 0` so each
+ * clone geometry is reset exactly once. The clone's bounding_sphere
+ * is NOT reset here — the derive-sphere pass at the end of the
+ * refresh chain overwrites it wholesale from the box, so no
+ * transient state matters.
+ */
+export const shader_meshlet_bounds_scatter = ComputeShader.from({
+    label: "Skinning/MeshletBoundsScatter",
+    resources,
+    body,
+});

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

@@ -1 +1 @@
-{"version":3,"file":"shader_skinned_mesh_bounds_refresh.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_skinned_mesh_bounds_refresh.js"],"names":[],"mappings":"AAWA,gCAAiC;AAuCjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,+DAIG;8BAnE2B,kCAAkC"}
+{"version":3,"file":"shader_skinned_mesh_bounds_refresh.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_skinned_mesh_bounds_refresh.js"],"names":[],"mappings":"AAWA,gCAAiC;AAyCjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,+DAIG;8BArE2B,kCAAkC"}

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

@@ -1,75 +1,77 @@
-import { 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 {
-    chunk_update_object_property_mesh_instance_bounds
-} from "../../../object_property/chunk_update_object_property_mesh_instance_bounds.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 resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    // Number of active skinning bindings (= one per skinned mesh
-    // instance). Threads past `binding_count` early-out.
-    .addUniform('binding_count', u32)
-    .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
-    // `chunk_update_object_property_mesh_instance_bounds` expects
-    // these binding names — see its docstring's importing-shader
-    // contract. scene_database is rw because the mesh bounds writes
-    // route through `scene_write_mesh_*` per-field helpers, which
-    // need the read_write access mode.
-    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
-    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@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];
-
-    // Per-instance world-space bounds: reads geometry.bounding_box
-    // (just refreshed by the per-meshlet reduce pass) and
-    // geometry.bounding_sphere (just refreshed by the sphere-derive
-    // pass), projects through the mesh's node.global, writes back
-    // to mesh.bounding_box / bounding_sphere. Reuses the existing
-    // chunk so the math (max-column-length sphere radius scaling for
-    // non-uniform-scale-safe culling) stays in one place.
-    update_object_property_mesh_instance_bounds(binding.mesh_instance_index);
-}
-`, [chunk_update_object_property_mesh_instance_bounds]);
-
-/**
- * Compute shader that refreshes the world-space `bounding_box` and
- * `bounding_sphere` of every SkinnedMesh instance in the scene's
- * meshes table from its (now up-to-date) clone geometry bounds.
- *
- * One thread per active skinning binding. Each thread:
- *  - Looks up its binding's `mesh_instance_index` in the meshes table.
- *  - Reads `geometry.bounding_box` + `geometry.bounding_sphere` from
- *    the geometry metadata table (post-reduce + post-sphere-derive).
- *  - Reads `node.global` for the mesh's world transform.
- *  - Projects the local AABB / sphere into world space.
- *  - Writes back to `mesh.bounding_box` / `mesh.bounding_sphere`.
- *
- * Must run AFTER `shader_geometry_sphere_derive` (which writes the
- * geometry sphere this pass reads) and AFTER the transform-hierarchy
- * propagate pass (which writes `node.global`). Without the mesh
- * bounds refreshed, the rasterizer's sphere-cull and frustum-cull
- * passes reject animated meshes that move outside their original
- * source-encoded bounds.
- */
-export const shader_skinned_mesh_bounds_refresh = ComputeShader.from({
-    label: "Skinning/SkinnedMeshBoundsRefresh",
-    resources,
-    body,
-});
+import { 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 {
+    chunk_update_object_property_mesh_instance_bounds
+} from "../../../object_property/chunk_update_object_property_mesh_instance_bounds.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 resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("binding_count", u32);
+resources.createGroup()
+    // Number of active skinning bindings (= one per skinned mesh
+    // instance). Threads past `binding_count` early-out.
+    .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
+    // `chunk_update_object_property_mesh_instance_bounds` expects
+    // these binding names — see its docstring's importing-shader
+    // contract. scene_database is rw because the mesh bounds writes
+    // route through `scene_write_mesh_*` per-field helpers, which
+    // need the read_write access mode.
+    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
+    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@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];
+
+    // Per-instance world-space bounds: reads geometry.bounding_box
+    // (just refreshed by the per-meshlet reduce pass) and
+    // geometry.bounding_sphere (just refreshed by the sphere-derive
+    // pass), projects through the mesh's node.global, writes back
+    // to mesh.bounding_box / bounding_sphere. Reuses the existing
+    // chunk so the math (max-column-length sphere radius scaling for
+    // non-uniform-scale-safe culling) stays in one place.
+    update_object_property_mesh_instance_bounds(binding.mesh_instance_index);
+}
+`, [chunk_update_object_property_mesh_instance_bounds]);
+
+/**
+ * Compute shader that refreshes the world-space `bounding_box` and
+ * `bounding_sphere` of every SkinnedMesh instance in the scene's
+ * meshes table from its (now up-to-date) clone geometry bounds.
+ *
+ * One thread per active skinning binding. Each thread:
+ *  - Looks up its binding's `mesh_instance_index` in the meshes table.
+ *  - Reads `geometry.bounding_box` + `geometry.bounding_sphere` from
+ *    the geometry metadata table (post-reduce + post-sphere-derive).
+ *  - Reads `node.global` for the mesh's world transform.
+ *  - Projects the local AABB / sphere into world space.
+ *  - Writes back to `mesh.bounding_box` / `mesh.bounding_sphere`.
+ *
+ * Must run AFTER `shader_geometry_sphere_derive` (which writes the
+ * geometry sphere this pass reads) and AFTER the transform-hierarchy
+ * propagate pass (which writes `node.global`). Without the mesh
+ * bounds refreshed, the rasterizer's sphere-cull and frustum-cull
+ * passes reject animated meshes that move outside their original
+ * source-encoded bounds.
+ */
+export const shader_skinned_mesh_bounds_refresh = ComputeShader.from({
+    label: "Skinning/SkinnedMeshBoundsRefresh",
+    resources,
+    body,
+});

package/src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_apply_skinning.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.js"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,yCAA0C;AA6S1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0DAIG;8BAlV2B,+BAA+B"}
+{"version":3,"file":"shader_meshlet_apply_skinning.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.js"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,yCAA0C;AAiT1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0DAIG;8BAtV2B,+BAA+B"}