@woosh/meep-engine 3.40.0 → 3.41.0

package/src/shade/renderer/scene/optimization/geometry/internal/neighbourhood_anchor_index.js

@@ -0,0 +1,124 @@
+import { array_quick_sort_by_lookup_uint } from "../../../../../../core/collection/array/array_quick_sort_by_lookup_uint.js";
+
+/**
+ * Words per anchor in the array {@link neighbourhood_anchor_index} returns.
+ * @type {number}
+ */
+export const ANCHOR_STRIDE = 4;
+
+/**
+ * Pair up triangles whose {@link face_neighbourhood_hash} values are equal, within a geometry or across
+ * two: each pair is a place where a copy may sit, for growth to confirm or throw out.
+ *
+ * Within one hash, every triangle is paired with the first, in input order (geometry, then triangle) -
+ * not every triangle with every other. A copy that matches the first is found from it, and one that
+ * does not still gets the first's canonical piece by another anchor; pairing them all only repeats
+ * growth that the first pair already did. On Sponza through scene_optimize's meshlet round trip,
+ * pairing them all grew 172k times against 41k, and shared fewer triangles: 144.5k against 145.8k.
+ *
+ * A hash shared by more than `seed_budget` triangles keeps the first `seed_budget` of them, so a
+ * featureless region repeated thousands of times does not swamp what follows.
+ *
+ * @param {Uint32Array[]} hash_streams one per geometry, one hash per triangle
+ * @param {number} seed_budget most triangles kept per hash, >= 2
+ * @returns {Uint32Array} {@link ANCHOR_STRIDE} words per anchor: a geometry, a triangle of it, b geometry,
+ * a triangle of it. The `a` side is the earlier of the two in input order.
+ */
+export function neighbourhood_anchor_index(hash_streams, seed_budget) {
+    let total = 0;
+
+    for (const stream of hash_streams) {
+        total += stream.length;
+    }
+
+    // every triangle of every geometry, numbered in input order
+    const hash = new Uint32Array(total);
+    const geometry_of = new Uint32Array(total);
+    const offset_of = new Uint32Array(hash_streams.length);
+
+    let cursor = 0;
+
+    for (let g = 0; g < hash_streams.length; g++) {
+        const stream = hash_streams[g];
+
+        offset_of[g] = cursor;
+        hash.set(stream, cursor);
+        geometry_of.fill(g, cursor, cursor + stream.length);
+
+        cursor += stream.length;
+    }
+
+    const order = new Uint32Array(total);
+
+    for (let i = 0; i < total; i++) {
+        order[i] = i;
+    }
+
+    array_quick_sort_by_lookup_uint(order, hash, 0, total - 1);
+
+    /*
+     Each shared hash's triangles, filed under the first of them in input order: where its run starts in
+     `order`, and how many of the run are kept. -1 for a triangle that is first of no run.
+    */
+    const run_of_first = new Int32Array(total).fill(-1);
+    const kept_of_first = new Uint32Array(total);
+
+    let anchor_count = 0;
+
+    for (let run_start = 0; run_start < total;) {
+        let run_end = run_start + 1;
+
+        while (run_end < total && hash[order[run_end]] === hash[order[run_start]]) {
+            run_end++;
+        }
+
+        if (run_end - run_start > 1) {
+            // the sort leaves equal hashes in no particular order; input order decides who is first and who is kept
+            order.subarray(run_start, run_end).sort();
+
+            const kept = Math.min(run_end - run_start, seed_budget);
+
+            run_of_first[order[run_start]] = run_start;
+            kept_of_first[order[run_start]] = kept;
+
+            anchor_count += kept - 1;
+        }
+
+        run_start = run_end;
+    }
+
+    /*
+     Emitted in input order of each run's first triangle, so growth meets the anchors geometry by geometry,
+     triangle by triangle. Growth claims the triangles it covers and later anchors inside them are skipped,
+     so the order decides which matches are grown: in the order the sort left the hashes, Sponza through
+     scene_optimize's meshlet round trip shared 125.7k triangles, against 145.8k in this one.
+    */
+    const anchors = new Uint32Array(anchor_count * ANCHOR_STRIDE);
+
+    let written = 0;
+
+    for (let first = 0; first < total; first++) {
+        const run_start = run_of_first[first];
+
+        if (run_start === -1) {
+            continue;
+        }
+
+        const first_geometry = geometry_of[first];
+        const first_triangle = first - offset_of[first_geometry];
+
+        const kept = kept_of_first[first];
+
+        for (let i = 1; i < kept; i++) {
+            const other = order[run_start + i];
+            const other_geometry = geometry_of[other];
+
+            anchors[written++] = first_geometry;
+            anchors[written++] = first_triangle;
+            anchors[written++] = other_geometry;
+            anchors[written++] = other - offset_of[other_geometry];
+        }
+    }
+
+    return anchors;
+}

