@woosh/meep-engine 3.23.0 → 3.24.0

package/src/shade/renderer/animation/pose/pose_evaluate_local.js

@@ -36,18 +36,20 @@ const DIRTY_SZ = 64;
  * the thing to fix. `pose_evaluator_lockstep.spec.js` fails when the WGSL moves, so that the pair
  * cannot drift silently.
  *
- * The node's own `transform_local` supplies the rest pose. That is sound because the CPU never
- * writes a GPU-authoritative row (`TransformAuthority`), so what the node holds is what was
- * authored, and undirty axes on the GPU hold the same value for the same reason.
+ * `rest` supplies the rest pose: the node's or the entity's authored local offset. That is sound
+ * because the CPU never writes a GPU-authoritative row, so what the authored offset holds is what
+ * the row started from, and undirty axes on the GPU hold the same value for the same reason.
  *
  * @param {Transform64} result written with the evaluated local TRS; its matrix is left stale
- * @param {Node3D} node
+ * @param {Node3D|number} target what the channels name — a node, or an entity
+ * @param {Transform64} rest the target's authored local pose
  * @param {PosePlayback[]} playbacks
  * @returns {Transform64} `result`
  */
-export function pose_evaluate_local(result, node, playbacks) {
+export function pose_evaluate_local(result, target, rest, playbacks) {
     assert.defined(result, 'result');
-    assert.defined(node, 'node');
+    assert.defined(target, 'target');
+    assert.defined(rest, 'rest');
     assert.isArray(playbacks, 'playbacks');
 
     SUM_TRANSLATION[0] = 0;
@@ -74,7 +76,7 @@ export function pose_evaluate_local(result, node, playbacks) {
         for (let c = 0; c < channels.length; c++) {
             const channel = channels[c];
 
-            if (channel.target !== node) {
+            if (channel.target !== target) {
                 continue;
             }
 
@@ -137,8 +139,6 @@ export function pose_evaluate_local(result, node, playbacks) {
         }
     }
 
-    const rest = node.transform_local;
-
     result.setTranslation(
         (dirty & DIRTY_TX) !== 0 ? SUM_TRANSLATION[0] : rest.translation_x,
         (dirty & DIRTY_TY) !== 0 ? SUM_TRANSLATION[1] : rest.translation_y,

package/src/shade/renderer/animation/skin_clip_scale_conflicts.d.ts

@@ -1,64 +1,10 @@
 /**
- * The channels of a clip that would scale this skin's joints out from under the frame it is
- * deformed in.
+ * The channels of a clip that scale something: scale channels whose curves leave one anywhere
+ * along their length, not only at their keys.
  *
- * ## Why this is worth asking
- *
- * {@link skin_normalize_mesh_frame} makes `inverse(mesh.global) × joint.global × inverse_bind`
- * rigid, and rigid is what a dual quaternion can carry. It does that with a **constant** correction,
- * which is sound because the frame and the joints share their ancestors and a placement multiplies
- * both on the left. A clip that scales a joint breaks that: the scale enters `joint.global` and not
- * the frame, the fold stops being rigid, and no choice of frame fixes it —
- * `SKINNING_FRAME_PLAN.md` §4 is the ladder out and neither of its rungs is built.
- *
- * The failure is per-frame and on the GPU, where nothing can see it. This is the same question asked
- * **statically**, off the clip's own curves, at registration: exact, cheap, and it needs no device.
- *
- * ## What counts
- *
- * Not "the channel targets a joint" — that understates it. What matters is whether the scale is
- * *shared* between the frame and the joints, and a scale is shared exactly when the node carrying it
- * is an ancestor of the mesh **and** of every joint. So:
- *
- * - a scale on the character's own root reaches the mesh and all the joints, cancels out of the
- *   fold, and is fine — this is how a model is made to grow;
- * - a scale on a joint, or on any node above only *some* of them, reaches the joints and not the
- *   mesh, and is a conflict;
- * - a scale on a node that reaches neither is somebody else's business.
- *
- * A channel whose curves are all the constant 1 is not a scale at all, whatever it targets. The
- * range is taken with {@link animation_curve_compute_aabb}, which follows the Hermite spline between
- * keys rather than only reading the keys — a curve that leaves 1 and returns to it is a scale.
- *
- * @param {Skin} skin
- * @param {ShadeAnimationClip} clip
- * @returns {Array<{
- *     channel: ShadeAnimationChannel,
- *     node: Node3D,
- *     uniform: boolean,
- *     joints_reached: number,
- *     reaches_mesh: boolean,
- * }>} one entry per conflicting channel, empty when the clip and the skin can coexist. `uniform`
- *     says which rung of §4's ladder would be needed: a uniform scale is one a dual quaternion could
- *     be taught to carry alongside, a non-uniform one is not. It is `true` only when all three
- *     components are animated by equal curves, so a channel that is uniform by coincidence of the
- *     node's own scale reads as non-uniform — the safe direction for a report
- */
-export function skin_clip_scale_conflicts(skin: Skin, clip: ShadeAnimationClip): Array<{
-    channel: ShadeAnimationChannel;
-    node: Node3D;
-    uniform: boolean;
-    joints_reached: number;
-    reaches_mesh: boolean;
-}>;
-/**
- * The channels of a clip that scale something, anywhere — before any question of *whose* joints.
- *
- * Separated out because it is the cheap half and almost always the whole answer. A character's clips
- * rotate and translate; a clip with no scale channel at all can be dismissed in one pass over its
- * channel list, which is what keeps the per-`(skin, clip)` pair check from costing anything at a
- * few hundred dancers. {@link GPUAnimationManager} asks this first and only remembers a clip that
- * says yes.
+ * Whether such a scale is a *problem* for a skin — whether it reaches the skin's joints without
+ * reaching its mesh, so the fold the skinning pass performs stops being rigid — is asked of the
+ * model's hierarchy by `prefab_skin_clip_scale_conflicts`, once per model at compile.
  *
  * @param {ShadeAnimationClip} clip
  * @returns {ShadeAnimationChannel[]}

package/src/shade/renderer/animation/skin_clip_scale_conflicts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skin_clip_scale_conflicts.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/skin_clip_scale_conflicts.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,iFAZa,MAAM;IAClB,OAAa,wBAAwB;IACrC,IAAU,SAAS;IACnB,OAAa,EAAE,OAAO,CAAC;IACvB,cAAoB,EAAE,MAAM,CAAC;IAC7B,YAAkB,EAAE,OAAO,CAAC;CACzB,CAAC,CAqDJ;AAED;;;;;;;;;;;GAWG;AACH,+DAFa,uBAAuB,CAuBnC"}
+{"version":3,"file":"skin_clip_scale_conflicts.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/skin_clip_scale_conflicts.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;GAUG;AACH,+DAFa,uBAAuB,CAuBnC"}

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

@@ -6,126 +6,23 @@ import {
 import { Node3DProperty } from "../object_property/Node3DProperty.js";
 
 /**
- * How far from 1 a scale curve may run and still count as not scaling.
- *
- * The same order as the `IDENTITY_EPSILON` {@link ShadeAnimationChannel#optimize} drops an identity
- * channel by, and for the same reason: a scale curve authored as the constant 1 arrives with f32
- * round-trip noise on it and is not a scale. Anything a person authored is orders above this.
+ * How far from one a scale curve may stray and still be no scale at all. Exporters write a scale
+ * channel on every joint whether or not anything scales, and those sit at one to the precision of
+ * the file.
  *
  * @type {number}
  */
 const UNIT_EPSILON = 1e-5;
 
-/**
- * Scratch for one curve's value range. Nothing here re-enters.
- *
- * @type {AABB2}
- */
 const _bounds = new AABB2();
 
 /**
- * The channels of a clip that would scale this skin's joints out from under the frame it is
- * deformed in.
- *
- * ## Why this is worth asking
- *
- * {@link skin_normalize_mesh_frame} makes `inverse(mesh.global) × joint.global × inverse_bind`
- * rigid, and rigid is what a dual quaternion can carry. It does that with a **constant** correction,
- * which is sound because the frame and the joints share their ancestors and a placement multiplies
- * both on the left. A clip that scales a joint breaks that: the scale enters `joint.global` and not
- * the frame, the fold stops being rigid, and no choice of frame fixes it —
- * `SKINNING_FRAME_PLAN.md` §4 is the ladder out and neither of its rungs is built.
- *
- * The failure is per-frame and on the GPU, where nothing can see it. This is the same question asked
- * **statically**, off the clip's own curves, at registration: exact, cheap, and it needs no device.
- *
- * ## What counts
- *
- * Not "the channel targets a joint" — that understates it. What matters is whether the scale is
- * *shared* between the frame and the joints, and a scale is shared exactly when the node carrying it
- * is an ancestor of the mesh **and** of every joint. So:
- *
- * - a scale on the character's own root reaches the mesh and all the joints, cancels out of the
- *   fold, and is fine — this is how a model is made to grow;
- * - a scale on a joint, or on any node above only *some* of them, reaches the joints and not the
- *   mesh, and is a conflict;
- * - a scale on a node that reaches neither is somebody else's business.
- *
- * A channel whose curves are all the constant 1 is not a scale at all, whatever it targets. The
- * range is taken with {@link animation_curve_compute_aabb}, which follows the Hermite spline between
- * keys rather than only reading the keys — a curve that leaves 1 and returns to it is a scale.
- *
- * @param {Skin} skin
- * @param {ShadeAnimationClip} clip
- * @returns {Array<{
- *     channel: ShadeAnimationChannel,
- *     node: Node3D,
- *     uniform: boolean,
- *     joints_reached: number,
- *     reaches_mesh: boolean,
- * }>} one entry per conflicting channel, empty when the clip and the skin can coexist. `uniform`
- *     says which rung of §4's ladder would be needed: a uniform scale is one a dual quaternion could
- *     be taught to carry alongside, a non-uniform one is not. It is `true` only when all three
- *     components are animated by equal curves, so a channel that is uniform by coincidence of the
- *     node's own scale reads as non-uniform — the safe direction for a report
- */
-export function skin_clip_scale_conflicts(skin, clip) {
-    assert.defined(skin, 'skin');
-    assert.equal(skin.isSkin, true, 'skin.isSkin !== true');
-    assert.defined(clip, 'clip');
-
-    const scaling = clip_scale_channels(clip);
-
-    const conflicts = [];
-
-    if (scaling.length === 0) {
-        return conflicts;
-    }
-
-    const joints = new Set(skin.joints);
-    const meshes = new Set(skin.meshes);
-
-    for (const channel of scaling) {
-        let joints_reached = 0;
-        let meshes_reached = 0;
-
-        channel.target.traverse(node => {
-            if (joints.has(node)) {
-                joints_reached++;
-            }
-
-            if (meshes.has(node)) {
-                meshes_reached++;
-            }
-        });
-
-        const reaches_everything = joints_reached === joints.size && meshes_reached === meshes.size;
-        const reaches_nothing = joints_reached === 0 && meshes_reached === 0;
-
-        if (reaches_everything || reaches_nothing) {
-            continue;
-        }
-
-        conflicts.push({
-            channel,
-            node: channel.target,
-            uniform: is_uniform(channel),
-            joints_reached,
-            reaches_mesh: meshes_reached > 0,
-        });
-    }
-
-    return conflicts;
-}
-
-/**
- * The channels of a clip that scale something, anywhere — before any question of *whose* joints.
+ * The channels of a clip that scale something: scale channels whose curves leave one anywhere
+ * along their length, not only at their keys.
  *
- * Separated out because it is the cheap half and almost always the whole answer. A character's clips
- * rotate and translate; a clip with no scale channel at all can be dismissed in one pass over its
- * channel list, which is what keeps the per-`(skin, clip)` pair check from costing anything at a
- * few hundred dancers. {@link GPUAnimationManager} asks this first and only remembers a clip that
- * says yes.
+ * Whether such a scale is a *problem* for a skin — whether it reaches the skin's joints without
+ * reaching its mesh, so the fold the skinning pass performs stops being rigid — is asked of the
+ * model's hierarchy by `prefab_skin_clip_scale_conflicts`, once per model at compile.
  *
  * @param {ShadeAnimationClip} clip
  * @returns {ShadeAnimationChannel[]}
@@ -154,8 +51,6 @@ export function clip_scale_channels(clip) {
 }
 
 /**
- * Whether a scale channel moves anything — false when every component it animates stays at 1.
- *
  * @param {ShadeAnimationChannel} channel
  * @returns {boolean}
  */
@@ -178,22 +73,3 @@ function scales(channel) {
 
     return false;
 }
-
-/**
- * Whether a scale channel drives all three axes by the same curve — the shape
- * {@link Node3DProperty.Scale} names as how a uniform pulsate is authored.
- *
- * @param {ShadeAnimationChannel} channel
- * @returns {boolean}
- */
-function is_uniform(channel) {
-    const { x, y, z } = channel.curves;
-
-    if (x === undefined || y === undefined || z === undefined) {
-        // an axis left unanimated keeps whatever the node's own scale holds while the others move,
-        // which is a non-uniform scale however uniform the curves that are there
-        return false;
-    }
-
-    return (x === y || x.equals(y)) && (x === z || x.equals(z));
-}

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.d.ts

@@ -2,16 +2,21 @@
  * Per-scene container for the skinning subsystem's state. Owned by
  * {@link GPUSceneContext}; receives the scene's
  * {@link GPUGeometryManager} so it can allocate per-instance geometry
- * clones for {@link SkinnedMesh} instances and route the skinning
- * compute pass against those clones.
+ * clones for skinned entities and route the skinning compute pass
+ * against those clones.
+ *
+ * **Everything here is addressed by entity.** A skinned entity is one whose mesh row draws a
+ * per-instance clone of its geometry, and its mesh row is `entity + 1` — the same row its
+ * transform holds — so a binding never has to be told where its mesh went.
  *
  * Three responsibilities:
- *  1. Geometry-clone routing — `obtain_geometry_index(mesh)` returns
- *     the clone id for SkinnedMesh, the source id for everyone else.
- *  2. Skinning binding bookkeeping — each SkinnedMesh with a `skin_id`
+ *  1. Geometry clones — {@link obtain_clone} makes an entity's per-instance copy of its source
+ *     geometry when its mesh row is written, and {@link release_clone} gives it back when the
+ *     row goes.
+ *  2. Skinning binding bookkeeping — each entity bound to a `skin_id`
  *     produces one binding record linking its clone's vertex region
  *     back to the source's data and to the skin's matrix range.
- *  3. Per-frame dispatch — `update(cmd_ctx, animation_manager)`
+ *  3. Per-frame dispatch — `update(cmd_ctx)`
  *     uploads any new bindings and dispatches the skinning compute
  *     pass that deforms the cloned vertex regions in place.
  *
@@ -70,49 +75,47 @@ export class GPUMeshSkinningContext {
      */
     get prev_position_offsets_buffer(): any;
     /**
-     * Geometry id to assign to this mesh's instance record. Idempotent.
-     *
-     * - For a {@link SkinnedMesh}: a per-instance clone of the source's
-     *   GPU geometry. The first time we see a given mesh, allocate a
-     *   clone; subsequent calls return the cached id. If the mesh has
-     *   already been bound to a skin via {@link bind}, the binding's
-     *   registration also runs here so scene.build's first sight of
-     *   a pre-bound mesh doesn't strand it without a deformation pass.
-     * - For a regular {@link Mesh}: the source's id from the geometry
-     *   manager.
-     *
-     * @param {Mesh} mesh
-     * @returns {number}
+     * The per-instance clone of `geometry` an entity's mesh row draws. Made on the first call and
+     * returned on every later one. If the entity has already been bound to a skin via
+     * {@link bind}, the binding is registered here too, so a row written after its skin arrived
+     * is not stranded without a deformation pass.
+     *
+     * Called by the scene rows when a skinned entity's mesh row is written — the geometry index
+     * the row carries is the clone's.
+     *
+     * @param {number} entity
+     * @param {MeshletGeometry} geometry the source
+     * @returns {GPUGeometryMetadata} the clone's record
      */
-    obtain_geometry_index(mesh: Mesh): number;
+    obtain_clone(entity: number, geometry: MeshletGeometry): GPUGeometryMetadata;
     /**
-     * Bind a {@link SkinnedMesh} to a skin. The mesh's clone (if not
-     * already allocated) is created on demand; a skinning-pass
-     * binding record is registered so the deformation runs each
-     * frame. The skin id is stored on the context (not on the mesh
-     * — `SkinnedMesh` carries no GPU state).
+     * The clone an entity's mesh row draws, if it has one.
      *
-     * Re-binding the same mesh with a different skin id is rejected
-     * (single-binding model in this MVP — use {@link unbind} first if
-     * you need to swap). Calling with the same skin id is a no-op.
+     * @param {number} entity
+     * @returns {GPUGeometryMetadata|undefined}
+     */
+    clone_of(entity: number): GPUGeometryMetadata | undefined;
+    /**
+     * Bind an entity's mesh to a skin: a skinning-pass binding record is registered so the
+     * deformation runs each frame, as soon as the entity has a clone to deform — which it has
+     * once its mesh row is written, before or after this call.
      *
-     * Tolerates being called before `scene.build` registers the mesh;
-     * the binding upload happens during the next per-frame
-     * {@link update}.
+     * Re-binding the same entity with a different skin id is rejected (one skin per mesh — use
+     * {@link unbind} first to swap). Calling with the same skin id is a no-op.
      *
-     * @param {SkinnedMesh} mesh
+     * @param {number} entity
      * @param {number} skin_id
      */
-    bind(mesh: SkinnedMesh, skin_id: number): void;
+    bind(entity: number, skin_id: number): void;
     /**
      * Skin id currently bound to this mesh, or `undefined` if the
      * mesh hasn't been bound. Read-only accessor — bookkeeping lives
      * here, not on the mesh.
      *
-     * @param {SkinnedMesh} mesh
+     * @param {number} entity
      * @returns {number|undefined}
      */
-    get_skin_id(mesh: SkinnedMesh): number | undefined;
+    get_skin_id(entity: number): number | undefined;
     /**
      * Drop the binding for a single mesh. The mesh's geometry clone
      * stays allocated (deallocation needs compaction work the MVP
@@ -122,9 +125,9 @@ export class GPUMeshSkinningContext {
      *
      * No-op if the mesh isn't bound.
      *
-     * @param {SkinnedMesh} mesh
+     * @param {number} entity
      */
-    unbind(mesh: SkinnedMesh): void;
+    unbind(entity: number): void;
     /**
      * Drop every binding that points at the given skin id. Called
      * by {@link GPUAnimationManager#unregister_skin} so freeing the
@@ -136,38 +139,36 @@ export class GPUMeshSkinningContext {
      */
     unbind_all_by_skin(skin_id: number): void;
     /**
-     * Give back everything a {@link SkinnedMesh} was holding on the GPU: its binding, its
+     * Give back everything a skinned entity was holding on the GPU: its binding, its
      * prev-position slice, and the per-instance geometry clone it rendered.
      *
-     * **Called when the mesh leaves the scene, not when it unbinds.** A clone is named by the
-     * meshes-table row of the instance that renders it, so it lives exactly as long as that
-     * row does — {@link GPUSceneContext} calls this from the same place it gives the row
-     * back. Unbinding is a different event: an unbound mesh keeps rendering its clone frozen
-     * at the last pose the skinning pass wrote, and freeing there would hand a live renderer
-     * a vertex region that has since gone to somebody else.
+     * **Called when the entity's mesh row goes, not when it unbinds.** A clone lives exactly as
+     * long as the row that draws it — the scene rows call this from the same place they give
+     * the row back. Unbinding is a different event: an unbound mesh keeps rendering its clone
+     * frozen at the last pose the skinning pass wrote, and freeing there would hand a live
+     * renderer a vertex region that has since gone to somebody else.
      *
      * The binding record goes first, and for its own reason: it names the clone's meshlet
      * rows, and the skinning pass would deform whatever took their place.
      *
-     * **Which skin the mesh belongs to is not forgotten.** A mesh may leave the scene and
-     * come back — the row it gets is not even the row it had — and the engine's answer to
-     * that is {@link #try_register_binding}, which rebuilds the binding from
-     * {@link #skin_id_by_mesh} the next time `scene.build` asks for the mesh's geometry id.
-     * Releasing through {@link unbind} would drop that association too and hand the returning
-     * mesh back undeformed. Forgetting the skin is what {@link unbind} is for, and it is a
-     * different thing to want.
+     * **Which skin the entity belongs to is not forgotten.** A mesh row may go and come back,
+     * and the engine's answer to that is {@link #try_register_binding}, which rebuilds the
+     * binding from {@link #skin_by_entity} when the new clone is made. Releasing through
+     * {@link unbind} would drop that association too and hand the returning mesh back
+     * undeformed. Forgetting the skin is what {@link unbind} is for, and it is a different
+     * thing to want.
      *
-     * The mesh does pay for a fresh clone on its way back in: a new vertex region, its copy
-     * from source, and a new tree. That is the right trade while nothing removes a mesh from
-     * the scene except an entity that is actually leaving — culling and LOD never do — and it
-     * is what a clone cache keyed by source geometry would take away if that ever changes.
+     * The entity does pay for a fresh clone on its way back in: a new vertex region, its copy
+     * from source, and a new tree. That is the right trade while nothing takes a mesh row away
+     * except an entity that is actually leaving — culling and LOD never do — and it is what a
+     * clone cache keyed by source geometry would take away if that ever changes.
      *
-     * No-op for a mesh that has no clone — a {@link SkinnedMesh} that never reached
-     * `scene.build` or was released already.
+     * No-op for an entity that has no clone — one whose mesh row was never written, or was
+     * released already.
      *
-     * @param {SkinnedMesh} mesh
+     * @param {number} entity
      */
-    release_clone(mesh: SkinnedMesh): void;
+    release_clone(entity: number): void;
     /**
      * Per-frame: upload any new bindings + dispatch the skinning
      * compute pass that deforms cloned vertex regions in place.
@@ -183,15 +184,17 @@ export class GPUMeshSkinningContext {
      * `skin_matrix_offset` for the binding records.
      *
      * @param {ShadeGPUCommandContext} cmd_ctx
+     * @returns {boolean} whether a skinning pass ran — whether any bound row's vertices, and so
+     * its bounds, moved this frame
      */
-    update(cmd_ctx: ShadeGPUCommandContext): void;
+    update(cmd_ctx: ShadeGPUCommandContext): boolean;
     destroy(): void;
     #private;
 }
 export type ShadeGPUCommandContext = import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
 export type GPUGeometryManager = import("../../geometry/GPUGeometryManager.js").GPUGeometryManager;
 export type GPUSceneContext = import("../../scene/GPUSceneContext.js").GPUSceneContext;
-export type Mesh = import("../../scene/Mesh.js").Mesh;
-export type SkinnedMesh = import("../../scene/SkinnedMesh.js").SkinnedMesh;
+export type MeshletGeometry = import("../../geometry/MeshletGeometry.js").MeshletGeometry;
+export type GPUGeometryMetadata = import("../../geometry/GPUGeometryMetadata.js").GPUGeometryMetadata;
 export type GPUAnimationManager = import("../GPUAnimationManager.js").GPUAnimationManager;
 //# sourceMappingURL=GPUMeshSkinningContext.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAkFA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA0OI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,4BAHW,IAAI,GACF,MAAM,CAelB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,WAHW,WAAW,WACX,MAAM,QAmBhB;IAED;;;;;;;OAOG;IACH,kBAHW,WAAW,GACT,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,aAFW,WAAW,QAYrB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA0FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,oBAFW,WAAW,QAqBrB;IAyCD;;;;;;;;;;;;;;;OAeG;IACH,gBAFW,sBAAsB,QA2NhC;IA4SD,gBAkBC;;CACJ;qCA7sCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;mBACxD,OAAO,qBAAqB,EAAE,IAAI;0BAClC,OAAO,4BAA4B,EAAE,WAAW;kCAChD,OAAO,2BAA2B,EAAE,mBAAmB"}
+{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAyMI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA0FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CAuNnB;IAkSD,gBAkBC;;CACJ;qCA9pCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}