@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-ECDK6QBF.mjs

@@ -0,0 +1,981 @@
+import { clamp, wrapAt, dampFactor, yawInto, atan2Into, CameraBoom, LensDriver, interpolatedPosition, BOOM_OX, BOOM_OY, BOOM_OZ, BOOM_DX, BOOM_DY, BOOM_DZ, BOOM_DISTANCE, BOOM_FREE, placeCamera, BOOM_IO_WORDS } from './chunk-Y2EMGN4T.mjs';
+import { STAGE_X, STAGE_Y, STAGE_TIME, InputDevice } from './chunk-22BD3RHN.mjs';
+import { emptyClipEvent, emptyClipState } from './chunk-7ARSJPV3.mjs';
+import { CharacterMove, RayQuery, RayHit } from './chunk-HF5HPS4T.mjs';
+import { Vec3, ShapeCastQuery } from './chunk-XPG3N5CF.mjs';
+import { NO_ENTITY } from './chunk-T3AFF3L7.mjs';
+import { FRAME_STEP_SECONDS_SLOT, FRAME_SECONDS_SLOT } from './chunk-IDLW4NWA.mjs';
+import { DEFAULT_THEME, UiAction, UiProp, parseColor } from './chunk-RFVRPYR2.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/kit/character/motor.ts
+var CHAR_VX = 0, CHAR_VY = 1, CHAR_VZ = 2, CHAR_HEADING = 3, CHAR_SPEED = 4, CHAR_COYOTE = 5, CHAR_BUFFER = 6, CHAR_CROUCH = 7, CHAR_GROUND_NX = 8, CHAR_GROUND_NY = 9, CHAR_GROUND_NZ = 10, CHAR_PLATFORM_VX = 11, CHAR_PLATFORM_VY = 12, CHAR_PLATFORM_VZ = 13, CHAR_AIR_SECONDS = 14, CHAR_LANDING_SPEED = 15, CHAR_MOVE_X = 16, CHAR_MOVE_Z = 17, CHAR_MOVE_MAGNITUDE = 18, CHAR_SPEED_NORMALIZED = 19, PLATFORM_X = 20, PLATFORM_Y = 21, PLATFORM_Z = 22, PLATFORM_YAW = 23, ROOT_DX = 24, ROOT_DZ = 25, ROOT_YAW = 26, PLATFORM_DX = 27, PLATFORM_DY = 28, PLATFORM_DZ = 29, PLATFORM_DYAW = 30, DT = 31, CACHED_DT = 32, TURN_K = 33, CROUCH_K = 34, SCRATCH = 35, SCRATCH_WORDS = 3, STATE_WORDS = (35) + (3), MOVE_IO_X = 0, MOVE_IO_Z = 1, MOVE_IO_MAGNITUDE = 2, ROOT_IO_DX = 0, ROOT_IO_DZ = 1, ROOT_IO_YAW = 2, DEFAULT_RADIUS = 0.35, DEFAULT_HEIGHT = 1.8, DEFAULT_CROUCH_HEIGHT = 1.15, DEFAULT_WALK_SPEED = 2, DEFAULT_RUN_SPEED = 5.4, DEFAULT_SPRINT_SPEED = 8, DEFAULT_CROUCH_SPEED = 1.9, DEFAULT_GROUND_ACCELERATION = 45, DEFAULT_GROUND_DECELERATION = 60, DEFAULT_AIR_ACCELERATION = 14, DEFAULT_JUMP_HEIGHT = 1.3, DEFAULT_GRAVITY = 24, DEFAULT_FALL_SCALE = 1.55, DEFAULT_CUT_SCALE = 2.8, DEFAULT_MAX_FALL = 42, DEFAULT_COYOTE = 0.11, DEFAULT_BUFFER = 0.13, DEFAULT_MAX_SLOPE = 46, DEFAULT_SLIDE_SLOPE = 50, DEFAULT_STEP_HEIGHT = 0.35, DEFAULT_SNAP = 0.3, DEFAULT_SKIN = 0.02, DEFAULT_TURN_SHARPNESS = 16, DEFAULT_MAX_TURN_SPEED = 14, DEFAULT_CROUCH_SHARPNESS = 14, DEFAULT_GROUND_STICK = 2, PROBE_DEPTH = 0.3, MIN_GROUND_NORMAL_Y = 0.2, TURN_MIN_INPUT = 0.05, SPRINT_MIN_INPUT = 0.5, WALK_INPUT = 0.5, CEILING_BLOCK = 0.5, STAND_CLEARANCE = 0.95, MIN_STEP = 1e-6, HALF = 0.5, NONE = NO_ENTITY, PLATFORM_PROBE = 0, PLATFORM_CURRENT = 1, PLATFORM_SLOTS = 2, TUNING_SPRINT = 0, TUNING_MAX_FALL = 1, TUNING_WORDS = 2, CharacterMotor = class {
+  constructor(physics, transforms, entity, options = {}) {
+    this.state = new Float64Array(STATE_WORDS);
+    this.tuning = new Float64Array((2));
+    this.grounded = false;
+    this.crouched = false;
+    this.sprinting = false;
+    this.jumping = false;
+    this.landed = false;
+    this.jumped = false;
+    this.landings = 0;
+    this.jumps = 0;
+    this.useRootMotion = false;
+    this.faceMovement = true;
+    this.wasGrounded = false;
+    this.jumpPressed = false;
+    this.jumpHeld = false;
+    this.sprintWanted = false;
+    this.crouchWanted = false;
+    this.platform = new Uint32Array((2)).fill(NONE);
+    this.onPlatform = false;
+    this.desired = new Vec3();
+    this.moved = new CharacterMove();
+    this.ray = new RayQuery();
+    this.hit = new RayHit();
+    this.cast = new ShapeCastQuery();
+    this.physics = physics, this.transforms = transforms, this.entity = entity, this.radius = options.radius ?? (0.35), this.height = Math.max(options.height ?? (1.8), this.radius * 2), this.crouchHeight = clamp(options.crouchHeight ?? (1.15), this.radius * 2, this.height), this.walkSpeed = options.walkSpeed ?? (2), this.runSpeed = options.runSpeed ?? (5.4), this.sprintSpeed = options.sprintSpeed ?? (8), this.crouchSpeed = options.crouchSpeed ?? (1.9), this.groundAcceleration = options.groundAcceleration ?? (45), this.groundDeceleration = options.groundDeceleration ?? (60), this.airAcceleration = options.airAcceleration ?? (14), this.gravity = options.gravity ?? (24), this.jumpVelocity = Math.sqrt(2 * this.gravity * (options.jumpHeight ?? (1.3))), this.fallScale = options.fallGravityScale ?? (1.55), this.cutScale = options.jumpCutGravityScale ?? (2.8), this.maxFall = options.maxFallSpeed ?? (42), this.tuning[(0)] = this.sprintSpeed, this.tuning[(1)] = this.maxFall, this.coyoteSeconds = options.coyoteSeconds ?? (0.11), this.bufferSeconds = options.jumpBufferSeconds ?? (0.13), this.turnSharpness = options.turnSharpness ?? (16), this.maxTurnSpeed = options.maxTurnSpeed ?? (14), this.crouchSharpness = options.crouchSharpness ?? (14), this.groundStick = options.groundStickSpeed ?? (2), this.headingOffset = options.modelForward === -1 ? Math.PI : 0, this.body = physics.addBody(entity, { kind: "kinematic" });
+    let r = this.radius;
+    this.standCollider = physics.addCollider(entity, {
+      shape: { kind: "capsule", halfHeight: this.height / 2 - r, radius: r },
+      offset: [0, this.height / 2, 0]
+    }), this.crouchCollider = physics.addCollider(entity, {
+      shape: { kind: "capsule", halfHeight: this.crouchHeight / 2 - r, radius: r },
+      offset: [0, this.crouchHeight / 2, 0]
+    }), physics.setColliderEnabled(this.crouchCollider, false), this.controller = physics.createCharacterController({
+      offset: options.skin ?? (0.02),
+      maxSlopeClimbDegrees: options.maxSlopeDegrees ?? (46),
+      minSlopeSlideDegrees: options.slideSlopeDegrees ?? (50),
+      autostepMaxHeight: options.stepHeight ?? (0.35),
+      autostepMinWidth: r,
+      snapToGround: options.snapDistance ?? (0.3),
+      slide: true
+    }), this.state[(9)] = 1, this.state[(32)] = Number.NaN, this.cast.ball(r * (0.95)), this.cast.direction.set(0, 1, 0), this.ray.direction.set(0, -1, 0), this.writeRotation();
+  }
+  get collider() {
+    return this.crouched ? this.crouchCollider : this.standCollider;
+  }
+  get bodyId() {
+    return this.body;
+  }
+  get heading() {
+    return this.state[(3)];
+  }
+  set heading(value) {
+    this.state[(3)] = value, wrapAt(this.state, (3)), this.writeRotation();
+  }
+  faceView(view, yawIndex) {
+    let s = this.state;
+    s[(3)] = view[yawIndex] + Math.PI, wrapAt(s, (3)), this.writeRotation();
+  }
+  setMove(x, z, magnitude) {
+    let s = this.state;
+    s[(35)] = x, s[(35) + 1] = z, s[(35) + 2] = magnitude, this.setMoveFrom(s, (35));
+  }
+  setMoveFrom(io, at) {
+    let s = this.state, x = io[at + (0)], z = io[at + (1)], magnitude = io[at + (2)], length = (x * x + z * z) ** 0.5;
+    if (length < (1e-6) || magnitude <= 0) {
+      s[(16)] = 0, s[(17)] = 0, s[(18)] = 0;
+      return;
+    }
+    s[(16)] = x / length, s[(17)] = z / length, s[(18)] = magnitude > 1 ? 1 : magnitude;
+  }
+  setButtons(jumpPressed, jumpHeld, sprint, crouch) {
+    jumpPressed && (this.jumpPressed = true), this.jumpHeld = jumpHeld, this.sprintWanted = sprint, this.crouchWanted = crouch;
+  }
+  addRootMotionFrom(io, at) {
+    let s = this.state;
+    s[(24)] += io[at + (0)], s[(25)] += io[at + (1)], s[(26)] += io[at + (2)];
+  }
+  teleport(x, y, z) {
+    let v = this.desired.set(x, y, z);
+    this.physics.teleport(this.entity, v);
+    let s = this.state;
+    s[(0)] = 0, s[(1)] = 0, s[(2)] = 0, this.onPlatform = false, this.grounded = false, this.jumping = false;
+  }
+  step(clock) {
+    let s = this.state, dt = clock[FRAME_STEP_SECONDS_SLOT];
+    s[(31)] = dt, s[(32)] !== dt && (s[(32)] = dt, s[(33)] = dampFactor(this.turnSharpness, dt), s[(34)] = dampFactor(this.crouchSharpness, dt)), this.landed = false, this.jumped = false, this.updateCrouch(), this.trackPlatform(), this.grounded ? s[(5)] = this.coyoteSeconds : s[(5)] = s[(5)] > dt ? s[(5)] - dt : 0, this.jumpPressed ? s[(6)] = this.bufferSeconds : s[(6)] = s[(6)] > dt ? s[(6)] - dt : 0, this.jumpPressed = false, this.accelerate(), s[(6)] > 0 && s[(5)] > 0 && !this.crouched && (s[(1)] = this.jumpVelocity + (s[(12)] > 0 ? s[(12)] : 0), s[(0)] += s[(11)], s[(2)] += s[(13)], s[(5)] = 0, s[(6)] = 0, this.jumping = true, this.jumped = true, this.jumps++, this.grounded = false, this.onPlatform = false), this.fall(), this.move(), this.face(), this.probeGround();
+  }
+  updateCrouch() {
+    if (this.crouchWanted && !this.crouched) this.setCrouched(true);
+    else if (!this.crouchWanted && this.crouched) {
+      let p = this.transforms.row(this.entity) * 3, positions = this.transforms.store.fields.position, cast = this.cast, origin = cast.origin;
+      origin.x = positions[p], origin.y = positions[p + 1] + this.crouchHeight - this.radius, origin.z = positions[p + 2], cast.maxDistance = this.height - this.crouchHeight, cast.excludeBody = this.body, this.physics.castShape(cast, this.hit) || this.setCrouched(false);
+    }
+    let s = this.state, target = this.crouched ? 1 : 0;
+    s[(7)] += (target - s[(7)]) * s[(34)];
+  }
+  setCrouched(crouched) {
+    this.crouched = crouched, this.physics.setColliderEnabled(this.crouchCollider, crouched), this.physics.setColliderEnabled(this.standCollider, !crouched);
+  }
+  trackPlatform() {
+    let s = this.state;
+    s[(27)] = 0, s[(28)] = 0, s[(29)] = 0, s[(30)] = 0;
+    let platform = this.platform[(1)];
+    if (!this.onPlatform || !this.grounded) {
+      s[(11)] = 0, s[(12)] = 0, s[(13)] = 0;
+      return;
+    }
+    let dt = s[(31)], fields = this.transforms.store.fields, row = this.transforms.row(platform), at = row * 3, px = fields.position[at], py = fields.position[at + 1], pz = fields.position[at + 2];
+    yawInto(fields.rotation, row * 4, s, (35)), s[(30)] = s[(35)] - s[(23)], wrapAt(s, (30));
+    let dyaw = s[(30)], me = this.transforms.row(this.entity) * 3, ox = fields.position[me] - s[(20)], oz = fields.position[me + 2] - s[(22)], c = Math.cos(dyaw), n = Math.sin(dyaw), dx = px - s[(20)] + (ox * c + oz * n - ox), dz = pz - s[(22)] + (-ox * n + oz * c - oz), dy = py - s[(21)];
+    s[(27)] = dx, s[(28)] = dy, s[(29)] = dz, s[(11)] = dx / dt, s[(12)] = dy / dt, s[(13)] = dz / dt, s[(20)] = px, s[(21)] = py, s[(22)] = pz, s[(23)] = s[(35)];
+  }
+  accelerate() {
+    let s = this.state, dt = s[(31)], magnitude = s[(18)];
+    if (this.sprinting = this.sprintWanted && !this.crouched && magnitude >= (0.5), this.useRootMotion && this.grounded) {
+      s[(0)] = s[(24)] / dt, s[(2)] = s[(25)] / dt, s[(24)] = 0, s[(25)] = 0;
+      return;
+    }
+    s[(24)] = 0, s[(25)] = 0;
+    let speed;
+    this.crouched ? speed = this.crouchSpeed * magnitude : this.sprinting ? speed = this.tuning[(0)] : magnitude <= (0.5) ? speed = this.walkSpeed * magnitude / (0.5) : speed = this.walkSpeed + (this.runSpeed - this.walkSpeed) * (magnitude - (0.5)) / (1 - (0.5));
+    let tx = s[(16)] * speed, tz = s[(17)] * speed, vx = s[(0)], vz = s[(2)], dvx = tx - vx, dvz = tz - vz, gap = (dvx * dvx + dvz * dvz) ** 0.5;
+    if (gap < (1e-6)) return;
+    let rate = this.airAcceleration;
+    this.grounded && (rate = tx * tx + tz * tz >= vx * vx + vz * vz ? this.groundAcceleration : this.groundDeceleration);
+    let reach = rate * dt, k = gap > reach ? reach / gap : 1;
+    s[(0)] = vx + dvx * k, s[(2)] = vz + dvz * k;
+  }
+  fall() {
+    let s = this.state;
+    if (this.grounded) {
+      s[(1)] = 0;
+      return;
+    }
+    let vy = s[(1)], scale = vy > 0 ? this.jumping && !this.jumpHeld ? this.cutScale : 1 : this.fallScale, next = vy - this.gravity * scale * s[(31)], floor = -this.tuning[(1)];
+    s[(1)] = next < floor ? floor : next;
+  }
+  move() {
+    let s = this.state, dt = s[(31)], vx = s[(0)], vy = s[(1)], vz = s[(2)], dy = vy * dt + s[(28)];
+    this.grounded && s[(9)] > (0.2) && (dy -= (s[(8)] * vx + s[(10)] * vz) / s[(9)] * dt);
+    let desired = this.desired;
+    desired.x = vx * dt + s[(27)], desired.y = dy, desired.z = vz * dt + s[(29)];
+    let out = this.physics.moveCharacter(this.controller, this.crouched ? this.crouchCollider : this.standCollider, desired, this.moved), rising = this.jumping && vy > 0, grounded = out.grounded && !rising;
+    vy > 0 && dy > (1e-6) && out.y < dy * (0.5) && (s[(1)] = 0), s[(0)] = (out.x - s[(27)]) / dt, s[(2)] = (out.z - s[(29)]) / dt, s[(4)] = (s[(0)] * s[(0)] + s[(2)] * s[(2)]) ** 0.5, s[(19)] = this.runSpeed > 0 ? s[(4)] / this.runSpeed : 0, this.wasGrounded = this.grounded, this.grounded = grounded, grounded ? (this.wasGrounded || (this.landed = true, this.landings++, s[(15)] = vy < 0 ? -vy : 0), this.jumping = false, s[(14)] = 0) : (this.wasGrounded && !this.jumping && (s[(1)] = -this.groundStick), s[(14)] += dt);
+  }
+  face() {
+    let s = this.state;
+    if (s[(3)] += s[(30)], this.useRootMotion && (s[(3)] += s[(26)]), s[(26)] = 0, this.faceMovement && s[(18)] > (0.05)) {
+      s[(35)] = s[(16)], s[(35) + 1] = s[(17)], atan2Into(s, (35)), s[(35)] -= s[(3)], wrapAt(s, (35)), s[(35)] *= s[(33)], s[(35) + 1] = this.maxTurnSpeed * s[(31)], s[(35) + 2] = -s[(35) + 1];
+      let pick = s[(35)] > s[(35) + 1] ? 1 : s[(35)] < s[(35) + 2] ? 2 : 0;
+      s[(3)] += s[(35) + pick];
+    }
+    wrapAt(s, (3)), this.writeRotation();
+  }
+  writeRotation() {
+    let half = (this.state[(3)] + this.headingOffset) * (0.5), rotation = this.transforms.store.fields.rotation, o = this.transforms.row(this.entity) * 4;
+    rotation[o] = 0, rotation[o + 1] = Math.sin(half), rotation[o + 2] = 0, rotation[o + 3] = Math.cos(half);
+  }
+  probeGround() {
+    let s = this.state;
+    if (!this.grounded) {
+      this.onPlatform = false;
+      return;
+    }
+    let p = this.transforms.row(this.entity) * 3, positions = this.transforms.store.fields.position, ray = this.ray, origin = ray.origin;
+    origin.x = positions[p], origin.y = positions[p + 1] + this.radius, origin.z = positions[p + 2], ray.maxDistance = this.radius + (0.3), ray.excludeCollider = this.crouched ? this.crouchCollider : this.standCollider;
+    let hit = this.hit;
+    if (!this.physics.raycast(ray, hit)) {
+      s[(8)] = 0, s[(9)] = 1, s[(10)] = 0, this.onPlatform = false;
+      return;
+    }
+    s[(8)] = hit.normalX, s[(9)] = hit.normalY, s[(10)] = hit.normalZ;
+    let slot = this.platform;
+    if (slot[(0)] = this.physics.entityOfCollider(hit.collider), slot[(0)] === NONE) {
+      this.onPlatform = false;
+      return;
+    }
+    if (this.onPlatform && slot[(0)] === slot[(1)]) return;
+    slot[(1)] = slot[(0)], this.onPlatform = true;
+    let ground = slot[(1)], fields = this.transforms.store.fields, row = this.transforms.row(ground);
+    s[(20)] = fields.position[row * 3], s[(21)] = fields.position[row * 3 + 1], s[(22)] = fields.position[row * 3 + 2], yawInto(fields.rotation, row * 4, s, (23));
+  }
+};
+
+// src/game/kit/camera/follow.ts
+var FOLLOW_CAMERA_X = 0, FOLLOW_CAMERA_Y = 1, FOLLOW_CAMERA_Z = 2, FOLLOW_YAW = 3, FOLLOW_PITCH = 4, FOLLOW_DISTANCE = 5, FOLLOW_PIVOT_X = 6, FOLLOW_PIVOT_Y = 7, FOLLOW_PIVOT_Z = 8, FOLLOW_SHOULDER = 9, FOLLOW_FOV = 10, FOLLOW_CLOSENESS = 11, IDLE = 12, SPRINT = 13, LOOK_X = 14, LOOK_Y = 15, RATE_X = 16, RATE_Y = 17, TARGET = 18, DT2 = 24, SCRATCH2 = 25, lockAngle = new Float64Array(2), BOOM = 26, STATE_WORDS2 = (26) + BOOM_IO_WORDS, MOVE_IN_X = 0, MOVE_IN_Y = 1, MOVE_OUT_X = 2, MOVE_OUT_Z = 3, MOVE_IO_WORDS = 4, DEFAULT_LOOK_SENSITIVITY = 62e-4, DEFAULT_GAMEPAD_LOOK_SPEED = 3.4, DEFAULT_DISTANCE = 4.2, DEFAULT_HEIGHT2 = 1.55, DEFAULT_CROUCH_HEIGHT2 = 1.05, DEFAULT_SHOULDER = 0.55, DEFAULT_PITCH = -0.3, DEFAULT_MIN_PITCH = -1.25, DEFAULT_MAX_PITCH = 0.95, DEFAULT_FOLLOW_SHARPNESS = 22, DEFAULT_VERTICAL_SHARPNESS = 8, DEFAULT_SHOULDER_SHARPNESS = 9, DEFAULT_RECOVER_SHARPNESS = 4.5, DEFAULT_RECENTER_DELAY = 1.5, DEFAULT_RECENTER_SHARPNESS = 1.8, MANUAL_RECENTER_SHARPNESS = 10, DEFAULT_FOV = 62, DEFAULT_SPRINT_KICK = 8, DEFAULT_FOV_SHARPNESS = 6, DEFAULT_LOCK_SOFT_ZONE = 0.12, DEFAULT_LOCK_SHARPNESS = 7, DEFAULT_LOCK_MAX_DISTANCE = 30, DEFAULT_LOCK_HEIGHT = 1.2, LOCK_PITCH_SHARE = 0.5, RECENTER_MIN_SPEED = 0.15, RECENTER_DONE = 0.02, CLOSE_DISTANCE = 1.1, MIN_LOCK_DISTANCE = 0.5, FollowCamera = class {
+  constructor(physics, transforms, camera, subject, options = {}) {
+    this.state = new Float64Array(STATE_WORDS2);
+    this.recenterPick = new Float64Array(2);
+    this.lockTarget = new Uint32Array(1).fill(NO_ENTITY);
+    this.locking = false;
+    this.recentering = false;
+    this.initialised = false;
+    this.transforms = transforms, this.camera = camera, this.subject = subject, this.boom = new CameraBoom(physics, options), this.distance = options.distance ?? (4.2), this.height = options.height ?? (1.55), this.crouchHeight = options.crouchHeight ?? (1.05), this.shoulder = options.shoulder ?? (0.55), this.shoulderSide = options.shoulderSide ?? 1, this.defaultPitch = options.pitch ?? (-0.3), this.minPitch = options.minPitch ?? (-1.25), this.maxPitch = options.maxPitch ?? (0.95), this.followSharpness = options.followSharpness ?? (22), this.verticalSharpness = options.verticalSharpness ?? (8), this.shoulderSharpness = options.shoulderSharpness ?? (9), this.recoverSharpness = options.recoverSharpness ?? (4.5), this.autoRecenter = options.autoRecenter ?? true, this.recenterDelay = options.recenterDelay ?? (1.5), this.recenterSharpness = options.recenterSharpness ?? (1.8), this.fov = options.fov ?? (62), this.sprintFovKick = options.sprintFovKick ?? (8), this.fovSharpness = options.fovSharpness ?? (6), this.lockSoftZone = options.lockSoftZone ?? (0.12), this.lockSharpness = options.lockSharpness ?? (7), this.lockMaxDistance = options.lockMaxDistance ?? (30), this.lockHeight = options.lockHeight ?? (1.2), this.lookSensitivity = options.lookSensitivity ?? (62e-4), this.gamepadLookSpeed = options.gamepadLookSpeed ?? (3.4), this.invertY = options.invertY ?? false, this.lens = new LensDriver(options.lens ?? null);
+    let s = this.state;
+    s[(3)] = subject.state[(3)] + Math.PI, wrapAt(s, (3)), s[(4)] = this.defaultPitch, s[(5)] = this.distance, s[(9)] = this.shoulder * this.shoulderSide, s[(10)] = this.fov;
+  }
+  get yaw() {
+    return this.state[(3)];
+  }
+  get pitch() {
+    return this.state[(4)];
+  }
+  get hasLock() {
+    return this.locking;
+  }
+  get locked() {
+    return this.lockTarget[0];
+  }
+  look(delta) {
+    this.state[(14)] += delta.x, this.state[(15)] += delta.y;
+  }
+  lookRateFrom(input, x, y) {
+    input.valueInto(x, this.state, (16)), input.valueInto(y, this.state, (17));
+  }
+  swapShoulder() {
+    this.shoulderSide = -this.shoulderSide;
+  }
+  recenter() {
+    this.recentering = true;
+  }
+  lockOn(target) {
+    this.lockTarget[0] = target, this.locking = target !== NO_ENTITY, this.locking && (this.recentering = false);
+  }
+  snap() {
+    this.initialised = false;
+  }
+  moveRelative(io, at) {
+    let yaw = this.state[(3)], sy = Math.sin(yaw), cy = Math.cos(yaw), x = io[at + (0)], y = io[at + (1)];
+    io[at + (2)] = cy * x - sy * y, io[at + (3)] = -sy * x - cy * y;
+  }
+  update(clock) {
+    let s = this.state, subject = this.subject, dt = clock[FRAME_SECONDS_SLOT];
+    s[(24)] = dt, this.applyLook(), interpolatedPosition(this.transforms, subject.entity, clock, s, (18));
+    let height = this.height + (this.crouchHeight - this.height) * subject.state[(7)], tx = s[(18)], ty = s[(18) + 1] + height, tz = s[(18) + 2];
+    if (!this.initialised)
+      s[(6)] = tx, s[(7)] = ty, s[(8)] = tz;
+    else {
+      let k = 1 - Math.exp(-this.followSharpness * dt);
+      s[(6)] += (tx - s[(6)]) * k, s[(8)] += (tz - s[(8)]) * k, s[(7)] += (ty - s[(7)]) * (1 - Math.exp(-this.verticalSharpness * dt));
+    }
+    this.steerLock() || this.steerRecenter(), s[(9)] += (this.shoulder * this.shoulderSide - s[(9)]) * (1 - Math.exp(-this.shoulderSharpness * dt)), s[(13)] += ((subject.sprinting ? 1 : 0) - s[(13)]) * (1 - Math.exp(-this.fovSharpness * dt)), s[(10)] = this.fov + this.sprintFovKick * s[(13)], this.lens.apply(s, (10)), this.place(), this.initialised = true;
+  }
+  applyLook() {
+    let s = this.state, dt = s[(24)], invert = this.invertY ? -1 : 1, yawDelta = -s[(14)] * this.lookSensitivity - s[(16)] * this.gamepadLookSpeed * dt, pitchDelta = (-s[(15)] * this.lookSensitivity - s[(17)] * this.gamepadLookSpeed * dt) * invert;
+    s[(14)] = 0, s[(15)] = 0, yawDelta !== 0 || pitchDelta !== 0 ? (s[(12)] = 0, this.recentering = false) : s[(12)] += dt, s[(3)] += yawDelta, wrapAt(s, (3));
+    let pitch = s[(4)] + pitchDelta;
+    s[(4)] = pitch < this.minPitch ? this.minPitch : pitch > this.maxPitch ? this.maxPitch : pitch;
+  }
+  steerLock() {
+    if (!this.locking) return false;
+    let target = this.lockTarget[0], s = this.state, dt = s[(24)], f = this.transforms.store.fields.position, o = this.transforms.row(target) * 3, dx = f[o] - s[(6)], dy = f[o + 1] + this.lockHeight - s[(7)], dz = f[o + 2] - s[(8)], flat = (dx * dx + dz * dz) ** 0.5;
+    if (flat < (0.5) || flat > this.lockMaxDistance) return false;
+    let angle = lockAngle;
+    angle[0] = -dx, angle[1] = -dz, atan2Into(angle, 0), s[(25)] = angle[0] - s[(3)], wrapAt(s, (25));
+    let error = s[(25)], excess = (error < 0 ? -error : error) - this.lockSoftZone;
+    excess > 0 && (s[(3)] += (error < 0 ? -excess : excess) * (1 - Math.exp(-this.lockSharpness * dt)), wrapAt(s, (3))), angle[0] = dy, angle[1] = flat, atan2Into(angle, 0);
+    let pitch = angle[0] * (0.5) + this.defaultPitch * (1 - (0.5));
+    return pitch = pitch < this.minPitch ? this.minPitch : pitch > this.maxPitch ? this.maxPitch : pitch, s[(4)] += (pitch - s[(4)]) * (1 - Math.exp(-this.lockSharpness * (0.5) * dt)), s[(12)] = 0, true;
+  }
+  steerRecenter() {
+    let s = this.state, subject = this.subject, manual = this.recentering, speedNormalized = subject.state[(19)], moving = speedNormalized > (0.15);
+    if (!manual && !(this.autoRecenter && moving && s[(12)] > this.recenterDelay)) return;
+    s[(25)] = subject.state[(3)] + Math.PI - s[(3)], wrapAt(s, (25));
+    let error = s[(25)], pick = this.recenterPick;
+    pick[0] = speedNormalized, pick[1] = 1, pick[0] = this.recenterSharpness * pick[speedNormalized < 1 ? 0 : 1], pick[1] = (10);
+    let k = 1 - Math.exp(-pick[manual ? 1 : 0] * s[(24)]);
+    s[(3)] += error * k, wrapAt(s, (3)), manual && (s[(4)] += (this.defaultPitch - s[(4)]) * k, Math.abs(error) < (0.02) && (this.recentering = false));
+  }
+  place() {
+    let s = this.state, yaw = s[(3)], pitch = s[(4)], sy = Math.sin(yaw), cy = Math.cos(yaw), sp = Math.sin(pitch), cp = Math.cos(pitch), fx = -sy * cp, fy = sp, fz = -cy * cp, px = s[(6)], py = s[(7)], pz = s[(8)], exclude = this.subject.bodyId, shoulder = s[(9)], side = shoulder < 0 ? -1 : 1;
+    s[(26) + BOOM_OX] = px, s[(26) + BOOM_OY] = py, s[(26) + BOOM_OZ] = pz, s[(26) + BOOM_DX] = cy * side, s[(26) + BOOM_DY] = 0, s[(26) + BOOM_DZ] = -sy * side, s[(26) + BOOM_DISTANCE] = shoulder * side, this.boom.cast(s, (26), exclude);
+    let lateral = s[(26) + BOOM_FREE] * side, ax = px + cy * lateral, az = pz - sy * lateral;
+    s[(26) + BOOM_OX] = ax, s[(26) + BOOM_OZ] = az, s[(26) + BOOM_DX] = -fx, s[(26) + BOOM_DY] = -fy, s[(26) + BOOM_DZ] = -fz, s[(26) + BOOM_DISTANCE] = this.distance, this.boom.cast(s, (26), exclude);
+    let allowed = s[(26) + BOOM_FREE], distance = s[(5)];
+    !this.initialised || allowed < distance ? distance = allowed : distance += (allowed - distance) * (1 - Math.exp(-this.recoverSharpness * s[(24)])), distance > allowed && (distance = allowed), s[(5)] = distance, s[(0)] = ax - fx * distance, s[(1)] = py - fy * distance, s[(2)] = az - fz * distance;
+    let close = 1 - distance / (1.1);
+    s[(11)] = close > 0 ? close : 0, placeCamera(this.transforms, this.camera, s, (0));
+  }
+};
+
+// src/game/kit/character/events.ts
+var DEFAULT_CLIP_EVENT_CAPACITY = 64, ClipEventReader = class {
+  constructor(capacity = (64)) {
+    this.count = 0;
+    this.events = Array.from({ length: capacity }, emptyClipEvent);
+  }
+  read(port) {
+    return this.count = port.readClipEvents(this.events), this.count;
+  }
+};
+function actionListed(actions, action) {
+  for (let i = 0; i < actions.length; i++) if (actions[i] === action) return true;
+  return false;
+}
+
+// src/game/kit/character/contact.ts
+var CONTACT_WEIGHT = 0, CONTACT_PLANTED = 1, CONTACT_LOCKED = 2, CONTACT_LOCK_X = 3, CONTACT_LOCK_Y = 4, CONTACT_LOCK_Z = 5, CONTACT_LOCK_BLEND = 6, CONTACT_TILT_X = 7, CONTACT_TILT_Y = 8, CONTACT_TILT_Z = 9, CONTACT_TILT_WEIGHT = 10, CONTACT_EVENT_PLANTED = 11, CONTACT_WORDS = 12, DEFAULT_CONTACT_WEIGHT_SECONDS = 0.08, DEFAULT_CONTACT_RELEASE_SECONDS = 0.2, DEFAULT_CONTACT_MAX_SLIDE = 0.25, DEFAULT_MAX_FOOT_TILT = Math.PI / 6, DEFAULT_PLANT_THRESHOLD = 0.5, DEFAULT_FOOT_UP = [0, 1, 0], TARGET_Y = 1, TARGET_Z = 2, TARGET_WEIGHT = 3, MIN_HORIZONTAL = 1e-6, ON = 1, OFF = 0, EVENT_KIND = "event", NO_EVENT = -1;
+function createFootTiltChain(port, root, bone, up = DEFAULT_FOOT_UP, maxTilt = DEFAULT_MAX_FOOT_TILT) {
+  return port.createIk(root, { solver: "lookAt", bones: [bone], forward: up, maxAngle: maxTilt });
+}
+var FootContact = class {
+  constructor(port, options, tuning = {}) {
+    this.state = new Float64Array((12));
+    this.clip = emptyClipState();
+    this.port = port;
+    let curves = options.curves ?? [];
+    if (this.footDown = options.footDown ?? (-1), this.footUp = options.footUp ?? (-1), curves.length === 0 && this.footDown === (-1))
+      throw new GameError("invalid_argument", "a foot contact needs weight curves or a footDown clip event id");
+    this.actions = Float64Array.from(options.actions ?? []), this.curveAction = Float64Array.from(curves.map((c) => c.action)), this.curveStart = new Int32Array(curves.length + 1);
+    let keys = 0;
+    for (let c of curves) {
+      if (c.times.length === 0 || c.times.length !== c.weights.length)
+        throw new GameError("invalid_argument", "foot contact curves need matching time and weight keys");
+      keys += c.times.length;
+    }
+    this.times = new Float64Array(keys), this.weights = new Float64Array(keys);
+    let k = 0;
+    curves.forEach((c, i) => {
+      this.curveStart[i] = k;
+      for (let j = 0; j < c.times.length; j++, k++)
+        this.times[k] = c.times[j], this.weights[k] = c.weights[j];
+    }), this.curveStart[curves.length] = k, this.tilt = options.tilt ?? null, this.lock = tuning.lock ?? true, this.weightSeconds = tuning.weightSeconds ?? (0.08), this.releaseSeconds = tuning.releaseSeconds ?? (0.2), this.maxSlide = tuning.maxSlide ?? (0.25);
+    let maxTilt = tuning.maxTilt ?? DEFAULT_MAX_FOOT_TILT;
+    this.tiltCos = Math.cos(maxTilt), this.tiltSin = Math.sin(maxTilt), this.threshold = tuning.plantThreshold ?? (0.5);
+  }
+  get planted() {
+    return this.state[(1)] === (1);
+  }
+  get locked() {
+    return this.state[(2)] === (1);
+  }
+  consume(events, count) {
+    if (this.footDown === (-1)) return;
+    let s = this.state;
+    for (let i = 0; i < count; i++) {
+      let e = events[i];
+      e.kind === EVENT_KIND && (this.actions.length > 0 && !actionListed(this.actions, e.action) || (e.id === this.footDown ? s[(11)] = (1) : e.id === this.footUp && (s[(11)] = (0))));
+    }
+  }
+  sample(dt) {
+    let s = this.state;
+    if (this.curveAction.length > 0) {
+      let weight = 0;
+      for (let c = 0; c < this.curveAction.length; c++)
+        this.port.readClipState(this.curveAction[c], this.clip), weight += this.curveAt(c, this.clip.time) * this.clip.weight;
+      s[(0)] = weight < 0 ? 0 : weight > 1 ? 1 : weight, s[(1)] = s[(0)] >= this.threshold ? (1) : (0);
+      return;
+    }
+    let target = s[(11)], step = this.weightSeconds > 0 ? dt / this.weightSeconds : 1, w = s[(0)];
+    w < target ? s[(0)] = w + step >= target ? target : w + step : w > target && (s[(0)] = w - step <= target ? target : w - step), s[(1)] = target;
+  }
+  resolve(target, at, hit, nx, ny, nz, dt) {
+    let s = this.state;
+    this.lock && this.applyLock(target, at, hit, dt);
+    let weight = target[at + (3)] * s[(0)];
+    if (target[at + (3)] = weight, this.tilt === null) return;
+    let x = nx, y = ny, z = nz, horizontal = (x * x + z * z) ** 0.5;
+    if (y < this.tiltCos && horizontal > (1e-6)) {
+      let scale = this.tiltSin / horizontal;
+      x *= scale, z *= scale, y = this.tiltCos;
+    }
+    s[(7)] = target[at] + x, s[(8)] = target[at + (1)] + y, s[(9)] = target[at + (2)] + z, s[(10)] = hit ? weight : 0, this.port.setIkTargetFrom(this.tilt, s, (7));
+  }
+  applyLock(target, at, hit, dt) {
+    let s = this.state;
+    if (s[(1)] === (1) && hit) {
+      if (s[(2)] === (0)) this.latch(target, at);
+      else {
+        let dx = target[at] - s[(3)], dz = target[at + (2)] - s[(5)];
+        dx * dx + dz * dz > this.maxSlide * this.maxSlide && this.latch(target, at);
+      }
+      s[(6)] = 1;
+    } else {
+      s[(2)] = (0);
+      let step = this.releaseSeconds > 0 ? dt / this.releaseSeconds : 1, b2 = s[(6)] - step;
+      s[(6)] = b2 > 0 ? b2 : 0;
+    }
+    let b = s[(6)];
+    b <= 0 || (target[at] += (s[(3)] - target[at]) * b, target[at + (1)] += (s[(4)] - target[at + (1)]) * b, target[at + (2)] += (s[(5)] - target[at + (2)]) * b);
+  }
+  latch(target, at) {
+    let s = this.state;
+    s[(2)] = (1), s[(3)] = target[at], s[(4)] = target[at + (1)], s[(5)] = target[at + (2)];
+  }
+  curveAt(curve, time) {
+    let start = this.curveStart[curve], last = this.curveStart[curve + 1] - 1, times = this.times, weights = this.weights;
+    if (time <= times[start]) return weights[start];
+    if (time >= times[last]) return weights[last];
+    let lo = start, hi = last;
+    for (; hi - lo > 1; ) {
+      let mid = lo + hi >> 1;
+      times[mid] <= time ? lo = mid : hi = mid;
+    }
+    let span = times[hi] - times[lo], f = span > 0 ? (time - times[lo]) / span : 0;
+    return weights[lo] + (weights[hi] - weights[lo]) * f;
+  }
+};
+
+// src/game/kit/touch/layouts.ts
+var BOTTOM_RIGHT = [1, 1];
+function corner(dx, dy, size) {
+  return { anchor: BOTTOM_RIGHT, offset: [dx, dy], size };
+}
+var LEFT_STICK_RIGHT_BUTTONS = {
+  move: { zone: [0, 0.32, 0.5, 1], home: [0.16, 0.74] },
+  aim: null,
+  look: { zone: [0.5, 0, 1, 1] },
+  buttons: [corner(-82, -86, 78), corner(-176, -58, 62), corner(-70, -186, 62), corner(-166, -152, 54), corner(-250, -40, 48)]
+}, TWIN_STICK = {
+  move: { zone: [0, 0.3, 0.5, 1], home: [0.16, 0.74] },
+  aim: { zone: [0.5, 0.3, 1, 1], home: [0.84, 0.74] },
+  look: null,
+  buttons: [corner(-70, -248, 58), corner(-146, -232, 50), corner(-212, -200, 46)]
+}, ONE_THUMB = {
+  move: { zone: [0, 0.22, 1, 1], home: [0.5, 0.78] },
+  aim: null,
+  look: null,
+  buttons: [corner(-48, -500, 44)]
+}, DRIVING = {
+  move: { zone: [0, 0.3, 0.5, 1], home: [0.18, 0.76] },
+  aim: null,
+  look: { zone: [0.5, 0, 1, 0.5] },
+  buttons: [corner(-84, -92, 86), corner(-190, -62, 66), corner(-74, -204, 58), corner(-176, -170, 48)]
+};
+function touchLayout(name) {
+  switch (name) {
+    case "twinStick":
+      return TWIN_STICK;
+    case "oneThumb":
+      return ONE_THUMB;
+    case "driving":
+      return DRIVING;
+    default:
+      return LEFT_STICK_RIGHT_BUTTONS;
+  }
+}
+
+// src/game/kit/touch/stick.ts
+var STICK_X = 0, STICK_Y = 1, STICK_MAGNITUDE = 2, STICK_OUT_WORDS = 3, STICK_DX = 3, STICK_DY = 4, STICK_RADIUS = 5, STICK_DEAD_ZONE = 6, STICK_CURVE = 7, STICK_IO_WORDS = 8;
+var scratch = new Float64Array(8);
+function stickAxesCode(axes) {
+  return axes === "x" ? 1 : axes === "y" ? 2 : 0;
+}
+function shapeStickInto(io, axes) {
+  let dx = io[3], dy = io[4];
+  axes === 1 ? dy = 0 : axes === 2 && (dx = 0);
+  let radius = io[5], deadZone = io[6], length = (dx * dx + dy * dy) ** 0.5, travel = radius > 0 ? length / radius : 0;
+  if (travel > 1 && (travel = 1), travel <= deadZone || length === 0) {
+    io[0] = 0, io[1] = 0, io[2] = 0;
+    return;
+  }
+  let magnitude = (travel - deadZone) / (1 - deadZone), curve = io[7];
+  curve !== 1 && (magnitude = Math.pow(magnitude, curve));
+  let scale = magnitude / length;
+  io[0] = dx * scale, io[1] = -dy * scale, io[2] = magnitude;
+}
+function shapeStick(dx, dy, radius, deadZone, curve, axes, out, offset) {
+  let io = scratch;
+  io[3] = dx, io[4] = dy, io[5] = radius, io[6] = deadZone, io[7] = curve, shapeStickInto(io, axes), out[offset + 0] = io[0], out[offset + 1] = io[1], out[offset + 2] = io[2];
+}
+function followOriginInto(origin, at, target, targetAt, radius, radiusAt) {
+  let dx = target[targetAt] - origin[at], dy = target[targetAt + 1] - origin[at + 1], length = (dx * dx + dy * dy) ** 0.5, r = radius[radiusAt];
+  if (length <= r || length === 0) return;
+  let pull = 1 - r / length;
+  origin[at] += dx * pull, origin[at + 1] += dy * pull;
+}
+function followOrigin(origin, at, x, y, radius) {
+  let io = scratch;
+  io[0] = x, io[1] = y, io[2] = radius, followOriginInto(origin, at, io, 0, io, 2);
+}
+
+// src/game/kit/touch/touch-controls.ts
+var STICK_MOVE = 0, STICK_AIM = 1, MAX_STICKS = 2, MAX_TOUCH_BUTTONS = 8, KIND_STICK = 0, KIND_LOOK = 1, KIND_BUTTON = 2, KIND_SHIFT = 4, INDEX_MASK = (1 << (4)) - 1, NO_OWNER = -1, NO_POINTER = -1, NO_SLOT = -1, ACCESSIBLE_STEP_SECONDS = 0.4, SEEN_WIDTH = 0, SEEN_HEIGHT = 1, SEEN_TOP = 2, SEEN_RIGHT = 3, SEEN_BOTTOM = 4, SEEN_LEFT = 5, SEEN_WORDS = 6, MOVE_LABEL = "Move", AIM_LABEL = "Aim", SIZED_BASE = 0, SIZED_KNOB = 1, SIZED_BUTTON = 2, MODE_HOLD = 0, MODE_TOGGLE = 1, REFERENCE_SHORT_SIDE = 390, MIN_UI_SCALE = 0.85, MAX_UI_SCALE = 1.4, DEFAULT_VIEWPORT_WIDTH = 844, DEFAULT_VIEWPORT_HEIGHT = 390, DEFAULT_STICK_RADIUS = 58, DEFAULT_DEAD_ZONE = 0.12, DEFAULT_CURVE = 1, DEFAULT_SNAP_SECONDS = 0.12, KNOB_FRACTION = 0.46, BUTTON_SLOP = 14, TAP_MAX_MS = 220, TAP_SLOP_FRACTION = 0.25, DOUBLE_TAP_MS = 280, DEFAULT_LOOK_SENSITIVITY2 = 1, DEFAULT_LOOK_INERTIA = 0.16, FLING_RELEASE_MS = 60, MIN_FLING_SPEED = 30, VELOCITY_BLEND = 0.6, MS_PER_SECOND = 1e3, DEFAULT_IDLE_OPACITY = 0.5, ACTIVE_OPACITY = 1, COOLDOWN_OPACITY = 0.55, VISUAL_EPSILON = 0.25, COOLDOWN_EPSILON = 1 / 256, SNAP_SETTLE = 3, DEFAULT_Z = 50, BORDER = 2, ALPHA_MASK = 4294967040, KNOB_ALPHA = 217, OVERLAY_ALPHA = 179, HALF2 = 0.5, RECT_WORDS = 4, PAIR = 2, ON2 = 1, OFF2 = 0, SAFE_LEFT = 0, SAFE_TOP = 1, SAFE_RIGHT = 2, SAFE_BOTTOM = 3, R_X = 0, R_Y = 1, R_TIME = 2, R_DT = 3, R_SCALE = 4, R_WIDTH = 5, R_HEIGHT = 6, R_LOOK_SENSITIVITY = 7, R_LOOK_INERTIA = 8, R_LOOK_LAST_MS = 9, R_SHOWN_ROOT = 10, R_IDLE_OPACITY = 11, R_SAFE = 12, REGISTER_WORDS = 16, TouchControls = class {
+  constructor(input, options = {}) {
+    this.reg = new Float64Array((16));
+    this.enabledState = true;
+    this.attached = false;
+    this.pointerId = new Int32Array(10).fill((-1));
+    this.pointerOwner = new Int32Array(10).fill((-1));
+    this.stickUsed = new Uint8Array((2));
+    this.stickSlotX = new Int32Array((2)).fill((-1));
+    this.stickSlotY = new Int32Array((2)).fill((-1));
+    this.stickSlotTap = new Int32Array((2)).fill((-1));
+    this.stickFloating = new Uint8Array((2));
+    this.stickFollow = new Uint8Array((2));
+    this.stickAxes = new Uint8Array((2));
+    this.stickBaseRadius = new Float64Array((2));
+    this.stickRadius = new Float64Array((2));
+    this.stickDead = new Float64Array((2));
+    this.stickCurve = new Float64Array((2));
+    this.stickSnap = new Float64Array((2));
+    this.stickZoneFraction = new Float64Array((2) * (4));
+    this.stickHomeFraction = new Float64Array((2) * (2));
+    this.stickZone = new Float64Array((2) * (4));
+    this.stickHome = new Float64Array((2) * (2));
+    this.stickOrigin = new Float64Array((2) * (2));
+    this.stickTouch = new Float64Array((2) * (2));
+    this.stickFollowTarget = new Float64Array((2));
+    this.stickPointer = new Int32Array((2)).fill((-1));
+    this.stickDownMs = new Float64Array((2));
+    this.stickMoved = new Uint8Array((2));
+    this.stickValue = new Float64Array((2) * 3);
+    this.stickKnob = new Float64Array((2) * (2));
+    this.stickShownBase = new Float64Array((2) * (2)).fill(Number.NaN);
+    this.stickShownKnob = new Float64Array((2) * (2)).fill(Number.NaN);
+    this.stickShownOpacity = new Float64Array((2)).fill(Number.NaN);
+    this.stickBaseNode = new Int32Array((2)).fill((-1));
+    this.stickKnobNode = new Int32Array((2)).fill((-1));
+    this.stickIo = new Float64Array(8);
+    this.stickAccessibleLeft = new Float64Array((2));
+    this.viewportSource = null;
+    this.seen = new Float64Array((6)).fill(Number.NaN);
+    this.lookUsed = false;
+    this.lookZoneFraction = new Float64Array((4));
+    this.lookZone = new Float64Array((4));
+    this.lookPointer = (-1);
+    this.lookLast = new Float64Array((2));
+    this.lookVelocity = new Float64Array((2));
+    this.lookCoasting = false;
+    this.buttonCount = 0;
+    this.buttonSlot = new Int32Array((8)).fill((-1));
+    this.buttonDoubleSlot = new Int32Array((8)).fill((-1));
+    this.buttonMode = new Uint8Array((8));
+    this.buttonLookThrough = new Uint8Array((8));
+    this.buttonCooldownTotal = new Float64Array((8));
+    this.buttonCooldownLeft = new Float64Array((8));
+    this.buttonSize = new Float64Array((8));
+    this.buttonCenter = new Float64Array((8) * (2));
+    this.buttonRadius = new Float64Array((8));
+    this.buttonPointer = new Int32Array((8)).fill((-1));
+    this.buttonToggled = new Uint8Array((8));
+    this.buttonLastUpMs = new Float64Array((8)).fill(-1 / 0);
+    this.buttonLast = new Float64Array((8) * (2));
+    this.buttonShownPressed = new Int8Array((8)).fill(-1);
+    this.buttonShownCooldown = new Float64Array((8)).fill(Number.NaN);
+    this.buttonShownCenter = new Float64Array((8) * (2)).fill(Number.NaN);
+    this.buttonNode = new Int32Array((8)).fill((-1));
+    this.buttonOverlayNode = new Int32Array((8)).fill((-1));
+    this.buttonIndex = /* @__PURE__ */ new Map();
+    this.placements = [];
+    this.pair = new Float32Array((2));
+    this.single = new Float32Array(1);
+    this.shade = new Float64Array(1);
+    this.buttonHighlightNode = new Int32Array((8)).fill((-1));
+    this.rootNode = (-1);
+    this.elements = [];
+    this.sizedElements = [];
+    this.sizedKind = [];
+    this.sizedIndex = [];
+    if (this.input = input, this.ui = options.ui ?? null, this.theme = options.theme ?? DEFAULT_THEME, this.layout = typeof options.layout == "object" ? options.layout : touchLayout(options.layout ?? "leftStickRightButtons"), this.autoHide = options.autoHide ?? true, this.reg[(11)] = options.idleOpacity ?? (0.5), this.reg[(10)] = Number.NaN, this.z = options.z ?? (50), this.pressScale = this.theme.press_scale, options.move !== null && this.layout.move !== null && this.addStick((0), options.move ?? {}, this.layout.move), options.aim !== void 0 && options.aim !== null && this.layout.aim !== null && this.addStick((1), options.aim, this.layout.aim), options.look !== null && this.layout.look !== null) {
+      let look = options.look ?? {};
+      this.lookUsed = true, copyRect(this.layout.look.zone, this.lookZoneFraction), this.reg[(7)] = look.sensitivity ?? (1), this.reg[(8)] = look.inertiaSeconds ?? (0.16);
+    }
+    let buttons = options.buttons ?? [];
+    for (let i = 0; i < buttons.length && i < this.layout.buttons.length && i < (8); i++) this.addButton(buttons[i], this.layout.buttons[i]);
+    let viewport = options.viewport;
+    this.resolve(viewport?.width ?? (844), viewport?.height ?? (390), viewport?.insets ?? null), this.ui !== null && this.build(this.ui, buttons);
+  }
+  get enabled() {
+    return this.enabledState;
+  }
+  get visible() {
+    return this.reg[(10)] === (1);
+  }
+  get activeTouches() {
+    let n = 0;
+    for (let i = 0; i < 10; i++) this.pointerId[i] !== (-1) && n++;
+    return n;
+  }
+  get viewportWidth() {
+    return this.reg[(5)];
+  }
+  get viewportHeight() {
+    return this.reg[(6)];
+  }
+  attach() {
+    return this.input.setPointerFilter(this), this.attached = true, this;
+  }
+  detach() {
+    this.attached && (this.input.setPointerFilter(null), this.attached = false, this.releaseAll());
+  }
+  setEnabled(enabled) {
+    enabled !== this.enabledState && (this.enabledState = enabled, enabled || this.releaseAll());
+  }
+  setViewport(width, height, insets = null) {
+    this.resolve(width, height, insets), this.ui !== null && this.resize();
+  }
+  followViewport(source) {
+    this.viewportSource = source, this.seen.fill(Number.NaN), source !== null && this.syncViewport(source);
+  }
+  syncViewport(source) {
+    let seen = this.seen, area = source.safe_area, top = area === void 0 ? 0 : area.top, right = area === void 0 ? 0 : area.right, bottom = area === void 0 ? 0 : area.bottom, left = area === void 0 ? 0 : area.left;
+    seen[(0)] === source.width && seen[(1)] === source.height && seen[(2)] === top && seen[(3)] === right && seen[(4)] === bottom && seen[(5)] === left || (seen[(0)] = source.width, seen[(1)] = source.height, seen[(2)] = top, seen[(3)] = right, seen[(4)] = bottom, seen[(5)] = left, this.setViewport(source.width, source.height, area ?? null));
+  }
+  button(control) {
+    let index = this.buttonIndex.get(control);
+    return index === void 0 ? -1 : index;
+  }
+  cooldown(button, seconds) {
+    button < 0 || button >= this.buttonCount || (this.buttonCooldownTotal[button] = seconds, this.buttonCooldownLeft[button] = seconds);
+  }
+  cooldownRemaining(button) {
+    return button < 0 || button >= this.buttonCount ? 0 : this.buttonCooldownLeft[button];
+  }
+  readStick(index, out, offset = 0) {
+    let o = index * 3;
+    out[offset + 0] = this.stickValue[o + 0], out[offset + 1] = this.stickValue[o + 1], out[offset + 2] = this.stickValue[o + 2];
+  }
+  readStickOrigin(index, out, offset = 0) {
+    out[offset] = this.stickOrigin[index * (2)], out[offset + 1] = this.stickOrigin[index * (2) + 1];
+  }
+  readButtonCenter(index, out, offset = 0) {
+    out[offset] = this.buttonCenter[index * (2)], out[offset + 1] = this.buttonCenter[index * (2) + 1];
+  }
+  buttonNodeId(index) {
+    return index < 0 || index >= this.buttonCount ? (-1) : this.buttonNode[index];
+  }
+  stickNodeId(index) {
+    return index < 0 || index >= (2) ? (-1) : this.stickBaseNode[index];
+  }
+  readStickZone(index, out, offset = 0) {
+    for (let k = 0; k < (4); k++) out[offset + k] = this.stickZone[index * (4) + k];
+  }
+  filterPointer(phase, id, stage) {
+    let r = this.reg, px = stage[STAGE_X] * r[(5)], py = stage[STAGE_Y] * r[(6)], time = stage[STAGE_TIME];
+    r[(0)] = px, r[(1)] = py, r[(2)] = time;
+    let input = this.input, inputStage = input.stage;
+    if (phase === "down") {
+      if (!this.enabledState) return false;
+      let owner2 = (-1), bestDistance = 1 / 0, slop = (14) * r[(4)];
+      for (let b = 0; b < this.buttonCount; b++) {
+        if (this.buttonPointer[b] !== (-1)) continue;
+        let dx = px - this.buttonCenter[b * (2)], dy = py - this.buttonCenter[b * (2) + 1], reach = this.buttonRadius[b] + slop, d = dx * dx + dy * dy;
+        d <= reach * reach && d < bestDistance && (bestDistance = d, owner2 = (2) << (4) | b);
+      }
+      if (owner2 === (-1)) {
+        let zone = this.stickZone;
+        for (let s = 0; s < (2); s++) {
+          if (this.stickUsed[s] === (0) || this.stickPointer[s] !== (-1)) continue;
+          let z = s * (4);
+          if (px >= zone[z] && px <= zone[z + 2] && py >= zone[z + 1] && py <= zone[z + 3]) {
+            owner2 = (0) << (4) | s;
+            break;
+          }
+        }
+      }
+      if (owner2 === (-1) && this.lookUsed && this.lookPointer === (-1)) {
+        let zone = this.lookZone;
+        px >= zone[0] && px <= zone[2] && py >= zone[1] && py <= zone[3] && (owner2 = (1) << (4));
+      }
+      if (owner2 === (-1)) return false;
+      let slot2 = -1;
+      for (let i = 0; i < 10; i++)
+        if (this.pointerId[i] === (-1)) {
+          slot2 = i;
+          break;
+        }
+      if (slot2 < 0) return false;
+      this.pointerId[slot2] = id, this.pointerOwner[slot2] = owner2;
+      let index2 = owner2 & INDEX_MASK, kind2 = owner2 >> (4);
+      if (kind2 === (0)) {
+        let o = index2 * (2);
+        if (this.stickPointer[index2] = id, this.stickDownMs[index2] = time, this.stickMoved[index2] = (0), this.stickFloating[index2] === (1)) {
+          let radius = this.stickRadius[index2], lx = r[(12) + (0)] + radius, hx = r[(12) + (2)] - radius, ly = r[(12) + (1)] + radius, hy = r[(12) + (3)] - radius;
+          this.stickOrigin[o] = lx > hx ? (lx + hx) * (0.5) : px < lx ? lx : px > hx ? hx : px, this.stickOrigin[o + 1] = ly > hy ? (ly + hy) * (0.5) : py < ly ? ly : py > hy ? hy : py;
+        } else
+          this.stickOrigin[o] = this.stickHome[o], this.stickOrigin[o + 1] = this.stickHome[o + 1];
+        this.stickTouch[o] = px, this.stickTouch[o + 1] = py, this.emitStick(index2);
+      } else if (kind2 === (1))
+        this.lookPointer = id, this.lookCoasting = false, this.lookLast[0] = px, this.lookLast[1] = py, r[(9)] = time, this.lookVelocity[0] = 0, this.lookVelocity[1] = 0;
+      else {
+        this.buttonPointer[index2] = id, this.buttonLast[index2 * (2)] = px, this.buttonLast[index2 * (2) + 1] = py;
+        let doubleSlot = this.buttonDoubleSlot[index2];
+        if (doubleSlot !== (-1) && time - this.buttonLastUpMs[index2] <= (280) && (inputStage[STAGE_X] = 1, inputStage[STAGE_TIME] = time, input.virtualStaged(doubleSlot), inputStage[STAGE_TIME] = time, input.virtualStaged(doubleSlot), this.buttonLastUpMs[index2] = -1 / 0), this.buttonCooldownLeft[index2] <= 0) {
+          let on = 1;
+          this.buttonMode[index2] === (1) && (on = this.buttonToggled[index2] === (1) ? (0) : (1), this.buttonToggled[index2] = on), inputStage[STAGE_X] = on, inputStage[STAGE_TIME] = time, input.virtualStaged(this.buttonSlot[index2]), this.buttonCooldownTotal[index2] > 0 && (this.buttonCooldownLeft[index2] = this.buttonCooldownTotal[index2]);
+        }
+      }
+      return true;
+    }
+    let slot = -1;
+    for (let i = 0; i < 10; i++)
+      if (this.pointerId[i] === id) {
+        slot = i;
+        break;
+      }
+    if (slot < 0) return false;
+    let owner = this.pointerOwner[slot], index = owner & INDEX_MASK, kind = owner >> (4);
+    if (kind === (0)) this.stickMove(index);
+    else if (kind === (1)) {
+      let sensitivity = r[(7)], dx = (px - this.lookLast[0]) * sensitivity, dy = (py - this.lookLast[1]) * sensitivity;
+      this.lookLast[0] = px, this.lookLast[1] = py, (dx !== 0 || dy !== 0) && (inputStage[STAGE_X] = dx, inputStage[STAGE_Y] = dy, inputStage[STAGE_TIME] = time, input.lookStaged());
+      let elapsed = time - r[(9)];
+      if (elapsed > 0) {
+        let v = this.lookVelocity;
+        v[0] += (dx * (1e3) / elapsed - v[0]) * (0.6), v[1] += (dy * (1e3) / elapsed - v[1]) * (0.6), r[(9)] = time;
+      }
+    } else if (this.buttonLookThrough[index] === (1)) {
+      let o = index * (2), sensitivity = r[(7)] > 0 ? r[(7)] : (1), dx = (px - this.buttonLast[o]) * sensitivity, dy = (py - this.buttonLast[o + 1]) * sensitivity;
+      this.buttonLast[o] = px, this.buttonLast[o + 1] = py, (dx !== 0 || dy !== 0) && (inputStage[STAGE_X] = dx, inputStage[STAGE_Y] = dy, inputStage[STAGE_TIME] = time, input.lookStaged());
+    }
+    if (phase === "move") return true;
+    if (this.pointerId[slot] = (-1), this.pointerOwner[slot] = (-1), kind === (0)) {
+      this.stickPointer[index] = (-1);
+      let tap = this.stickSlotTap[index];
+      tap !== (-1) && this.stickMoved[index] === (0) && time - this.stickDownMs[index] <= (220) && (inputStage[STAGE_X] = 1, inputStage[STAGE_TIME] = time, input.virtualStaged(tap), inputStage[STAGE_TIME] = time, input.virtualStaged(tap));
+      let io = this.stickIo;
+      io[0] = 0, io[1] = 0, io[2] = 0, this.publishStick(index);
+    } else if (kind === (1)) {
+      this.lookPointer = (-1);
+      let v = this.lookVelocity, fresh = time - r[(9)] <= (60);
+      this.lookCoasting = r[(8)] > 0 && fresh && v[0] * v[0] + v[1] * v[1] > (30) * (30), this.lookCoasting || (v[0] = 0, v[1] = 0);
+    } else
+      this.buttonPointer[index] = (-1), this.buttonLastUpMs[index] = time, this.buttonMode[index] === (0) && (inputStage[STAGE_X] = 0, inputStage[STAGE_TIME] = time, input.virtualStaged(this.buttonSlot[index]));
+    return true;
+  }
+  accessibleActivate(button, timeMs) {
+    if (button < 0 || button >= this.buttonCount || !this.enabledState || this.buttonCooldownLeft[button] > 0) return;
+    let input = this.input, stage = input.stage, slot = this.buttonSlot[button];
+    this.buttonMode[button] === (1) ? (this.buttonToggled[button] = this.buttonToggled[button] === (1) ? (0) : (1), stage[STAGE_X] = this.buttonToggled[button], stage[STAGE_TIME] = timeMs, input.virtualStaged(slot)) : (stage[STAGE_X] = 1, stage[STAGE_TIME] = timeMs, input.virtualStaged(slot), stage[STAGE_TIME] = timeMs, input.virtualStaged(slot)), this.buttonCooldownTotal[button] > 0 && (this.buttonCooldownLeft[button] = this.buttonCooldownTotal[button]);
+  }
+  accessibleStep(stick, action, timeMs) {
+    if (stick < 0 || stick >= (2) || this.stickUsed[stick] === (0) || !this.enabledState || this.stickPointer[stick] !== (-1)) return;
+    let direction = action === UiAction.increment ? 1 : action === UiAction.decrement ? -1 : 0;
+    if (direction === 0) return;
+    let io = this.stickIo, horizontal = this.stickAxes[stick] === 1;
+    io[0] = horizontal ? direction : 0, io[1] = horizontal ? 0 : direction, io[2] = 1, this.reg[(2)] = timeMs, this.publishStick(stick), this.stickAccessibleLeft[stick] = (0.4);
+  }
+  update(clock) {
+    let r = this.reg, dt = clock[FRAME_SECONDS_SLOT];
+    r[(3)] = dt, this.viewportSource !== null && this.syncViewport(this.viewportSource);
+    for (let s = 0; s < (2); s++) {
+      let left = this.stickAccessibleLeft[s];
+      if (left <= 0 || (this.stickAccessibleLeft[s] = left - dt, left - dt > 0 || this.stickPointer[s] !== (-1))) continue;
+      let io = this.stickIo;
+      io[0] = 0, io[1] = 0, io[2] = 0, this.publishStick(s);
+    }
+    for (let b = 0; b < this.buttonCount; b++) {
+      let left = this.buttonCooldownLeft[b];
+      left > 0 && (this.buttonCooldownLeft[b] = left - dt > 0 ? left - dt : 0);
+    }
+    if (this.lookCoasting) {
+      let v = this.lookVelocity, stage = this.input.stage;
+      stage[STAGE_X] = v[0] * dt, stage[STAGE_Y] = v[1] * dt, stage[STAGE_TIME] = r[(9)], this.input.lookStaged();
+      let decay = Math.exp(-dt / r[(8)]);
+      v[0] *= decay, v[1] *= decay, v[0] * v[0] + v[1] * v[1] < (30) * (30) && (v[0] = 0, v[1] = 0, this.lookCoasting = false);
+    }
+    let ui = this.ui;
+    if (ui === null) return;
+    let writer = ui.writer, records = writer.records;
+    this.drawVisibility(writer);
+    for (let s = 0; s < (2); s++) this.stickUsed[s] === (1) && this.drawStick(writer, s);
+    for (let b = 0; b < this.buttonCount; b++) this.drawButton(writer, b);
+    writer.records !== records && ui.touched();
+  }
+  dispose() {
+    this.detach();
+    for (let i = 0; i < this.elements.length; i++) this.elements[i].destroy();
+    this.elements.length = 0;
+  }
+  addStick(index, spec, placement) {
+    let input = this.input;
+    this.stickUsed[index] = (1);
+    let prefix = index === (0) ? "touch.move" : "touch.aim";
+    this.stickSlotX[index] = input.virtualControl(spec.x ?? `${prefix}.x`), this.stickSlotY[index] = input.virtualControl(spec.y ?? `${prefix}.y`), spec.tap !== void 0 && (this.stickSlotTap[index] = input.virtualControl(spec.tap));
+    let floating = (spec.mode ?? "floating") === "floating";
+    this.stickFloating[index] = floating ? (1) : (0), this.stickFollow[index] = spec.follow ?? floating ? (1) : (0), this.stickAxes[index] = stickAxesCode(spec.axes ?? "both"), this.stickBaseRadius[index] = spec.radius ?? (58), this.stickDead[index] = spec.deadZone ?? (0.12), this.stickCurve[index] = spec.curve ?? (1), this.stickSnap[index] = spec.snapSeconds ?? (0.12), copyRect(placement.zone, this.stickZoneFraction, index * (4)), this.stickHomeFraction[index * (2)] = placement.home[0], this.stickHomeFraction[index * (2) + 1] = placement.home[1];
+  }
+  addButton(spec, placement) {
+    let b = this.buttonCount++, input = this.input;
+    this.buttonSlot[b] = input.virtualControl(spec.control), spec.doubleTap !== void 0 && (this.buttonDoubleSlot[b] = input.virtualControl(spec.doubleTap)), this.buttonMode[b] = spec.mode === "toggle" ? (1) : (0), this.buttonLookThrough[b] = spec.lookThrough ? (1) : (0), this.buttonCooldownTotal[b] = spec.cooldownSeconds ?? 0, this.buttonSize[b] = spec.size ?? placement.size, this.buttonIndex.set(spec.control, b), this.placements.push(placement);
+  }
+  resolve(width, height, insets) {
+    let r = this.reg;
+    r[(5)] = width > 0 ? width : (844), r[(6)] = height > 0 ? height : (390), r[(12) + (0)] = insets?.left ?? 0, r[(12) + (1)] = insets?.top ?? 0, r[(12) + (2)] = r[(5)] - (insets?.right ?? 0), r[(12) + (3)] = r[(6)] - (insets?.bottom ?? 0);
+    let shortSide = Math.min(r[(5)], r[(6)]);
+    r[(4)] = Math.min((1.4), Math.max((0.85), shortSide / (390)));
+    let scale = r[(4)], sx = r[(12) + (0)], sy = r[(12) + (1)], sw = r[(12) + (2)] - sx, sh = r[(12) + (3)] - sy;
+    for (let s = 0; s < (2); s++) {
+      if (this.stickUsed[s] === (0)) continue;
+      this.stickRadius[s] = this.stickBaseRadius[s] * scale, this.placeRect(this.stickZoneFraction, s * (4), this.stickZone);
+      let hx = sx + sw * this.stickHomeFraction[s * (2)], hy = sy + sh * this.stickHomeFraction[s * (2) + 1];
+      this.stickHome[s * (2)] = hx, this.stickHome[s * (2) + 1] = hy, this.stickPointer[s] === (-1) && (this.stickOrigin[s * (2)] = hx, this.stickOrigin[s * (2) + 1] = hy);
+    }
+    this.lookUsed && this.placeRect(this.lookZoneFraction, 0, this.lookZone);
+    for (let b = 0; b < this.buttonCount; b++) {
+      let p = this.placements[b];
+      this.buttonRadius[b] = this.buttonSize[b] * scale / 2, this.buttonCenter[b * (2)] = sx + sw * p.anchor[0] + p.offset[0] * scale, this.buttonCenter[b * (2) + 1] = sy + sh * p.anchor[1] + p.offset[1] * scale;
+    }
+  }
+  placeRect(fractions, at, out) {
+    let r = this.reg, sx = r[(12) + (0)], sy = r[(12) + (1)], w = r[(12) + (2)] - sx, h = r[(12) + (3)] - sy;
+    out[at] = sx + w * fractions[at], out[at + 1] = sy + h * fractions[at + 1], out[at + 2] = sx + w * fractions[at + 2], out[at + 3] = sy + h * fractions[at + 3];
+  }
+  stickMove(s) {
+    let r = this.reg, o = s * (2);
+    if (this.stickTouch[o] = r[(0)], this.stickTouch[o + 1] = r[(1)], this.stickFollow[s] === (1)) {
+      let axes = this.stickAxes[s], target = this.stickFollowTarget;
+      target[0] = axes === 2 ? this.stickOrigin[o] : r[(0)], target[1] = axes === 1 ? this.stickOrigin[o + 1] : r[(1)], followOriginInto(this.stickOrigin, o, target, 0, this.stickRadius, s);
+    }
+    if (this.stickMoved[s] === (0)) {
+      let dx = r[(0)] - this.stickOrigin[o], dy = r[(1)] - this.stickOrigin[o + 1], slop = this.stickRadius[s] * (0.25);
+      dx * dx + dy * dy > slop * slop && (this.stickMoved[s] = (1));
+    }
+    this.emitStick(s);
+  }
+  stickRelease(s) {
+    this.stickPointer[s] = (-1), this.stickIo[0] = 0, this.stickIo[1] = 0, this.stickIo[2] = 0, this.publishStick(s);
+  }
+  emitStick(s) {
+    let o = s * (2), io = this.stickIo;
+    io[3] = this.stickTouch[o] - this.stickOrigin[o], io[4] = this.stickTouch[o + 1] - this.stickOrigin[o + 1], io[5] = this.stickRadius[s], io[6] = this.stickDead[s], io[7] = this.stickCurve[s], shapeStickInto(io, this.stickAxes[s]), this.publishStick(s);
+  }
+  publishStick(s) {
+    let io = this.stickIo, v = this.stickValue, o = s * 3, input = this.input, stage = input.stage;
+    v[o + 0] !== io[0] && this.stickSlotX[s] !== (-1) && (stage[STAGE_X] = io[0], stage[STAGE_TIME] = this.reg[(2)], input.virtualStaged(this.stickSlotX[s])), v[o + 1] !== io[1] && this.stickSlotY[s] !== (-1) && (stage[STAGE_X] = io[1], stage[STAGE_TIME] = this.reg[(2)], input.virtualStaged(this.stickSlotY[s])), v[o + 0] = io[0], v[o + 1] = io[1], v[o + 2] = io[2];
+  }
+  buttonRelease(b) {
+    if (this.buttonPointer[b] = (-1), this.buttonMode[b] !== (0)) return;
+    let stage = this.input.stage;
+    stage[STAGE_X] = 0, stage[STAGE_TIME] = this.reg[(2)], this.input.virtualStaged(this.buttonSlot[b]);
+  }
+  releaseAll() {
+    for (let i = 0; i < 10; i++) {
+      let owner = this.pointerOwner[i];
+      if (owner === (-1)) continue;
+      this.pointerId[i] = (-1), this.pointerOwner[i] = (-1);
+      let index = owner & INDEX_MASK, kind = owner >> (4);
+      kind === (0) ? this.stickRelease(index) : kind === (1) ? (this.lookPointer = (-1), this.lookCoasting = false) : this.buttonRelease(index);
+    }
+  }
+  drawVisibility(writer) {
+    let device = this.input.device, visible = this.enabledState;
+    visible && this.autoHide && (device === InputDevice.keyboard || device === InputDevice.gamepad) && this.activeTouches === 0 && (visible = false);
+    let opacity = visible ? (1) : 0;
+    opacity !== this.reg[(10)] && (this.reg[(10)] = opacity, this.single[0] = opacity, writer.propF32(this.rootNode, UiProp.opacity, this.single));
+  }
+  drawStick(writer, s) {
+    let o = s * (2), radius = this.stickRadius[s], active = this.stickPointer[s] !== (-1), knob = this.stickKnob;
+    if (active) {
+      let kx = this.stickTouch[o] - this.stickOrigin[o], ky = this.stickTouch[o + 1] - this.stickOrigin[o + 1], axes = this.stickAxes[s];
+      axes === 1 ? ky = 0 : axes === 2 && (kx = 0);
+      let length = (kx * kx + ky * ky) ** 0.5;
+      length > radius && (kx *= radius / length, ky *= radius / length), knob[o] = kx, knob[o + 1] = ky;
+    } else {
+      let k = 1 - Math.exp(-this.reg[(3)] * (3) / this.stickSnap[s]);
+      knob[o] -= knob[o] * k, knob[o + 1] -= knob[o + 1] * k, this.stickFloating[s] === (1) && (this.stickOrigin[o] = this.stickHome[o], this.stickOrigin[o + 1] = this.stickHome[o + 1]);
+    }
+    let shownBase = this.stickShownBase, baseX = this.stickOrigin[o] - radius, baseY = this.stickOrigin[o + 1] - radius;
+    Math.abs(shownBase[o] - baseX) < (0.25) && Math.abs(shownBase[o + 1] - baseY) < (0.25) || (shownBase[o] = baseX, shownBase[o + 1] = baseY, this.pair[0] = baseX, this.pair[1] = baseY, writer.propF32(this.stickBaseNode[s], UiProp.translate, this.pair));
+    let shownKnob = this.stickShownKnob;
+    Math.abs(shownKnob[o] - knob[o]) < (0.25) && Math.abs(shownKnob[o + 1] - knob[o + 1]) < (0.25) || (shownKnob[o] = knob[o], shownKnob[o + 1] = knob[o + 1], this.pair[0] = knob[o], this.pair[1] = knob[o + 1], writer.propF32(this.stickKnobNode[s], UiProp.translate, this.pair));
+    let shade = this.shade;
+    shade[0] = this.reg[(11)], active && (shade[0] = (1)), this.stickShownOpacity[s] !== shade[0] && (this.stickShownOpacity[s] = shade[0], this.single[0] = shade[0], writer.propF32(this.stickBaseNode[s], UiProp.opacity, this.single));
+  }
+  drawButton(writer, b) {
+    let node = this.buttonNode[b], o = b * (2), radius = this.buttonRadius[b], cx = this.buttonCenter[o] - radius, cy = this.buttonCenter[o + 1] - radius, shown = this.buttonShownCenter;
+    Math.abs(shown[o] - cx) < (0.25) && Math.abs(shown[o + 1] - cy) < (0.25) || (shown[o] = cx, shown[o + 1] = cy, this.pair[0] = cx, this.pair[1] = cy, writer.propF32(node, UiProp.translate, this.pair));
+    let held = this.buttonPointer[b] !== (-1) && this.buttonCooldownLeft[b] <= 0, lit = held || this.buttonMode[b] === (1) && this.buttonToggled[b] === (1), pressed = lit ? (1) : (0);
+    if (this.buttonShownPressed[b] !== pressed) {
+      this.buttonShownPressed[b] = pressed, this.single[0] = lit ? (1) : 0, writer.propF32(this.buttonHighlightNode[b], UiProp.opacity, this.single);
+      let scale = held ? this.pressScale : 1;
+      this.pair[0] = scale, this.pair[1] = scale, writer.propF32(node, UiProp.scale, this.pair);
+    }
+    let total = this.buttonCooldownTotal[b], shade = this.shade;
+    shade[0] = 0, total > 0 && (shade[0] = this.buttonCooldownLeft[b] / total);
+    let ratio = shade[0], before = this.buttonShownCooldown[b];
+    (before !== before || Math.abs(before - ratio) >= COOLDOWN_EPSILON || ratio === 0 && before !== 0) && (this.buttonShownCooldown[b] = ratio, this.pair[0] = 1, this.pair[1] = ratio, writer.propF32(this.buttonOverlayNode[b], UiProp.scale, this.pair), this.single[0] = ratio > 0 ? (0.55) : (1), writer.propF32(node, UiProp.opacity, this.single));
+  }
+  build(ui, buttons) {
+    let t = this.theme, root = ui.box({ position: "absolute", left: 0, top: 0, width: "100%", height: "100%", pointerEvents: "none" });
+    root.transition(["opacity"], { duration: t.motion, easing: "ease_out" }), ui.root(root, { anchor: "top_left", safe_area: false, z: this.z }), this.rootNode = root.id, this.elements.push(root);
+    for (let s = 0; s < (2); s++) {
+      if (this.stickUsed[s] === (0)) continue;
+      let base = ui.box({
+        position: "absolute",
+        left: 0,
+        top: 0,
+        fill: t.track,
+        borderWidth: (2),
+        borderColor: t.border,
+        pointerEvents: "none",
+        layer: true
+      });
+      base.transition(["opacity"], { duration: t.motion, easing: "ease_out" });
+      let stick = s;
+      base.accessibility({ role: "adjustable", label: s === (0) ? MOVE_LABEL : AIM_LABEL, actions: ["increment", "decrement"] }), base.on("action", (event) => this.accessibleStep(stick, event.value, event.time_ms));
+      let knob = ui.box({ position: "absolute", fill: (parseColor(t.text) & (4294967040) | (217)) >>> 0, pointerEvents: "none", layer: true });
+      base.append(knob), root.append(base), this.stickBaseNode[s] = base.id, this.stickKnobNode[s] = knob.id, this.elements.push(base, knob), this.sized(base, (0), s), this.sized(knob, (1), s);
+    }
+    for (let b = 0; b < this.buttonCount; b++) {
+      let spec = buttons[b], button = ui.box({
+        position: "absolute",
+        left: 0,
+        top: 0,
+        alignItems: "center",
+        justify: "center",
+        fill: t.raised,
+        borderWidth: (2),
+        borderColor: t.border,
+        clip: true,
+        pointerEvents: "none",
+        layer: true,
+        origin: [(0.5), (0.5)]
+      });
+      button.transition(["scale_x", "scale_y", "opacity"], { duration: t.motion, easing: "back_out" });
+      let highlight = ui.box({
+        position: "absolute",
+        left: 0,
+        top: 0,
+        width: "100%",
+        height: "100%",
+        fill: t.accent,
+        opacity: 0,
+        pointerEvents: "none",
+        layer: true
+      });
+      highlight.transition(["opacity"], { duration: t.motion, easing: "ease_out" }), button.append(highlight);
+      let overlay = ui.box({
+        position: "absolute",
+        left: 0,
+        top: 0,
+        width: "100%",
+        height: "100%",
+        fill: (parseColor(t.surface) & (4294967040) | (179)) >>> 0,
+        origin: [(0.5), 1],
+        pointerEvents: "none",
+        layer: true
+      });
+      if (button.append(overlay), spec.icon !== void 0) {
+        let size = t.body * 2, icon = ui.image(spec.icon, [size, size], { width: size, height: size, pointerEvents: "none" });
+        button.append(icon), this.elements.push(icon);
+      } else if (spec.label !== void 0) {
+        let label = ui.text(spec.label, { fontFamily: t.font, fontSize: t.small, textColor: t.text, textAlign: "center", pointerEvents: "none" });
+        button.append(label), this.elements.push(label);
+      }
+      button.accessibility({ role: "button", label: spec.label ?? spec.control, actions: ["activate"] });
+      let index = b;
+      button.on("tap", (event) => this.accessibleActivate(index, event.time_ms)), root.append(button), this.buttonNode[b] = button.id, this.buttonOverlayNode[b] = overlay.id, this.buttonHighlightNode[b] = highlight.id, this.elements.push(button, highlight, overlay), this.sized(button, (2), b);
+    }
+    this.resize();
+  }
+  sized(element, kind, index) {
+    this.sizedElements.push(element), this.sizedKind.push(kind), this.sizedIndex.push(index);
+  }
+  resize() {
+    for (let i = 0; i < this.sizedElements.length; i++) {
+      let element = this.sizedElements[i], index = this.sizedIndex[i], kind = this.sizedKind[i];
+      if (kind === (2)) {
+        let d = this.buttonRadius[index] * 2;
+        element.style({ width: d, height: d, radius: d / 2 });
+      } else if (kind === (0)) {
+        let d = this.stickRadius[index] * 2;
+        element.style({ width: d, height: d, radius: d / 2 });
+      } else {
+        let r = this.stickRadius[index], d = r * 2 * (0.46);
+        element.style({ width: d, height: d, radius: d / 2, left: r - d / 2, top: r - d / 2 });
+      }
+    }
+    this.stickShownBase.fill(Number.NaN), this.buttonShownCenter.fill(Number.NaN);
+  }
+};
+function copyRect(source, out, at = 0) {
+  out[at] = source[0], out[at + 1] = source[1], out[at + 2] = source[2], out[at + 3] = source[3];
+}
+
+export { CHAR_AIR_SECONDS, CHAR_BUFFER, CHAR_COYOTE, CHAR_CROUCH, CHAR_GROUND_NX, CHAR_GROUND_NY, CHAR_GROUND_NZ, CHAR_HEADING, CHAR_LANDING_SPEED, CHAR_MOVE_MAGNITUDE, CHAR_MOVE_X, CHAR_MOVE_Z, CHAR_PLATFORM_VX, CHAR_PLATFORM_VY, CHAR_PLATFORM_VZ, CHAR_SPEED, CHAR_SPEED_NORMALIZED, CHAR_VX, CHAR_VY, CHAR_VZ, CONTACT_LOCKED, CONTACT_LOCK_BLEND, CONTACT_LOCK_X, CONTACT_LOCK_Y, CONTACT_LOCK_Z, CONTACT_PLANTED, CONTACT_WEIGHT, CharacterMotor, ClipEventReader, DEFAULT_CLIP_EVENT_CAPACITY, DEFAULT_CONTACT_MAX_SLIDE, DEFAULT_CONTACT_RELEASE_SECONDS, DEFAULT_CONTACT_WEIGHT_SECONDS, DEFAULT_FOOT_UP, DEFAULT_GAMEPAD_LOOK_SPEED, DEFAULT_LOOK_SENSITIVITY, DEFAULT_MAX_FOOT_TILT, DEFAULT_PLANT_THRESHOLD, FOLLOW_CAMERA_X, FOLLOW_CAMERA_Y, FOLLOW_CAMERA_Z, FOLLOW_CLOSENESS, FOLLOW_DISTANCE, FOLLOW_FOV, FOLLOW_PITCH, FOLLOW_PIVOT_X, FOLLOW_PIVOT_Y, FOLLOW_PIVOT_Z, FOLLOW_SHOULDER, FOLLOW_YAW, FollowCamera, FootContact, MAX_TOUCH_BUTTONS, MOVE_IN_X, MOVE_IN_Y, MOVE_IO_MAGNITUDE, MOVE_IO_WORDS, MOVE_IO_X, MOVE_IO_Z, MOVE_OUT_X, MOVE_OUT_Z, ROOT_IO_DX, ROOT_IO_DZ, ROOT_IO_YAW, STICK_AIM, STICK_CURVE, STICK_DEAD_ZONE, STICK_DX, STICK_DY, STICK_IO_WORDS, STICK_MAGNITUDE, STICK_MOVE, STICK_OUT_WORDS, STICK_RADIUS, STICK_X, STICK_Y, TouchControls, actionListed, createFootTiltChain, followOrigin, followOriginInto, shapeStick, shapeStickInto, touchLayout };