@pmndrs/klipp 0.0.0-stage → 0.14.0

package/dist/core/body/PositionComposerBody.d.ts

@@ -0,0 +1,28 @@
+import type { Vec3 } from 'math';
+import type { CameraState } from '../CameraState.js';
+import type { TargetPose } from '../TargetPose.js';
+import type { DampingConstant } from '../damping/damping.js';
+import * as positionComposer from './positionComposer.js';
+import type { PositionComposerParams } from './positionComposer.js';
+/** Positions the camera using depth and screen-space composition. Layers override `readTarget`. */
+export declare class PositionComposerBody<T = TargetPose | null> implements PositionComposerParams {
+    target: T;
+    cameraDistance: number;
+    screenPosition: [number, number];
+    aspect: number;
+    deadZone: [number, number];
+    damping: DampingConstant;
+    hardLimit: [number, number];
+    depthDeadZone: number;
+    maxSpeed: number;
+    lookaheadTime: number;
+    lookaheadSmoothing: number;
+    lookaheadIgnoreY: boolean;
+    readonly state: positionComposer.PositionComposerState;
+    private lastTarget;
+    constructor(target: T, options?: Partial<PositionComposerParams>);
+    primeFrom: (position: Vec3) => void;
+    update: (out: CameraState, dt: number, justActivated: boolean) => void;
+    /** This frame's target pose with its extent, or `null` when there is none. */
+    protected readTarget(): TargetPose | null;
+}

package/dist/core/body/PositionComposerBody.js

@@ -0,0 +1,27 @@
+import { createParams, createState, prime, retarget, update } from "./positionComposer.js";
+//#region src/core/body/PositionComposerBody.ts
+/** Positions the camera using depth and screen-space composition. Layers override `readTarget`. */
+var PositionComposerBody = class {
+	target;
+	state = createState();
+	lastTarget = void 0;
+	constructor(target, options) {
+		this.target = target;
+		Object.assign(this, createParams(options));
+	}
+	primeFrom = (position) => prime(this.state, this, position);
+	update = (out, dt, justActivated) => {
+		const pose = this.readTarget();
+		if (pose) {
+			if (this.target !== this.lastTarget) retarget(this.state);
+			this.lastTarget = this.target;
+		}
+		update(out, this.state, this, pose, dt, justActivated);
+	};
+	/** This frame's target pose with its extent, or `null` when there is none. */
+	readTarget() {
+		return this.target;
+	}
+};
+//#endregion
+export { PositionComposerBody };

package/dist/core/body/follow.d.ts

@@ -0,0 +1,33 @@
+import { type Vec3 } from 'math';
+import type { CameraState } from '../CameraState.js';
+import type { TargetPose } from '../TargetPose.js';
+import type { DampingConstant } from '../damping/damping.js';
+import { type BindingMode } from './BindingModes.js';
+import type { TrackerState } from './tracker.js';
+export type FollowParams = {
+    /** Offset from the target, rotated according to `bindingMode`. */
+    offset: Vec3;
+    /** Response time for following the target position. */
+    damping: DampingConstant;
+    /** Response time for turning with the target, for every `bindingMode` but `worldSpace`. */
+    rotationDamping: DampingConstant;
+    /** Rotation frame used to interpret `offset`. */
+    bindingMode: BindingMode;
+    /** Maximum damping speed, in world units/sec. */
+    maxSpeed: number;
+};
+/** Every setting from `settings`, or its default. */
+export declare const createParams: (settings?: Partial<FollowParams>) => FollowParams;
+export type FollowState = {
+    tracker: TrackerState;
+    /** Position set by `prime`, applied once a target is available. */
+    primePosition: Vec3;
+    primed: boolean;
+};
+export declare const createState: () => FollowState;
+/** Whether `update` will read `target.rotation` this frame. */
+export declare const needsTargetRotation: (state: FollowState, params: FollowParams) => boolean;
+/** Moves `out` to the target position plus `offset`, rotated according to `bindingMode`. A `null` target leaves `out` as is. */
+export declare function update(out: CameraState, state: FollowState, params: FollowParams, target: TargetPose | null, dt: number, justActivated: boolean): void;
+/** Start the next activation from `position` instead of snapping to the target. */
+export declare function prime(state: FollowState, position: Vec3): void;