package/src/shade/renderer/scene/optimization/geometry/internal/seed_correspondence_from_face_pair.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Lay triangle `face_b` of B on triangle `face_a` of A corner to corner, keeping the winding: corner `k`
+ * of A on corner `(k + offset) % 3` of B. Writes the three pairs into `out` (vertex of A → vertex of B)
+ * when every pair carries equal attributes.
+ *
+ * A triangle lies on another in three ways that keep the winding. Attributes usually rule out two; where
+ * they leave more than one, the caller grows from each in turn and lets positions decide.
+ *
+ * @param {Map<number, number>} out cleared first; left empty when the offset does not fit
+ * @param {import("./vertex_attributes_equal.js").VertexAttributePairs} attributes
+ * @param {BinaryTopology} topology_a
+ * @param {BinaryTopology} topology_b
+ * @param {number} face_a
+ * @param {number} face_b
+ * @param {number} offset 0, 1 or 2
+ * @returns {boolean} whether `out` holds a correspondence
+ */
+export function seed_correspondence_from_face_pair(out: Map<number, number>, attributes: import("./vertex_attributes_equal.js").VertexAttributePairs, topology_a: BinaryTopology, topology_b: BinaryTopology, face_a: number, face_b: number, offset: number): boolean;
+//# sourceMappingURL=seed_correspondence_from_face_pair.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seed_correspondence_from_face_pair.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/seed_correspondence_from_face_pair.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,wDATW,IAAI,MAAM,EAAE,MAAM,CAAC,cACnB,OAAO,8BAA8B,EAAE,oBAAoB,kEAG3D,MAAM,UACN,MAAM,UACN,MAAM,GACJ,OAAO,CA0BnB"}

package/src/shade/renderer/scene/optimization/geometry/internal/seed_correspondence_from_face_pair.js

@@ -0,0 +1,48 @@
+import { bt_face_read_triangle_vertices } from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
+import { vertex_attributes_match } from "./vertex_attributes_equal.js";
+
+const a_corners = [0, 0, 0];
+const b_corners = [0, 0, 0];
+
+/**
+ * Lay triangle `face_b` of B on triangle `face_a` of A corner to corner, keeping the winding: corner `k`
+ * of A on corner `(k + offset) % 3` of B. Writes the three pairs into `out` (vertex of A → vertex of B)
+ * when every pair carries equal attributes.
+ *
+ * A triangle lies on another in three ways that keep the winding. Attributes usually rule out two; where
+ * they leave more than one, the caller grows from each in turn and lets positions decide.
+ *
+ * @param {Map<number, number>} out cleared first; left empty when the offset does not fit
+ * @param {import("./vertex_attributes_equal.js").VertexAttributePairs} attributes
+ * @param {BinaryTopology} topology_a
+ * @param {BinaryTopology} topology_b
+ * @param {number} face_a
+ * @param {number} face_b
+ * @param {number} offset 0, 1 or 2
+ * @returns {boolean} whether `out` holds a correspondence
+ */
+export function seed_correspondence_from_face_pair(
+    out,
+    attributes,
+    topology_a, topology_b,
+    face_a, face_b,
+    offset
+) {
+    out.clear();
+
+    if (!bt_face_read_triangle_vertices(a_corners, topology_a, face_a)) return false;
+    if (!bt_face_read_triangle_vertices(b_corners, topology_b, face_b)) return false;
+
+    for (let k = 0; k < 3; k++) {
+        if (!vertex_attributes_match(attributes, a_corners[k], b_corners[(k + offset) % 3])) {
+            return false;
+        }
+    }
+
+    for (let k = 0; k < 3; k++) {
+        out.set(a_corners[k], b_corners[(k + offset) % 3]);
+    }
+
+    // a triangle with a repeated vertex has fewer than three to fit a transform to
+    return out.size === 3;
+}

