@woosh/meep-engine 3.40.0 → 3.41.0

package/src/engine/physics/ecs/ContactProbeSystem.js

@@ -0,0 +1,397 @@
+import { quat3_multiply } from "../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { quat3_shortest_arc } from "../../../core/geom/3d/quaternion/quat3_shortest_arc.js";
+import { Ray3 } from "../../../core/geom/3d/ray/Ray3.js";
+import { SphereShape3D } from "../../../core/geom/3d/shape/SphereShape3D.js";
+import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
+import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
+import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
+import { Animation } from "../../ecs/animation/Animation.js";
+import { GPUStateAuthority } from "../../ecs/gpu/GPUStateAuthority.js";
+import { ParentEntity } from "../../ecs/parent/ParentEntity.js";
+import { System } from "../../ecs/System.js";
+import { TRANSFORM_ATTACHMENT_EVENT_CHANGE } from "../../ecs/transform-attachment/TRANSFORM_ATTACHMENT_EVENT_CHANGE.js";
+import { TransformAttachment } from "../../ecs/transform-attachment/TransformAttachment.js";
+import { T64WorldCache } from "../../ecs/transform/T64WorldCache.js";
+import {
+    Transform64,
+    TRANSFORM64_ROTATION_OFFSET,
+    TRANSFORM64_SCALE_OFFSET,
+    TRANSFORM64_TRANSLATION_OFFSET
+} from "../../ecs/transform/Transform64.js";
+import { AnimationGraphController } from "../../graphics3/animation/AnimationGraphController.js";
+import { collect_entity_playbacks } from "../../graphics3/pose/collect_entity_playbacks.js";
+import { PhysicsSurfacePoint } from "../queries/PhysicsSurfacePoint.js";
+import { Collider } from "./Collider.js";
+import { ContactProbe } from "./ContactProbe.js";
+import { PhysicsSystem } from "./PhysicsSystem.js";
+
+/**
+ * One linked probe and what its casts need.
+ */
+class ProbeRecord {
+    /**
+     * @type {number}
+     */
+    entity = -1;
+
+    /**
+     * @type {ContactProbe|null}
+     */
+    probe = null;
+
+    /**
+     * @type {TransformAttachment|null}
+     */
+    attachment = null;
+
+    /**
+     * The sphere a non-zero radius casts.
+     * @type {SphereShape3D}
+     */
+    sphere = SphereShape3D.from(1);
+}
+
+const ray = new Ray3();
+const surface = new PhysicsSurfacePoint();
+
+const reference_world = new Transform64();
+const parent_world = new Transform64();
+
+const scratch_q = new Float64Array(4);
+const scratch_arc = new Float64Array(4);
+const scratch_v = new Float64Array(3);
+
+/**
+ * The cast's sphere turns with nothing: its orientation is the identity.
+ * @type {Float64Array}
+ */
+const NO_TURN = Float64Array.of(0, 0, 0, 1);
+
+/**
+ * Casts each {@link ContactProbe} and places its entity at what the cast meets.
+ *
+ * Runs in `update`, where the clips' times for the tick are set: a reference a clip drives is
+ * evaluated exactly (`T64WorldCache`), as the GPU draws it.
+ *
+ * **Register it before a system that reads where it puts its entities** and that writes
+ * `TransformAttachment` too, IK's among them. Both read and write `TransformAttachment`, so the
+ * order declared access derives leaves the two a cycle, and between them the scheduler keeps the
+ * order they were registered in.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ContactProbeSystem extends System {
+
+    dependencies = [ContactProbe, TransformAttachment];
+
+    components_used = [
+        ResourceAccessSpecification.from(ContactProbe, ResourceAccessKind.Read | ResourceAccessKind.Write),
+        ResourceAccessSpecification.from(TransformAttachment, ResourceAccessKind.Read | ResourceAccessKind.Write),
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Read),
+        ResourceAccessSpecification.from(GPUStateAuthority, ResourceAccessKind.Read),
+        ResourceAccessSpecification.from(ParentEntity, ResourceAccessKind.Read),
+        ResourceAccessSpecification.from(Collider, ResourceAccessKind.Read),
+        ResourceAccessSpecification.from(Animation, ResourceAccessKind.Read),
+        ResourceAccessSpecification.from(AnimationGraphController, ResourceAccessKind.Read),
+    ];
+
+    /**
+     * @type {ProbeRecord[]}
+     */
+    #records = [];
+
+    /**
+     * The root of the probe being cast: colliders whose lifetime leads to it are passed through.
+     * @type {number}
+     */
+    #owner = -1;
+
+    /**
+     * {@link #accept}, bound once.
+     * @type {function(number, Collider):boolean}
+     */
+    #filter = (entity, collider) => this.#accept(entity);
+
+    /**
+     * Exact worlds per model, for one tick.
+     * @type {Map<number, T64WorldCache>}
+     */
+    #caches = new Map();
+
+    /**
+     * @type {T64WorldCache[]}
+     */
+    #cache_list = [];
+
+    /**
+     * @type {Map<number, PosePlayback[]>}
+     */
+    #playbacks = new Map();
+
+    /**
+     * Which models' playbacks were collected this tick.
+     * @type {Set<number>}
+     */
+    #collected = new Set();
+
+    /**
+     * @param {ContactProbe} probe
+     * @param {TransformAttachment} attachment
+     * @param {number} entity
+     */
+    link(probe, attachment, entity) {
+        const record = new ProbeRecord();
+
+        record.entity = entity;
+        record.probe = probe;
+        record.attachment = attachment;
+
+        this.#records.push(record);
+    }
+
+    /**
+     * @param {ContactProbe} probe
+     * @param {TransformAttachment} attachment
+     * @param {number} entity
+     */
+    unlink(probe, attachment, entity) {
+        const records = this.#records;
+
+        for (let i = 0; i < records.length; i++) {
+            if (records[i].entity === entity) {
+                records.splice(i, 1);
+                return;
+            }
+        }
+    }
+
+    update(time_delta_seconds) {
+        const em = this.entityManager;
+        const dataset = em.dataset;
+
+        if (dataset === null || dataset === undefined) {
+            return;
+        }
+
+        const physics = em.getSystem(PhysicsSystem);
+
+        if (physics === null) {
+            return;
+        }
+
+        const caches = this.#cache_list;
+
+        for (let i = 0; i < caches.length; i++) {
+            caches[i].invalidate();
+        }
+
+        this.#collected.clear();
+
+        const records = this.#records;
+
+        for (let i = 0; i < records.length; i++) {
+            this.#cast(records[i], physics, dataset);
+        }
+    }
+
+    /**
+     * @param {number} entity
+     * @returns {boolean} whether the cast may stop at this body
+     */
+    #accept(entity) {
+        return root_of(this.entityManager.dataset, entity) !== this.#owner;
+    }
+
+    /**
+     * @param {ProbeRecord} record
+     * @param {PhysicsSystem} physics
+     * @param {EntityComponentDataset} dataset
+     */
+    #cast(record, physics, dataset) {
+        const probe = record.probe;
+        const reference = probe.reference;
+
+        if (!dataset.entityExists(reference)) {
+            probe.hit = false;
+            return;
+        }
+
+        this.#world_of(reference_world, reference);
+
+        const ox = reference_world[TRANSFORM64_TRANSLATION_OFFSET] + probe.offset[0];
+        const oy = reference_world[TRANSFORM64_TRANSLATION_OFFSET + 1] + probe.offset[1];
+        const oz = reference_world[TRANSFORM64_TRANSLATION_OFFSET + 2] + probe.offset[2];
+
+        const dx = probe.direction[0], dy = probe.direction[1], dz = probe.direction[2];
+
+        ray.setOrigin(ox, oy, oz);
+        ray.setDirection(dx, dy, dz);
+        ray.tMax = probe.distance;
+
+        this.#owner = root_of(dataset, record.entity);
+
+        let hit;
+
+        if (probe.radius === 0) {
+            hit = physics.raycast(ray, surface, this.#filter);
+        } else {
+            record.sphere.radius = probe.radius;
+
+            hit = physics.shapeCast(ray, record.sphere, NO_TURN, surface, this.#filter);
+        }
+
+        probe.hit = hit;
+
+        // where the entity goes, and how it is turned, in world
+        let px, py, pz;
+
+        const rx = reference_world[TRANSFORM64_ROTATION_OFFSET];
+        const ry = reference_world[TRANSFORM64_ROTATION_OFFSET + 1];
+        const rz = reference_world[TRANSFORM64_ROTATION_OFFSET + 2];
+        const rw = reference_world[TRANSFORM64_ROTATION_OFFSET + 3];
+
+        if (hit) {
+            const nx = surface.normal[0], ny = surface.normal[1], nz = surface.normal[2];
+
+            // a sphere's centre stands off the surface by its radius
+            px = surface.position[0] - nx * probe.radius;
+            py = surface.position[1] - ny * probe.radius;
+            pz = surface.position[2] - nz * probe.radius;
+
+            // the reference, tilted so that its up is the surface's
+            quat3_shortest_arc(scratch_arc, 0, 0, 1, 0, nx, ny, nz);
+            quat3_multiply(scratch_q, 0, scratch_arc[0], scratch_arc[1], scratch_arc[2], scratch_arc[3], rx, ry, rz, rw);
+        } else {
+            px = reference_world[TRANSFORM64_TRANSLATION_OFFSET];
+            py = reference_world[TRANSFORM64_TRANSLATION_OFFSET + 1];
+            pz = reference_world[TRANSFORM64_TRANSLATION_OFFSET + 2];
+
+            scratch_q[0] = rx;
+            scratch_q[1] = ry;
+            scratch_q[2] = rz;
+            scratch_q[3] = rw;
+        }
+
+        this.#place(record, px, py, pz, dataset);
+    }
+
+    /**
+     * Write the entity's offset so its world pose is `p` turned by `scratch_q`.
+     *
+     * @param {ProbeRecord} record
+     * @param {number} px
+     * @param {number} py
+     * @param {number} pz
+     * @param {EntityComponentDataset} dataset
+     */
+    #place(record, px, py, pz, dataset) {
+        const parent = record.attachment.parent;
+
+        this.#world_of(parent_world, parent);
+
+        // conj(R_p)
+        const cx = -parent_world[TRANSFORM64_ROTATION_OFFSET];
+        const cy = -parent_world[TRANSFORM64_ROTATION_OFFSET + 1];
+        const cz = -parent_world[TRANSFORM64_ROTATION_OFFSET + 2];
+        const cw = parent_world[TRANSFORM64_ROTATION_OFFSET + 3];
+
+        // uniform scale, as TransformAttachment composes
+        const inverse_scale = 1 / parent_world[TRANSFORM64_SCALE_OFFSET];
+
+        v3_quaternion_apply(
+            scratch_v, 0,
+            (px - parent_world[TRANSFORM64_TRANSLATION_OFFSET]) * inverse_scale,
+            (py - parent_world[TRANSFORM64_TRANSLATION_OFFSET + 1]) * inverse_scale,
+            (pz - parent_world[TRANSFORM64_TRANSLATION_OFFSET + 2]) * inverse_scale,
+            cx, cy, cz, cw
+        );
+
+        quat3_multiply(scratch_arc, 0, cx, cy, cz, cw, scratch_q[0], scratch_q[1], scratch_q[2], scratch_q[3]);
+
+        const local = record.attachment.transform;
+
+        local.setTranslation(scratch_v[0], scratch_v[1], scratch_v[2]);
+        local.setRotation(scratch_arc[0], scratch_arc[1], scratch_arc[2], scratch_arc[3]);
+        local.updateMatrix();
+
+        dataset.sendEvent(record.entity, TRANSFORM_ATTACHMENT_EVENT_CHANGE);
+    }
+
+    /**
+     * The entity's world pose this tick, exactly, under its own model's clips.
+     *
+     * @param {Transform64} result
+     * @param {number} entity
+     */
+    #world_of(result, entity) {
+        const dataset = this.entityManager.dataset;
+
+        const model = model_of(dataset, entity);
+
+        let cache = this.#caches.get(model);
+
+        if (cache === undefined) {
+            cache = new T64WorldCache();
+            this.#caches.set(model, cache);
+            this.#cache_list.push(cache);
+        }
+
+        let playbacks = this.#playbacks.get(model);
+
+        if (playbacks === undefined) {
+            playbacks = [];
+            this.#playbacks.set(model, playbacks);
+        }
+
+        if (!this.#collected.has(model)) {
+            this.#collected.add(model);
+
+            playbacks.length = 0;
+
+            collect_entity_playbacks(playbacks, this.entityManager, model);
+        }
+
+        cache.evaluate(result, dataset, entity, playbacks);
+    }
+}
+
+/**
+ * The entity whose clips drive `entity`: the model its lifetime belongs to, or itself.
+ *
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ * @returns {number}
+ */
+function model_of(dataset, entity) {
+    const owner = dataset.getComponent(entity, ParentEntity);
+
+    if (owner === undefined || owner === null) {
+        return entity;
+    }
+
+    return owner.entity;
+}
+
+/**
+ * The top of the lifetime chain an entity belongs to.
+ *
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ * @returns {number}
+ */
+function root_of(dataset, entity) {
+    let e = entity;
+
+    for (let guard = 0; guard < 1024; guard++) {
+        const owner = dataset.getComponent(e, ParentEntity);
+
+        if (owner === undefined || owner === null || owner.entity < 0) {
+            return e;
+        }
+
+        e = owner.entity;
+    }
+
+    return e;
+}