package/dist/core/body/follow.js

@@ -0,0 +1,83 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { withDefaults } from "../params.js";
+import { BindingModes } from "./BindingModes.js";
+import { createState as createState$1, needsTargetRotation as needsTargetRotation$1, prime as prime$1, referenceOrientation, reset, trackTarget } from "./tracker.js";
+import { vec3 } from "math";
+//#region src/core/body/follow.ts
+var follow_exports = /* @__PURE__ */ __exportAll({
+	createParams: () => createParams,
+	createState: () => createState,
+	needsTargetRotation: () => needsTargetRotation,
+	prime: () => prime,
+	update: () => update
+});
+/** Every setting from `settings`, or its default. */
+var createParams = (settings) => withDefaults({
+	offset: [
+		0,
+		0,
+		10
+	],
+	damping: 0,
+	rotationDamping: 0,
+	bindingMode: BindingModes.lockToTarget,
+	maxSpeed: Infinity
+}, settings);
+var createState = () => ({
+	tracker: createState$1(),
+	primePosition: [
+		0,
+		0,
+		0
+	],
+	primed: false
+});
+/** Whether `update` will read `target.rotation` this frame. */
+var needsTargetRotation = (state, params) => needsTargetRotation$1(state.tracker, params.bindingMode);
+var worldUp = [
+	0,
+	1,
+	0
+];
+var noOffset = [
+	0,
+	0,
+	0
+];
+var scratchRotation = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchRotatedOffset = [
+	0,
+	0,
+	0
+];
+function startFromPrime(state, params, target) {
+	referenceOrientation(scratchRotation, state.tracker, params.bindingMode, target);
+	vec3.transformQuat(scratchRotatedOffset, params.offset, scratchRotation);
+	vec3.subtract(scratchRotatedOffset, state.primePosition, scratchRotatedOffset);
+	prime$1(state.tracker, scratchRotatedOffset, params.offset, scratchRotation);
+}
+/** Moves `out` to the target position plus `offset`, rotated according to `bindingMode`. A `null` target leaves `out` as is. */
+function update(out, state, params, target, dt, justActivated) {
+	if (justActivated && !state.primed) reset(state.tracker);
+	if (!target) return;
+	if (state.primed) {
+		state.primed = false;
+		startFromPrime(state, params, target);
+	}
+	trackTarget(out.target, scratchRotation, state.tracker, params, target, params.offset, noOffset, dt);
+	vec3.add(out.position, out.target, vec3.transformQuat(scratchRotatedOffset, params.offset, scratchRotation));
+	out.hasTarget = true;
+	vec3.transformQuat(out.referenceUp, worldUp, scratchRotation);
+}
+/** Start the next activation from `position` instead of snapping to the target. */
+function prime(state, position) {
+	vec3.copy(state.primePosition, position);
+	state.primed = true;
+}
+//#endregion
+export { createParams, createState, follow_exports, needsTargetRotation, prime, update };

package/dist/core/body/hardLockToTarget.d.ts

@@ -0,0 +1,17 @@
+import { type Vec3 } from 'math';
+import type { CameraState } from '../CameraState.js';
+import type { DampingConstant, Vector3DamperState } from '../damping/damping.js';
+export type HardLockToTargetParams = {
+    /** Response time for following the target position. */
+    damping: DampingConstant;
+    /** Maximum damping speed, in world units/sec. */
+    maxSpeed: number;
+};
+/** Every setting from `settings`, or its default. */
+export declare const createParams: (settings?: Partial<HardLockToTargetParams>) => HardLockToTargetParams;
+export type HardLockToTargetState = {
+    damper: Vector3DamperState;
+};
+export declare const createState: () => HardLockToTargetState;
+/** Moves `out` onto `targetPosition`, optionally damped. A `null` target leaves `out` as is. */
+export declare function update(out: CameraState, state: HardLockToTargetState, params: HardLockToTargetParams, targetPosition: Vec3 | null, dt: number, justActivated: boolean): void;

