@woosh/meep-engine 3.39.0 → 3.41.0

package/src/engine/ecs/transform/T64WorldCache.js

@@ -1,139 +1,139 @@
-import { assert } from "../../../core/assert.js";
-import { pose_evaluate_local } from "../../../shade/renderer/animation/pose/pose_evaluate_local.js";
-import { TransformAttachment } from "../transform-attachment/TransformAttachment.js";
-import { Transform64 } from "./Transform64.js";
-
-/**
- * @typedef {import("../EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
- * @typedef {import("../../../shade/renderer/animation/pose/PosePlayback.js").PosePlayback} PosePlayback
- */
-
-/**
- * {@link t64_evaluate_world}, memoised per entity for the length of a tick.
- *
- * An exact evaluation walks the chain to the root and evaluates every level's clips; a socket on a
- * hand is fourteen levels deep on a character, and the sockets a game asks about share most of
- * that chain. Within a tick the inputs — the hierarchy, the clip set, the times, the weights — do
- * not move, so each entity's world is evaluated once and every query below it composes onto the
- * stored answer. Measured on a 70-joint skeleton with two clips: 764 µs to evaluate every joint
- * one query at a time, 160 µs through the cache.
- *
- * **One cache per tick, per model.** The answer for an entity depends on the playbacks it was
- * evaluated under, and the cache does not check them: a caller that changes what a model plays
- * between queries calls {@link invalidate} in between, and calls it once per tick regardless.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class T64WorldCache {
-    /**
-     * Evaluated worlds by entity, valid until {@link invalidate}.
-     *
-     * @type {Map<number, Transform64>}
-     */
-    #worlds = new Map();
-
-    /**
-     * Transforms handed back by {@link invalidate}, for the next tick's entries.
-     *
-     * @type {Transform64[]}
-     */
-    #pool = [];
-
-    /**
-     * Scratch for one level's animated local pose.
-     *
-     * @type {Transform64}
-     */
-    #local = new Transform64();
-
-    /**
-     * How many entities hold an evaluated world right now.
-     *
-     * @returns {number}
-     */
-    get size() {
-        return this.#worlds.size;
-    }
-
-    /**
-     * Forget every evaluated world. Once per tick, and again whenever a model's playbacks change
-     * within one.
-     */
-    invalidate() {
-        const pool = this.#pool;
-
-        for (const world of this.#worlds.values()) {
-            pool.push(world);
-        }
-
-        this.#worlds.clear();
-    }
-
-    /**
-     * The entity's world pose under the playbacks, exactly — the same answer as
-     * {@link t64_evaluate_world}, from the cache where it has it.
-     *
-     * @param {Transform64} result
-     * @param {EntityComponentDataset} dataset
-     * @param {number} entity
-     * @param {PosePlayback[]} playbacks
-     * @returns {Transform64} `result`
-     */
-    evaluate(result, dataset, entity, playbacks) {
-        assert.defined(result, 'result');
-        assert.defined(dataset, 'dataset');
-        assert.isNonNegativeInteger(entity, 'entity');
-        assert.isArray(playbacks, 'playbacks');
-
-        result.copy(this.#world_of(dataset, entity, playbacks));
-
-        return result;
-    }
-
-    /**
-     * @param {EntityComponentDataset} dataset
-     * @param {number} entity
-     * @param {PosePlayback[]} playbacks
-     * @returns {Transform64} the cache's own copy; not to be kept
-     */
-    #world_of(dataset, entity, playbacks) {
-        const cached = this.#worlds.get(entity);
-
-        if (cached !== undefined) {
-            return cached;
-        }
-
-        assert.ok(dataset.entityExists(entity), `entity ${entity} does not exist`);
-
-        const attachment = dataset.getComponent(entity, TransformAttachment);
-
-        const world = this.#pool.pop() ?? new Transform64();
-        const local = this.#local;
-
-        if (attachment === undefined || attachment === null || !dataset.entityExists(attachment.parent)) {
-            // the root of the chain, whose world pose is its own; a link whose parent has gone is
-            // a root until the attachment system detaches it, and answers from where it was
-            const rest = dataset.getComponent(entity, Transform64);
-
-            assert.defined(rest, `entity ${entity} carries no Transform64 and no attachment`);
-
-            pose_evaluate_local(local, entity, rest, playbacks);
-            local.updateMatrix();
-
-            world.copy(local);
-        } else {
-            // the parent first, so its answer is in the cache before this level's scratch is used
-            const parent = this.#world_of(dataset, attachment.parent, playbacks);
-
-            pose_evaluate_local(local, entity, attachment.transform, playbacks);
-            local.updateMatrix();
-
-            world.multiplyTransforms(parent, local);
-        }
-
-        this.#worlds.set(entity, world);
-
-        return world;
-    }
-}
+import { assert } from "../../../core/assert.js";
+import { TransformAttachment } from "../transform-attachment/TransformAttachment.js";
+import { t64_evaluate_local } from "./t64_evaluate_local.js";
+import { Transform64 } from "./Transform64.js";
+
+/**
+ * @typedef {import("../EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
+ * @typedef {import("../../../shade/renderer/animation/pose/PosePlayback.js").PosePlayback} PosePlayback
+ */
+
+/**
+ * {@link t64_evaluate_world}, memoised per entity for the length of a tick.
+ *
+ * An exact evaluation walks the chain to the root and evaluates every level's clips; a socket on a
+ * hand is fourteen levels deep on a character, and the sockets a game asks about share most of
+ * that chain. Within a tick the inputs — the hierarchy, the clip set, the times, the weights — do
+ * not move, so each entity's world is evaluated once and every query below it composes onto the
+ * stored answer. Measured on a 70-joint skeleton with two clips: 764 µs to evaluate every joint
+ * one query at a time, 160 µs through the cache.
+ *
+ * **One cache per tick, per model.** The answer for an entity depends on the playbacks it was
+ * evaluated under, and the cache does not check them: a caller that changes what a model plays
+ * between queries calls {@link invalidate} in between, and calls it once per tick regardless.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class T64WorldCache {
+    /**
+     * Evaluated worlds by entity, valid until {@link invalidate}.
+     *
+     * @type {Map<number, Transform64>}
+     */
+    #worlds = new Map();
+
+    /**
+     * Transforms handed back by {@link invalidate}, for the next tick's entries.
+     *
+     * @type {Transform64[]}
+     */
+    #pool = [];
+
+    /**
+     * Scratch for one level's animated local pose.
+     *
+     * @type {Transform64}
+     */
+    #local = new Transform64();
+
+    /**
+     * How many entities hold an evaluated world right now.
+     *
+     * @returns {number}
+     */
+    get size() {
+        return this.#worlds.size;
+    }
+
+    /**
+     * Forget every evaluated world. Once per tick, and again whenever a model's playbacks change
+     * within one.
+     */
+    invalidate() {
+        const pool = this.#pool;
+
+        for (const world of this.#worlds.values()) {
+            pool.push(world);
+        }
+
+        this.#worlds.clear();
+    }
+
+    /**
+     * The entity's world pose under the playbacks, exactly — the same answer as
+     * {@link t64_evaluate_world}, from the cache where it has it.
+     *
+     * @param {Transform64} result
+     * @param {EntityComponentDataset} dataset
+     * @param {number} entity
+     * @param {PosePlayback[]} playbacks
+     * @returns {Transform64} `result`
+     */
+    evaluate(result, dataset, entity, playbacks) {
+        assert.defined(result, 'result');
+        assert.defined(dataset, 'dataset');
+        assert.isNonNegativeInteger(entity, 'entity');
+        assert.isArray(playbacks, 'playbacks');
+
+        result.copy(this.#world_of(dataset, entity, playbacks));
+
+        return result;
+    }
+
+    /**
+     * @param {EntityComponentDataset} dataset
+     * @param {number} entity
+     * @param {PosePlayback[]} playbacks
+     * @returns {Transform64} the cache's own copy; not to be kept
+     */
+    #world_of(dataset, entity, playbacks) {
+        const cached = this.#worlds.get(entity);
+
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        assert.ok(dataset.entityExists(entity), `entity ${entity} does not exist`);
+
+        const attachment = dataset.getComponent(entity, TransformAttachment);
+
+        const world = this.#pool.pop() ?? new Transform64();
+        const local = this.#local;
+
+        if (attachment === undefined || attachment === null || !dataset.entityExists(attachment.parent)) {
+            // the root of the chain, whose world pose is its own; a link whose parent has gone is
+            // a root until the attachment system detaches it, and answers from where it was
+            const rest = dataset.getComponent(entity, Transform64);
+
+            assert.defined(rest, `entity ${entity} carries no Transform64 and no attachment`);
+
+            t64_evaluate_local(local, dataset, entity, rest, playbacks);
+            local.updateMatrix();
+
+            world.copy(local);
+        } else {
+            // the parent first, so its answer is in the cache before this level's scratch is used
+            const parent = this.#world_of(dataset, attachment.parent, playbacks);
+
+            t64_evaluate_local(local, dataset, entity, attachment.transform, playbacks);
+            local.updateMatrix();
+
+            world.multiplyTransforms(parent, local);
+        }
+
+        this.#worlds.set(entity, world);
+
+        return world;
+    }
+}

