@woosh/meep-engine 3.14.6 → 3.16.0

package/src/engine/ecs/gui/hud/HeadsUpDisplaySystem.js

@@ -5,7 +5,7 @@ import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { FogOfWarVisibilityPredicate } from "../../fow/FogOfWarVisibilityPredicate.js";
 import { System } from '../../System.js';
-import { Transform } from '../../transform/Transform.js';
+import { Transform64 } from '../../transform/Transform64.js';
 import GUIElement from "../GUIElement.js";
 import ViewportPosition from "../position/ViewportPosition.js";
 import HeadsUpDisplay from './HeadsUpDisplay.js';
@@ -76,7 +76,7 @@ class HeadsUpDisplaySystem extends System {
      * The quaternion rotation is NOT inlined — {@link v3_quaternion_apply} already writes into a caller-supplied
      * array, so it costs no allocation and there is nothing to gain from a private copy of the expansion.
      * @param {HeadsUpDisplay} hud
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {ViewportPosition} vp
      * @param {GUIElement} element
      * @private
@@ -90,15 +90,14 @@ class HeadsUpDisplaySystem extends System {
 
         if (hud.getFlag(HeadsUpDisplayFlag.TransformWorldOffset)) {
             //apply scale and rotation
-            const transform_scale = transform.scale;
 
-            x *= transform_scale.x;
-            y *= transform_scale.y;
-            z *= transform_scale.z;
+            x *= transform.scale_x;
+            y *= transform.scale_y;
+            z *= transform.scale_z;
 
             const q = transform.rotation;
 
-            v3_quaternion_apply(scratch_rotated_offset, 0, x, y, z, q.x, q.y, q.z, q.w);
+            v3_quaternion_apply(scratch_rotated_offset, 0, x, y, z, q[0], q[1], q[2], q[3]);
 
             x = scratch_rotated_offset[0];
             y = scratch_rotated_offset[1];
@@ -106,11 +105,11 @@ class HeadsUpDisplaySystem extends System {
         }
 
         // add transform position to get final world position
-        const position = transform.position;
+        const position = transform.translation;
 
-        x += position.x;
-        y += position.y;
-        z += position.z;
+        x += position[0];
+        y += position[1];
+        z += position[2];
 
         const worldPositionX = x;
         const worldPositionY = y;
@@ -188,7 +187,8 @@ class HeadsUpDisplaySystem extends System {
             ndcY = 0.5 + dy;
         }
 
-        vp.position.set(ndcX, ndcY);
+        vp.position[0] = ndcX;
+            position[1] = ndcY;
 
         const visible = (!trackedPositionOutOfBounds || vp.stickToScreenEdge) && this.__visibility_predicate.test(worldPositionX, worldPositionY, worldPositionZ);
 
@@ -248,7 +248,7 @@ class HeadsUpDisplaySystem extends System {
         const dataset = entityManager.dataset;
         if (dataset !== null) {
             visibilityPredicate.initialize(dataset);
-            dataset.traverseEntities([HeadsUpDisplay, Transform, ViewportPosition, GUIElement], this.__apply_entity_transformation, this);
+            dataset.traverseEntities([HeadsUpDisplay, Transform64, ViewportPosition, GUIElement], this.__apply_entity_transformation, this);
             visibilityPredicate.finalize();
         }
     };

package/src/engine/ecs/gui/hud/testHudEdgeStick.js

@@ -1,6 +1,6 @@
 import { EngineHarness } from "../../../EngineHarness.js";
 import Entity from "../../Entity.js";
-import { Transform } from "../../transform/Transform.js";
+import { Transform64 } from "../../transform/Transform64.js";
 import EmptyView from "../../../../view/elements/EmptyView.js";
 import GUIElement from "../GUIElement.js";
 import GUIElementSystem from "../GUIElementSystem.js";
@@ -85,8 +85,8 @@ async function main(engine) {
         view.size.set(28, 28);
         view.el.textContent = String(i);
 
-        const transform = new Transform();
-        transform.position.set(x, 0.5, z);
+        const transform = new Transform64();
+        transform.setTranslation(x, 0.5, z);
 
         const vp = new ViewportPosition();
         vp.anchor.set(0.5, 0.5);

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

@@ -4,13 +4,13 @@
  *
  * **A bone is an entity here.** The constraint names one, the name is resolved to an entity beneath
  * the constrained entity, and the chain above it is the {@link TransformAttachment} parent walk. So
- * this system knows nothing about renderers: it reads world {@link Transform}s the hierarchy has
+ * this system knows nothing about renderers: it reads world {@link Transform64}s the hierarchy has
  * already composed and writes local ones back, which is the whole of what a joint angle is.
  */
 export class InverseKinematicsSystem extends System<any> {
     constructor();
-    dependencies: (typeof Transform | typeof InverseKinematics)[];
-    components_used: ResourceAccessSpecification<typeof Transform>[];
+    dependencies: (typeof Transform64 | typeof InverseKinematics)[];
+    components_used: ResourceAccessSpecification<typeof Transform64>[];
     /**
      *
      * @type {{"2BIK": TwoBoneInverseKinematicsSolver, "1BSA": OneBoneSurfaceAlignmentSolver}}
@@ -24,29 +24,29 @@ export class InverseKinematicsSystem extends System<any> {
     /**
      *
      * @param {InverseKinematics} ik
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    link(ik: InverseKinematics, transform: Transform, entity: number): void;
+    link(ik: InverseKinematics, transform: Transform64, entity: number): void;
     /**
      *
      * @param {InverseKinematics} ik
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    unlink(ik: InverseKinematics, transform: Transform, entity: number): void;
+    unlink(ik: InverseKinematics, transform: Transform64, entity: number): void;
     /**
      *
      * @param {InverseKinematics} ik
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    recordEntityProblems(ik: InverseKinematics, transform: Transform, entity: number): void;
+    recordEntityProblems(ik: InverseKinematics, transform: Transform64, entity: number): void;
     update(timeDelta: any): void;
     #private;
 }
 import { System } from "../System.js";
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 import { InverseKinematics } from "./InverseKinematics.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { TwoBoneInverseKinematicsSolver } from "./TwoBoneInverseKinematicsSolver.js";

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

@@ -1 +1 @@
-{"version":3,"file":"InverseKinematicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/InverseKinematicsSystem.js"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH;;IAEI,8DAA8C;IAE9C,iEAEE;IAEF;;;OAGG;IACH,SAFU;QAAC,MAAM,EAAE,8BAA8B,CAAC;QAAC,MAAM,EAAE,6BAA6B,CAAA;KAAC,CAKvF;IAEF,aAAc;IAsBd,+CAEC;IAED;;;;;OAKG;IACH,SAJW,iBAAiB,aACjB,SAAS,UACT,MAAM,QAIhB;IAED;;;;;OAKG;IACH,WAJW,iBAAiB,aACjB,SAAS,UACT,MAAM,QAIhB;IAED;;;;;OAKG;IACH,yBAJW,iBAAiB,aACjB,SAAS,UACT,MAAM,QAiDhB;IAED,6BAmDC;;CACJ;uBA9LsB,cAAc;0BAKX,2BAA2B;kCAEnB,wBAAwB;4CARd,oDAAoD;+CAUjD,qCAAqC;8CADtC,oCAAoC"}
+{"version":3,"file":"InverseKinematicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/InverseKinematicsSystem.js"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH;;IAEI,gEAAgD;IAEhD,mEAEE;IAEF;;;OAGG;IACH,SAFU;QAAC,MAAM,EAAE,8BAA8B,CAAC;QAAC,MAAM,EAAE,6BAA6B,CAAA;KAAC,CAKvF;IAEF,aAAc;IAsBd,+CAEC;IAED;;;;;OAKG;IACH,SAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAIhB;IAED;;;;;OAKG;IACH,WAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAIhB;IAED;;;;;OAKG;IACH,yBAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAiDhB;IAED,6BAmDC;;CACJ;uBA9LsB,cAAc;4BAKT,6BAA6B;kCAEvB,wBAAwB;4CARd,oDAAoD;+CAUjD,qCAAqC;8CADtC,oCAAoC"}

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

@@ -5,7 +5,7 @@ import { obtainTerrain } from "../terrain/util/obtainTerrain.js";
 import {
     transform_attachment_find_descendant_by_name
 } from "../transform-attachment/transform_attachment_find_descendant_by_name.js";
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 import { IKProblem } from "./IKProblem.js";
 import { InverseKinematics } from "./InverseKinematics.js";
 import { OneBoneSurfaceAlignmentSolver } from "./OneBoneSurfaceAlignmentSolver.js";
@@ -17,15 +17,15 @@ import { TwoBoneInverseKinematicsSolver } from "./TwoBoneInverseKinematicsSolver
  *
  * **A bone is an entity here.** The constraint names one, the name is resolved to an entity beneath
  * the constrained entity, and the chain above it is the {@link TransformAttachment} parent walk. So
- * this system knows nothing about renderers: it reads world {@link Transform}s the hierarchy has
+ * this system knows nothing about renderers: it reads world {@link Transform64}s the hierarchy has
  * already composed and writes local ones back, which is the whole of what a joint angle is.
  */
 export class InverseKinematicsSystem extends System {
 
-    dependencies = [InverseKinematics, Transform];
+    dependencies = [InverseKinematics, Transform64];
 
     components_used = [
-        ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read | ResourceAccessKind.Write)
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Read | ResourceAccessKind.Write)
     ];
 
     /**
@@ -66,7 +66,7 @@ export class InverseKinematicsSystem extends System {
     /**
      *
      * @param {InverseKinematics} ik
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     link(ik, transform, entity) {
@@ -76,7 +76,7 @@ export class InverseKinematicsSystem extends System {
     /**
      *
      * @param {InverseKinematics} ik
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     unlink(ik, transform, entity) {
@@ -86,7 +86,7 @@ export class InverseKinematicsSystem extends System {
     /**
      *
      * @param {InverseKinematics} ik
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     recordEntityProblems(ik, transform, entity) {
@@ -156,7 +156,7 @@ export class InverseKinematicsSystem extends System {
         }
 
 
-        ecd.traverseEntities([InverseKinematics, Transform], this.recordEntityProblems, this);
+        ecd.traverseEntities([InverseKinematics, Transform64], this.recordEntityProblems, this);
 
         //solve problems
         for (const solverID in this.solvers) {

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

@@ -1 +1 @@
-{"version":3,"file":"TwoBoneInverseKinematicsSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/TwoBoneInverseKinematicsSolver.js"],"names":[],"mappings":"AAyBA;IAGI,0BAmEC;CACJ;yBA1FwB,eAAe"}
+{"version":3,"file":"TwoBoneInverseKinematicsSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/TwoBoneInverseKinematicsSolver.js"],"names":[],"mappings":"AAsCA;IAGI,0BA6EC;CACJ;yBA/GwB,eAAe"}

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

@@ -1,97 +1,120 @@
-import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
-import Quaternion from "../../../core/geom/Quaternion.js";
-import Vector3 from "../../../core/geom/Vector3.js";
-import { two_joint_ik } from "../../physics/inverse_kinematics/two_joint_ik.js";
-import { IKBone, ik_bone_chain } from "./ik_bone_chain.js";
-import { ik_probe_terrain_contact } from "./ik_probe_terrain_contact.js";
-import { IKSolver } from "./IKSolver.js";
-
-const contact = new SurfacePoint3();
-
-const targetPosition = new Vector3();
-
-const targetLocalRotationA = new Quaternion();
-const targetLocalRotationB = new Quaternion();
-
-const r0 = new Quaternion();
-const r1 = new Quaternion();
-
-/**
- * effector, its parent, its grandparent
- *
- * @type {IKBone[]}
- */
-const CHAIN = [new IKBone(), new IKBone(), new IKBone()];
-
-export class TwoBoneInverseKinematicsSolver extends IKSolver {
-
-
-    solve(problem) {
-
-        const { dataset, effector, terrain, constraint } = problem;
-
-        if (!ik_bone_chain(CHAIN, dataset, effector, 3)) {
-            // the hierarchy does not hold three links yet
-            return;
-        }
-
-        const boneC = CHAIN[0];
-        const boneB = CHAIN[1];
-        const boneA = CHAIN[2];
-
-        /*
-         The world poses are read straight off the components. There is no matrix to bring up to
-         date first: `TransformAttachmentSystem` composes a world transform the moment anything it
-         depends on changes, so what is on the component is what the hierarchy currently says.
-        */
-        const boneWorldPositionA = boneA.world.position;
-        const boneWorldPositionB = boneB.world.position;
-        const boneWorldPositionC = boneC.world.position;
-
-        //compute total length of the limb
-        const limbLength = boneWorldPositionA.distanceTo(boneWorldPositionB) + boneWorldPositionB.distanceTo(boneWorldPositionC);
-
-        //check if there is a penetration with the terrain between the two bones
-        const influence = ik_probe_terrain_contact(
-            targetPosition,
-            contact,
-            terrain,
-            boneWorldPositionA,
-            boneWorldPositionC,
-            constraint,
-            limbLength
-        );
-
-        if (influence <= 0) {
-            //no contact, or no influence
-            return;
-        }
-
-        targetLocalRotationA.copy(boneA.local.rotation);
-        targetLocalRotationB.copy(boneB.local.rotation);
-
-        //compute
-        two_joint_ik(
-            boneWorldPositionA,
-            boneWorldPositionB,
-            boneWorldPositionC,
-            targetPosition,
-            0.01,
-            boneA.world.rotation,
-            boneB.world.rotation,
-            targetLocalRotationA,
-            targetLocalRotationB
-        );
-
-        //lerp bone rotations based on influence
-        r0.lerpQuaternions(boneA.local.rotation, targetLocalRotationA, influence);
-        r1.lerpQuaternions(boneB.local.rotation, targetLocalRotationB, influence);
-
-        /*
-         Both lerps are taken before either write, because a write recomposes every world transform
-         below it — reading a bone's pose after moving its parent would read the corrected one.
-        */
-        boneA.local.rotation.copy(r0);
-        boneB.local.rotation.copy(r1);
-    }
-}
+import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
+import Quaternion from "../../../core/geom/Quaternion.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { two_joint_ik } from "../../physics/inverse_kinematics/two_joint_ik.js";
+import { IKBone, ik_bone_chain } from "./ik_bone_chain.js";
+import { ik_probe_terrain_contact } from "./ik_probe_terrain_contact.js";
+import { t64_read_rotation } from "../transform/t64_read_rotation.js";
+import { t64_read_translation } from "../transform/t64_read_translation.js";
+import { IKSolver } from "./IKSolver.js";
+import { ik_write_local_rotation } from "./ik_write_local_rotation.js";
+
+const contact = new SurfacePoint3();
+
+const targetPosition = new Vector3();
+
+const positionA = new Vector3();
+const positionB = new Vector3();
+const positionC = new Vector3();
+
+const worldRotationA = new Quaternion();
+const worldRotationB = new Quaternion();
+
+const localRotationA = new Quaternion();
+const localRotationB = new Quaternion();
+
+const targetLocalRotationA = new Quaternion();
+const targetLocalRotationB = new Quaternion();
+
+const r0 = new Quaternion();
+const r1 = new Quaternion();
+
+/**
+ * effector, its parent, its grandparent
+ *
+ * @type {IKBone[]}
+ */
+const CHAIN = [new IKBone(), new IKBone(), new IKBone()];
+
+export class TwoBoneInverseKinematicsSolver extends IKSolver {
+
+
+    solve(problem) {
+
+        const { dataset, effector, terrain, constraint } = problem;
+
+        if (!ik_bone_chain(CHAIN, dataset, effector, 3)) {
+            // the hierarchy does not hold three links yet
+            return;
+        }
+
+        const boneC = CHAIN[0];
+        const boneB = CHAIN[1];
+        const boneA = CHAIN[2];
+
+        /*
+         The world poses are read straight off the components. There is no matrix to bring up to
+         date first: `TransformAttachmentSystem` composes a world transform the moment anything it
+         depends on changes, so what is on the component is what the hierarchy currently says.
+
+         They are read OUT of the transforms rather than used in place, because `two_joint_ik` is
+         geometry math over vectors and quaternions and a Transform64 is an array with none of their
+         methods on it.
+        */
+        t64_read_translation(positionA, boneA.world);
+        t64_read_translation(positionB, boneB.world);
+        t64_read_translation(positionC, boneC.world);
+
+        //compute total length of the limb
+        const limbLength = positionA.distanceTo(positionB) + positionB.distanceTo(positionC);
+
+        //check if there is a penetration with the terrain between the two bones
+        const influence = ik_probe_terrain_contact(
+            targetPosition,
+            contact,
+            terrain,
+            positionA.x, positionA.y, positionA.z,
+            positionC.x, positionC.y, positionC.z,
+            constraint,
+            limbLength
+        );
+
+        if (influence <= 0) {
+            //no contact, or no influence
+            return;
+        }
+
+        t64_read_rotation(localRotationA, boneA.local);
+        t64_read_rotation(localRotationB, boneB.local);
+
+        t64_read_rotation(worldRotationA, boneA.world);
+        t64_read_rotation(worldRotationB, boneB.world);
+
+        targetLocalRotationA.copy(localRotationA);
+        targetLocalRotationB.copy(localRotationB);
+
+        //compute
+        two_joint_ik(
+            positionA,
+            positionB,
+            positionC,
+            targetPosition,
+            0.01,
+            worldRotationA,
+            worldRotationB,
+            targetLocalRotationA,
+            targetLocalRotationB
+        );
+
+        //lerp bone rotations based on influence
+        r0.lerpQuaternions(localRotationA, targetLocalRotationA, influence);
+        r1.lerpQuaternions(localRotationB, targetLocalRotationB, influence);
+
+        /*
+         Both lerps are taken before either write, because a write recomposes every world transform
+         below it — reading a bone's pose after moving its parent would read the corrected one.
+        */
+        ik_write_local_rotation(dataset, boneA, r0);
+        ik_write_local_rotation(dataset, boneB, r1);
+    }
+}

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

@@ -30,15 +30,26 @@ export class IKBone {
     /**
      * Composed by {@link TransformAttachmentSystem}. Read only.
      *
-     * @type {Transform|null}
+     * @type {Transform64|null}
      */
-    world: Transform | null;
+    world: Transform64 | null;
     /**
      * Relative to the parent bone. This is what a solver writes.
      *
-     * @type {Transform|null}
+     * @type {Transform64|null}
      */
-    local: Transform | null;
+    local: Transform64 | null;
+    /**
+     * The component {@link IKBone#local} belongs to.
+     *
+     * A Transform64 announces nothing when it is written, so a solver has to say that it changed,
+     * and the announcement names the component the hierarchy is listening for - which is this one,
+     * not the transform inside it.
+     *
+     * @type {TransformAttachment|null}
+     */
+    attachment: TransformAttachment | null;
 }
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
+import { TransformAttachment } from "../transform-attachment/TransformAttachment.js";
 //# sourceMappingURL=ik_bone_chain.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ik_bone_chain.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/ik_bone_chain.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;GAaG;AACH,sCARW,MAAM,EAAE,6CAER,MAAM,SACN,MAAM,GACJ,OAAO,CAuCnB;AA/ED;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;;OAIG;IACH,OAFU,SAAS,GAAC,IAAI,CAEX;IAEb;;;;OAIG;IACH,OAFU,SAAS,GAAC,IAAI,CAEX;CAChB;0BA9ByB,2BAA2B"}
+{"version":3,"file":"ik_bone_chain.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/ik_bone_chain.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;GAaG;AACH,sCARW,MAAM,EAAE,6CAER,MAAM,SACN,MAAM,GACJ,OAAO,CAwCnB;AA3FD;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;;OAIG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb;;;;OAIG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb;;;;;;;;OAQG;IACH,YAFU,mBAAmB,GAAC,IAAI,CAEhB;CACrB;4BAzC2B,6BAA6B;oCADrB,gDAAgD"}

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

@@ -1,7 +1,7 @@
 import { assert } from "../../../core/assert.js";
 import { transform_attachment_parent_of } from "../transform-attachment/transform_attachment_parent_of.js";
 import { TransformAttachment } from "../transform-attachment/TransformAttachment.js";
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 
 /**
  * One link of a chain the solvers work on: the entity, the world pose the hierarchy composed for
@@ -21,16 +21,27 @@ export class IKBone {
     /**
      * Composed by {@link TransformAttachmentSystem}. Read only.
      *
-     * @type {Transform|null}
+     * @type {Transform64|null}
      */
     world = null;
 
     /**
      * Relative to the parent bone. This is what a solver writes.
      *
-     * @type {Transform|null}
+     * @type {Transform64|null}
      */
     local = null;
+
+    /**
+     * The component {@link IKBone#local} belongs to.
+     *
+     * A Transform64 announces nothing when it is written, so a solver has to say that it changed,
+     * and the announcement names the component the hierarchy is listening for - which is this one,
+     * not the transform inside it.
+     *
+     * @type {TransformAttachment|null}
+     */
+    attachment = null;
 }
 
 /**
@@ -59,7 +70,7 @@ export function ik_bone_chain(result, dataset, effector, count) {
             return false;
         }
 
-        const world = dataset.getComponent(entity, Transform);
+        const world = dataset.getComponent(entity, Transform64);
 
         if (world === undefined) {
             return false;
@@ -77,6 +88,7 @@ export function ik_bone_chain(result, dataset, effector, count) {
         bone.entity = entity;
         bone.world = world;
         bone.local = attachment.transform;
+        bone.attachment = attachment;
 
         entity = transform_attachment_parent_of(dataset, entity);
     }

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

@@ -25,14 +25,18 @@
  * written when a non-zero influence is returned. Solvers that need the contact normal (surface
  * alignment) read it from here
  * @param {Terrain} terrain
- * @param {Vector3} origin start of the limb, the root bone's world position
- * @param {Vector3} effector world position of the bone being placed. The probe direction is
+ * @param {number} origin_x start of the limb, the root bone's world position
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} effector_x world position of the bone being placed. The probe direction is
  * `effector - origin`, so these must not coincide
+ * @param {number} effector_y
+ * @param {number} effector_z
  * @param {IKConstraint} constraint supplies `offset` (how far off the surface the effector rests)
  * and `distance` (the hover band over which influence falls off)
  * @param {number} length_scale limb length in world units; `constraint.offset` and the hover
  * distance are both expressed relative to it. Must be greater than 0
  * @returns {number} influence in `[0,1]`; `0` means "do nothing"
  */
-export function ik_probe_terrain_contact(out_target: Vector3, out_contact: SurfacePoint3, terrain: Terrain, origin: Vector3, effector: Vector3, constraint: IKConstraint, length_scale: number): number;
+export function ik_probe_terrain_contact(out_target: Vector3, out_contact: SurfacePoint3, terrain: Terrain, origin_x: number, origin_y: number, origin_z: number, effector_x: number, effector_y: number, effector_z: number, constraint: IKConstraint, length_scale: number): number;
 //# sourceMappingURL=ik_probe_terrain_contact.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ik_probe_terrain_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/ik_probe_terrain_contact.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wLAJW,MAAM,GAEJ,MAAM,CA8ElB"}
+{"version":3,"file":"ik_probe_terrain_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/ik_probe_terrain_contact.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,sHAbW,MAAM,YACN,MAAM,YACN,MAAM,cACN,MAAM,cAEN,MAAM,cACN,MAAM,0CAGN,MAAM,GAEJ,MAAM,CA8ElB"}

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

@@ -31,9 +31,13 @@ import { inverseLerp } from "../../../core/math/inverseLerp.js";
  * written when a non-zero influence is returned. Solvers that need the contact normal (surface
  * alignment) read it from here
  * @param {Terrain} terrain
- * @param {Vector3} origin start of the limb, the root bone's world position
- * @param {Vector3} effector world position of the bone being placed. The probe direction is
+ * @param {number} origin_x start of the limb, the root bone's world position
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} effector_x world position of the bone being placed. The probe direction is
  * `effector - origin`, so these must not coincide
+ * @param {number} effector_y
+ * @param {number} effector_z
  * @param {IKConstraint} constraint supplies `offset` (how far off the surface the effector rests)
  * and `distance` (the hover band over which influence falls off)
  * @param {number} length_scale limb length in world units; `constraint.offset` and the hover
@@ -44,22 +48,22 @@ export function ik_probe_terrain_contact(
     out_target,
     out_contact,
     terrain,
-    origin,
-    effector,
+    origin_x, origin_y, origin_z,
+    effector_x, effector_y, effector_z,
     constraint,
     length_scale
 ) {
 
     //check if the there is a penetration with the terrain between the two bones
-    const directionX = effector.x - origin.x;
-    const directionY = effector.y - origin.y;
-    const directionZ = effector.z - origin.z;
+    const directionX = effector_x - origin_x;
+    const directionY = effector_y - origin_y;
+    const directionZ = effector_z - origin_z;
 
     let contactExists = terrain.raycastFirstSync(
         out_contact,
-        origin.x,
-        origin.y,
-        origin.z,
+        origin_x,
+        origin_y,
+        origin_z,
         directionX,
         directionY,
         directionZ
@@ -76,9 +80,9 @@ export function ik_probe_terrain_contact(
     //perform secondary cast from the bone, back along the surface normal
     contactExists = terrain.raycastFirstSync(
         out_contact,
-        effector.x + contactNormal.x,
-        effector.y + contactNormal.y,
-        effector.z + contactNormal.z,
+        effector_x + contactNormal.x,
+        effector_y + contactNormal.y,
+        effector_z + contactNormal.z,
         -contactNormal.x,
         -contactNormal.y,
         -contactNormal.z
@@ -98,9 +102,9 @@ export function ik_probe_terrain_contact(
         contactNormal.x, contactNormal.y, contactNormal.z
     );
 
-    const delta_contact_c_x = out_target.x - effector.x;
-    const delta_contact_c_y = out_target.y - effector.y;
-    const delta_contact_c_z = out_target.z - effector.z;
+    const delta_contact_c_x = out_target.x - effector_x;
+    const delta_contact_c_y = out_target.y - effector_y;
+    const delta_contact_c_z = out_target.z - effector_z;
 
     //check if current effector position is above the contact point
     const dot_contact_side = v3_dot(directionX, directionY, directionZ, delta_contact_c_x, delta_contact_c_y, delta_contact_c_z);