package/dist/core/body/hardLockToTarget.js

@@ -0,0 +1,26 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { createVector3State, dampVector3, resetVector3 } from "../damping/damping.js";
+import { withDefaults } from "../params.js";
+import { vec3 } from "math";
+//#region src/core/body/hardLockToTarget.ts
+var hardLockToTarget_exports = /* @__PURE__ */ __exportAll({
+	createParams: () => createParams,
+	createState: () => createState,
+	update: () => update
+});
+/** Every setting from `settings`, or its default. */
+var createParams = (settings) => withDefaults({
+	damping: 0,
+	maxSpeed: Infinity
+}, settings);
+var createState = () => ({ damper: createVector3State() });
+/** Moves `out` onto `targetPosition`, optionally damped. A `null` target leaves `out` as is. */
+function update(out, state, params, targetPosition, dt, justActivated) {
+	if (justActivated) resetVector3(state.damper);
+	if (!targetPosition) return;
+	dampVector3(state.damper, out.position, targetPosition, params.damping, dt, params.maxSpeed);
+	vec3.copy(out.target, out.position);
+	out.hasTarget = true;
+}
+//#endregion
+export { createParams, createState, hardLockToTarget_exports, update };

package/dist/core/body/index.d.ts

@@ -0,0 +1,17 @@
+export { BindingModes, type BindingMode } from './BindingModes.js';
+export { HardLockToTargetBody, type HardLockToTargetOptions } from './HardLockToTargetBody.js';
+export * as hardLockToTarget from './hardLockToTarget.js';
+export type { HardLockToTargetParams, HardLockToTargetState } from './hardLockToTarget.js';
+export { FollowBody, type FollowOptions } from './FollowBody.js';
+export * as follow from './follow.js';
+export type { FollowParams, FollowState } from './follow.js';
+export { OrbitFollowBody, type OrbitFollowOptions } from './OrbitFollowBody.js';
+export * as orbitFollow from './orbitFollow.js';
+export type { OrbitFollowParams, OrbitFollowState, OrbitStyle, RecenteringTarget } from './orbitFollow.js';
+export * as threeRing from './threeRing.js';
+export type { Orbit, Orbits, ThreeRingState } from './threeRing.js';
+export * as tracker from './tracker.js';
+export type { TrackerParams, TrackerState } from './tracker.js';
+export { PositionComposerBody } from './PositionComposerBody.js';
+export * as positionComposer from './positionComposer.js';
+export type { PositionComposerParams, PositionComposerState } from './positionComposer.js';

package/dist/core/body/orbitFollow.d.ts