package/src/shade/renderer/scene/rows/GPUSceneRows.d.ts

@@ -42,7 +42,8 @@ export function entity_of_row(row: number): number;
  * **Change flow is mark, then flush.** The systems that place entities listen to the dataset's
  * change events and {@link mark_local} or {@link mark_world}; nothing is read at mark time. The
  * flush, in `GPUSceneContext.build`, reads each marked entity's components once, consults
- * `GPUStateAuthority` then, writes the ranges the CPU owns, and clears the list. A world mark on
+ * `GPUStateAuthority` then, writes the ranges the CPU owns — and an offset the GPU has just taken,
+ * once ({@link mark_handover}) — and clears the list. A world mark on
  * an attached entity whose parent has a row writes nothing: its local offset and its parent are
  * unchanged, and the GPU composes the rest. That is what stops a root's move from costing a row
  * per descendant.
@@ -155,6 +156,21 @@ export class GPUSceneRows {
      * @param {number} entity
      */
     mark_local(entity: number): void;
+    /**
+     * The entity's offset passes to the GPU as it stands: a clip binds it for the first time, or a
+     * CPU writer that held it has let go and a clip still bound has it back. The next flush writes
+     * the offset into the row once more, though `GPUStateAuthority` already says the GPU writes it.
+     *
+     * The bit is granted at that moment, and the flush runs later, in the frame's build, and reads
+     * the bit then. So whatever was written since the last flush — an offset announced in the frame
+     * the clip binds; a holder's last step, or an offset it captured and put back — would never
+     * reach the row: the axes no bound clip keys would keep the previous pose on the GPU, while the
+     * CPU twin reads the offset. The axes a clip keys are rewritten by the resolve, which runs after
+     * the flush.
+     *
+     * @param {number} entity
+     */
+    mark_handover(entity: number): void;
     /**
      * The entity's world transform changed. For an entity the GPU composes under a parent row this
      * is nothing to write; for one carrying its world pose it is the row's contents.

package/src/shade/renderer/scene/rows/GPUSceneRows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAoID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,oBAA8B;IAE9B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAuChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QAgDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAwCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IAyMD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;;;;OAKG;IACH,gBAUC;;CACJ;qCA1nCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}
+{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AA0ID;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,oBAA8B;IAE9B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAuChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;;;;;;;;;OAaG;IACH,sBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QAgDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAwCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IA0MD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;;;;OAKG;IACH,gBAUC;;CACJ;qCAppCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}

package/src/shade/renderer/scene/rows/GPUSceneRows.js

@@ -57,6 +57,12 @@ const MARK_LOCAL = 1;
 const MARK_WORLD = 2;
 const MARK_MESH = 4;
 
+/**
+ * The offset goes to the row although the GPU writes it now — see {@link GPUSceneRows#mark_handover}.
+ * Always carried with {@link MARK_LOCAL}.
+ */
+const MARK_HANDOVER = 8;
+
 /**
  * Staging for one `transforms` row, reused across every write. `global` and `prev_global` are read
  * only on a row's first write.
@@ -193,7 +199,8 @@ class MeshEntry {
  * **Change flow is mark, then flush.** The systems that place entities listen to the dataset's
  * change events and {@link mark_local} or {@link mark_world}; nothing is read at mark time. The
  * flush, in `GPUSceneContext.build`, reads each marked entity's components once, consults
- * `GPUStateAuthority` then, writes the ranges the CPU owns, and clears the list. A world mark on
+ * `GPUStateAuthority` then, writes the ranges the CPU owns — and an offset the GPU has just taken,
+ * once ({@link mark_handover}) — and clears the list. A world mark on
  * an attached entity whose parent has a row writes nothing: its local offset and its parent are
  * unchanged, and the GPU composes the rest. That is what stops a root's move from costing a row
  * per descendant.
@@ -564,6 +571,24 @@ export class GPUSceneRows {
         this.#mark(entity, MARK_LOCAL);
     }
 
+    /**
+     * The entity's offset passes to the GPU as it stands: a clip binds it for the first time, or a
+     * CPU writer that held it has let go and a clip still bound has it back. The next flush writes
+     * the offset into the row once more, though `GPUStateAuthority` already says the GPU writes it.
+     *
+     * The bit is granted at that moment, and the flush runs later, in the frame's build, and reads
+     * the bit then. So whatever was written since the last flush — an offset announced in the frame
+     * the clip binds; a holder's last step, or an offset it captured and put back — would never
+     * reach the row: the axes no bound clip keys would keep the previous pose on the GPU, while the
+     * CPU twin reads the offset. The axes a clip keys are rewritten by the resolve, which runs after
+     * the flush.
+     *
+     * @param {number} entity
+     */
+    mark_handover(entity) {
+        this.#mark(entity, MARK_LOCAL | MARK_HANDOVER);
+    }
+
     /**
      * The entity's world transform changed. For an entity the GPU composes under a parent row this
      * is nothing to write; for one carrying its world pose it is the row's contents.
@@ -845,10 +870,11 @@ export class GPUSceneRows {
 
         const parent_changed = this.#parent_row[entity] !== parent_row;
 
-        if ((flags & GPUStateAuthorityFlags.TransformAttachment) !== 0) {
+        if ((flags & GPUStateAuthorityFlags.TransformAttachment) !== 0 && (why & MARK_HANDOVER) === 0) {
             // The GPU writes this row's TRS — a clip, a pose the CPU never sees — and a CPU that
             // wrote it too would race what the animation just resolved. The parent row is still
-            // this side's, and changes only when the parent's own row comes or goes.
+            // this side's, and changes only when the parent's own row comes or goes. A hand-over
+            // is the one write past the bit: the offset as the GPU takes it.
             if (!parent_changed) {
                 return 0;
             }

package/src/engine/ecs/ik/IKConstraint.d.ts

@@ -1,52 +0,0 @@
-export class IKConstraint {
-    /**
-     * End bone that is going to be placed
-     * @type {String}
-     */
-    effector: string;
-    /**
-     * How far should effector be from the contact, positive values result in effector not reaching the surface, and negative result in penetration
-     * @example For a foot effector this would be distance above the ground
-     * @type {number}
-     */
-    offset: number;
-    /**
-     * Positive distance from the surface at which IK starts to take effect, low value represents full effect and high value represents where the influence begins
-     * @type {NumericInterval}
-     */
-    distance: NumericInterval;
-    /**
-     *
-     * @type {number}
-     */
-    strength: number;
-    /**
-     *
-     * @type {number}
-     */
-    limit: number;
-    /**
-     * Solver to be used for this constraint
-     * @type {string}
-     */
-    solver: string;
-    /**
-     *
-     * @param {IKConstraint} other
-     */
-    copy(other: IKConstraint): void;
-    clone(): IKConstraint;
-    /**
-     *
-     * @param {IKConstraint} other
-     * @returns {boolean}
-     */
-    equals(other: IKConstraint): boolean;
-    /**
-     *
-     * @return {number}
-     */
-    hash(): number;
-}
-import { NumericInterval } from "../../../core/math/interval/NumericInterval.js";
-//# sourceMappingURL=IKConstraint.d.ts.map