package/src/engine/physics/fluid/ecs/FluidComponent.d.ts

@@ -20,7 +20,7 @@
  * origin} becomes system-managed in this case.
  *
  * NOTE on layout: sibling physics ECS code lives under `engine/ecs/*` (see
- * `engine/ecs/ik/InverseKinematicsSystem.js`). This component is placed inside the
+ * `engine/ecs/ik/IKGoalSystem.js`). This component is placed inside the
  * fluid package because edits to the ECS folder were out-of-scope when it was first
  * written. Moving it under `engine/ecs/fluid/` later is a pure relocation.
  */

package/src/engine/physics/fluid/ecs/FluidComponent.js

@@ -24,7 +24,7 @@ import { FluidField } from "../FluidField.js";
  * origin} becomes system-managed in this case.
  *
  * NOTE on layout: sibling physics ECS code lives under `engine/ecs/*` (see
- * `engine/ecs/ik/InverseKinematicsSystem.js`). This component is placed inside the
+ * `engine/ecs/ik/IKGoalSystem.js`). This component is placed inside the
  * fluid package because edits to the ECS folder were out-of-scope when it was first
  * written. Moving it under `engine/ecs/fluid/` later is a pure relocation.
  */

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -66,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#423@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#426@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#423@#clear_field"(fluid: FluidComponent): void;
+    static "__#426@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -82,7 +82,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#423@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#426@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -102,7 +102,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#423@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#426@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];

