@aethervtt/shard-controls 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,3 @@
-# Temporary Holding Version
+# @aethervtt/shard-controls
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/components.d.ts

@@ -0,0 +1,59 @@
+import { type Infer } from '@aethervtt/shard-core';
+/**
+ * Orbit, pan and dolly around a target, on a perspective camera (0060). The fields are where the
+ * camera is going: input changes them, a host may write them (to restore a saved view), and with
+ * `smoothing` the camera eases toward them.
+ */
+export declare const OrbitControls: import("@aethervtt/shard-core").ComponentDef<{
+    readonly target: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly distance: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly yaw: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly pitch: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly minPitch: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly maxPitch: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly minDistance: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly maxDistance: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly orbitButton: import("@aethervtt/shard-core").FieldType<"left" | "middle" | "right", "u8">;
+    readonly panButton: import("@aethervtt/shard-core").FieldType<"left" | "middle" | "right", "u8">;
+    readonly leftDrag: import("@aethervtt/shard-core").FieldType<"none" | "orbit" | "pan", "u8">;
+    readonly rotateSpeed: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly zoomSpeed: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly autoRotate: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly smoothing: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly enabled: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+}>;
+export type OrbitControlsValue = Infer<typeof OrbitControls>;
+/**
+ * Pan and zoom-to-cursor on an orthographic camera over a floor (0060): the Map view, looking
+ * down (or tilted by `pitch`), or a 2D world on the xy plane. The fields are where the camera is
+ * going, as for `OrbitControls`.
+ */
+export declare const MapControls: import("@aethervtt/shard-core").ComponentDef<{
+    readonly target: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly zoom: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly minZoom: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly maxZoom: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly elevation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly pitch: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly plane: import("@aethervtt/shard-core").FieldType<"xy" | "xz", "u8">;
+    readonly bounded: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly boundsMin: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly boundsMax: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly panButton: import("@aethervtt/shard-core").FieldType<"left" | "middle" | "right", "u8">;
+    readonly leftDrag: import("@aethervtt/shard-core").FieldType<"none" | "pan", "u8">;
+    readonly zoomSpeed: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly smoothing: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly enabled: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+}>;
+export type MapControlsValue = Infer<typeof MapControls>;
+export interface ControlsSettingsValue {
+    /** Snap instead of easing, whatever a control's `smoothing` (the host's reduced-motion setting). */
+    reducedMotion: boolean;
+    /**
+     * The view size in CSS pixels for cameras that haven't rendered yet (headless runs): rendered
+     * cameras use their target's size.
+     */
+    viewport: [number, number];
+}
+export declare const ControlsSettings: import("@aethervtt/shard-core").ResourceDef<ControlsSettingsValue>;

package/dist/components.js