package/src/engine/ecs/ik/IKConstraint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IKConstraint.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/IKConstraint.js"],"names":[],"mappings":"AAKA;IAEI;;;OAGG;IACH,iBAAc;IAEd;;;;OAIG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,UAFU,eAAe,CAEY;IAErC;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,OAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,QAFU,MAAM,CAEA;IAGhB;;;OAGG;IACH,YAFW,YAAY,QAStB;IAED,sBAMC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CASnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAWjB;CACJ;gCA7F+B,gDAAgD"}

package/src/engine/ecs/ik/IKConstraint.js

@@ -1,95 +0,0 @@
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
-import { NumericInterval } from "../../../core/math/interval/NumericInterval.js";
-import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
-import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
-
-export class IKConstraint {
-
-    /**
-     * End bone that is going to be placed
-     * @type {String}
-     */
-    effector = "";
-
-    /**
-     * How far should effector be from the contact, positive values result in effector not reaching the surface, and negative result in penetration
-     * @example For a foot effector this would be distance above the ground
-     * @type {number}
-     */
-    offset = 0;
-
-    /**
-     * Positive distance from the surface at which IK starts to take effect, low value represents full effect and high value represents where the influence begins
-     * @type {NumericInterval}
-     */
-    distance = new NumericInterval(0, 0);
-
-    /**
-     *
-     * @type {number}
-     */
-    strength = 1;
-
-    /**
-     *
-     * @type {number}
-     */
-    limit = Math.PI;
-
-    /**
-     * Solver to be used for this constraint
-     * @type {string}
-     */
-    solver = "2BIK";
-
-
-    /**
-     *
-     * @param {IKConstraint} other
-     */
-    copy(other) {
-        this.effector = other.effector;
-        this.offset = other.offset;
-        this.distance.copy(other.distance);
-        this.strength = other.strength;
-        this.limit = other.limit;
-        this.solver = other.solver;
-    }
-
-    clone() {
-        const r = new IKConstraint();
-
-        r.copy(this);
-
-        return r;
-    }
-
-    /**
-     *
-     * @param {IKConstraint} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.effector === other.effector
-            && this.offset === other.offset
-            && this.distance.equals(other.distance)
-            && this.strength === other.strength
-            && this.limit === other.limit
-            && this.solver === other.solver;
-    }
-
-    /**
-     *
-     * @return {number}
-     */
-    hash() {
-        return combine_hash(
-            computeStringHash(this.effector),
-            computeHashFloat(this.offset),
-            this.distance.hash(),
-            computeHashFloat(this.strength),
-            computeHashFloat(this.limit),
-            computeStringHash(this.solver)
-        );
-    }
-}