package/src/engine/physics/inverse_kinematics/frame_fabrik/FrameFabrikProblem.d.ts

@@ -0,0 +1,205 @@
+/**
+ * One tree for {@link frame_fabrik_solve} to pose: its joints, as the animation left them, the goals
+ * pulling on them, and, once solved, where they went.
+ *
+ * Every array is sized once, at construction, for the most joints and goals the problem will ever
+ * hold; a solve allocates nothing. Joints are indices into the problem, not entities: the problem
+ * knows nothing about where its tree came from.
+ *
+ * The caller fills the inputs and {@link joint_count} / {@link goal_count}; the fields under "solver
+ * state" belong to the solver, which overwrites them on every solve.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class FrameFabrikProblem {
+    /**
+     * @param {number} joint_capacity the most joints a solve will be given
+     * @param {number} goal_capacity the most goals a solve will be given
+     */
+    constructor(joint_capacity: number, goal_capacity: number);
+    /**
+     * @readonly
+     * @type {number}
+     */
+    readonly joint_capacity: number;
+    /**
+     * @readonly
+     * @type {number}
+     */
+    readonly goal_capacity: number;
+    /**
+     * How many joints this solve poses.
+     * @type {number}
+     */
+    joint_count: number;
+    /**
+     * How many goals pull on them.
+     * @type {number}
+     */
+    goal_count: number;
+    /**
+     * Each joint's parent, as an index into this problem, or -1 for a joint whose parent the solve
+     * does not pose: its parent's frame is fixed, as animated. Every parent comes before its
+     * children, `joint_parent[i] < i`.
+     * @type {Int32Array}
+     */
+    joint_parent: Int32Array;
+    /**
+     * Where each joint is as animated, in world. Packed `[x, y, z]` per joint.
+     * @type {Float64Array}
+     */
+    base_position: Float64Array;
+    /**
+     * How each joint is turned as animated, in world, a unit quaternion. Packed `[x, y, z, w]` per
+     * joint.
+     * @type {Float64Array}
+     */
+    base_rotation: Float64Array;
+    /**
+     * How each joint is turned relative to its parent as animated, a unit quaternion: the parent's
+     * {@link base_rotation} composed with it is the joint's. For a joint whose parent is not posed,
+     * relative to that parent, whose frame it gives the solve. Packed `[x, y, z, w]` per joint.
+     * @type {Float64Array}
+     */
+    base_local_rotation: Float64Array;
+    /**
+     * 1 for a joint whose turn relative to its parent is limited, by {@link limit_basis_a},
+     * {@link limit_basis_b}, {@link limit_lower} and {@link limit_upper}; 0 for one that turns
+     * freely.
+     * @type {Uint8Array}
+     */
+    joint_limited: Uint8Array;
+    /**
+     * The limit's frame in the parent's, a unit quaternion: a physics `Joint`'s `localBasisA`.
+     * Packed `[x, y, z, w]` per joint.
+     * @type {Float64Array}
+     */
+    limit_basis_a: Float64Array;
+    /**
+     * The limit's frame in the joint's own, a unit quaternion: a physics `Joint`'s `localBasisB`.
+     * Packed `[x, y, z, w]` per joint.
+     * @type {Float64Array}
+     */
+    limit_basis_b: Float64Array;
+    /**
+     * Lower bounds of the turn of frame B relative to frame A, as `swing_twist_error_array`
+     * measures it: `[twist about X, swing Y, swing Z]` per joint, radians. `-Infinity` for an
+     * axis that turns freely, 0 for a locked one.
+     * @type {Float64Array}
+     */
+    limit_lower: Float64Array;
+    /**
+     * Upper bounds, as {@link limit_lower}.
+     * @type {Float64Array}
+     */
+    limit_upper: Float64Array;
+    /**
+     * The joint each goal pulls on.
+     * @type {Int32Array}
+     */
+    goal_effector: Int32Array;
+    /**
+     * The highest joint each goal turns: its effector or an ancestor of it. The goal's path runs
+     * from the effector up to here. This joint turns and never moves.
+     * @type {Int32Array}
+     */
+    goal_root: Int32Array;
+    /**
+     * How hard each goal pulls, 0..1. 0 gives the pose the solve gives without the goal, and the
+     * pose is continuous in it.
+     * @type {Float64Array}
+     */
+    goal_weight: Float64Array;
+    /**
+     * The joint each goal's target hangs below, or -1 for a target the solve does not move. A
+     * target hanging below a joint is carried by that joint's frame as the solve turns it, read
+     * afresh on every iteration.
+     * @type {Int32Array}
+     */
+    goal_target_joint: Int32Array;
+    /**
+     * Where each goal wants its effector, in world, as animated: the frame of
+     * {@link goal_target_joint} carries it from there. Packed `[x, y, z]` per goal.
+     * @type {Float64Array}
+     */
+    goal_target: Float64Array;
+    /**
+     * The solved pose: where each joint went, in world. Packed `[x, y, z]` per joint.
+     * @type {Float64Array}
+     */
+    solved_position: Float64Array;
+    /**
+     * The solved pose: how each joint is turned, in world. Packed `[x, y, z, w]` per joint.
+     * @type {Float64Array}
+     */
+    solved_rotation: Float64Array;
+    /**
+     * Each joint's place in its parent's frame, as animated: the rigid offset the solve keeps.
+     * @type {Float64Array}
+     */
+    _offset: Float64Array;
+    /**
+     * The weight of the link from each joint's parent to it: the heaviest goal whose path holds
+     * both ends. 0 for a link no path holds.
+     * @type {Float64Array}
+     */
+    _link_weight: Float64Array;
+    /**
+     * Children of joint `i` are `_child[_child_start[i] .. _child_start[i + 1]]`.
+     * @type {Int32Array}
+     */
+    _child_start: Int32Array;
+    /**
+     * @type {Int32Array}
+     */
+    _child: Int32Array;
+    /**
+     * How many goals of non-zero weight have the joint on their path.
+     * @type {Int32Array}
+     */
+    _path_count: Int32Array;
+    /**
+     * 1 for a joint some goal's path holds below that goal's root.
+     * @type {Uint8Array}
+     */
+    _interior: Uint8Array;
+    /**
+     * 1 for a joint that turns and never moves: a goal's root no path holds below its own root.
+     * @type {Uint8Array}
+     */
+    _root_only: Uint8Array;
+    /**
+     * The goal whose effector the joint is, or -1.
+     * @type {Int32Array}
+     */
+    _effector_goal: Int32Array;
+    /**
+     * The joint whose frame carries each goal's effector when the goal does not pull: the deepest
+     * joint of its path another goal's path holds too, else its root's parent (-1 when that is
+     * not posed).
+     * @type {Int32Array}
+     */
+    _goal_anchor: Int32Array;
+    /**
+     * The effector in its anchor's frame, as animated. Packed `[x, y, z]` per goal.
+     * @type {Float64Array}
+     */
+    _goal_anchor_offset: Float64Array;
+    /**
+     * Each target in its target joint's frame, as animated. Packed `[x, y, z]` per goal.
+     * @type {Float64Array}
+     */
+    _goal_target_local: Float64Array;
+    /**
+     * This iteration's target for each effector. Packed `[x, y, z]` per goal.
+     * @type {Float64Array}
+     */
+    _target: Float64Array;
+    /**
+     * Where each joint was before this iteration, to measure how far the iteration moved it.
+     * @type {Float64Array}
+     */
+    _previous: Float64Array;
+}
+//# sourceMappingURL=FrameFabrikProblem.d.ts.map