package/src/engine/ecs/transform/t64_evaluate_local.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @typedef {import("../EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
+ * @typedef {import("../../../shade/renderer/animation/pose/PosePlayback.js").PosePlayback} PosePlayback
+ */
+/**
+ * One level of an exact evaluation: an entity's local pose under the playing clips
+ * ({@link pose_evaluate_local}), or — where a CPU writer holds its offset (`gpu_authority_hold`) —
+ * the offset itself, whatever the clips say of it.
+ *
+ * That is the GPU's rule, mirrored: the animation manager mutes every binding that names a held
+ * entity, so its row is what the holder wrote and no clip reaches it. A twin that applied the clips
+ * there would put a socket under a cape joint where the clip says the joint is, and the cape where
+ * the cloth says it is.
+ *
+ * @param {Transform64} result written with the local TRS; its matrix is left stale
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ * @param {Transform64} rest the entity's own offset, or a root's world
+ * @param {PosePlayback[]} playbacks
+ * @returns {Transform64} `result`
+ */
+export function t64_evaluate_local(result: Transform64, dataset: EntityComponentDataset, entity: number, rest: Transform64, playbacks: PosePlayback[]): Transform64;
+export type EntityComponentDataset = import("../EntityComponentDataset.js").EntityComponentDataset;
+export type PosePlayback = import("../../../shade/renderer/animation/pose/PosePlayback.js").PosePlayback;
+//# sourceMappingURL=t64_evaluate_local.d.ts.map

package/src/engine/ecs/transform/t64_evaluate_local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"t64_evaluate_local.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/t64_evaluate_local.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,iEANW,sBAAsB,UACtB,MAAM,gCAEN,YAAY,EAAE,eAWxB;qCA7BY,OAAO,8BAA8B,EAAE,sBAAsB;2BAC7D,OAAO,wDAAwD,EAAE,YAAY"}

package/src/engine/ecs/transform/t64_evaluate_local.js

@@ -0,0 +1,35 @@
+import { pose_evaluate_local } from "../../../shade/renderer/animation/pose/pose_evaluate_local.js";
+import { GPUStateAuthorityFlags } from "../gpu/GPUStateAuthorityFlags.js";
+import { gpu_authority_held } from "../gpu/gpu_authority_held.js";
+
+/**
+ * @typedef {import("../EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
+ * @typedef {import("../../../shade/renderer/animation/pose/PosePlayback.js").PosePlayback} PosePlayback
+ */
+
+/**
+ * One level of an exact evaluation: an entity's local pose under the playing clips
+ * ({@link pose_evaluate_local}), or — where a CPU writer holds its offset (`gpu_authority_hold`) —
+ * the offset itself, whatever the clips say of it.
+ *
+ * That is the GPU's rule, mirrored: the animation manager mutes every binding that names a held
+ * entity, so its row is what the holder wrote and no clip reaches it. A twin that applied the clips
+ * there would put a socket under a cape joint where the clip says the joint is, and the cape where
+ * the cloth says it is.
+ *
+ * @param {Transform64} result written with the local TRS; its matrix is left stale
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ * @param {Transform64} rest the entity's own offset, or a root's world
+ * @param {PosePlayback[]} playbacks
+ * @returns {Transform64} `result`
+ */
+export function t64_evaluate_local(result, dataset, entity, rest, playbacks) {
+    if (gpu_authority_held(dataset, entity, GPUStateAuthorityFlags.TransformAttachment)) {
+        result.copy(rest);
+
+        return result;
+    }
+
+    return pose_evaluate_local(result, entity, rest, playbacks);
+}

package/src/engine/ecs/transform/t64_evaluate_world.d.ts

@@ -12,10 +12,12 @@
  *
  * An entity the GPU owns the transform of — see `GPUStateAuthority` — is answered the same way;
  * that is the point. A row the GPU composes and a chain this evaluates agree to float precision.
+ * So does a level a CPU writer holds (`gpu_authority_hold`): no clip reaches its row on the GPU,
+ * and none reaches it here — it is its offset ({@link t64_evaluate_local}).
  *
- * Each level costs a scan of every channel of every playing clip, so a query is a few
- * microseconds at a character's depth and a whole skeleton one query at a time is most of a
- * millisecond; a caller asking about several entities of one model within a tick goes through
+ * Each level costs a lookup in every playing clip and the curves of the channels that name it in the
+ * audible ones, so a whole skeleton one query at a time re-evaluates every level above each joint
+ * again; a caller asking about several entities of one model within a tick goes through
  * {@link T64WorldCache}, which evaluates each entity once and composes the rest onto it.
  *
  * @param {Transform64} result written with the evaluated world TRS and matrix

package/src/engine/ecs/transform/t64_evaluate_world.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"t64_evaluate_world.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/t64_evaluate_world.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,2CANW,WAAW,WACX,sBAAsB,UACtB,MAAM,aACN,YAAY,EAAE,GACZ,WAAW,CA2DvB;qCAvHY,OAAO,8BAA8B,EAAE,sBAAsB;2BAC7D,OAAO,wDAAwD,EAAE,YAAY;4BAJ9D,kBAAkB"}
+{"version":3,"file":"t64_evaluate_world.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/t64_evaluate_world.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,2CANW,WAAW,WACX,sBAAsB,UACtB,MAAM,aACN,YAAY,EAAE,GACZ,WAAW,CA2DvB;qCAzHY,OAAO,8BAA8B,EAAE,sBAAsB;2BAC7D,OAAO,wDAAwD,EAAE,YAAY;4BAJ9D,kBAAkB"}