package/src/engine/ecs/ik/IKProblem.d.ts

@@ -1,45 +0,0 @@
-export class IKProblem {
-    /**
-     *
-     * @type {IKConstraint}
-     */
-    constraint: IKConstraint;
-    /**
-     * Where the hierarchy lives. Bones are entities, so the chain is walked here rather than on a
-     * skeleton object.
-     *
-     * @type {EntityComponentDataset}
-     */
-    dataset: EntityComponentDataset;
-    /**
-     * The bone being placed. Its ancestors are the rest of the chain, reached through
-     * {@link transform_attachment_parent_of}.
-     *
-     * @type {number}
-     */
-    effector: number;
-    /**
-     *
-     * @type {Terrain}
-     */
-    terrain: Terrain;
-    /**
-     * The clips playing on the constrained entity's model, with their times and weights: what a
-     * chain under a GPU-composed ancestor is evaluated against. Empty for a model nothing plays.
-     *
-     * @type {PosePlayback[]}
-     */
-    playbacks: PosePlayback[];
-    /**
-     * The system's per-tick evaluation cache, shared by every problem of the tick; null where a
-     * chain is evaluated on its own.
-     *
-     * @type {T64WorldCache|null}
-     */
-    cache: T64WorldCache | null;
-}
-export namespace IKProblem {
-    let pool: ObjectPoolFactory<IKProblem>;
-}
-import { ObjectPoolFactory } from "../../../core/model/object/ObjectPoolFactory.js";
-//# sourceMappingURL=IKProblem.d.ts.map

package/src/engine/ecs/ik/IKProblem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IKProblem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/IKProblem.js"],"names":[],"mappings":"AAGA;IAEI;;;OAGG;IACH,yBAAkB;IAElB;;;;;OAKG;IACH,gCAAe;IAEf;;;;;OAKG;IACH,UAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,iBAAe;IAEf;;;;;OAKG;IACH,WAFU,cAAc,CAET;IAEf;;;;;OAKG;IACH,OAFU,gBAAc,IAAI,CAEf;CAEhB;;cAIS,kBAAkB,SAAS,CAAC;;kCApDJ,iDAAiD"}

package/src/engine/ecs/ik/IKProblem.js