package/src/engine/physics/inverse_kinematics/frame_fabrik/FrameFabrikProblem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrameFabrikProblem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/inverse_kinematics/frame_fabrik/FrameFabrikProblem.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;IAEI;;;OAGG;IACH,4BAHW,MAAM,iBACN,MAAM,EA+NhB;IAzNG;;;OAGG;IACH,yBAFU,MAAM,CAEoB;IAEpC;;;OAGG;IACH,wBAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,aAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;;;OAKG;IACH,cAFU,UAAU,CAE8B;IAElD;;;OAGG;IACH,eAFU,YAAY,CAEmC;IAEzD;;;;OAIG;IACH,eAFU,YAAY,CAEmC;IAEzD;;;;;OAKG;IACH,qBAFU,YAAY,CAEyC;IAE/D;;;;;OAKG;IACH,eAFU,UAAU,CAE+B;IAEnD;;;;OAIG;IACH,eAFU,YAAY,CAEmC;IAEzD;;;;OAIG;IACH,eAFU,YAAY,CAEmC;IAEzD;;;;;OAKG;IACH,aAFU,YAAY,CAEiC;IAEvD;;;OAGG;IACH,aAFU,YAAY,CAEiC;IAEvD;;;OAGG;IACH,eAFU,UAAU,CAE8B;IAElD;;;;OAIG;IACH,WAFU,UAAU,CAE0B;IAE9C;;;;OAIG;IACH,aAFU,YAAY,CAE4B;IAElD;;;;;OAKG;IACH,mBAFU,UAAU,CAEkC;IAEtD;;;;OAIG;IACH,aAFU,YAAY,CAEgC;IAEtD;;;OAGG;IACH,iBAFU,YAAY,CAEqC;IAE3D;;;OAGG;IACH,iBAFU,YAAY,CAEqC;IAI3D;;;OAGG;IACH,SAFU,YAAY,CAE6B;IAEnD;;;;OAIG;IACH,cAFU,YAAY,CAE8B;IAEpD;;;OAGG;IACH,cAFU,UAAU,CAEkC;IAEtD;;OAEG;IACH,QAFU,UAAU,CAEwB;IAE5C;;;OAGG;IACH,aAFU,UAAU,CAE6B;IAEjD;;;OAGG;IACH,WAFU,UAAU,CAE2B;IAE/C;;;OAGG;IACH,YAFU,UAAU,CAE4B;IAEhD;;;OAGG;IACH,gBAFU,UAAU,CAEgC;IAEpD;;;;;OAKG;IACH,cAFU,UAAU,CAE6B;IAEjD;;;OAGG;IACH,qBAFU,YAAY,CAEwC;IAE9D;;;OAGG;IACH,oBAFU,YAAY,CAEuC;IAE7D;;;OAGG;IACH,SAFU,YAAY,CAE4B;IAElD;;;OAGG;IACH,WAFU,YAAY,CAE+B;CAE5D"}