@woosh/meep-engine 3.38.0 → 3.39.0

package/src/engine/control/first-person/abilities/Ability.d.ts

@@ -57,10 +57,18 @@ export class Ability {
     onActivate(controller: any, runtime: any): void;
     /**
      * Runs each fixed step while active. The ability OWNS body motion
-     * during this window — writes directly to runtime.velocity*, the body
-     * Transform position, springs, etc. Returning false releases control
-     * back to the AbilitySet (which will run base locomotion or the next
-     * queued ability in the same tick).
+     * during this window — writes directly to runtime.velocity*, the
+     * body's position for this tick, springs, etc. Returning false releases
+     * control back to the AbilitySet (which will run base locomotion or the
+     * next queued ability in the same tick).
+     *
+     * The body's position for this tick is `runtime.bodyPosition`, never the
+     * transform: the tick hands it to the body at its end, and the physics
+     * step moves the body there at the speed that covers the distance. Write
+     * it to move the body (the system's `_resolveMotion` sweeps a velocity
+     * into it); set `runtime.bodyTeleport` as well for a warp, which the body
+     * makes with no velocity. A write to `bodyTransform` is taken for a
+     * teleport made by someone else, and the tick's own move is dropped.
      *
      * The `system` parameter is the {@link FirstPersonPlayerControllerSystem}
      * itself, passed through so abilities can call shared helpers like
@@ -70,7 +78,8 @@ export class Ability {
      *
      * @param {*} controller
      * @param {*} runtime
-     * @param {*} bodyTransform
+     * @param {*} bodyTransform the body's transform, holding the pose the
+     *   tick started from
      * @param {number} dt
      * @param {*} system  the FirstPersonPlayerControllerSystem instance
      * @returns {boolean} true = stay active; false = release control

package/src/engine/control/first-person/abilities/Ability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ability.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Ability.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACI;;;;;;;OAOG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,MAFU,MAAM,CAEC;IAEjB;;;;;;;;;;;;OAYG;IAEH,0DAHa,OAAO,CAKnB;IAED;;;;;;OAMG;IAEH,gDAAkC;IAElC;;;;;;;;;;;;;;;;;;;OAmBG;IAEH,4DALW,MAAM,gBAEJ,OAAO,CAKnB;IAED;;;;;;;;;;;OAWG;IAEH,6CAHa,OAAO,CAKnB;IAED;;;;;;OAMG;IAEH,kDAAoC;CACvC"}
+{"version":3,"file":"Ability.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Ability.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACI;;;;;;;OAOG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,MAFU,MAAM,CAEC;IAEjB;;;;;;;;;;;;OAYG;IAEH,0DAHa,OAAO,CAKnB;IAED;;;;;;OAMG;IAEH,gDAAkC;IAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IAEH,4DALW,MAAM,gBAEJ,OAAO,CAKnB;IAED;;;;;;;;;;;OAWG;IAEH,6CAHa,OAAO,CAKnB;IAED;;;;;;OAMG;IAEH,kDAAoC;CACvC"}

package/src/engine/control/first-person/abilities/Ability.js

@@ -65,10 +65,18 @@ export class Ability {
 
     /**
      * Runs each fixed step while active. The ability OWNS body motion
-     * during this window — writes directly to runtime.velocity*, the body
-     * Transform position, springs, etc. Returning false releases control
-     * back to the AbilitySet (which will run base locomotion or the next
-     * queued ability in the same tick).
+     * during this window — writes directly to runtime.velocity*, the
+     * body's position for this tick, springs, etc. Returning false releases
+     * control back to the AbilitySet (which will run base locomotion or the
+     * next queued ability in the same tick).
+     *
+     * The body's position for this tick is `runtime.bodyPosition`, never the
+     * transform: the tick hands it to the body at its end, and the physics
+     * step moves the body there at the speed that covers the distance. Write
+     * it to move the body (the system's `_resolveMotion` sweeps a velocity
+     * into it); set `runtime.bodyTeleport` as well for a warp, which the body
+     * makes with no velocity. A write to `bodyTransform` is taken for a
+     * teleport made by someone else, and the tick's own move is dropped.
      *
      * The `system` parameter is the {@link FirstPersonPlayerControllerSystem}
      * itself, passed through so abilities can call shared helpers like
@@ -78,7 +86,8 @@ export class Ability {
      *
      * @param {*} controller
      * @param {*} runtime
-     * @param {*} bodyTransform
+     * @param {*} bodyTransform the body's transform, holding the pose the
+     *   tick started from
      * @param {number} dt
      * @param {*} system  the FirstPersonPlayerControllerSystem instance
      * @returns {boolean} true = stay active; false = release control

package/src/engine/control/first-person/abilities/LedgeGrab.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LedgeGrab.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/LedgeGrab.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAII;;;;iCAI6B;IAC7B,iBAAa;IAEb,iBAAa;IACb,YAAQ;IACR,YAAQ;IACR,eAAW;IAEX;mEAC+D;IAC/D,aAAkB;IAElB,0BAAiC;IAEjC,kEAiCC;IAED,gDAuDC;IAED,wBAIC;IAED,kDAOC;IAED,wFA6GC;IAED;;;;;;OAMG;IACH,sBASC;IAED;;;;;;;OAOG;IACH,yBAgBC;IAED;;;;;;;;;;;;;;OAcG;IACH,mBA8CC;CACJ;wBA7YuB,cAAc;oCAFF,iDAAiD"}
+{"version":3,"file":"LedgeGrab.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/LedgeGrab.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAII;;;;iCAI6B;IAC7B,iBAAa;IAEb,iBAAa;IACb,YAAQ;IACR,YAAQ;IACR,eAAW;IAEX;mEAC+D;IAC/D,aAAkB;IAElB,0BAAiC;IAEjC,kEAiCC;IAED,gDAuDC;IAED,wBAIC;IAED,kDAOC;IAED,wFAiHC;IAED;;;;;;OAMG;IACH,sBASC;IAED;;;;;;;OAOG;IACH,yBAgBC;IAED;;;;;;;;;;;;;;OAcG;IACH,mBA8CC;CACJ;wBAjZuB,cAAc;oCAFF,iDAAiD"}

package/src/engine/control/first-person/abilities/LedgeGrab.js

@@ -267,21 +267,25 @@ export class LedgeGrab extends Ability {
         //    when the ledge was reached obliquely (a facing-relative offset
         //    would sink it into a thin wall).
         const standoff = controller.config.body.radius + cfg.hangOffsetForward;
-        bodyTransform.setTranslation(
-            this._anchorX + this._nx * standoff,
-            this._edgeY + cfg.hangOffsetY,
-            this._anchorZ + this._nz * standoff,
-        );
+        const position = runtime.bodyPosition;
+        position[0] = this._anchorX + this._nx * standoff;
+        position[1] = this._edgeY + cfg.hangOffsetY;
+        position[2] = this._anchorZ + this._nz * standoff;
         runtime.velocityX = 0;
         runtime.velocityY = 0;
         runtime.velocityZ = 0;
         controller.state.grounded = false;
 
-        // Teleport-snap the camera on a parked (non-shimmying) hang: the body
-        // was just snapped onto the wall from wherever it was falling, so the
-        // render interpolation must JUMP to the hang pose, not glide into it.
-        // During a shimmy the body moves smoothly, so we let it interpolate.
-        if (!shimmying) runtime.renderSnap = true;
+        // A parked (non-shimmying) hang is a warp: the body was just snapped
+        // onto the wall from wherever it was falling, so it gets there with
+        // no velocity from the jump (setPose, not a target), and the render
+        // interpolation must JUMP to the hang pose, not glide into it. A
+        // shimmy step is a motion: the body moves to it at the shimmy speed,
+        // and the camera interpolates.
+        if (!shimmying) {
+            runtime.bodyTeleport = true;
+            runtime.renderSnap = true;
+        }
 
         // Exertion rises while hanging — fatigue. Faster while actively
         // shimmying. Mass-scaled like the rest of the exertion system.
@@ -334,7 +338,7 @@ export class LedgeGrab extends Ability {
         );
         ray.setDirection(0, -1, 0);
         ray.tMax = cfg.shimmyContinuityProbeUp + cfg.shimmyContinuityProbeDown;
-        const filter = (_e, c) => c !== runtime.collider;
+        const filter = runtime.notSelf; // every collider of the player's own body
         if (!physics.raycast(ray, hit, filter)) return false;
         return Math.abs(hit.position[1] - this._edgeY) <= cfg.shimmyContinuityTol;
     }
@@ -364,7 +368,7 @@ export class LedgeGrab extends Ability {
         const tx = dir * (-this._nz);
         const tz = dir * this._nx;
         const step = cfg.shimmySpeed * dt;
-        const filter = (_e, c) => c !== runtime.collider; // exclude own body
+        const filter = runtime.notSelf; // every collider of the player's own body
         const ray = this._ray;
         const hit = this._hit;
 

package/src/engine/control/first-person/abilities/Mantle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Mantle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Mantle.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAKI,6CAA6C;IAC7C,WAAO;IAEP,uCAAuC;IACvC,kBAAgB;IAEhB,gBAAY;IACZ,gBAAY;IACZ,gBAAY;IACZ,cAAU;IACV,cAAU;IACV,cAAU;IAEV;;0EAEsE;IACtE,cAAiB;IAEjB,8CAA8C;IAC9C,eAAW;IAEX,kEAgCC;IAED,gDAiEC;IAED,wBAGC;IAED,wFA0DC;IAED,oDAEC;CACJ;wBA3OuB,cAAc"}
+{"version":3,"file":"Mantle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Mantle.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAKI,6CAA6C;IAC7C,WAAO;IAEP,uCAAuC;IACvC,kBAAgB;IAEhB,gBAAY;IACZ,gBAAY;IACZ,gBAAY;IACZ,cAAU;IACV,cAAU;IACV,cAAU;IAEV;;0EAEsE;IACtE,cAAiB;IAEjB,8CAA8C;IAC9C,eAAW;IAEX,kEAgCC;IAED,gDAiEC;IAED,wBAGC;IAED,wFA8DC;IAED,oDAEC;CACJ;wBA/OuB,cAAc"}

package/src/engine/control/first-person/abilities/Mantle.js

@@ -201,7 +201,11 @@ export class Mantle extends Ability {
         } else {
             y = this._startY + (this._endY - this._startY) * easeOutCubic(t);
         }
-        bodyTransform.setTranslation(x, y, z);
+        // A motion along the path: the body moves to each point at the speed that covers the step.
+        const position = runtime.bodyPosition;
+        position[0] = x;
+        position[1] = y;
+        position[2] = z;
         // On the path — no integration; velocity stays 0 until release.
         runtime.velocityX = 0;
         runtime.velocityY = 0;

package/src/engine/control/first-person/abilities/Slide.js

@@ -126,7 +126,7 @@ export class Slide extends Ability {
             runtime.velocityY = runtime.jumpInitialVy * cfg.slideJumpUpFactor;
             runtime.midJump = true;
             runtime.apexFired = false;
-            runtime.peakAltitude = bodyTransform.translation_y;
+            runtime.peakAltitude = runtime.bodyPosition[1];
             controller.state.isVariableJumpCut = false;
             controller.state.isAscending = true;
             // Mastery: scale the impulse via JumpImpulse evaluators if any.

package/src/engine/control/first-person/collision/KinematicMover.d.ts

@@ -2,8 +2,8 @@
  * Kinematic character collision solver. See DESIGN_COLLISION.md.
  *
  * **The mover is controller-agnostic, and the path it lives at says otherwise.** It imports
- * `Vector3`, `Ray3`, `Transform64`, `Collider`, `compute_penetration` and `PhysicsSurfacePoint` —
- * nothing from `FirstPersonPlayerController`. If you have your own movement model and have decided
+ * `assert`, `Vector3`, `Ray3`, `v3_add`, `v3_set`, `Collider`, `is_sensor`, `compute_penetration`,
+ * `convex_overlaps_shape` and `PhysicsSurfacePoint` — nothing from `FirstPersonPlayerController`. If you have your own movement model and have decided
  * that controller is not for you, **this class still is**: it carries the standoff (`skin`), the
  * start-solid depenetration pass, Quake's five-plane crease handling and `MIN_WALK_NORMAL`, and it
  * is the thing to build a character on. It sits under `control/first-person/` because that is where
@@ -33,11 +33,9 @@
  */
 export class KinematicMover {
     /**
-     * @param {import("../../../physics/ecs/PhysicsSystem.js").PhysicsSystem} physicsSystem
-     * @param {import("../../../ecs/EntityComponentDataset.js").EntityComponentDataset} ecd
-     *   used to resolve an overlapping `body_id` (via
-     *   `physicsSystem.entityOf`) back to its {@link Transform64} +
-     *   {@link Collider} for `compute_penetration`.
+     * @param {import("../../../physics/ecs/PhysicsSystem.js").PhysicsSystem} physicsSystem the
+     *   world the mover queries; recovery also takes an overlapping body's colliders, each at its
+     *   own world transform, from it ({@link PhysicsSystem#collidersOf})
      * @param {object} [options]
      * @param {number} [options.skin=0.005] clearance left after each
      *   sweep stop / push-out so the next query doesn't start in contact.
@@ -63,7 +61,7 @@ export class KinematicMover {
      *   Source `sv_stepsize` is ~0.34 m; the default is just under the
      *   capsule radius so low ledges don't feel "magnetic".
      */
-    constructor(physicsSystem: import("../../../physics/ecs/PhysicsSystem.js").PhysicsSystem, ecd: import("../../../ecs/EntityComponentDataset.js").EntityComponentDataset, options?: {
+    constructor(physicsSystem: import("../../../physics/ecs/PhysicsSystem.js").PhysicsSystem, options?: {
         skin?: number;
         maxSlideIterations?: number;
         maxRecoverIterations?: number;
@@ -72,11 +70,20 @@ export class KinematicMover {
     });
     _ray: Ray3;
     _hit: PhysicsSurfacePoint;
+    /**
+     * Overlap query output. Grown by {@link _overlapAll} whenever a query fills it, and the
+     * high-water mark kept: the query caps its count at the buffer and drops the rest without a
+     * word, and the body it drops can be the one the capsule is deepest in.
+     * @type {Uint32Array}
+     */
     _overlapBuf: Uint32Array;
     _penDir: Float64Array;
+    _otherPosition: Float64Array;
+    _otherRotation: Float64Array;
     _planes: Float64Array;
     _cand: Float64Array;
     _support: Float64Array;
+    _supportDir: Float64Array;
     /**
      * Reused result.
      *
@@ -118,8 +125,21 @@ export class KinematicMover {
      * @type {boolean}
      */
     private _wasGrounded;
+    /**
+     * The filter of the {@link move} in progress, for {@link _solidCast}, which the shape cast
+     * calls back without it. `null` between moves.
+     * @private
+     * @type {((entity:number, collider:Collider)=>boolean)|null}
+     */
+    private _filter;
+    /**
+     * Shape-cast filter for the move in progress: {@link _isSolid} with the move's filter. Made once
+     * per mover, so a cast allocates no closure.
+     * @private
+     * @type {(entity:number, collider:Collider, body_id:number)=>boolean}
+     */
+    private _solidCast;
     physicsSystem: import("../../../physics/ecs/PhysicsSystem.js").PhysicsSystem;
-    ecd: import("../../../ecs/EntityComponentDataset.js").EntityComponentDataset;
     skin: number;
     maxSlideIterations: number;
     maxRecoverIterations: number;
@@ -129,17 +149,23 @@ export class KinematicMover {
      * Resolve one move. Mutates `position` to the resolved location and
      * `velocity` to the corrected value.
      *
-     * @param {Vector3} position in/out — current pose, written to the resolved pose
+     * @param {Vector3|Float64Array} position in/out, `[x, y, z]` — current pose, written to the
+     *   resolved pose. The caller's own array: hand it a body's live translation and the move lands
+     *   in the body as it is resolved
      * @param {ArrayLike<number>} rotation capsule orientation as `[x, y, z, w]` (read) - a
-     *   Quaternion is one, and so is a Transform64's rotation
+     *   Quaternion is one. A Transform64's `rotation` is one too, but its getter builds a new view
+     *   on every read; copy the four components into a retained array instead
      * @param {import("../../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D} shape convex capsule
      * @param {Vector3} velocity in/out — desired velocity, written to the corrected velocity
      * @param {number} dt
-     * @param {(entity:number, collider:Collider)=>boolean} filter excludes
-     *   the player's own body in integration; accept-all in isolation
+     * @param {(entity:number, collider:Collider)=>boolean} filter required: which colliders the
+     *   move collides with, asked with the owning body's entity — exclude the moving body's own
+     *   colliders here; pass an accept-all function to collide with everything. Sensors (a
+     *   collider or body flagged IsSensor) are never solid to the mover, whatever this says: the
+     *   capsule passes through a trigger and is never pushed out of one
      * @returns {{hit:boolean, grounded:boolean, groundNormal:Vector3, groundBody:number, groundEntity:number, stepUp:number, landed:boolean, landingSpeed:number}} reused result — see {@link _result} for what each field is for
      */
-    move(position: Vector3, rotation: ArrayLike<number>, shape: import("../../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D, velocity: Vector3, dt: number, filter: (entity: number, collider: Collider) => boolean): {
+    move(position: Vector3 | Float64Array, rotation: ArrayLike<number>, shape: import("../../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D, velocity: Vector3, dt: number, filter: (entity: number, collider: Collider) => boolean): {
         hit: boolean;
         grounded: boolean;
         groundNormal: Vector3;
@@ -149,6 +175,11 @@ export class KinematicMover {
         landed: boolean;
         landingSpeed: number;
     };
+    /**
+     * {@link move}, with {@link _filter} set for the shape casts.
+     * @private
+     */
+    private _move;
     /**
      * Stair step-up. Called after a slide that hit something while the
      * player was trying to move horizontally on the ground. Re-runs the
@@ -185,9 +216,56 @@ export class KinematicMover {
      * cap is hit. Deepest-first converges multi-body resting contact
      * (each pass removes the worst offender) without solving a system.
      *
+     * The query reports BODIES, and a body is every collider attached to it, each at its own world
+     * transform - a compound body's colliders live on child entities, away from the body's pose.
+     * The query stops at the first of a body's colliders it finds overlapping, so the rest are
+     * tested again here, one by one ({@link convex_overlaps_shape}), and the depth is measured only
+     * against those the `filter` accepts AND the capsule overlaps; the body entity's own `Collider`
+     * component, when it has one, is only one of them.
+     *
      * @private
      */
     private _recover;
+    /**
+     * Whether a collider is something the capsule collides with: not a sensor — a trigger is not a
+     * solid surface, by its own flag or its body's ({@link is_sensor}) — and accepted by the move's
+     * `filter`. The raycast already passes through sensors by itself; the shape cast and the overlap
+     * query report them, and other callers may want them reported, so the mover drops them here.
+     *
+     * @private
+     * @param {(entity:number, collider:Collider)=>boolean} filter
+     * @param {number} body_id the body the collider belongs to
+     * @param {number} entity that body's entity
+     * @param {Collider} collider
+     * @returns {boolean}
+     */
+    private _isSolid;
+    /**
+     * Whether the shape overlaps any solid collider ({@link _isSolid}), each collider of an
+     * overlapping body tested on its own.
+     *
+     * @private
+     * @returns {boolean}
+     */
+    private _overlapsSolid;
+    /**
+     * Copy a collider's world pose into {@link _otherPosition} / {@link _otherRotation}. A
+     * Transform64's `translation` and `rotation` getters build a new view on every read; recovery
+     * reads one pose per collider per pass, and that was the allocation it made.
+     *
+     * @private
+     * @param {import("../../../ecs/transform/Transform64.js").Transform64} transform
+     */
+    private _readPose;
+    /**
+     * Every body the shape overlaps, into {@link _overlapBuf}; returns the count. The query caps
+     * its count at the buffer's capacity and drops the rest silently, so a full buffer is grown
+     * (doubled) and the query run again until the count fits.
+     *
+     * @private
+     * @returns {number}
+     */
+    private _overlapAll;
     /**
      * Unified 3D collide-and-slide. Faithful to Quake's `SV_FlyMove`:
      * sweep the velocity for the remaining time, stop at contact, clip

package/src/engine/control/first-person/collision/KinematicMover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KinematicMover.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/collision/KinematicMover.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA0DI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,2BA9BW,OAAO,uCAAuC,EAAE,aAAa,OAC7D,OAAO,wCAAwC,EAAE,sBAAsB;QAKtD,IAAI,GAArB,MAAM;QAEW,kBAAkB,GAAnC,MAAM;QAEW,oBAAoB,GAArC,MAAM;QAEW,aAAa,GAA9B,MAAM;QAIW,UAAU,GAA3B,MAAM;OAuBhB;IAhGD,WAAkB;IAElB,0BAAiC;IACjC,yBAAkC;IAClC,sBAA8B;IAC9B,sBAAgD;IAChD,oBAA4B;IAC5B,uBAA+B;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAFU;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CAgBzJ;IAEF;;;;OAIG;IACH,qBAAqB;IAkCjB,6EAAkC;IAClC,6EAAc;IACd,aAA6D;IAC7D,2BAAmG;IACnG,6BAAyG;IACzG,sBAAsF;IACtF,mBAA6E;IAIjF;;;;;;;;;;;;;OAaG;IACH,eAVW,OAAO,YACP,UAAU,MAAM,CAAC,SAEjB,OAAO,mDAAmD,EAAE,eAAe,YAC3E,OAAO,MACP,MAAM,UACN,CAAC,MAAM,EAAC,MAAM,EAAE,QAAQ,EAAC,QAAQ,KAAG,OAAO,GAEzC;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CA6E7J;IAED;;;;;;;;;;;;;;OAcG;IACH,mBAiGC;IAED;;;;OAIG;IACH,sBAQC;IAED;;;;OAIG;IACH,oBASC;IAED;;;;;;;;;OASG;IACH,iBAwCC;IAED;;;;;;;;OAQG;IACH,eAmIC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,0BAuFC;IAED;;;;;OAKG;IACH,cAKC;CACJ;qBAzsBoB,sCAAsC;oCAMvB,iDAAiD;oBAPjE,kCAAkC;yBAK7B,kCAAkC"}
+{"version":3,"file":"KinematicMover.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/collision/KinematicMover.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAmFI;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,2BA5BW,OAAO,uCAAuC,EAAE,aAAa;QAI5C,IAAI,GAArB,MAAM;QAEW,kBAAkB,GAAnC,MAAM;QAEW,oBAAoB,GAArC,MAAM;QAEW,aAAa,GAA9B,MAAM;QAIW,UAAU,GAA3B,MAAM;OAsBhB;IAtHD,WAAkB;IAElB,0BAAiC;IACjC;;;;;OAKG;IACH,aAFU,WAAW,CAEa;IAClC,sBAA8B;IAC9B,6BAAqC;IACrC,6BAAqC;IACrC,sBAAgD;IAChD,oBAA4B;IAC5B,uBAA+B;IAC/B,0BAAkC;IAClC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAFU;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CAgBzJ;IAEF;;;;OAIG;IACH,qBAAqB;IAErB;;;;;OAKG;IACH,gBAAe;IAEf;;;;;OAKG;IACH,mBAAmG;IAgC/F,6EAAkC;IAClC,aAA6D;IAC7D,2BAAmG;IACnG,6BAAyG;IACzG,sBAAsF;IACtF,mBAA6E;IAIjF;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAhBW,OAAO,GAAC,YAAY,YAGpB,UAAU,MAAM,CAAC,SAGjB,OAAO,mDAAmD,EAAE,eAAe,YAC3E,OAAO,MACP,MAAM,UACN,CAAC,MAAM,EAAC,MAAM,EAAE,QAAQ,EAAC,QAAQ,KAAG,OAAO,GAKzC;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CAU7J;IAED;;;OAGG;IACH,cA4EC;IAED;;;;;;;;;;;;;;OAcG;IACH,mBAqGC;IAED;;;;OAIG;IACH,sBAQC;IAED;;;;OAIG;IACH,oBASC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,iBA0DC;IAED;;;;;;;;;;;;OAYG;IACH,iBAIC;IAED;;;;;;OAMG;IACH,uBAyBC;IAED;;;;;;;OAOG;IACH,kBASC;IAED;;;;;;;OAOG;IACH,oBAOC;IAED;;;;;;;;OAQG;IACH,eAmIC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,0BAgGC;IAED;;;;;OAKG;IACH,cAKC;CACJ;qBA73BoB,sCAAsC;oCAOvB,iDAAiD;oBARjE,kCAAkC;yBAI7B,kCAAkC"}