@@ -0,0 +1,110 @@
+import { defineComponent, defineResource, t } from "@aethervtt/shard-core";
+import { Camera3d } from "@aethervtt/shard-render";
+const BUTTONS = ["left", "middle", "right"];
+const OrbitControls = defineComponent(
+  "controls/OrbitControls",
+  {
+    target: t.vec3({ unit: "m", description: "The point the camera orbits and looks at." }),
+    distance: t.f32({ default: 10, min: 1e-4, unit: "m", description: "From the target." }),
+    yaw: t.f32({
+      unit: "deg",
+      description: "Turn about +Y: 0 looks from +Z toward -Z, 90 from +X."
+    }),
+    pitch: t.f32({
+      default: 45,
+      unit: "deg",
+      description: "Height above the horizon: 90 looks straight down."
+    }),
+    minPitch: t.f32({ default: 15, min: -89, max: 89, unit: "deg" }),
+    maxPitch: t.f32({ default: 89, min: -89, max: 89, unit: "deg" }),
+    minDistance: t.f32({ default: 1, min: 1e-4, unit: "m" }),
+    maxDistance: t.f32({ default: 100, min: 1e-4, unit: "m" }),
+    orbitButton: t.enum(BUTTONS, {
+      default: "right",
+      description: "Drags with it orbit; with Shift held they pan (trackpads have no middle)."
+    }),
+    panButton: t.enum(BUTTONS, { default: "middle", description: "Drags with it pan." }),
+    leftDrag: t.enum(["orbit", "pan", "none"], {
+      default: "orbit",
+      description: "What a left or one-finger drag nothing else claimed does: the host's drags (tokens) come first."
+    }),
+    rotateSpeed: t.f32({ default: 0.3, min: 0, unit: "deg", description: "Orbit per CSS pixel." }),
+    zoomSpeed: t.f32({ default: 1, min: 0, description: "Wheel zoom rate multiplier." }),
+    autoRotate: t.f32({
+      unit: "deg",
+      description: "Yaw per second while nothing drags the camera (a turntable). 0: still."
+    }),
+    smoothing: t.f32({
+      min: 0,
+      unit: "s",
+      description: "Time constant the camera eases toward the fields with. 0 (and reduced motion): at once."
+    }),
+    enabled: t.bool({ default: true, description: "Takes input. The camera must be active too." })
+  },
+  {
+    description: "Orbit (right drag), pan (middle drag, Shift+right), dolly to the cursor (wheel), and pinch, two-finger pan and twist on touch, on a perspective camera.",
+    requires: [Camera3d]
+  }
+);
+const MapControls = defineComponent(
+  "controls/MapControls",
+  {
+    target: t.vec3({ unit: "m", description: "The floor point at the center of the view." }),
+    zoom: t.f32({ default: 1, min: 1e-4, description: "The view is `height / zoom` tall." }),
+    minZoom: t.f32({ default: 0.1, min: 1e-4 }),
+    maxZoom: t.f32({ default: 8, min: 1e-4 }),
+    height: t.f32({
+      default: 20,
+      min: 1e-4,
+      unit: "m",
+      description: "The view's height at zoom 1 (Camera3d.orthoHeight = height / zoom)."
+    }),
+    elevation: t.f32({
+      default: 50,
+      min: 1e-4,
+      unit: "m",
+      description: "How far from the target the camera sits, along its view: keep it inside near..far."
+    }),
+    pitch: t.f32({
+      default: 90,
+      min: 1,
+      max: 90,
+      unit: "deg",
+      description: "Tilt on the xz floor: 90 looks straight down (screen-up -Z); less looks from the south, so wall faces show."
+    }),
+    plane: t.enum(["xz", "xy"], {
+      default: "xz",
+      description: "The ground it pans over: the xz floor (3D), or the xy plane of a 2D world, seen along -Z."
+    }),
+    bounded: t.bool({
+      description: "Keep the target within boundsMin..boundsMax (x, z; x, y on the xy plane)."
+    }),
+    boundsMin: t.vec2({ unit: "m" }),
+    boundsMax: t.vec2({ unit: "m" }),
+    panButton: t.enum(BUTTONS, { default: "middle", description: "Drags with it pan." }),
+    leftDrag: t.enum(["pan", "none"], {
+      default: "pan",
+      description: "What a left or one-finger drag nothing else claimed does: the host's drags (tokens) come first."
+    }),
+    zoomSpeed: t.f32({ default: 1, min: 0, description: "Wheel zoom rate multiplier." }),
+    smoothing: t.f32({
+      min: 0,
+      unit: "s",
+      description: "Time constant the camera eases toward the fields with. 0 (and reduced motion): at once."
+    }),
+    enabled: t.bool({ default: true, description: "Takes input. The camera must be active too." })
+  },
+  {
+    description: "Pan (middle drag, or left drag on empty floor) and zoom to the cursor (wheel, pinch) on an orthographic camera over a floor, or a 2D world.",
+    requires: [Camera3d]
+  }
+);
+const ControlsSettings = defineResource("controls/Settings", {
+  description: "Camera controls settings: reduced motion, and the headless view size.",
+  init: () => ({ reducedMotion: false, viewport: [1280, 720] })
+});
+export {
+  ControlsSettings,
+  MapControls,
+  OrbitControls
+};

