@cimplify/sdk 0.108.0 → 0.110.2

package/dist/play-ClrMd_e8.d.mts

@@ -0,0 +1,940 @@
+import { G as GameTheme } from './game-theme-CBTw1b_d.mjs';
+import { G as GameUi } from './ui-DwHicuFv.mjs';
+import { E as Entity, e as Physics, T as Transforms } from './world-qekkXjJv.mjs';
+import { I as InputActions, A as ActionId, G as Game, P as PointerFilter, c as PointerPhase } from './game-Bx8onkhX.mjs';
+import { a as GameSystem } from './fluid-DLlEj2cs.mjs';
+import { al as ClipActionId, ap as IkChainId, am as ClipAnimationPort, aq as ClipEvent, N as NodeId, ar as BlendSpaceId, as as BoneSetId, at as RootMotionId, au as VehicleDesc, av as Vehicle } from './backend-gUCzs5Kg.mjs';
+import { a as EngineSurface } from './local-D8_I6UeL.mjs';
+
+type FootContactPort = Pick<ClipAnimationPort, "readClipState" | "setIkTargetFrom">;
+interface FootContactCurve {
+    readonly action: ClipActionId;
+    readonly times: ArrayLike<number>;
+    readonly weights: ArrayLike<number>;
+}
+interface FootContactOptions {
+    readonly footDown?: number;
+    readonly footUp?: number;
+    readonly actions?: readonly ClipActionId[];
+    readonly curves?: readonly FootContactCurve[];
+    readonly tilt?: IkChainId | null;
+}
+interface FootContactTuning {
+    readonly lock?: boolean;
+    readonly weightSeconds?: number;
+    readonly releaseSeconds?: number;
+    readonly maxSlide?: number;
+    readonly maxTilt?: number;
+    readonly plantThreshold?: number;
+}
+declare const CONTACT_WEIGHT = 0;
+declare const CONTACT_PLANTED = 1;
+declare const CONTACT_LOCKED = 2;
+declare const CONTACT_LOCK_X = 3;
+declare const CONTACT_LOCK_Y = 4;
+declare const CONTACT_LOCK_Z = 5;
+declare const CONTACT_LOCK_BLEND = 6;
+declare const DEFAULT_MAX_FOOT_TILT: number;
+declare const DEFAULT_FOOT_UP: readonly [number, number, number];
+declare function createFootTiltChain(port: Pick<ClipAnimationPort, "createIk">, root: NodeId, bone: string, up?: readonly [number, number, number], maxTilt?: number): IkChainId;
+declare class FootContact {
+    readonly state: Float64Array<ArrayBuffer>;
+    private readonly port;
+    private readonly footDown;
+    private readonly footUp;
+    private readonly actions;
+    private readonly curveAction;
+    private readonly curveStart;
+    private readonly times;
+    private readonly weights;
+    private readonly tilt;
+    private readonly lock;
+    private readonly weightSeconds;
+    private readonly releaseSeconds;
+    private readonly maxSlide;
+    private readonly tiltCos;
+    private readonly tiltSin;
+    private readonly threshold;
+    private readonly clip;
+    constructor(port: FootContactPort, options: FootContactOptions, tuning?: FootContactTuning);
+    get planted(): boolean;
+    get locked(): boolean;
+    consume(events: readonly ClipEvent[], count: number): void;
+    sample(dt: number): void;
+    resolve(target: Float64Array, at: number, hit: boolean, nx: number, ny: number, nz: number, dt: number): void;
+    private applyLock;
+    private latch;
+    private curveAt;
+}
+
+declare const DEFAULT_CLIP_EVENT_CAPACITY = 64;
+type ClipEventSource = Pick<ClipAnimationPort, "readClipEvents">;
+declare class ClipEventReader {
+    readonly events: ClipEvent[];
+    count: number;
+    constructor(capacity?: number);
+    read(port: ClipEventSource): number;
+}
+
+interface CharacterMotorOptions {
+    readonly radius?: number;
+    readonly height?: number;
+    readonly crouchHeight?: number;
+    readonly walkSpeed?: number;
+    readonly runSpeed?: number;
+    readonly sprintSpeed?: number;
+    readonly crouchSpeed?: number;
+    readonly groundAcceleration?: number;
+    readonly groundDeceleration?: number;
+    readonly airAcceleration?: number;
+    readonly jumpHeight?: number;
+    readonly gravity?: number;
+    readonly fallGravityScale?: number;
+    readonly jumpCutGravityScale?: number;
+    readonly maxFallSpeed?: number;
+    readonly coyoteSeconds?: number;
+    readonly jumpBufferSeconds?: number;
+    readonly maxSlopeDegrees?: number;
+    readonly slideSlopeDegrees?: number;
+    readonly stepHeight?: number;
+    readonly snapDistance?: number;
+    readonly skin?: number;
+    readonly turnSharpness?: number;
+    readonly maxTurnSpeed?: number;
+    readonly crouchSharpness?: number;
+    readonly groundStickSpeed?: number;
+    readonly modelForward?: 1 | -1;
+}
+declare const CHAR_VX = 0;
+declare const CHAR_VY = 1;
+declare const CHAR_VZ = 2;
+declare const CHAR_HEADING = 3;
+declare const CHAR_SPEED = 4;
+declare const CHAR_COYOTE = 5;
+declare const CHAR_BUFFER = 6;
+declare const CHAR_CROUCH = 7;
+declare const CHAR_GROUND_NX = 8;
+declare const CHAR_GROUND_NY = 9;
+declare const CHAR_GROUND_NZ = 10;
+declare const CHAR_PLATFORM_VX = 11;
+declare const CHAR_PLATFORM_VY = 12;
+declare const CHAR_PLATFORM_VZ = 13;
+declare const CHAR_AIR_SECONDS = 14;
+declare const CHAR_LANDING_SPEED = 15;
+declare const CHAR_MOVE_X = 16;
+declare const CHAR_MOVE_Z = 17;
+declare const CHAR_MOVE_MAGNITUDE = 18;
+declare const CHAR_SPEED_NORMALIZED = 19;
+declare const MOVE_IO_X = 0;
+declare const MOVE_IO_Z = 1;
+declare const MOVE_IO_MAGNITUDE = 2;
+declare const ROOT_IO_DX = 0;
+declare const ROOT_IO_DZ = 1;
+declare const ROOT_IO_YAW = 2;
+declare class CharacterMotor {
+    readonly entity: Entity;
+    readonly state: Float64Array<ArrayBuffer>;
+    private readonly tuning;
+    readonly radius: number;
+    readonly height: number;
+    readonly crouchHeight: number;
+    readonly standCollider: number;
+    readonly crouchCollider: number;
+    readonly controller: number;
+    readonly body: number;
+    readonly runSpeed: number;
+    grounded: boolean;
+    crouched: boolean;
+    sprinting: boolean;
+    jumping: boolean;
+    landed: boolean;
+    jumped: boolean;
+    landings: number;
+    jumps: number;
+    useRootMotion: boolean;
+    faceMovement: boolean;
+    private wasGrounded;
+    private jumpPressed;
+    private jumpHeld;
+    private sprintWanted;
+    private crouchWanted;
+    private readonly platform;
+    private onPlatform;
+    private readonly physics;
+    private readonly transforms;
+    private readonly walkSpeed;
+    private readonly sprintSpeed;
+    private readonly crouchSpeed;
+    private readonly groundAcceleration;
+    private readonly groundDeceleration;
+    private readonly airAcceleration;
+    private readonly jumpVelocity;
+    private readonly gravity;
+    private readonly fallScale;
+    private readonly cutScale;
+    private readonly maxFall;
+    private readonly coyoteSeconds;
+    private readonly bufferSeconds;
+    private readonly turnSharpness;
+    private readonly maxTurnSpeed;
+    private readonly crouchSharpness;
+    private readonly groundStick;
+    private readonly headingOffset;
+    private readonly desired;
+    private readonly moved;
+    private readonly ray;
+    private readonly hit;
+    private readonly cast;
+    constructor(physics: Physics, transforms: Transforms, entity: Entity, options?: CharacterMotorOptions);
+    get collider(): number;
+    get bodyId(): number;
+    get heading(): number;
+    set heading(value: number);
+    faceView(view: Float64Array, yawIndex: number): void;
+    setMove(x: number, z: number, magnitude: number): void;
+    setMoveFrom(io: Float64Array, at: number): void;
+    setButtons(jumpPressed: boolean, jumpHeld: boolean, sprint: boolean, crouch: boolean): void;
+    addRootMotionFrom(io: Float64Array, at: number): void;
+    teleport(x: number, y: number, z: number): void;
+    step(clock: Float64Array): void;
+    private updateCrouch;
+    private setCrouched;
+    private trackPlatform;
+    private accelerate;
+    private fall;
+    private move;
+    private face;
+    private writeRotation;
+    private probeGround;
+}
+
+type CharacterAnimationPort = Pick<ClipAnimationPort, "setBlendParameterFrom" | "fadeClipFrom" | "setIkTargetFrom" | "readRootMotion"> & Partial<Pick<ClipAnimationPort, "readClipState" | "readClipEvents" | "readBonePoses">>;
+interface FootIkOptions extends FootContactTuning {
+    readonly left: IkChainId;
+    readonly right: IkChainId;
+    readonly physics: Physics;
+    readonly spacing?: number;
+    readonly ankleHeight?: number;
+    readonly reach?: number;
+    readonly leftContact?: FootContactOptions | null;
+    readonly rightContact?: FootContactOptions | null;
+    readonly events?: ClipEventReader | null;
+    readonly feet?: BoneSetId | null;
+}
+interface CharacterAnimatorOptions {
+    readonly locomotion: BlendSpaceId;
+    readonly directional?: boolean;
+    readonly crouch?: BlendSpaceId | null;
+    readonly air?: ClipActionId | null;
+    readonly blendSharpness?: number;
+    readonly footIk?: FootIkOptions | null;
+    readonly rootMotion?: RootMotionId | null;
+    readonly modelForward?: 1 | -1;
+}
+declare const ANIM_AIR = 0;
+declare const ANIM_CROUCH = 1;
+declare const ANIM_SPEED = 2;
+declare const ANIM_PELVIS_OFFSET = 3;
+declare class CharacterAnimator {
+    readonly state: Float64Array<ArrayBuffer>;
+    private readonly port;
+    private readonly motor;
+    private readonly transforms;
+    private readonly locomotion;
+    private readonly directional;
+    private readonly crouch;
+    private readonly air;
+    private readonly sharpness;
+    private readonly foot;
+    private readonly spacing;
+    private readonly ankle;
+    private readonly reach;
+    private readonly motion;
+    private readonly headingOffset;
+    private readonly root;
+    private readonly ray;
+    private readonly hit;
+    private readonly leftContact;
+    private readonly rightContact;
+    private readonly events;
+    private readonly ownsEvents;
+    private readonly feet;
+    private readonly footPoses;
+    constructor(port: CharacterAnimationPort, motor: CharacterMotor, transforms: Transforms, options: CharacterAnimatorOptions);
+    update(clock: Float64Array): void;
+    get leftFoot(): FootContact | null;
+    get rightFoot(): FootContact | null;
+    private sendLocomotion;
+    private sendCrouch;
+    private sendAir;
+    private readRoot;
+    private alignFeet;
+    private footTarget;
+}
+
+type VehiclePresetName = "danfo" | "keke" | "okada" | "car";
+type DrivingModel = "arcade" | "sim";
+interface ChassisSpec {
+    readonly mass: number;
+    readonly halfExtents: readonly [number, number, number];
+    readonly ballastShare: number;
+    readonly ballastDrop: number;
+    readonly linearDamping: number;
+    readonly angularDamping: number;
+}
+interface AssistSpec {
+    readonly tractionSlip: number;
+    readonly brakeSlip: number;
+    readonly steerFade: number;
+    readonly steerFadeSpeed: number;
+    readonly autoReverse: boolean;
+    readonly yawDamping: number;
+}
+interface VehicleSpec {
+    readonly name: VehiclePresetName;
+    readonly model: DrivingModel;
+    readonly chassis: ChassisSpec;
+    readonly desc: VehicleDesc;
+    readonly assists: AssistSpec | null;
+}
+declare function vehiclePreset(name: VehiclePresetName, model?: DrivingModel): VehicleSpec;
+
+interface CameraLens {
+    readonly graphics: {
+        setPerspectiveFrom(camera: NodeId, values: Float32Array | Float64Array, offset: number): void;
+    };
+    readonly node: NodeId;
+    readonly near: number;
+    readonly far: number;
+}
+interface CameraBoomOptions {
+    readonly radius?: number;
+    readonly margin?: number;
+}
+declare const BOOM_OX = 0;
+declare const BOOM_OY = 1;
+declare const BOOM_OZ = 2;
+declare const BOOM_DX = 3;
+declare const BOOM_DY = 4;
+declare const BOOM_DZ = 5;
+declare const BOOM_DISTANCE = 6;
+declare const BOOM_FREE = 7;
+declare const BOOM_IO_WORDS = 8;
+declare const POSE_X = 0;
+declare const POSE_Y = 1;
+declare const POSE_Z = 2;
+declare const POSE_YAW = 3;
+declare const POSE_PITCH = 4;
+declare const DEFAULT_BOOM_RADIUS = 0.22;
+declare class CameraBoom {
+    readonly radius: number;
+    readonly margin: number;
+    private readonly physics;
+    private readonly query;
+    private readonly hit;
+    private readonly pick;
+    constructor(physics: Physics, options?: CameraBoomOptions);
+    cast(io: Float64Array, at: number, excludeBody: number): void;
+}
+declare function interpolatedPosition(transforms: Transforms, entity: Entity, clock: Float64Array, out: Float64Array, offset: number): void;
+declare function placeCamera(transforms: Transforms, camera: Entity, pose: Float64Array, at: number): void;
+declare class LensDriver {
+    private readonly lens;
+    private readonly projection;
+    constructor(lens: CameraLens | null);
+    apply(values: Float64Array, index: number): void;
+}
+
+interface CameraSubject {
+    readonly entity: Entity;
+    readonly bodyId: number;
+    readonly sprinting: boolean;
+    readonly state: Float64Array;
+}
+interface LookDelta {
+    readonly x: number;
+    readonly y: number;
+}
+interface LookOptions {
+    readonly lookSensitivity?: number;
+    readonly gamepadLookSpeed?: number;
+    readonly invertY?: boolean;
+}
+interface FollowCameraOptions extends LookOptions, CameraBoomOptions {
+    readonly distance?: number;
+    readonly height?: number;
+    readonly crouchHeight?: number;
+    readonly shoulder?: number;
+    readonly shoulderSide?: 1 | -1;
+    readonly pitch?: number;
+    readonly minPitch?: number;
+    readonly maxPitch?: number;
+    readonly followSharpness?: number;
+    readonly verticalSharpness?: number;
+    readonly shoulderSharpness?: number;
+    readonly recoverSharpness?: number;
+    readonly autoRecenter?: boolean;
+    readonly recenterDelay?: number;
+    readonly recenterSharpness?: number;
+    readonly fov?: number;
+    readonly sprintFovKick?: number;
+    readonly fovSharpness?: number;
+    readonly lockSoftZone?: number;
+    readonly lockSharpness?: number;
+    readonly lockMaxDistance?: number;
+    readonly lockHeight?: number;
+    readonly lens?: CameraLens | null;
+}
+declare const FOLLOW_CAMERA_X = 0;
+declare const FOLLOW_CAMERA_Y = 1;
+declare const FOLLOW_CAMERA_Z = 2;
+declare const FOLLOW_YAW = 3;
+declare const FOLLOW_PITCH = 4;
+declare const FOLLOW_DISTANCE = 5;
+declare const FOLLOW_PIVOT_X = 6;
+declare const FOLLOW_PIVOT_Y = 7;
+declare const FOLLOW_PIVOT_Z = 8;
+declare const FOLLOW_SHOULDER = 9;
+declare const FOLLOW_FOV = 10;
+declare const FOLLOW_CLOSENESS = 11;
+declare const MOVE_IN_X = 0;
+declare const MOVE_IN_Y = 1;
+declare const MOVE_OUT_X = 2;
+declare const MOVE_OUT_Z = 3;
+declare const MOVE_IO_WORDS = 4;
+declare const DEFAULT_LOOK_SENSITIVITY = 0.0062;
+declare const DEFAULT_GAMEPAD_LOOK_SPEED = 3.4;
+declare class FollowCamera {
+    readonly camera: Entity;
+    readonly state: Float64Array<ArrayBuffer>;
+    private readonly recenterPick;
+    readonly boom: CameraBoom;
+    subject: CameraSubject;
+    distance: number;
+    height: number;
+    crouchHeight: number;
+    shoulder: number;
+    shoulderSide: number;
+    fov: number;
+    sprintFovKick: number;
+    lookSensitivity: number;
+    gamepadLookSpeed: number;
+    invertY: boolean;
+    autoRecenter: boolean;
+    private readonly transforms;
+    private readonly defaultPitch;
+    private readonly minPitch;
+    private readonly maxPitch;
+    private readonly followSharpness;
+    private readonly verticalSharpness;
+    private readonly shoulderSharpness;
+    private readonly recoverSharpness;
+    private readonly recenterDelay;
+    private readonly recenterSharpness;
+    private readonly fovSharpness;
+    private readonly lockSoftZone;
+    private readonly lockSharpness;
+    private readonly lockMaxDistance;
+    private readonly lockHeight;
+    private readonly lens;
+    private readonly lockTarget;
+    private locking;
+    private recentering;
+    private initialised;
+    constructor(physics: Physics, transforms: Transforms, camera: Entity, subject: CameraSubject, options?: FollowCameraOptions);
+    get yaw(): number;
+    get pitch(): number;
+    get hasLock(): boolean;
+    get locked(): Entity;
+    look(delta: LookDelta): void;
+    lookRateFrom(input: InputActions, x: ActionId, y: ActionId): void;
+    swapShoulder(): void;
+    recenter(): void;
+    lockOn(target: Entity): void;
+    snap(): void;
+    moveRelative(io: Float64Array, at: number): void;
+    update(clock: Float64Array): void;
+    private applyLook;
+    private steerLock;
+    private steerRecenter;
+    private place;
+}
+
+interface ChaseSubject {
+    readonly entity: Entity;
+    readonly bodyId: number;
+}
+interface ChaseCameraOptions extends LookOptions, CameraBoomOptions {
+    readonly distance?: number;
+    readonly lookHeight?: number;
+    readonly pitch?: number;
+    readonly speedForEffects?: number;
+    readonly distanceGain?: number;
+    readonly fov?: number;
+    readonly speedFovKick?: number;
+    readonly followSharpness?: number;
+    readonly yawSharpness?: number;
+    readonly lookReturnDelay?: number;
+    readonly lookReturnSharpness?: number;
+    readonly recoverSharpness?: number;
+    readonly lens?: CameraLens | null;
+}
+declare const CHASE_X = 0;
+declare const CHASE_Y = 1;
+declare const CHASE_Z = 2;
+declare const CHASE_YAW = 3;
+declare const CHASE_PITCH = 4;
+declare const CHASE_DISTANCE = 5;
+declare const CHASE_FOV = 6;
+declare const CHASE_SPEED = 7;
+declare function chasePreset(name: VehiclePresetName, overrides?: ChaseCameraOptions): ChaseCameraOptions;
+declare class ChaseCamera {
+    readonly camera: Entity;
+    readonly state: Float64Array<ArrayBuffer>;
+    readonly boom: CameraBoom;
+    subject: ChaseSubject;
+    distance: number;
+    lookHeight: number;
+    pitch: number;
+    fov: number;
+    lookSensitivity: number;
+    gamepadLookSpeed: number;
+    invertY: boolean;
+    private readonly transforms;
+    private readonly speedForEffects;
+    private readonly distanceGain;
+    private readonly speedFovKick;
+    private readonly followSharpness;
+    private readonly yawSharpness;
+    private readonly lookReturnDelay;
+    private readonly lookReturnSharpness;
+    private readonly recoverSharpness;
+    private readonly lens;
+    private initialised;
+    constructor(physics: Physics, transforms: Transforms, camera: Entity, subject: ChaseSubject, options?: ChaseCameraOptions);
+    look(delta: LookDelta): void;
+    lookRateFrom(input: InputActions, x: ActionId, y: ActionId): void;
+    snap(): void;
+    update(clock: Float64Array): void;
+}
+
+interface FirstPersonSubject extends CameraSubject {
+    readonly grounded: boolean;
+    readonly landings: number;
+    faceView(view: Float64Array, yawIndex: number): void;
+}
+interface FirstPersonViewOptions extends LookOptions {
+    readonly eyeHeight?: number;
+    readonly crouchEyeHeight?: number;
+    readonly headBob?: boolean;
+    readonly bobAmplitude?: number;
+    readonly bobStride?: number;
+    readonly landDip?: number;
+    readonly minPitch?: number;
+    readonly maxPitch?: number;
+    readonly fov?: number;
+    readonly sprintFovKick?: number;
+    readonly fovSharpness?: number;
+    readonly lens?: CameraLens | null;
+}
+declare const VIEW_X = 0;
+declare const VIEW_Y = 1;
+declare const VIEW_Z = 2;
+declare const VIEW_YAW = 3;
+declare const VIEW_PITCH = 4;
+declare const VIEW_BOB_PHASE = 5;
+declare const VIEW_BOB_WEIGHT = 6;
+declare const VIEW_DIP = 7;
+declare const VIEW_FOV = 8;
+declare class FirstPersonView {
+    readonly camera: Entity;
+    readonly state: Float64Array<ArrayBuffer>;
+    subject: FirstPersonSubject;
+    eyeHeight: number;
+    crouchEyeHeight: number;
+    headBob: boolean;
+    lookSensitivity: number;
+    gamepadLookSpeed: number;
+    invertY: boolean;
+    fov: number;
+    sprintFovKick: number;
+    private readonly transforms;
+    private readonly bobAmplitude;
+    private readonly bobStride;
+    private readonly landDip;
+    private readonly minPitch;
+    private readonly maxPitch;
+    private readonly fovSharpness;
+    private readonly lens;
+    private landings;
+    constructor(transforms: Transforms, camera: Entity, subject: FirstPersonSubject, options?: FirstPersonViewOptions);
+    get yaw(): number;
+    get pitch(): number;
+    look(delta: LookDelta): void;
+    lookRateFrom(input: InputActions, x: ActionId, y: ActionId): void;
+    moveRelative(io: Float64Array, at: number): void;
+    update(clock: Float64Array): void;
+}
+
+type TouchLayoutName = "leftStickRightButtons" | "twinStick" | "oneThumb" | "driving";
+type FractionRect = readonly [number, number, number, number];
+type FractionPoint = readonly [number, number];
+interface StickPlacement {
+    readonly zone: FractionRect;
+    readonly home: FractionPoint;
+}
+interface LookPlacement {
+    readonly zone: FractionRect;
+}
+interface ButtonPlacement {
+    readonly anchor: FractionPoint;
+    readonly offset: readonly [number, number];
+    readonly size: number;
+}
+interface TouchLayout {
+    readonly move: StickPlacement | null;
+    readonly aim: StickPlacement | null;
+    readonly look: LookPlacement | null;
+    readonly buttons: readonly ButtonPlacement[];
+}
+declare function touchLayout(name: TouchLayoutName): TouchLayout;
+
+type TouchViewportSource = Pick<EngineSurface, "width" | "height" | "safe_area">;
+declare function engineSurfaceOf(game: Game): EngineSurface | null;
+
+declare const STICK_X = 0;
+declare const STICK_Y = 1;
+declare const STICK_MAGNITUDE = 2;
+declare const STICK_OUT_WORDS = 3;
+declare const STICK_DX = 3;
+declare const STICK_DY = 4;
+declare const STICK_RADIUS = 5;
+declare const STICK_DEAD_ZONE = 6;
+declare const STICK_CURVE = 7;
+declare const STICK_IO_WORDS = 8;
+type StickAxes = "both" | "x" | "y";
+declare function shapeStickInto(io: Float64Array, axes: number): void;
+declare function shapeStick(dx: number, dy: number, radius: number, deadZone: number, curve: number, axes: number, out: Float64Array, offset: number): void;
+declare function followOriginInto(origin: Float64Array, at: number, target: Float64Array, targetAt: number, radius: Float64Array, radiusAt: number): void;
+declare function followOrigin(origin: Float64Array, at: number, x: number, y: number, radius: number): void;
+
+interface SafeInsets {
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+}
+interface TouchViewport {
+    readonly width: number;
+    readonly height: number;
+    readonly insets?: SafeInsets;
+}
+interface StickSpec {
+    readonly x?: string;
+    readonly y?: string;
+    readonly tap?: string;
+    readonly mode?: "floating" | "fixed";
+    readonly axes?: StickAxes;
+    readonly radius?: number;
+    readonly deadZone?: number;
+    readonly curve?: number;
+    readonly follow?: boolean;
+    readonly snapSeconds?: number;
+}
+interface LookSpec {
+    readonly sensitivity?: number;
+    readonly inertiaSeconds?: number;
+}
+interface ButtonSpec {
+    readonly control: string;
+    readonly label?: string;
+    readonly icon?: number;
+    readonly mode?: "hold" | "toggle";
+    readonly doubleTap?: string;
+    readonly cooldownSeconds?: number;
+    readonly lookThrough?: boolean;
+    readonly size?: number;
+}
+interface TouchControlsOptions {
+    readonly ui?: GameUi | null;
+    readonly theme?: GameTheme;
+    readonly layout?: TouchLayoutName | TouchLayout;
+    readonly move?: StickSpec | null;
+    readonly aim?: StickSpec | null;
+    readonly look?: LookSpec | null;
+    readonly buttons?: readonly ButtonSpec[];
+    readonly viewport?: TouchViewport;
+    readonly autoHide?: boolean;
+    readonly idleOpacity?: number;
+    readonly z?: number;
+}
+declare const STICK_MOVE = 0;
+declare const STICK_AIM = 1;
+declare const MAX_TOUCH_BUTTONS = 8;
+declare class TouchControls implements PointerFilter {
+    readonly input: InputActions;
+    private readonly ui;
+    private readonly theme;
+    private readonly layout;
+    private readonly autoHide;
+    private readonly z;
+    private readonly reg;
+    private enabledState;
+    private attached;
+    private readonly pointerId;
+    private readonly pointerOwner;
+    private readonly stickUsed;
+    private readonly stickSlotX;
+    private readonly stickSlotY;
+    private readonly stickSlotTap;
+    private readonly stickFloating;
+    private readonly stickFollow;
+    private readonly stickAxes;
+    private readonly stickBaseRadius;
+    private readonly stickRadius;
+    private readonly stickDead;
+    private readonly stickCurve;
+    private readonly stickSnap;
+    private readonly stickZoneFraction;
+    private readonly stickHomeFraction;
+    private readonly stickZone;
+    private readonly stickHome;
+    private readonly stickOrigin;
+    private readonly stickTouch;
+    private readonly stickFollowTarget;
+    private readonly stickPointer;
+    private readonly stickDownMs;
+    private readonly stickMoved;
+    private readonly stickValue;
+    private readonly stickKnob;
+    private readonly stickShownBase;
+    private readonly stickShownKnob;
+    private readonly stickShownOpacity;
+    private readonly stickBaseNode;
+    private readonly stickKnobNode;
+    private readonly stickIo;
+    private readonly stickAccessibleLeft;
+    private viewportSource;
+    private readonly seen;
+    private lookUsed;
+    private readonly lookZoneFraction;
+    private readonly lookZone;
+    private lookPointer;
+    private readonly lookLast;
+    private readonly lookVelocity;
+    private lookCoasting;
+    private buttonCount;
+    private readonly buttonSlot;
+    private readonly buttonDoubleSlot;
+    private readonly buttonMode;
+    private readonly buttonLookThrough;
+    private readonly buttonCooldownTotal;
+    private readonly buttonCooldownLeft;
+    private readonly buttonSize;
+    private readonly buttonCenter;
+    private readonly buttonRadius;
+    private readonly buttonPointer;
+    private readonly buttonToggled;
+    private readonly buttonLastUpMs;
+    private readonly buttonLast;
+    private readonly buttonShownPressed;
+    private readonly buttonShownCooldown;
+    private readonly buttonShownCenter;
+    private readonly buttonNode;
+    private readonly buttonOverlayNode;
+    private readonly buttonIndex;
+    private readonly placements;
+    private readonly pair;
+    private readonly single;
+    private readonly shade;
+    private readonly buttonHighlightNode;
+    private readonly pressScale;
+    private rootNode;
+    private readonly elements;
+    private readonly sizedElements;
+    private readonly sizedKind;
+    private readonly sizedIndex;
+    constructor(input: InputActions, options?: TouchControlsOptions);
+    get enabled(): boolean;
+    get visible(): boolean;
+    get activeTouches(): number;
+    get viewportWidth(): number;
+    get viewportHeight(): number;
+    attach(): this;
+    detach(): void;
+    setEnabled(enabled: boolean): void;
+    setViewport(width: number, height: number, insets?: SafeInsets | null): void;
+    followViewport(source: TouchViewportSource | null): void;
+    private syncViewport;
+    button(control: string): number;
+    cooldown(button: number, seconds: number): void;
+    cooldownRemaining(button: number): number;
+    readStick(index: number, out: Float64Array, offset?: number): void;
+    readStickOrigin(index: number, out: Float64Array, offset?: number): void;
+    readButtonCenter(index: number, out: Float64Array, offset?: number): void;
+    buttonNodeId(index: number): number;
+    stickNodeId(index: number): number;
+    readStickZone(index: number, out: Float64Array, offset?: number): void;
+    filterPointer(phase: PointerPhase, id: number, stage: Float64Array): boolean;
+    accessibleActivate(button: number, timeMs: number): void;
+    accessibleStep(stick: number, action: number, timeMs: number): void;
+    update(clock: Float64Array): void;
+    dispose(): void;
+    private addStick;
+    private addButton;
+    private resolve;
+    private placeRect;
+    private stickMove;
+    private stickRelease;
+    private emitStick;
+    private publishStick;
+    private buttonRelease;
+    private releaseAll;
+    private drawVisibility;
+    private drawStick;
+    private drawButton;
+    private build;
+    private sized;
+    private resize;
+}
+
+interface DriveControls {
+    throttle: number;
+    brake: number;
+    steer: number;
+    handbrake: number;
+}
+declare class KitVehicle {
+    readonly vehicle: Vehicle;
+    readonly spec: VehicleSpec;
+    private reversing;
+    private stoppedFor;
+    private readonly io;
+    private constructor();
+    static spawn(physics: Physics, entity: Entity, spec: VehicleSpec): KitVehicle;
+    get speedKmh(): number;
+    get wholeKmh(): number;
+    drive(controls: DriveControls, dt: number): void;
+    wheelPosition(index: number, out: Float32Array, offset?: number): void;
+    wheelRotation(index: number, chassis: Float32Array, chassisOffset: number, out: Float32Array, offset?: number): void;
+    wheelSpeed(index: number): number;
+}
+
+interface PlayActions {
+    readonly moveX: ActionId;
+    readonly moveY: ActionId;
+    readonly lookX: ActionId;
+    readonly lookY: ActionId;
+    readonly jump: ActionId;
+    readonly sprint: ActionId;
+    readonly crouch: ActionId;
+    readonly interact: ActionId;
+    readonly fire: ActionId;
+    readonly lockOn: ActionId;
+    readonly swapShoulder: ActionId;
+    readonly recenter: ActionId;
+}
+interface DriveActions {
+    readonly steer: ActionId;
+    readonly gas: ActionId;
+    readonly brake: ActionId;
+    readonly handbrake: ActionId;
+    readonly horn: ActionId;
+    readonly lookX: ActionId;
+    readonly lookY: ActionId;
+}
+declare const TOUCH_CONTROLS: {
+    readonly moveX: "touch.move.x";
+    readonly moveY: "touch.move.y";
+    readonly aimX: "touch.aim.x";
+    readonly aimY: "touch.aim.y";
+    readonly jump: "touch.jump";
+    readonly sprint: "touch.sprint";
+    readonly crouch: "touch.crouch";
+    readonly interact: "touch.interact";
+    readonly fire: "touch.fire";
+    readonly lockOn: "touch.lock";
+    readonly gas: "touch.gas";
+    readonly brake: "touch.brake";
+    readonly handbrake: "touch.handbrake";
+    readonly horn: "touch.horn";
+};
+declare function definePlayActions(input: InputActions, prefix?: string): PlayActions;
+declare function defineDriveActions(input: InputActions, prefix?: string): DriveActions;
+interface TouchOptions {
+    readonly ui?: GameUi | null;
+    readonly theme?: GameTheme;
+    readonly viewport?: TouchViewport;
+    readonly surface?: TouchViewportSource | null;
+    readonly layout?: TouchLayoutName;
+    readonly move?: StickSpec;
+    readonly look?: LookSpec;
+    readonly buttons?: readonly ButtonSpec[];
+}
+interface RigBase {
+    readonly game: Game;
+    readonly controls: TouchControls;
+    readonly cameraEntity: Entity;
+    readonly system: GameSystem<Game>;
+    readonly active: boolean;
+    setActive(active: boolean): void;
+    fixedUpdate(game: Game): void;
+    update(game: Game): void;
+    dispose(): void;
+}
+interface CharacterRigOptions extends TouchOptions {
+    readonly entity?: Entity;
+    readonly position?: readonly [number, number, number];
+    readonly heading?: number;
+    readonly camera?: Entity;
+    readonly character?: CharacterMotorOptions;
+    readonly animation?: {
+        readonly port: CharacterAnimationPort;
+        readonly options: CharacterAnimatorOptions;
+    } | null;
+    readonly prefix?: string;
+    readonly register?: boolean;
+}
+interface ThirdPersonOptions extends CharacterRigOptions {
+    readonly follow?: FollowCameraOptions;
+}
+interface FirstPersonOptions extends CharacterRigOptions {
+    readonly view?: FirstPersonViewOptions;
+}
+interface ThirdPersonRig extends RigBase {
+    readonly actions: PlayActions;
+    readonly motor: CharacterMotor;
+    readonly camera: FollowCamera;
+    readonly animator: CharacterAnimator | null;
+    readonly entity: Entity;
+    readonly lockTargets: Entity[];
+}
+interface FirstPersonRig extends RigBase {
+    readonly actions: PlayActions;
+    readonly motor: CharacterMotor;
+    readonly view: FirstPersonView;
+    readonly animator: CharacterAnimator | null;
+    readonly entity: Entity;
+}
+interface VehicleDriverOptions extends TouchOptions {
+    readonly vehicle?: KitVehicle;
+    readonly preset?: VehiclePresetName;
+    readonly model?: DrivingModel;
+    readonly position?: readonly [number, number, number];
+    readonly camera?: Entity;
+    readonly chase?: ChaseCameraOptions;
+    readonly prefix?: string;
+    readonly register?: boolean;
+}
+interface VehicleDriverRig extends RigBase {
+    readonly actions: DriveActions;
+    readonly vehicle: KitVehicle;
+    readonly camera: ChaseCamera;
+    readonly drive: DriveControls;
+    readonly entity: Entity;
+}
+declare function thirdPersonCharacter(game: Game, options?: ThirdPersonOptions): ThirdPersonRig;
+declare function firstPerson(game: Game, options?: FirstPersonOptions): FirstPersonRig;
+declare function vehicleDriver(game: Game, options?: VehicleDriverOptions): VehicleDriverRig;
+
+export { type CameraLens as $, ANIM_AIR as A, BOOM_DISTANCE as B, CHAR_AIR_SECONDS as C, CHAR_PLATFORM_VY as D, CHAR_PLATFORM_VZ as E, CHAR_SPEED as F, CHAR_SPEED_NORMALIZED as G, CHAR_VX as H, CHAR_VY as I, CHAR_VZ as J, CHASE_DISTANCE as K, CHASE_FOV as L, CHASE_PITCH as M, CHASE_SPEED as N, CHASE_X as O, CHASE_Y as P, CHASE_YAW as Q, CHASE_Z as R, CONTACT_LOCKED as S, CONTACT_LOCK_BLEND as T, CONTACT_LOCK_X as U, CONTACT_LOCK_Y as V, CONTACT_LOCK_Z as W, CONTACT_PLANTED as X, CONTACT_WEIGHT as Y, CameraBoom as Z, type CameraBoomOptions as _, ANIM_CROUCH as a, MOVE_OUT_Z as a$, type CameraSubject as a0, type CharacterAnimationPort as a1, CharacterAnimator as a2, type CharacterAnimatorOptions as a3, CharacterMotor as a4, type CharacterMotorOptions as a5, type CharacterRigOptions as a6, ChaseCamera as a7, type ChaseCameraOptions as a8, type ChaseSubject as a9, type FirstPersonSubject as aA, FirstPersonView as aB, type FirstPersonViewOptions as aC, FollowCamera as aD, type FollowCameraOptions as aE, FootContact as aF, type FootContactCurve as aG, type FootContactOptions as aH, type FootContactPort as aI, type FootContactTuning as aJ, type FootIkOptions as aK, type FractionPoint as aL, type FractionRect as aM, KitVehicle as aN, LensDriver as aO, type LookDelta as aP, type LookOptions as aQ, type LookPlacement as aR, type LookSpec as aS, MAX_TOUCH_BUTTONS as aT, MOVE_IN_X as aU, MOVE_IN_Y as aV, MOVE_IO_MAGNITUDE as aW, MOVE_IO_WORDS as aX, MOVE_IO_X as aY, MOVE_IO_Z as aZ, MOVE_OUT_X as a_, type ChassisSpec as aa, ClipEventReader as ab, type ClipEventSource as ac, DEFAULT_BOOM_RADIUS as ad, DEFAULT_CLIP_EVENT_CAPACITY as ae, DEFAULT_FOOT_UP as af, DEFAULT_GAMEPAD_LOOK_SPEED as ag, DEFAULT_LOOK_SENSITIVITY as ah, DEFAULT_MAX_FOOT_TILT as ai, type DriveActions as aj, type DriveControls as ak, type DrivingModel as al, FOLLOW_CAMERA_X as am, FOLLOW_CAMERA_Y as an, FOLLOW_CAMERA_Z as ao, FOLLOW_CLOSENESS as ap, FOLLOW_DISTANCE as aq, FOLLOW_FOV as ar, FOLLOW_PITCH as as, FOLLOW_PIVOT_X as at, FOLLOW_PIVOT_Y as au, FOLLOW_PIVOT_Z as av, FOLLOW_SHOULDER as aw, FOLLOW_YAW as ax, type FirstPersonOptions as ay, type FirstPersonRig as az, ANIM_PELVIS_OFFSET as b, vehicleDriver as b$, POSE_PITCH as b0, POSE_X as b1, POSE_Y as b2, POSE_YAW as b3, POSE_Z as b4, type PlayActions as b5, ROOT_IO_DX as b6, ROOT_IO_DZ as b7, ROOT_IO_YAW as b8, type RigBase as b9, VIEW_BOB_PHASE as bA, VIEW_BOB_WEIGHT as bB, VIEW_DIP as bC, VIEW_FOV as bD, VIEW_PITCH as bE, VIEW_X as bF, VIEW_Y as bG, VIEW_YAW as bH, VIEW_Z as bI, type VehicleDriverOptions as bJ, type VehicleDriverRig as bK, type VehiclePresetName as bL, type VehicleSpec as bM, chasePreset as bN, createFootTiltChain as bO, defineDriveActions as bP, definePlayActions as bQ, engineSurfaceOf as bR, firstPerson as bS, followOrigin as bT, followOriginInto as bU, interpolatedPosition as bV, placeCamera as bW, shapeStick as bX, shapeStickInto as bY, thirdPersonCharacter as bZ, touchLayout as b_, STICK_AIM as ba, STICK_CURVE as bb, STICK_DEAD_ZONE as bc, STICK_DX as bd, STICK_DY as be, STICK_IO_WORDS as bf, STICK_MAGNITUDE as bg, STICK_MOVE as bh, STICK_OUT_WORDS as bi, STICK_RADIUS as bj, STICK_X as bk, STICK_Y as bl, type SafeInsets as bm, type StickAxes as bn, type StickPlacement as bo, type StickSpec as bp, TOUCH_CONTROLS as bq, type ThirdPersonOptions as br, type ThirdPersonRig as bs, TouchControls as bt, type TouchControlsOptions as bu, type TouchLayout as bv, type TouchLayoutName as bw, type TouchOptions as bx, type TouchViewport as by, type TouchViewportSource as bz, ANIM_SPEED as c, vehiclePreset as c0, type AssistSpec as d, BOOM_DX as e, BOOM_DY as f, BOOM_DZ as g, BOOM_FREE as h, BOOM_IO_WORDS as i, BOOM_OX as j, BOOM_OY as k, BOOM_OZ as l, type ButtonPlacement as m, type ButtonSpec as n, CHAR_BUFFER as o, CHAR_COYOTE as p, CHAR_CROUCH as q, CHAR_GROUND_NX as r, CHAR_GROUND_NY as s, CHAR_GROUND_NZ as t, CHAR_HEADING as u, CHAR_LANDING_SPEED as v, CHAR_MOVE_MAGNITUDE as w, CHAR_MOVE_X as x, CHAR_MOVE_Z as y, CHAR_PLATFORM_VX as z };