@@ -0,0 +1,76 @@
+import { type Quat, type Vec3 } from 'math';
+import type { CameraState } from '../CameraState.js';
+import type { TargetPose } from '../TargetPose.js';
+import type { DamperState, DampingConstant } from '../damping/damping.js';
+import type { InputAxisParams } from '../input/axis.js';
+import { InputAxis } from '../input/InputAxis.js';
+import { type BindingMode } from './BindingModes.js';
+import type { Orbits, ThreeRingState } from './threeRing.js';
+import type { TrackerState } from './tracker.js';
+export type OrbitFollowParams = {
+    /** Shape the camera moves on: a sphere of `radius`, or a surface through three `orbits`. */
+    orbitStyle: OrbitStyle;
+    /** Distance from the target while `radial` is `0`, for `sphere`. Changes ease in with `radial.damping`. */
+    radius: number;
+    /** Rings the `threeRing` surface passes through, from `vertical`'s minimum to its maximum. */
+    orbits: Orbits;
+    /** How strongly the `threeRing` surface curves between the rings, from `0` to `1`. */
+    splineCurvature: number;
+    /** Center of the orbit relative to the target, rotated according to `bindingMode`. */
+    targetOffset: Vec3;
+    /** Rotation frame the orbit is measured in. */
+    bindingMode: BindingMode;
+    /** Response time for following the target position. */
+    damping: DampingConstant;
+    /** Response time for turning with the target, for every `bindingMode` but `worldSpace`. */
+    rotationDamping: DampingConstant;
+    /** Maximum damping speed, in world units/sec. */
+    maxSpeed: number;
+    /** What `horizontal` recenters to: its `center`, or the side behind the target's forward. */
+    recenteringTarget: RecenteringTarget;
+};
+export type OrbitStyle = 'sphere' | 'threeRing';
+export type RecenteringTarget = 'axisCenter' | 'trackingTarget';
+/** Every setting from `settings`, or its default. */
+export declare const createParams: (settings?: Partial<OrbitFollowParams>) => OrbitFollowParams;
+/**
+ * `horizontal` (around the target, wraps ±180°) and `vertical` (elevation, or from the bottom to the top ring) in
+ * degrees, and `radial` as the natural log of the radius scale.
+ */
+export type OrbitFollowState = {
+    horizontal: InputAxis;
+    vertical: InputAxis;
+    radial: InputAxis;
+    radius: DamperState;
+    threeRing: ThreeRingState;
+    tracker: TrackerState;
+    /** Binding frame of the last `update`. */
+    orientation: Quat;
+    /** Position set by `prime`, applied once a target is available. */
+    primePosition: Vec3;
+    primed: boolean;
+};
+type AxisSettings = Partial<InputAxisParams>;
+/** Default settings of each axis. Every axis starts at its `center`. */
+export declare const createAxisSettings: () => {
+    horizontal: AxisSettings;
+    vertical: AxisSettings;
+    radial: AxisSettings;
+};
+export declare function createState(): OrbitFollowState;
+/** Whether `update` will read `target.rotation` this frame. */
+export declare const needsTargetRotation: (state: OrbitFollowState, params: OrbitFollowParams) => boolean;
+/** Start the next update from `position`'s direction around the target. `radial` keeps its value. */
+export declare function prime(state: OrbitFollowState, position: Vec3): void;
+/** Where the camera would be at these axis values, around the tracked point and in the frame of the last `update`. */
+export declare function point(out: Vec3, state: OrbitFollowState, params: OrbitFollowParams, horizontal: number, vertical: number): Vec3;
+/** Eases `horizontal` and `vertical` toward `position`'s direction around the target. `radial` keeps its value. */
+export declare function setFromPosition(state: OrbitFollowState, params: OrbitFollowParams, target: TargetPose, position: Vec3): void;
+/** Eases `horizontal` and `vertical` so the camera looks along `rotation`'s forward at the target. */
+export declare function setFromRotation(state: OrbitFollowState, params: OrbitFollowParams, target: TargetPose, rotation: Quat): void;
+/**
+ * Advances the axes and places `out` on the orbit around the target. A `null` target leaves `out` as is.
+ * Returns `true` while an axis still has to move.
+ */
+export declare function update(out: CameraState, state: OrbitFollowState, params: OrbitFollowParams, target: TargetPose | null, dt: number, justActivated: boolean): boolean;
+export {};

package/dist/core/body/orbitFollow.js