package/dist/controls.d.ts

@@ -0,0 +1,42 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+import { type GestureEvent } from '@aethervtt/shard-input';
+type Kind = 'orbit' | 'map';
+export interface ControlLive {
+    entity: Entity;
+    kind: Kind;
+    /** The owner name it claims gestures with. */
+    owner: string;
+    /** Where the camera is now (eased toward the component's fields). */
+    target: Float64Array;
+    /** Orbit: distance. Map: zoom. */
+    scale: number;
+    yaw: number;
+    pitch: number;
+    /** The one-finger drag it owns (0: none), what it does, and the floor point it grabbed. */
+    dragId: number;
+    dragMode: 'pan' | 'orbit';
+    grab: Float64Array;
+    /** The two-finger gesture it owns (0: none). */
+    twoId: number;
+    moving: boolean;
+    active: boolean;
+    /** The buttons its pointer policy takes (bits), -1 when it has none set. */
+    policyBits: number;
+    seen: number;
+}
+export interface ControlsStateValue {
+    live: Map<Entity, ControlLive>;
+    frame: number;
+}
+export declare const ControlsState: import("@aethervtt/shard-core").ResourceDef<ControlsStateValue>;
+/** The size in CSS pixels `camera` is shown at: its target's once rendered, else the setting. */
+export declare function viewportOf(world: World, camera: Entity, out: [number, number]): [number, number];
+/** Reads gestures into the controls and places their cameras, before transform propagation. */
+export declare const updateControls: import("@aethervtt/shard-core").SystemDef<{
+    reader: import("@aethervtt/shard-core").EventReader<GestureEvent>;
+    orbit: import("@aethervtt/shard-core").Query;
+    map: import("@aethervtt/shard-core").Query;
+}>;
+/** Jumps a control's camera to its fields, skipping the easing (after a host sets a view). */
+export declare function snapControls(world: World, entity: Entity): void;
+export {};

package/dist/controls.js