@@ -1,58 +0,0 @@
-import { noop } from "../../../core/function/noop.js";
-import { ObjectPoolFactory } from "../../../core/model/object/ObjectPoolFactory.js";
-
-export class IKProblem {
-
-    /**
-     *
-     * @type {IKConstraint}
-     */
-    constraint = null;
-
-    /**
-     * Where the hierarchy lives. Bones are entities, so the chain is walked here rather than on a
-     * skeleton object.
-     *
-     * @type {EntityComponentDataset}
-     */
-    dataset = null;
-
-    /**
-     * The bone being placed. Its ancestors are the rest of the chain, reached through
-     * {@link transform_attachment_parent_of}.
-     *
-     * @type {number}
-     */
-    effector = -1;
-
-    /**
-     *
-     * @type {Terrain}
-     */
-    terrain = null;
-
-    /**
-     * The clips playing on the constrained entity's model, with their times and weights: what a
-     * chain under a GPU-composed ancestor is evaluated against. Empty for a model nothing plays.
-     *
-     * @type {PosePlayback[]}
-     */
-    playbacks = [];
-
-    /**
-     * The system's per-tick evaluation cache, shared by every problem of the tick; null where a
-     * chain is evaluated on its own.
-     *
-     * @type {T64WorldCache|null}
-     */
-    cache = null;
-
-}
-
-/**
- *
- * @type {ObjectPoolFactory<IKProblem>}
- */
-IKProblem.pool = new ObjectPoolFactory(() => {
-    return new IKProblem();
-}, noop, noop);

package/src/engine/ecs/ik/IKSolver.d.ts

@@ -1,8 +0,0 @@
-export class IKSolver {
-    /**
-     *
-     * @param {IKProblem} problem
-     */
-    solve(problem: IKProblem): void;
-}
-//# sourceMappingURL=IKSolver.d.ts.map

package/src/engine/ecs/ik/IKSolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IKSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/IKSolver.js"],"names":[],"mappings":"AAAA;IACI;;;OAGG;IACH,gCAEC;CACJ"}

package/src/engine/ecs/ik/IKSolver.js

@@ -1,9 +0,0 @@
-export class IKSolver {
-    /**
-     *
-     * @param {IKProblem} problem
-     */
-    solve(problem) {
-        throw new Error('Not implemented');
-    }
-}

package/src/engine/ecs/ik/InverseKinematics.d.ts

@@ -1,48 +0,0 @@
-export class InverseKinematics {
-    /**
-     * @readonly
-     * @type {IKConstraint[]}
-     */
-    readonly constraints: IKConstraint[];
-    /**
-     *
-     * @param {InverseKinematics} other
-     */
-    copy(other: InverseKinematics): void;
-    clone(): InverseKinematics;
-    /**
-     *
-     * @param {Object} options
-     * @param {String} options.effector
-     * @param {number} options.offset
-     * @param {number} options.distanceMin
-     * @param {number} options.distanceMax
-     * @param {number} options.strength
-     * @param {number} options.limit
-     * @param {String} options.solver
-     */
-    add({ effector, offset, distanceMin, distanceMax, strength, limit, solver }: {
-        effector: string;
-        offset: number;
-        distanceMin: number;
-        distanceMax: number;
-        strength: number;
-        limit: number;
-        solver: string;
-    }): void;
-    /**
-     *
-     * @param {InverseKinematics} other
-     * @returns {boolean}
-     */
-    equals(other: InverseKinematics): boolean;
-    /**
-     * @returns {number}
-     */
-    hash(): number;
-}
-export namespace InverseKinematics {
-    let typeName: string;
-}
-import { IKConstraint } from "./IKConstraint.js";
-//# sourceMappingURL=InverseKinematics.d.ts.map

package/src/engine/ecs/ik/InverseKinematics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"InverseKinematics.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/InverseKinematics.js"],"names":[],"mappings":"AAGA;IAEI;;;OAGG;IACH,sBAFU,YAAY,EAAE,CAEP;IAEjB;;;OAGG;IACH,YAFW,iBAAiB,QAe3B;IAED,2BAMC;IAED;;;;;;;;;;OAUG;IACH;QAR2B,QAAQ;QACR,MAAM,EAAtB,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,QAAQ,EAAxB,MAAM;QACU,KAAK,EAArB,MAAM;QACU,MAAM;aAqBhC;IAED;;;;OAIG;IACH,cAHW,iBAAiB,GACf,OAAO,CAsBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAgBlB;CACJ;;;;6BAnH4B,mBAAmB"}