@@ -0,0 +1,336 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { createState as createState$1, damp, reset } from "../damping/damping.js";
+import { withDefaults } from "../params.js";
+import { shortestWrappedDelta } from "../input/shortestWrappedDelta.js";
+import { InputAxis } from "../input/InputAxis.js";
+import { BindingModes } from "./BindingModes.js";
+import { safeFromToRotation } from "./safeFromToRotation.js";
+import { createState as createState$2, needsTargetRotation as needsTargetRotation$1, referenceOrientation, reset as reset$1, trackTarget } from "./tracker.js";
+import { createState as createState$3, point as point$1 } from "./threeRing.js";
+import { clamp, degreesToRadians, quat, radiansToDegrees, vec3 } from "math";
+//#region src/core/body/orbitFollow.ts
+var orbitFollow_exports = /* @__PURE__ */ __exportAll({
+	createAxisSettings: () => createAxisSettings,
+	createParams: () => createParams,
+	createState: () => createState,
+	needsTargetRotation: () => needsTargetRotation,
+	point: () => point,
+	prime: () => prime,
+	setFromPosition: () => setFromPosition,
+	setFromRotation: () => setFromRotation,
+	update: () => update
+});
+/** Every setting from `settings`, or its default. */
+var createParams = (settings) => withDefaults({
+	orbitStyle: "sphere",
+	radius: 10,
+	orbits: {
+		top: {
+			height: 10,
+			radius: 10
+		},
+		center: {
+			height: 0,
+			radius: 10
+		},
+		bottom: {
+			height: -10,
+			radius: 10
+		}
+	},
+	splineCurvature: 0,
+	targetOffset: [
+		0,
+		0,
+		0
+	],
+	bindingMode: BindingModes.worldSpace,
+	damping: 0,
+	rotationDamping: 0,
+	maxSpeed: Infinity,
+	recenteringTarget: "trackingTarget"
+}, settings);
+/** Default settings of each axis. Every axis starts at its `center`. */
+var createAxisSettings = () => ({
+	horizontal: {
+		center: 0,
+		range: [-180, 180],
+		wrap: true
+	},
+	vertical: {
+		center: 0,
+		range: [-90, 90]
+	},
+	radial: {
+		center: 0,
+		range: [Math.log(.5), Math.log(2)]
+	}
+});
+function createState() {
+	const { horizontal, vertical, radial } = createAxisSettings();
+	return {
+		horizontal: new InputAxis({
+			...horizontal,
+			value: horizontal.center
+		}),
+		vertical: new InputAxis({
+			...vertical,
+			value: vertical.center
+		}),
+		radial: new InputAxis({
+			...radial,
+			value: radial.center
+		}),
+		radius: createState$1(),
+		threeRing: createState$3(),
+		tracker: createState$2(),
+		orientation: [
+			0,
+			0,
+			0,
+			1
+		],
+		primePosition: [
+			0,
+			0,
+			0
+		],
+		primed: false
+	};
+}
+var recentersBehindTarget = (state, params) => params.recenteringTarget === "trackingTarget" && state.horizontal.recentering.enabled;
+/** Whether `update` will read `target.rotation` this frame. */
+var needsTargetRotation = (state, params) => needsTargetRotation$1(state.tracker, params.bindingMode) || recentersBehindTarget(state, params);
+/** Start the next update from `position`'s direction around the target. `radial` keeps its value. */
+function prime(state, position) {
+	vec3.copy(state.primePosition, position);
+	state.primed = true;
+}
+var poleLimit = 89.999;
+var worldUp = [
+	0,
+	1,
+	0
+];
+var forwardAxis = [
+	0,
+	0,
+	-1
+];
+var scratchEuler = [
+	0,
+	0,
+	0,
+	"yxz"
+];
+var scratchRotation = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchOffset = [
+	0,
+	0,
+	0
+];
+var scratchOrientation = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchInverse = [
+	0,
+	0,
+	0,
+	1
+];
+var backAxis = [
+	0,
+	0,
+	1
+];
+var scratchDirection = [
+	0,
+	0,
+	0
+];
+var scratchWorld = [
+	0,
+	0,
+	0
+];
+var scratchAxes = [0, 0];
+var scratchPreviousOffset = [
+	0,
+	0,
+	0
+];
+/** Where `value` is within `axis`' range, from `0` to `1`. */
+function normalize(axis, value) {
+	const range = axis.range;
+	if (!range || range[1] <= range[0]) return .5;
+	return clamp((value - range[0]) / (range[1] - range[0]), 0, 1);
+}
+/** The camera's offset from the tracked point at these axis values, in the binding frame. */
+function orbitOffset(out, state, params, horizontal, vertical) {
+	const scale = Math.exp(state.radial.value);
+	if (params.orbitStyle === "threeRing") {
+		const t = normalize(state.vertical, vertical);
+		point$1(out, state.threeRing, params.orbits, params.splineCurvature, t);
+		vec3.scale(out, out, scale);
+		quat.setAxisAngle(scratchRotation, worldUp, -degreesToRadians(horizontal));
+	} else {
+		scratchEuler[0] = -degreesToRadians(clamp(vertical, -89.999, poleLimit));
+		scratchEuler[1] = -degreesToRadians(horizontal);
+		quat.fromEuler(scratchRotation, scratchEuler);
+		vec3.set(out, 0, 0, state.radius.value * scale);
+	}
+	return vec3.transformQuat(out, out, scratchRotation);
+}
+/** Where the camera would be at these axis values, around the tracked point and in the frame of the last `update`. */
+function point(out, state, params, horizontal, vertical) {
+	orbitOffset(out, state, params, horizontal, vertical);
+	vec3.transformQuat(out, out, state.orientation);
+	return vec3.add(out, out, state.tracker.trackedPoint);
+}
+function directionFrom(out, state, params, target, position) {
+	referenceOrientation(scratchOrientation, state.tracker, params.bindingMode, target);
+	vec3.add(out, target.position, vec3.transformQuat(out, params.targetOffset, scratchOrientation));
+	return vec3.subtract(out, position, out);
+}
+/** The `horizontal` and `vertical` values that put the camera along world `direction` from the orbit's center. */
+function axesAlong(state, params, target, direction) {
+	referenceOrientation(scratchOrientation, state.tracker, params.bindingMode, target);
+	vec3.transformQuat(scratchDirection, direction, quat.conjugate(scratchInverse, scratchOrientation));
+	const x = scratchDirection[0];
+	const y = scratchDirection[1];
+	const z = scratchDirection[2];
+	if (x * x + y * y + z * z < 1e-12) return null;
+	scratchAxes[0] = radiansToDegrees(Math.atan2(-x, z));
+	const elevation = Math.atan2(y, Math.hypot(x, z));
+	const range = state.vertical.range;
+	if (params.orbitStyle !== "threeRing") scratchAxes[1] = radiansToDegrees(elevation);
+	else if (range) scratchAxes[1] = range[0] + closestOrbitPoint(state, params, elevation) * (range[1] - range[0]);
+	else scratchAxes[1] = state.vertical.value;
+	return scratchAxes;
+}
+function easeAxesTo(state, axes) {
+	if (!axes) return;
+	const { horizontal, vertical } = state;
+	const wrapped = horizontal.wrap && horizontal.range;
+	horizontal.applyDelta(wrapped ? shortestWrappedDelta(horizontal.rawValue, axes[0], wrapped) : axes[0] - horizontal.rawValue);
+	vertical.applyDelta(axes[1] - vertical.rawValue);
+}
+/** Eases `horizontal` and `vertical` toward `position`'s direction around the target. `radial` keeps its value. */
+function setFromPosition(state, params, target, position) {
+	easeAxesTo(state, axesAlong(state, params, target, directionFrom(scratchWorld, state, params, target, position)));
+}
+/** Eases `horizontal` and `vertical` so the camera looks along `rotation`'s forward at the target. */
+function setFromRotation(state, params, target, rotation) {
+	easeAxesTo(state, axesAlong(state, params, target, vec3.transformQuat(scratchWorld, backAxis, rotation)));
+}
+function primeAxes(state, params, target, position) {
+	const axes = axesAlong(state, params, target, directionFrom(scratchWorld, state, params, target, position));
+	if (!axes) return;
+	state.horizontal.setValue(axes[0]);
+	state.vertical.setValue(axes[1]);
+}
+function elevationError(state, params, t, elevation) {
+	point$1(scratchDirection, state.threeRing, params.orbits, params.splineCurvature, t);
+	return Math.abs(Math.atan2(scratchDirection[1], scratchDirection[2]) - elevation);
+}
+/** Where between the bottom (`0`) and top (`1`) ring the direction from the target is closest to `elevation`. */
+function closestOrbitPoint(state, params, elevation) {
+	const samples = 32;
+	let best = 0;
+	let bestError = Infinity;
+	for (let i = 0; i <= samples; i++) {
+		const error = elevationError(state, params, i / samples, elevation);
+		if (error < bestError) {
+			bestError = error;
+			best = i / samples;
+		}
+	}
+	for (let step = .5 / samples; step > 1e-7; step /= 2) {
+		const below = clamp(best - step, 0, 1);
+		const above = clamp(best + step, 0, 1);
+		const belowError = elevationError(state, params, below, elevation);
+		const aboveError = elevationError(state, params, above, elevation);
+		if (belowError < bestError && belowError <= aboveError) {
+			best = below;
+			bestError = belowError;
+		} else if (aboveError < bestError) {
+			best = above;
+			bestError = aboveError;
+		}
+	}
+	return best;
+}
+function centerBehindTarget(state, params, target) {
+	if (!target.hasRotation) return;
+	referenceOrientation(scratchOrientation, state.tracker, params.bindingMode, target);
+	vec3.transformQuat(scratchDirection, forwardAxis, target.rotation);
+	vec3.transformQuat(scratchDirection, scratchDirection, quat.conjugate(scratchInverse, scratchOrientation));
+	const x = scratchDirection[0];
+	const z = scratchDirection[2];
+	if (x * x + z * z < 1e-12) return;
+	state.horizontal.center = radiansToDegrees(Math.atan2(x, -z));
+}
+var isActive = (axis) => axis.held || axis.hadDelta;
+function shareInput(axis, other, otherActive) {
+	if (otherActive && other.recentering.time === axis.recentering.time) axis.hadDelta = true;
+}
+/** Input on one axis restarts the recentering wait of every axis with the same `recentering.time`. */
+function syncRecentering({ horizontal, vertical, radial }) {
+	const h = isActive(horizontal);
+	const v = isActive(vertical);
+	const r = isActive(radial);
+	shareInput(horizontal, vertical, v);
+	shareInput(horizontal, radial, r);
+	shareInput(vertical, horizontal, h);
+	shareInput(vertical, radial, r);
+	shareInput(radial, horizontal, h);
+	shareInput(radial, vertical, v);
+}
+/**
+* Advances the axes and places `out` on the orbit around the target. A `null` target leaves `out` as is.
+* Returns `true` while an axis still has to move.
+*/
+function update(out, state, params, target, dt, justActivated) {
+	quat.identity(out.rotationDampingBypass);
+	if (justActivated) {
+		reset$1(state.tracker);
+		reset(state.radius);
+		state.horizontal.idleTime = 0;
+		state.vertical.idleTime = 0;
+		state.radial.idleTime = 0;
+	}
+	if (target && recentersBehindTarget(state, params)) centerBehindTarget(state, params, target);
+	syncRecentering(state);
+	const horizontalMoving = state.horizontal.update(dt);
+	const verticalMoving = state.vertical.update(dt);
+	const radialMoving = state.radial.update(dt);
+	const radius = damp(state.radius, params.radius, state.radial.damping, dt).value;
+	const moving = horizontalMoving || verticalMoving || radialMoving || radius !== params.radius;
+	if (!target) return moving;
+	if (state.primed) {
+		state.primed = false;
+		primeAxes(state, params, target, state.primePosition);
+	}
+	orbitOffset(scratchOffset, state, params, state.horizontal.value, state.vertical.value);
+	const hadPrevious = state.tracker.hasPrevious;
+	vec3.copy(scratchPreviousOffset, state.tracker.previousOffset);
+	trackTarget(out.target, state.orientation, state.tracker, params, target, scratchOffset, params.targetOffset, dt);
+	vec3.add(out.position, out.target, vec3.transformQuat(scratchOffset, scratchOffset, state.orientation));
+	out.hasTarget = true;
+	vec3.transformQuat(out.referenceUp, worldUp, state.orientation);
+	if (hadPrevious) {
+		vec3.transformQuat(scratchPreviousOffset, scratchPreviousOffset, state.orientation);
+		safeFromToRotation(out.rotationDampingBypass, scratchPreviousOffset, scratchOffset, out.referenceUp);
+	}
+	return moving;
+}
+//#endregion
+export { createAxisSettings, createParams, createState, needsTargetRotation, orbitFollow_exports, point, prime, setFromPosition, setFromRotation, update };