package/src/engine/ecs/transform/t64_evaluate_world.js

@@ -1,126 +1,128 @@
-import { assert } from "../../../core/assert.js";
-import { pose_evaluate_local } from "../../../shade/renderer/animation/pose/pose_evaluate_local.js";
-import { TransformAttachment } from "../transform-attachment/TransformAttachment.js";
-import { Transform64 } from "./Transform64.js";
-
-/**
- * @typedef {import("../EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
- * @typedef {import("../../../shade/renderer/animation/pose/PosePlayback.js").PosePlayback} PosePlayback
- */
-
-/**
- * Scratch for one level of the parent walk. Depth is bounded by the hierarchy, and reusing a
- * small stack keeps the query allocation-free.
- *
- * @type {Transform64[]}
- */
-const SCRATCH = [];
-
-/**
- * The chain from the entity up to its root, and each level's rest pose.
- *
- * @type {number[]}
- */
-const CHAIN = [];
-
-/**
- * @type {Transform64[]}
- */
-const RESTS = [];
-
-/**
- * @param {number} depth
- * @returns {Transform64}
- */
-function scratch_at(depth) {
-    while (SCRATCH.length <= depth) {
-        SCRATCH.push(new Transform64());
-    }
-
-    return SCRATCH[depth];
-}
-
-/**
- * Evaluate an entity's **world** pose under a set of playing clips, exactly, from its own chain.
- *
- * This is the question gameplay asks of an animated model and the only way the simulation may
- * ask it: where is the muzzle, where does this effect attach, where does the projectile leave
- * from. It walks the entity's `TransformAttachment` parents to the root, evaluates each level's
- * animated local pose from the clips ({@link pose_evaluate_local}, with the attachment's offset —
- * or the root's `Transform64` — as the rest pose), and composes down in double precision. Nothing
- * is read back from the GPU, nothing is a frame late, and nothing on the CPU has to have been
- * composed first: the answer is a pure function of (hierarchy, clip set, time, weights), which is
- * what keeps it deterministic on a peer with no device at all.
- *
- * An entity the GPU owns the transform of — see `GPUStateAuthority` — is answered the same way;
- * that is the point. A row the GPU composes and a chain this evaluates agree to float precision.
- *
- * Each level costs a scan of every channel of every playing clip, so a query is a few
- * microseconds at a character's depth and a whole skeleton one query at a time is most of a
- * millisecond; a caller asking about several entities of one model within a tick goes through
- * {@link T64WorldCache}, which evaluates each entity once and composes the rest onto it.
- *
- * @param {Transform64} result written with the evaluated world TRS and matrix
- * @param {EntityComponentDataset} dataset
- * @param {number} entity
- * @param {PosePlayback[]} playbacks every clip playing on the model, with its time and weight
- * @returns {Transform64} `result`
- */
-export function t64_evaluate_world(result, dataset, entity, playbacks) {
-    assert.defined(result, 'result');
-    assert.defined(dataset, 'dataset');
-    assert.isNonNegativeInteger(entity, 'entity');
-    assert.isArray(playbacks, 'playbacks');
-
-    CHAIN.length = 0;
-    RESTS.length = 0;
-
-    let cursor = entity;
-
-    while (cursor !== -1) {
-        assert.ok(dataset.entityExists(cursor), `entity ${cursor} in the chain above ${entity} does not exist`);
-
-        const attachment = dataset.getComponent(cursor, TransformAttachment);
-
-        CHAIN.push(cursor);
-
-        if (attachment === undefined || attachment === null || !dataset.entityExists(attachment.parent)) {
-            // the root of the chain, whose world pose is its own; a link whose parent has gone is
-            // a root until the attachment system detaches it, and answers from where it was
-            const world = dataset.getComponent(cursor, Transform64);
-
-            assert.defined(world, `entity ${cursor} carries no Transform64 and no attachment`);
-
-            RESTS.push(world);
-
-            break;
-        }
-
-        RESTS.push(attachment.transform);
-
-        cursor = attachment.parent;
-    }
-
-    // root first, so each step composes onto what is already accumulated
-    let depth = 0;
-
-    for (let i = CHAIN.length - 1; i >= 0; i--) {
-        const local = scratch_at(depth);
-
-        pose_evaluate_local(local, CHAIN[i], RESTS[i], playbacks);
-        local.updateMatrix();
-
-        if (i === CHAIN.length - 1) {
-            result.copy(local);
-        } else {
-            result.multiplyTransforms(result, local);
-        }
-
-        depth++;
-    }
-
-    CHAIN.length = 0;
-    RESTS.length = 0;
-
-    return result;
-}
+import { assert } from "../../../core/assert.js";
+import { TransformAttachment } from "../transform-attachment/TransformAttachment.js";
+import { t64_evaluate_local } from "./t64_evaluate_local.js";
+import { Transform64 } from "./Transform64.js";
+
+/**
+ * @typedef {import("../EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
+ * @typedef {import("../../../shade/renderer/animation/pose/PosePlayback.js").PosePlayback} PosePlayback
+ */
+
+/**
+ * Scratch for one level of the parent walk. Depth is bounded by the hierarchy, and reusing a
+ * small stack keeps the query allocation-free.
+ *
+ * @type {Transform64[]}
+ */
+const SCRATCH = [];
+
+/**
+ * The chain from the entity up to its root, and each level's rest pose.
+ *
+ * @type {number[]}
+ */
+const CHAIN = [];
+
+/**
+ * @type {Transform64[]}
+ */
+const RESTS = [];
+
+/**
+ * @param {number} depth
+ * @returns {Transform64}
+ */
+function scratch_at(depth) {
+    while (SCRATCH.length <= depth) {
+        SCRATCH.push(new Transform64());
+    }
+
+    return SCRATCH[depth];
+}
+
+/**
+ * Evaluate an entity's **world** pose under a set of playing clips, exactly, from its own chain.
+ *
+ * This is the question gameplay asks of an animated model and the only way the simulation may
+ * ask it: where is the muzzle, where does this effect attach, where does the projectile leave
+ * from. It walks the entity's `TransformAttachment` parents to the root, evaluates each level's
+ * animated local pose from the clips ({@link pose_evaluate_local}, with the attachment's offset —
+ * or the root's `Transform64` — as the rest pose), and composes down in double precision. Nothing
+ * is read back from the GPU, nothing is a frame late, and nothing on the CPU has to have been
+ * composed first: the answer is a pure function of (hierarchy, clip set, time, weights), which is
+ * what keeps it deterministic on a peer with no device at all.
+ *
+ * An entity the GPU owns the transform of — see `GPUStateAuthority` — is answered the same way;
+ * that is the point. A row the GPU composes and a chain this evaluates agree to float precision.
+ * So does a level a CPU writer holds (`gpu_authority_hold`): no clip reaches its row on the GPU,
+ * and none reaches it here — it is its offset ({@link t64_evaluate_local}).
+ *
+ * Each level costs a lookup in every playing clip and the curves of the channels that name it in the
+ * audible ones, so a whole skeleton one query at a time re-evaluates every level above each joint
+ * again; a caller asking about several entities of one model within a tick goes through
+ * {@link T64WorldCache}, which evaluates each entity once and composes the rest onto it.
+ *
+ * @param {Transform64} result written with the evaluated world TRS and matrix
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ * @param {PosePlayback[]} playbacks every clip playing on the model, with its time and weight
+ * @returns {Transform64} `result`
+ */
+export function t64_evaluate_world(result, dataset, entity, playbacks) {
+    assert.defined(result, 'result');
+    assert.defined(dataset, 'dataset');
+    assert.isNonNegativeInteger(entity, 'entity');
+    assert.isArray(playbacks, 'playbacks');
+
+    CHAIN.length = 0;
+    RESTS.length = 0;
+
+    let cursor = entity;
+
+    while (cursor !== -1) {
+        assert.ok(dataset.entityExists(cursor), `entity ${cursor} in the chain above ${entity} does not exist`);
+
+        const attachment = dataset.getComponent(cursor, TransformAttachment);
+
+        CHAIN.push(cursor);
+
+        if (attachment === undefined || attachment === null || !dataset.entityExists(attachment.parent)) {
+            // the root of the chain, whose world pose is its own; a link whose parent has gone is
+            // a root until the attachment system detaches it, and answers from where it was
+            const world = dataset.getComponent(cursor, Transform64);
+
+            assert.defined(world, `entity ${cursor} carries no Transform64 and no attachment`);
+
+            RESTS.push(world);
+
+            break;
+        }
+
+        RESTS.push(attachment.transform);
+
+        cursor = attachment.parent;
+    }
+
+    // root first, so each step composes onto what is already accumulated
+    let depth = 0;
+
+    for (let i = CHAIN.length - 1; i >= 0; i--) {
+        const local = scratch_at(depth);
+
+        t64_evaluate_local(local, dataset, CHAIN[i], RESTS[i], playbacks);
+        local.updateMatrix();
+
+        if (i === CHAIN.length - 1) {
+            result.copy(local);
+        } else {
+            result.multiplyTransforms(result, local);
+        }
+
+        depth++;
+    }
+
+    CHAIN.length = 0;
+    RESTS.length = 0;
+
+    return result;
+}