@woosh/meep-engine 2.142.0 → 2.144.0

package/src/engine/control/first-person/DESIGN_COLLISION.md

@@ -0,0 +1,302 @@
+# Collision handling — ground-up construction plan
+
+Companion to DESIGN.md (base controller) and TODO.md.
+
+**Premise.** The control layer is excellent and stays. The collision
+layer is being **replaced wholesale** — the current
+`_moveAndSlide` + `_integrateVerticalAndResolveGround` + scalar
+ground-resolver regime is not a foundation to build on; it's scaffolding
+to delete once the replacement reaches parity. We keep relying on
+`PhysicsSystem` for all the heavy lifting (`shapeCast`, `raycast`,
+`overlap`, `compute_penetration`) — this plan does *more* with it, not
+less.
+
+Every phase is **guard-test-first**, and ordered so the controller stays
+shippable and green after each one. The new mover is built alongside,
+proven against ported + new specs, switched over, and only then is the
+old code deleted.
+
+---
+
+## 1. The seam: control produces motion, collision resolves it
+
+The clean split that makes a ground-up rebuild safe — the control layer
+already does its half today:
+
+```
+CONTROL (sacred, unchanged)                COLLISION (rebuilt)
+──────────────────────────                 ──────────────────
+intent → desired velocity                  move(pose, shape, velocity, dt)
+accel curves, jump FSM,          ──v──▶       → resolved position
+gravity/impulse, abilities,                   → corrected velocity
+mastery, posture                              → ground state {grounded, normal}
+        ▲                                              │
+        └──────────  grounded, groundNormal  ◀─────────┘
+                     (read next tick by jump FSM,
+                      gravity gating, slope logic)
+```
+
+The control layer's output each tick is a **desired velocity** (it
+already computes this — intent+accel horizontally, gravity+jump
+vertically). The collision layer's *only* job is: given that velocity,
+the capsule pose, and the world, produce the actual resulting position,
+the velocity corrected for what it hit, and the ground state. It never
+invents motion; it only constrains it.
+
+One cleanup this forces (Phase 4): **gravity + jump-impulse application
+move out of the deleted collision method into a small motor helper**
+the base loop and abilities call. The solver stays purely about
+collision.
+
+---
+
+## 2. What we keep / replace / delete
+
+**Keep (untouched):** the whole control stack — intent, mono-exp accel,
+jump FSM, posture→collider sizing, abilities (Slide/WallRun/Mantle/
+LedgeGrab), mastery, camera composition, sensors.
+
+**Replace:** the regime that *consumes* velocity —
+`_moveAndSlide` (horizontal-only swept slide), the direct vertical
+position add, and the downward-ray scalar-Y ground snap.
+
+**Delete (Phase 4, after parity):** `_moveAndSlide`,
+`_integrateVerticalAndResolveGround`'s collision body, the
+`CAST_STEP_HEIGHT` implicit-step hack, and the scalar `groundResolver`
+*as the grounding authority* (it survives only as a no-physics fallback
+inside the new ground probe).
+
+---
+
+## 3. Physics capabilities we build on
+
+The P1–P6 narrowphase/query work is the enabling foundation — the
+rebuild is only feasible because these are now narrowphase-exact.
+
+| Capability | Status | Source |
+|---|---|---|
+| `raycast` exact surface **normal** (sphere/box/capsule/mesh/heightmap) | ✅ | refine_ray_hit P1–P3 (`6f931b4`…`4c2292c`) |
+| `shapeCast` true contact **normal at TOI** (MPR, not broadphase −dir) | ✅ | `shape_cast.js` normal-recovery |
+| `shapeCast` **start-in-contact** → `t=0` + valid normal | ✅ | `shape_cast.js:195`, `:350` |
+| `shapeCast` analytic slab-narrowing (long-sweep accuracy) | ✅ | `shape_cast.js:203` |
+| `compute_penetration(out, A,pa,ra, B,pb,rb) → depth`, `out`=unit B→A | ✅ **public** | `compute_penetration.js:138` |
+| `overlap(shape,pos,rot,out,off,filter)` → body-id list | ✅ | `overlap_shape.js` |
+| EPA adaptive tol / MPR fallback / box-box edge / capsule-tri manifold / GJK cache | ✅ | P2.2, P3.1, P3.2, P1.1c, P2.1 |
+
+Contracts the plan honours:
+- `shapeCast` `result.t` is a **world distance** when direction is
+  unit-length and `tMax = sweepLength`. New casts keep that.
+- `compute_penetration` accepts the convex player capsule vs any
+  shape (only concave-vs-concave throws); `out_direction` is the unit
+  **B→A** separation, depth is the scalar return. Push the capsule (A)
+  out along `+out_direction · depth`.
+- `shapeCast` `result.position` is the swept **centre**, not the
+  contact point — we derive ground-surface Y from the cast `t` + the
+  capsule's bottom offset, so we never need a contact point.
+
+---
+
+## 4. Target architecture — a dedicated `KinematicMover`
+
+Extract the collision solver into its own module (name placeholder —
+`KinematicMover` / `CharacterMover`), testable in isolation against a
+real `PhysicsSystem`, not buried in the 1500-line system file. Matches
+the repo's extraction taste (Spring, EyeOffsetStack, FirstPersonSensors).
+
+It knows nothing about the controller — just a capsule, a velocity, the
+world, and an `up` axis. Single entry point:
+
+```
+move(transform, shape, velocity, dt, filter) → MoveResult
+    // mutates transform.position; returns:
+    //   { velocityX/Y/Z (corrected), grounded, groundNormal, hit }
+```
+
+Modelled on modern kinematic character controllers (Jolt
+`CharacterVirtual`, Source `TryPlayerMove`+`CategorizePosition`), the
+move is an explicit sequence — **recover → slide → (stairs) → ground →
+settle**:
+
+1. **Recover (depenetration).** Before moving, get clear. `overlap()`
+   the capsule; for each body, `compute_penetration` → push the capsule
+   out by `depth · dir`; iterate a few times (deepest-first) to
+   convergence. Handles spawned-in-geometry, world-crushed-into-us, and
+   the start-solid case a pure sweep *cannot*. This is now a **core
+   step**, available from Phase 1 — not a bolt-on — because
+   `compute_penetration` is public.
+
+2. **Sweep-and-slide (unified 3D).** Sweep the *full* velocity·dt
+   (gravity folded in — no H/V split) via `shapeCast`; stop at TOI,
+   clip velocity onto the contact tangent, project the residual, repeat
+   up to N iterations. **Crease-aware**: a second plane re-violating the
+   first → project onto the seam `normalize(n₁×n₂)`; a third plane in
+   one move → dead-stop. Walls, floors, ceilings are all just contact
+   planes, so anti-tunnelling (H and V) falls out of one loop.
+
+3. **Stairs (explicit, optional per move).** When grounded and blocked
+   by a low step: sweep up by `stepHeight`, sweep the residual forward,
+   sweep back down — the Jolt/Source step pattern. Replaces the 5 cm
+   implicit-cast hack with real stair climbing, gated so walls taller
+   than `stepHeight` still block.
+
+4. **Ground categorize + stick.** Short downward `shapeCast` (capsule
+   swept down a `SKIN + band`); if it hits within the band with
+   `normal.y ≥ MIN_WALK_NORMAL` (~0.7), set `grounded`, capture the
+   normal, snap to the surface, and kill the into-ground velocity
+   component. Band-test + active snap (not a strict `y ≤ testY`) is what
+   structurally kills the landing **bounce**. Too-steep normal →
+   not grounded → the slope was already a slide plane in step 2, so the
+   player slides down it.
+
+5. **Settle.** One final `compute_penetration` recover pass guarantees
+   the tick ends penetration-free (resting-contact float drift
+   insurance; usually a no-op).
+
+Slope handling, multi-body resting contact, and unstick all fall out of
+steps 1/2/4 — no special cases. Abilities get correct collision for free
+by routing their motion through the same `move()`.
+
+---
+
+## 5. Phased plan (rebuild, not patch)
+
+### Phase 1 — `KinematicMover`: recover + unified sweep-and-slide
+Stand up the module. Implement **recover** (overlap +
+compute_penetration) and **unified 3D sweep-and-slide** (crease-aware).
+The system calls `move()` for the combined velocity·dt, replacing both
+`_moveAndSlide` and the direct vertical add. Grounding stays on the old
+resolver as a short-lived interim shim (removed in Phase 2) so this
+phase isolates "does the new mover move correctly."
+
+**Guard tests** (`KinematicMover.spec.js`, against a real PhysicsSystem):
+spawn straddling a box → recovered outside within a tick; wall stop;
+slide-along axis-aligned + oblique wall; **vertical** anti-tunnel (drop
+through a thin slab → lands on top); jump into ceiling → stops; corner
+crease → clean stop, no leak/chatter. Port the existing
+`MoveAndSlide.spec.js` scenarios through the new path.
+
+**Risk:** medium. New module, but isolated; old grounding still in place.
+
+### Phase 2 — Ground categorize + slope + stick (inside the mover)
+Add steps 4 (categorize/stick) to the mover. Down-`shapeCast` →
+`{grounded, normal}`; `MIN_WALK_NORMAL` gate; snap + kill into-ground
+velocity; reproject grounded velocity onto the slope. **Remove the
+interim grounding shim and the scalar resolver authority** (resolver
+demoted to no-physics fallback *inside* the probe, behind one function —
+uniform flow). Feed `grounded`/`groundNormal` back to control.
+
+**Guard tests** (`GroundSlope.spec.js`): walk up a 30° ramp keeps speed,
+stays grounded, correct normal; stationary-on-floor stays at y≈0 across
+120 ticks (the no-bounce repro, now with nothing masking it); 60° face →
+not grounded, slides down, not glued.
+
+**Risk:** medium. Changes grounding semantics; the bounce reconciliation
+lives here.
+
+### Phase 3 — Stairs  ✅ **landed**
+Real stair climbing, gated by `stepHeight` (default 0.3 m, just under
+the capsule radius).
+
+The implementation diverged from the planned explicit "up-forward-down"
+step sweep — that was tried and removed. The capsule's *round bottom*
+already rolls up a riser shorter than its radius (the slide moves the
+player up positionally), and an explicit step-up fought it (incremental
+wall-climbing, edge-wedging). What was actually needed was **honest
+ground categorization on a step edge**, which two probes split cleanly:
+
+  - **Step-DOWN** = the ground-stick reach is `stepHeight`: walking off
+    a drop ≤ stepHeight snaps onto the lower surface (stays grounded);
+    a larger drop goes airborne.
+  - **Step-UP** = categorize takes **walkability from a centre raycast**
+    (sees the real planar surface; ignores a step's convex top edge and
+    a wall's side face — so a steep *slope* is correctly not-grounded)
+    and **rest height from a footprint shapecast** (raises onto a step
+    the leading edge overhangs, capped at `stepHeight`). A single probe
+    can't tell a climbable step edge from a steep slope — both are
+    steep-normal contacts — which is why the two are split.
+
+This is also what fixed the "launch off every low step" jank: with the
+player correctly grounded through the roll, the per-tick vertical
+velocity is zeroed and never accumulates.
+
+**Guard tests** (`collision/Stairs.spec.js`, all green): climb a 5-step
+staircase staying grounded; clear a single curb without stalling; a
+0.5 m riser (> stepHeight) blocks; descend a staircase grounded the
+whole way (no launch off each lip).
+
+### Phase 4 — Motor seam + delete old code  ✅ **landed**
+The mover is now the **only** collision path when a `PhysicsSystem` is
+present — the opt-in flag is gone; dispatch is on physics presence, not
+a flag.
+
+What shipped:
+- `_integrateVerticalAndResolveGround` is now a thin dispatcher:
+  `_applyGravity` (the motor) → `_moveViaMover` (physics) **or**
+  `_moveFlatGround` (no physics) → `_detectJumpApex`.
+- **Gravity** extracted to `_applyGravity`; **land / leave-ground**
+  extracted to `_onLand` / `_onLeaveGround`, shared by both move paths
+  (the duplicated scaffolding from Phase 1's wiring is gone).
+- **Deleted** `_moveAndSlide` (+ its `CAST_STEP_HEIGHT` / `SKIN`
+  constants and the `slideRay` / `slideHit` scratch), the legacy ground-
+  resolution body, and the `useKinematicMover` flag.
+- `MoveAndSlide.spec.js` deleted — it tested `_moveAndSlide`; its
+  scenarios (wall-stop, axis + oblique slide, anti-tunnel) are covered
+  by `collision/KinematicMover.spec.js`.
+
+What stayed (deliberately):
+- `useBuiltInFlatGround` / `groundY` / `groundResolver` remain — they're
+  the **no-physics** fallback (`_moveFlatGround`) for headless and
+  control-layer unit tests, and the resolver is still spec-covered. With
+  physics present they're unused (the mover probes the world).
+- **WallRun still self-integrates** its reduced-gravity model rather than
+  routing through `move()`. Slide already routes through the mover (it
+  calls `_integrateVerticalAndResolveGround`); WallRun's custom model is
+  left as a future enhancement, not required for the legacy deletion.
+
+**Result:** 29 suites / 236 tests green; the entire ability + jump +
+momentum + posture suite passes through the consolidated path.
+
+---
+
+## 6. Physics requirements — status
+
+**Resolved.** My one HIGH ask from the review — a public penetration
+query — is **satisfied**: `compute_penetration` is public and is exactly
+the right shape (unit B→A direction + scalar depth, capsule-vs-anything).
+It graduates from "deferred safety net" to the **core recover/settle
+primitive** the whole mover leans on (steps 1 & 5). Confirmed it works:
+yes, this is precisely what's needed — thank you for keeping it decoupled
+and public.
+
+**No remaining blocking requirements.** Phases 1–4 need nothing further
+from the physics engine. The two low-priority niceties from the review
+turned out not to bite:
+- *Contact point from `shapeCast`* — not needed; ground-surface Y is
+  derivable from the cast `t` + the capsule bottom offset.
+- *Multi-contact manifold from one query* — covered for resting contact
+  by iterating `compute_penetration` over **every** `overlap()` body in
+  the recover pass; the single-sweep corner case is handled by the slide
+  iteration instead. So no native multi-contact query is required.
+
+If anything *would* be a future nicety (not needed now): a swept query
+returning the *set* of TOI-simultaneous contacts (for one-pass corner
+creases instead of iterating). Strictly an optimisation; the iterative
+slide is correct without it.
+
+---
+
+## 7. Constants (ours ← reference lineage)
+
+| Constant | Plan value | Reference | Phase |
+|---|---|---|---|
+| slide iterations | 4 | Quake `numbumps` 4 | 1 |
+| `SKIN` | 0.005 m | Fauerby `veryCloseDistance` ~0.005 | 1 |
+| recover max iters | ~4 | — (convergence cap) | 1 |
+| `MIN_WALK_NORMAL` | ~0.7 (≈45°) | Quake3 0.7 / Source `normal.z ≥ 0.7` | 2 |
+| ground-probe band | ~0.06 m | Source `StayOnGround` ~2 u | 2 |
+| crease dead-stop | zero on 3rd plane | Quake `SV_FlyMove` | 1 |
+| `stepHeight` | ~0.3 m (tunable) | Source `sv_stepsize` 18 u (~0.34 m) | 3 |
+
+Clip stays at effective overbounce `1.0` gated on into-wall (`v·n < 0`),
+relying on `SKIN` for clearance — equivalent in practice to Quake3's
+`OVERCLIP 1.001` nudge; no change planned.

package/src/engine/control/first-person/FirstPersonPlayerControllerSystem.d.ts

@@ -56,14 +56,30 @@ export class FirstPersonPlayerControllerSystem extends System<any, any, any, any
      */
     groundResolver: (x: number, y: number, z: number) => number | null;
     /**
-     * PhysicsSystem reference used by {@link _moveAndSlide}. Auto-
-     * acquired at startup; can be overridden by the caller. When
-     * null (no physics in the world), move-and-slide degrades to a
-     * direct position add — useful for spec setups that don't wire
-     * physics.
+     * PhysicsSystem reference. Auto-acquired at startup; can be
+     * overridden by the caller. When present, collision is resolved
+     * by the {@link KinematicMover}; when null, the controller uses
+     * the flat-ground integrator ({@link _moveFlatGround}) — useful
+     * for spec setups that don't wire physics.
      * @type {PhysicsSystem|null}
      */
     physicsSystem: PhysicsSystem | null;
+    /**
+     * The collision solver — the authoritative move resolver whenever
+     * a {@link PhysicsSystem} is present (recover + unified
+     * sweep-and-slide + ground-categorize; see DESIGN_COLLISION.md).
+     * Lazily built on first use. With no physics the controller falls
+     * back to a flat-ground integrator ({@link _moveFlatGround}).
+     * @private
+     * @type {KinematicMover|null}
+     */
+    private _mover;
+    /** @private Scratch velocity handed to the mover each tick. */
+    private _moverVelocity;
+    /** @private Scratch for the posture-headroom up-cast. */
+    private _postureRay;
+    /** @private @type {PhysicsSurfacePoint} */
+    private _postureHit;
     startup(entityManager: any): Promise<void>;
     /**
      * @param {FirstPersonPlayerController} controller
@@ -117,7 +133,27 @@ export class FirstPersonPlayerControllerSystem extends System<any, any, any, any
      * @private
      */
     private _syncColliderShape;
-    _resolveCrouchHeld(controller: any, runtime: any): any;
+    _resolveCrouchHeld(controller: any, runtime: any, bodyTransform: any): any;
+    /**
+     * Headroom probe for a posture change that GROWS the collider.
+     * Sweeps `fromShape` (the shorter posture's capsule) straight up by
+     * `growDelta` (the height the collider would gain). A hit means an
+     * overhang occupies the space the taller posture needs, so the grow
+     * is blocked. Returns true (clear) when no physics is wired or the
+     * grow is non-positive.
+     *
+     * Why an up-cast rather than an overlap-test of the taller shape:
+     * overlap would false-positive on a wall *beside* the player. The
+     * up-cast sweeps parallel to (and, per the mover's skin clearance,
+     * clear of) lateral walls so they aren't hit; the floor is below
+     * the rising probe; the player's own body is filtered out. Only
+     * genuine overhead geometry blocks the grow. Relies on the player
+     * resting at `floor+skin` (the mover's stick-to-ground), so the
+     * probe's bottom starts clear of the floor.
+     *
+     * @private
+     */
+    private _hasHeadroomToGrow;
     /**
      * Jump finite-state-machine: button-edge detection, buffer + coyote
      * grace, anticipation timer, impulse on completion. Variable-height
@@ -132,48 +168,12 @@ export class FirstPersonPlayerControllerSystem extends System<any, any, any, any
      */
     private _advanceJumpFsm;
     /**
-     * Sweep the player's collider along (dx, dy, dz) via
-     * {@link PhysicsSystem.shapeCast} and translate the Transform up to
-     * (but not past) the first contact. Prevents tunneling through
-     * static geometry and creep-penetration over many ticks.
-     *
-     * v1 limitations:
-     *   - The broadphase shape-cast returns the back-along-the-sweep
-     *     normal (`−direction`), not the true surface normal. With
-     *     that, the principled "slide along the surface" residual is
-     *     `delta -= dot(delta, n)·n = 0` — i.e. the player stops at
-     *     contact instead of sliding tangent to the wall. Once
-     *     narrowphase refinement lands and `result.normal` becomes the
-     *     true surface normal, the same residual computation will
-     *     naturally produce sliding without an API change.
-     *   - SKIN clearance (5 mm) keeps the player just shy of the wall
-     *     so the next cast doesn't start with the capsule already in
-     *     contact. Picking this too small risks GJK reporting `t = 0`
-     *     and the player getting stuck; too large is visible as a gap.
-     *
-     * Falls through to a direct position add when the host hasn't
-     * wired a {@link PhysicsSystem} — useful for spec setups that
-     * don't bring physics up.
-     *
-     * @private
-     * @param {PerEntityRuntime} runtime
-     * @param {Transform} bodyTransform
-     * @param {number} deltaX
-     * @param {number} deltaY
-     * @param {number} deltaZ
-     * @returns {boolean} true if a contact occurred (and the sweep was
-     *     truncated); false on a clean full advance.
-     */
-    private _moveAndSlide;
-    /**
-     * Gravity (with fall and cut multipliers), vertical integration,
-     * built-in flat-floor resolution (land event + impulse), and jump-apex
-     * detection. The full vertical phase of one fixed step.
-     *
-     * The built-in flat-floor branch only runs when `useBuiltInFlatGround`
-     * is true (the prototype's standalone mode); with an external physics
-     * layer attached the system relies on the layer to set `state.grounded`
-     * and only maintains airborne/grounded timers here.
+     * The vertical + collision phase of one fixed step: apply gravity
+     * (the motor), resolve the move against the world, then detect the
+     * jump apex. Collision resolution is the {@link KinematicMover} when
+     * a physics layer is present; otherwise a lightweight flat-ground
+     * integrator for headless / unit-test scenes with no collidable
+     * geometry. Land / leave-ground events flow identically from either.
      *
      * @private
      * @param {FirstPersonPlayerController} controller
@@ -182,6 +182,49 @@ export class FirstPersonPlayerControllerSystem extends System<any, any, any, any
      * @param {number} dt
      */
     private _integrateVerticalAndResolveGround;
+    /**
+     * Motor: integrate gravity into `velocityY` with the fall / variable-
+     * cut multipliers. The mover never invents motion, so gravity lives
+     * here (callable by abilities that want standard gravity too).
+     * @private
+     */
+    private _applyGravity;
+    /**
+     * Resolve the move against the world via {@link KinematicMover}
+     * (recover + unified sweep-and-slide + ground-categorize), then map
+     * the result back to controller state and land / leave events.
+     * @private
+     */
+    private _moveViaMover;
+    /**
+     * No-physics fallback: integrate the velocity directly (there's no
+     * collidable geometry to sweep against) and resolve the floor from
+     * the built-in flat ground and/or the host `groundResolver`. For
+     * headless scenes and control-layer unit tests. With both ground
+     * sources off, an external physics layer is expected to own
+     * `state.grounded`; we only advance timers.
+     * @private
+     */
+    private _moveFlatGround;
+    /**
+     * Landing transition: dip / impact springs, exertion impulse, flag
+     * resets, and the `onLand` signal (fired LAST so handlers see fully-
+     * reacted state). Shared by both move paths. `impactVy` is the
+     * downward speed at touchdown (positive).
+     * @private
+     */
+    private _onLand;
+    /**
+     * Leave-ground transition: `onLeaveGround` signal + takeoff bookkeeping.
+     * Shared by both move paths.
+     * @private
+     */
+    private _onLeaveGround;
+    /**
+     * Fire `onJumpApex` once, when an in-progress jump stops rising.
+     * @private
+     */
+    private _detectJumpApex;
     /**
      * Run the base (no-ability) L1 locomotion phases: speed selection,
      * desired-velocity computation, accel/decel, jump FSM, gravity, body
@@ -264,16 +307,6 @@ declare class PerEntityRuntime {
      * @type {Collider|null}
      */
     collider: Collider | null;
-    /**
-     * Pre-allocated move-and-slide scratch — Ray3 and PhysicsSurfacePoint
-     * reused per cast so the controller doesn't churn the allocator
-     * each fixed step. Lazily filled by {@link _moveAndSlide}.
-     * @private
-     * @type {Ray3|null}
-     */
-    private slideRay;
-    /** @private @type {PhysicsSurfacePoint|null} */
-    private slideHit;
     /**
      * Pre-built capsule colliders, one per posture. Cached at link
      * from `config.body.{height, crouchHeight, proneHeight, radius}`

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

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonPlayerControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerControllerSystem.js"],"names":[],"mappings":"AA0TA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACI,cAiEC;IAxDG,wEAA4D;IAE5D,gKAIC;IAED;;;OAGG;IACH,SAFU,IAAI,MAAM,EAAE,gBAAgB,CAAC,CAEf;IAExB;;;;OAIG;IACH,sBAFU,OAAO,CAEe;IAEhC;;;;OAIG;IACH,SAFU,MAAM,CAEA;IAEhB;;;;;;;;;;;;;;;;OAgBG;IACH,oBAFc,MAAM,KAAI,MAAM,KAAI,MAAM,KAAK,MAAM,GAAC,IAAI,CAE9B;IAE1B;;;;;;;OAOG;IACH,eAFU,aAAa,GAAC,IAAI,CAEH;IAG7B,2CAMC;IAED;;;;OAIG;IACH,iBAJW,2BAA2B,iBAC3B,SAAS,UACT,MAAM,QAuGhB;IAED;;;;OAIG;IACH,mBAJW,2BAA2B,iBAC3B,SAAS,UACT,MAAM,QAWhB;IAED;;;;;;;;OAQG;IACH,mBAHW,MAAM,GACJ,gBAAgB,GAAC,SAAS,CAItC;IAUG,mBAAoB;IAYpB,yBAA0B;IAI9B;;;;OAIG;IACH,oBAyUC;IAED;;;;;OAKG;IACH;;;;;;;;;;;;;;OAcG;IACH,2BAaC;IAED,uDAeC;IAED;;;;;;;;;;;OAWG;IACH,wBA0EC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,sBAgGC;IAED;;;;;;;;;;;;;;;OAeG;IACH,2CAuHC;IAED;;;;;;;;;;;;;;OAcG;IACH,2BA6HC;IAED;;;;;;;;;;;;;;;OAeG;IACH,kCAsDC;IAED;;;;;;;;;;OAUG;IACH,qBA8CC;IAED;;;;;OAKG;IACH,oBA4JC;CACJ;uBA5sDsB,qBAAqB;0BAClB,kCAAkC;4CAWhB,kCAAkC;0BAFpD,gCAAgC;4CAbd,oDAAoD;uBAKzE,qCAAqC;AA+E5D;;;;;GAKG;AACH;IAEQ;;;;;;;OAOG;IACH,WAFU,SAAS,GAAC,IAAI,CAEH;IAErB;;;;;OAKG;IACH,UAFU,QAAQ,GAAC,IAAI,CAEH;IAEpB;;;;;;OAMG;IACH,iBAAoB;IACpB,gDAAgD;IAChD,iBAAoB;IAEpB;;;;;;;;;;;OAWG;IACH,2BAA8B;IAC9B,+CAA+C;IAC/C,4BAA+B;IAC/B,+CAA+C;IAC/C,2BAA8B;IAC9B,eAAe;IACf,oBAAqB;IAErB,2DAA2D;IAC3D,iBAAiB;IACjB,6CAA6C;IAC7C,gBAAgB;IAChB,sEAAsE;IACtE,yBAAyB;IAEzB;sDACkD;IAClD,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;IAElB,qEAAqE;IACrE,sBAAyB;IACzB,oEAAoE;IACpE,wBAA2B;IAC3B,yEAAyE;IACzE,uBAA0B;IAE1B,wEAAwE;IACxE,8BAA8B;IAC9B,mEAAmE;IACnE,gBAAmB;IACnB,mEAAmE;IACnE,sBAAwB;IACxB;;;;OAIG;IACH,gBAAsB;IAEtB,kEAAkE;IAClE,mBAA8B;IAC9B,0CAA0C;IAC1C,kBAA+B;IAC/B,iDAAiD;IACjD,wBAAuC;IACvC,wEAAwE;IACxE,mBAA8B;IAC9B;;;;;;;OAOG;IACH,sBAAsB;IAEtB,sEAAsE;IACtE,sBAAsB;IACtB,sBAAsB;IAEtB,iDAAiD;IACjD,sBAAwB;IACxB,uDAAuD;IACvD,kBAAkB;IAClB,0EAA0E;IAC1E,qBAAqB;IACrB,+DAA+D;IAC/D,iBAAoB;IACpB,oDAAoD;IACpD,mBAAsB;IAEtB,2EAA2E;IAC3E,wBAAwB;IACxB,gFAAgF;IAChF,wBAAwB;IACxB,+DAA+D;IAC/D,qBAAuB;IACvB;;;;;;;;;;OAUG;IACH,qBAAuB;IAEvB;;;;;;OAMG;IACH,qBAAqB;IAErB;;;;OAIG;IACH,2BAAsC;IAEtC;;;;OAIG;IACH,6BAAwC;IAExC;;;;;OAKG;IACH,4BAAuC;IAEvC;;;;OAIG;IACH,wBAAmC;IAEnC;;;;OAIG;IACH,mBAAmB;IAEnB;;;;;OAKG;IACH,eAAe;IACf,eAAe;IAEf,8EAA8E;IAC9E,mBAAmB;IAEnB,4FAA4F;IAC5F,qBAAqB;IAErB;;;;;OAKG;IACH,+BAA0C;IAE1C;;;;;OAKG;IACH,4BAAuC;IAEvC,sDAAsD;IACtD,kBAAmB;CAE1B;8BArS6B,oCAAoC;yBADzC,+BAA+B;uBASjC,kBAAkB;+BAdV,8BAA8B;mCAkB1B,iCAAiC"}
+{"version":3,"file":"FirstPersonPlayerControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerControllerSystem.js"],"names":[],"mappings":"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"}