@@ -0,0 +1,444 @@
+import {
+  defineResource,
+  defineSystem,
+  quat
+} from "@aethervtt/shard-core";
+import { Gesture, Gestures } from "@aethervtt/shard-input";
+import { MODIFIERS } from "@aethervtt/shard-platform";
+import { Camera3d, Cameras } from "@aethervtt/shard-render";
+import { FrameDemand, Time } from "@aethervtt/shard-runtime";
+import { Transform } from "@aethervtt/shard-transform";
+import { ControlsSettings, MapControls, OrbitControls } from "./components.js";
+import { createView, mapView, orbitView, viewToPlane } from "./view.js";
+const BUTTON_NAMES = ["left", "middle", "right"];
+const BUTTON_BITS = { left: 1, middle: 2, right: 4, back: 0, forward: 0 };
+const DEMAND = "controls";
+const MAX_HIT = 50;
+const WHEEL_RATE = 15e-4;
+const ControlsState = defineResource("controls/State", {
+  description: "Each control's eased camera state, and the gestures it owns.",
+  init: () => ({ live: /* @__PURE__ */ new Map(), frame: 0 })
+});
+const goal = {
+  target: new Float64Array(3),
+  scale: 1,
+  yaw: 0,
+  pitch: 0,
+  minScale: 0,
+  maxScale: 1,
+  minPitch: 0,
+  maxPitch: 0,
+  height: 1,
+  elevation: 1,
+  fovY: 60,
+  axis: 1,
+  mapPitch: 90,
+  bounded: false,
+  boundsMin0: 0,
+  boundsMin1: 0,
+  boundsMax0: 0,
+  boundsMax1: 0
+};
+const view = createView();
+const hitA = new Float64Array(3);
+const hitB = new Float64Array(3);
+const grab2 = new Float64Array(3);
+const viewport = [1, 1];
+const scratchQuat = new Float32Array(4);
+const back = new Float64Array(3);
+const eye = new Float64Array(3);
+function viewportOf(world, camera, out) {
+  const cam = world.tryResource(Cameras)?.get(camera);
+  if (cam && cam.frames > 0) {
+    out[0] = cam.displayWidth / cam.pixelRatio;
+    out[1] = cam.displayHeight / cam.pixelRatio;
+  } else {
+    const v = world.resource(ControlsSettings).viewport;
+    out[0] = v[0];
+    out[1] = v[1];
+  }
+  return out;
+}
+function clampGoal(kind, g) {
+  if (!(g.scale >= g.minScale)) g.scale = g.minScale;
+  if (g.scale > g.maxScale) g.scale = Math.max(g.minScale, g.maxScale);
+  if (kind === "orbit") {
+    if (!(g.pitch >= g.minPitch)) g.pitch = g.minPitch;
+    if (g.pitch > g.maxPitch) g.pitch = Math.max(g.minPitch, g.maxPitch);
+  }
+  if (g.bounded) {
+    const t = g.target;
+    t[0] = Math.min(Math.max(t[0], g.boundsMin0), Math.max(g.boundsMin0, g.boundsMax0));
+    const b = g.axis === 1 ? 2 : 1;
+    t[b] = Math.min(Math.max(t[b], g.boundsMin1), Math.max(g.boundsMin1, g.boundsMax1));
+  }
+}
+function goalView(kind, g, aspect) {
+  return kind === "orbit" ? orbitView(view, g.target, g.scale, g.yaw, g.pitch, g.fovY, aspect) : mapView(view, g.target, g.elevation, g.mapPitch, g.height / g.scale, aspect, planeOf(g));
+}
+function planeOf(g) {
+  return g.axis === 1 ? "xz" : "xy";
+}
+function viewSize(kind, g) {
+  return kind === "orbit" ? g.scale : g.height / g.scale;
+}
+function zoomAt(kind, g, x, y, factor) {
+  if (!Number.isFinite(factor) || factor <= 0) return;
+  const before = g.scale;
+  const hit = grabAt(kind, g, x, y, hitA);
+  g.scale = kind === "orbit" ? before * factor : before / factor;
+  clampGoal(kind, g);
+  if (!hit) return;
+  const k = kind === "orbit" ? g.scale / before : before / g.scale;
+  const t = g.target;
+  const b = g.axis === 1 ? 2 : 1;
+  t[0] = hitA[0] + (t[0] - hitA[0]) * k;
+  t[b] = hitA[b] + (t[b] - hitA[b]) * k;
+  clampGoal(kind, g);
+}
+function panTo(kind, g, grab, x, y) {
+  const v = goalView(kind, g, viewport[0] / viewport[1]);
+  const max = MAX_HIT * viewSize(kind, g);
+  const a = g.axis;
+  if (!viewToPlane(v, x, y, viewport[0], viewport[1], g.target[a], hitB, max, a)) return;
+  const b = a === 1 ? 2 : 1;
+  g.target[0] = g.target[0] + grab[0] - hitB[0];
+  g.target[b] = g.target[b] + grab[b] - hitB[b];
+  clampGoal(kind, g);
+}
+function grabAt(kind, g, x, y, out) {
+  const v = goalView(kind, g, viewport[0] / viewport[1]);
+  return viewToPlane(
+    v,
+    x,
+    y,
+    viewport[0],
+    viewport[1],
+    g.target[g.axis],
+    out,
+    MAX_HIT * viewSize(kind, g),
+    g.axis
+  );
+}
+const buttons = { orbit: void 0, pan: "middle", left: "none" };
+function dragMode(g) {
+  if (g.pointer !== "touch") {
+    if (buttons.orbit !== void 0 && g.button === buttons.orbit)
+      return (g.modifiers & MODIFIERS.shift) !== 0 ? "pan" : "orbit";
+    if (g.button === buttons.pan) return "pan";
+    if (g.button !== "left") return "none";
+  }
+  return buttons.left;
+}
+function handle(kind, g, live, e, gestures, rotateSpeed, zoomSpeed) {
+  switch (e.kind) {
+    case "drag-start":
+    case "drag": {
+      if (live.dragId === e.id) {
+        if (gestures.owner(e.id) !== live.owner) {
+          live.dragId = 0;
+          return;
+        }
+      } else {
+        if (live.dragId !== 0 || !gestures.free(e.id)) return;
+        const mode = dragMode(e);
+        if (mode === "none") return;
+        if (mode === "pan" && !grabAt(kind, g, e.startX, e.startY, live.grab)) return;
+        if (!gestures.claim(e.id, live.owner)) return;
+        live.dragId = e.id;
+        live.dragMode = mode;
+        if (mode === "orbit") {
+          g.yaw -= (e.x - e.startX - e.dx) * rotateSpeed;
+          g.pitch += (e.y - e.startY - e.dy) * rotateSpeed;
+        }
+      }
+      if (live.dragMode === "pan") panTo(kind, g, live.grab, e.x, e.y);
+      else if (kind === "orbit") {
+        g.yaw -= e.dx * rotateSpeed;
+        g.pitch += e.dy * rotateSpeed;
+        clampGoal(kind, g);
+      }
+      return;
+    }
+    case "drag-end":
+      if (live.dragId === e.id) live.dragId = 0;
+      return;
+    case "wheel":
+      zoomAt(kind, g, e.x, e.y, Math.exp(e.dy * WHEEL_RATE * zoomSpeed));
+      return;
+    case "pinch":
+    case "pan2":
+    case "twist": {
+      if (e.id !== 0 && live.twoId !== e.id) {
+        if (!gestures.free(e.id) || !gestures.claim(e.id, live.owner)) return;
+        live.twoId = e.id;
+      } else if (e.id !== 0 && gestures.owner(e.id) !== live.owner) return;
+      if (e.kind === "pinch") zoomAt(kind, g, e.x, e.y, 1 / e.scale);
+      else if (e.kind === "pan2") {
+        if (grabAt(kind, g, e.x - e.dx, e.y - e.dy, grab2)) panTo(kind, g, grab2, e.x, e.y);
+      } else if (kind === "orbit") {
+        const anchored = grabAt(kind, g, e.x, e.y, grab2);
+        g.yaw += e.angle * 180 / Math.PI;
+        if (anchored) panTo(kind, g, grab2, e.x, e.y);
+      }
+      return;
+    }
+  }
+}
+function setPolicy(gestures, live, bits) {
+  if (live.policyBits === bits) return;
+  live.policyBits = bits;
+  if (bits < 0) {
+    gestures.setPolicy(live.owner, void 0);
+    return;
+  }
+  const list = [];
+  for (let i = 0; i < 3; i++) if ((bits & 1 << i) !== 0) list.push(BUTTON_NAMES[i]);
+  const policy = { buttons: list, wheel: true, touch: true };
+  gestures.setPolicy(live.owner, policy);
+}
+function releaseAll(gestures, live) {
+  if (live.dragId !== 0) gestures.release(live.dragId, live.owner);
+  if (live.twoId !== 0) gestures.release(live.twoId, live.owner);
+  live.dragId = 0;
+  live.twoId = 0;
+  setPolicy(gestures, live, -1);
+}
+function createLive(entity, kind, g) {
+  return {
+    entity,
+    kind,
+    owner: `controls:${entity}`,
+    target: Float64Array.from(g.target),
+    scale: g.scale,
+    yaw: g.yaw,
+    pitch: g.pitch,
+    dragId: 0,
+    dragMode: "pan",
+    grab: new Float64Array(3),
+    twoId: 0,
+    moving: false,
+    active: false,
+    policyBits: -1,
+    seen: 0
+  };
+}
+function stepTo(from, to, alpha, eps) {
+  const next = from + (to - from) * alpha;
+  return Math.abs(to - next) <= eps ? to : next;
+}
+function ease(live, g, alpha) {
+  const eps = Math.max(1e-6, viewSize(live.kind, g)) * 1e-5;
+  const t = live.target;
+  t[0] = stepTo(t[0], g.target[0], alpha, eps);
+  t[1] = stepTo(t[1], g.target[1], alpha, eps);
+  t[2] = stepTo(t[2], g.target[2], alpha, eps);
+  live.scale = stepTo(live.scale, g.scale, alpha, Math.max(1e-6, g.scale * 1e-5));
+  live.yaw = stepTo(live.yaw, g.yaw, alpha, 1e-4);
+  live.pitch = stepTo(live.pitch, g.pitch, alpha, 1e-4);
+  return t[0] !== g.target[0] || t[1] !== g.target[1] || t[2] !== g.target[2] || live.scale !== g.scale || live.yaw !== g.yaw || live.pitch !== g.pitch;
+}
+function put(column, index, value) {
+  const v = Math.fround(value);
+  if (column[index] === v) return false;
+  column[index] = v;
+  return true;
+}
+function writeCamera(table, row, kind, live, g) {
+  const aspect = viewport[0] / viewport[1];
+  const v = kind === "orbit" ? orbitView(view, live.target, live.scale, live.yaw, live.pitch, g.fovY, aspect) : mapView(
+    view,
+    live.target,
+    g.elevation,
+    g.mapPitch,
+    g.height / live.scale,
+    aspect,
+    planeOf(g)
+  );
+  back[0] = -v.forward[0];
+  back[1] = -v.forward[1];
+  back[2] = -v.forward[2];
+  quat.fromBasis(scratchQuat, v.right, v.up, back);
+  eye.set(v.eye);
+  const translation = table.column(Transform, "translation");
+  const rotation = table.column(Transform, "rotation");
+  let changed = false;
+  for (let k = 0; k < 3; k++) {
+    const value = Math.fround(eye[k]);
+    if (translation[row * 3 + k] !== value) {
+      translation[row * 3 + k] = value;
+      changed = true;
+    }
+  }
+  for (let k = 0; k < 4; k++) {
+    if (rotation[row * 4 + k] !== scratchQuat[k]) {
+      rotation[row * 4 + k] = scratchQuat[k];
+      changed = true;
+    }
+  }
+  if (changed) table.markChanged(Transform, row);
+  if (kind === "map") {
+    const height = table.column(Camera3d, "orthoHeight");
+    const value = Math.fround(g.height / live.scale);
+    if (height[row] !== value) {
+      height[row] = value;
+      table.markChanged(Camera3d, row);
+    }
+  }
+}
+const ORBIT_LEFT = ["orbit", "pan", "none"];
+function run(world, events, kind, table, state, reduced, dt) {
+  const o = kind === "orbit";
+  const def = o ? OrbitControls : MapControls;
+  const gestures = world.resource(Gestures);
+  const active = table.column(Camera3d, "active");
+  const fov = table.column(Camera3d, "fovY");
+  const target = o ? table.column(OrbitControls, "target") : table.column(MapControls, "target");
+  const enabled = o ? table.column(OrbitControls, "enabled") : table.column(MapControls, "enabled");
+  const smoothing = o ? table.column(OrbitControls, "smoothing") : table.column(MapControls, "smoothing");
+  const zoomSpeed = o ? table.column(OrbitControls, "zoomSpeed") : table.column(MapControls, "zoomSpeed");
+  const panButton = o ? table.column(OrbitControls, "panButton") : table.column(MapControls, "panButton");
+  const leftDrag = o ? table.column(OrbitControls, "leftDrag") : table.column(MapControls, "leftDrag");
+  const distance = o ? table.column(OrbitControls, "distance") : void 0;
+  const yaw = o ? table.column(OrbitControls, "yaw") : void 0;
+  const pitch = o ? table.column(OrbitControls, "pitch") : void 0;
+  const minPitch = o ? table.column(OrbitControls, "minPitch") : void 0;
+  const maxPitch = o ? table.column(OrbitControls, "maxPitch") : void 0;
+  const minScale = o ? table.column(OrbitControls, "minDistance") : table.column(MapControls, "minZoom");
+  const maxScale = o ? table.column(OrbitControls, "maxDistance") : table.column(MapControls, "maxZoom");
+  const orbitButton = o ? table.column(OrbitControls, "orbitButton") : void 0;
+  const rotateSpeed = o ? table.column(OrbitControls, "rotateSpeed") : void 0;
+  const autoRotate = o ? table.column(OrbitControls, "autoRotate") : void 0;
+  const zoom = o ? void 0 : table.column(MapControls, "zoom");
+  const height = o ? void 0 : table.column(MapControls, "height");
+  const elevation = o ? void 0 : table.column(MapControls, "elevation");
+  const bounded = o ? void 0 : table.column(MapControls, "bounded");
+  const mapPitch = o ? void 0 : table.column(MapControls, "pitch");
+  const plane = o ? void 0 : table.column(MapControls, "plane");
+  const boundsMin = o ? void 0 : table.column(MapControls, "boundsMin");
+  const boundsMax = o ? void 0 : table.column(MapControls, "boundsMax");
+  let moving = false;
+  for (let i = 0; i < table.count; i++) {
+    const entity = table.entities[i];
+    goal.target[0] = target[i * 3];
+    goal.target[1] = target[i * 3 + 1];
+    goal.target[2] = target[i * 3 + 2];
+    goal.scale = o ? distance[i] : zoom[i];
+    goal.yaw = o ? yaw[i] : 0;
+    goal.pitch = o ? pitch[i] : 90;
+    goal.minScale = minScale[i];
+    goal.maxScale = maxScale[i];
+    goal.minPitch = o ? minPitch[i] : 90;
+    goal.maxPitch = o ? maxPitch[i] : 90;
+    goal.fovY = fov[i];
+    goal.height = o ? 1 : height[i];
+    goal.elevation = o ? 1 : elevation[i];
+    goal.bounded = o ? false : bounded[i] !== 0;
+    goal.axis = o || plane[i] === 0 ? 1 : 2;
+    goal.mapPitch = o ? 90 : mapPitch[i];
+    goal.boundsMin0 = o ? 0 : boundsMin[i * 2];
+    goal.boundsMin1 = o ? 0 : boundsMin[i * 2 + 1];
+    goal.boundsMax0 = o ? 0 : boundsMax[i * 2];
+    goal.boundsMax1 = o ? 0 : boundsMax[i * 2 + 1];
+    let live = state.live.get(entity);
+    if (!live || live.kind !== kind) {
+      clampGoal(kind, goal);
+      live = createLive(entity, kind, goal);
+      state.live.set(entity, live);
+    }
+    live.seen = state.frame;
+    live.active = active[i] !== 0 && enabled[i] !== 0;
+    if (!live.active) {
+      releaseAll(gestures, live);
+      continue;
+    }
+    viewportOf(world, entity, viewport);
+    buttons.orbit = o ? BUTTON_NAMES[orbitButton[i]] : void 0;
+    buttons.pan = BUTTON_NAMES[panButton[i]];
+    buttons.left = o ? ORBIT_LEFT[leftDrag[i]] : leftDrag[i] === 0 ? "pan" : "none";
+    setPolicy(
+      gestures,
+      live,
+      (buttons.orbit ? BUTTON_BITS[buttons.orbit] : 0) | BUTTON_BITS[buttons.pan] | (buttons.left !== "none" ? BUTTON_BITS.left : 0)
+    );
+    clampGoal(kind, goal);
+    const rs = o ? rotateSpeed[i] : 0;
+    for (let k = 0; k < events.length; k++)
+      handle(kind, goal, live, events[k], gestures, rs, zoomSpeed[i]);
+    const turning = o && autoRotate[i] !== 0 && live.dragId === 0 && live.twoId === 0;
+    if (turning) goal.yaw += autoRotate[i] * dt;
+    clampGoal(kind, goal);
+    let changed = put(target, i * 3, goal.target[0]);
+    if (put(target, i * 3 + 1, goal.target[1])) changed = true;
+    if (put(target, i * 3 + 2, goal.target[2])) changed = true;
+    if (o) {
+      if (put(distance, i, goal.scale)) changed = true;
+      if (put(yaw, i, goal.yaw)) changed = true;
+      if (put(pitch, i, goal.pitch)) changed = true;
+    } else if (put(zoom, i, goal.scale)) changed = true;
+    if (changed) table.markChanged(def, i);
+    goal.target[0] = target[i * 3];
+    goal.target[1] = target[i * 3 + 1];
+    goal.target[2] = target[i * 3 + 2];
+    goal.scale = o ? distance[i] : zoom[i];
+    goal.yaw = o ? yaw[i] : 0;
+    goal.pitch = o ? pitch[i] : 90;
+    const s = smoothing[i];
+    const alpha = reduced || !(s > 0) ? 1 : 1 - Math.exp(-dt / s);
+    live.moving = ease(live, goal, alpha) || turning;
+    if (live.moving) moving = true;
+    writeCamera(table, i, kind, live, goal);
+  }
+  return moving;
+}
+const updateControls = defineSystem({
+  name: "controls/update",
+  description: "Orbit and Map controls: gestures move each active control, which eases and places its camera.",
+  setup: (world) => ({
+    reader: world.reader(Gesture),
+    orbit: world.query({ with: [OrbitControls, Camera3d, Transform] }),
+    map: world.query({ with: [MapControls, Camera3d, Transform] })
+  }),
+  run: ({ reader, orbit, map }, world) => {
+    const events = reader.read();
+    const state = world.resource(ControlsState);
+    state.frame++;
+    const dt = world.resource(Time).delta;
+    const reduced = world.resource(ControlsSettings).reducedMotion;
+    let moving = false;
+    for (const table of orbit.tables)
+      if (run(world, events, "orbit", table, state, reduced, dt)) moving = true;
+    for (const table of map.tables)
+      if (run(world, events, "map", table, state, reduced, dt)) moving = true;
+    let live = 0;
+    for (const table of orbit.tables) live += table.count;
+    for (const table of map.tables) live += table.count;
+    if (live !== state.live.size) {
+      const gestures = world.resource(Gestures);
+      for (const [entity, l] of state.live) {
+        if (l.seen === state.frame) continue;
+        releaseAll(gestures, l);
+        state.live.delete(entity);
+      }
+    }
+    world.resource(FrameDemand).set(DEMAND, moving);
+  }
+});
+function snapControls(world, entity) {
+  const live = world.resource(ControlsState).live.get(entity);
+  if (!live) return;
+  const orbit = world.tryGet(entity, OrbitControls);
+  const map = orbit ? void 0 : world.tryGet(entity, MapControls);
+  const value = orbit ?? map;
+  if (!value) return;
+  live.target.set(value.target);
+  live.scale = orbit ? orbit.distance : map.zoom;
+  live.yaw = orbit ? orbit.yaw : 0;
+  live.pitch = orbit ? orbit.pitch : 90;
+}
+export {
+  ControlsState,
+  snapControls,
+  updateControls,
+  viewportOf
+};