@pmndrs/klipp 0.0.0-stage → 0.14.0

package/dist/core/blend/BlendDefinition.d.ts

@@ -0,0 +1,21 @@
+import { type Ease } from './BlendCurves.js';
+/** A fixed-duration curve or a damped transition. */
+export type BlendDefinition = {
+    curve: Ease;
+    time: number;
+    damping?: never;
+    maxSpeed?: never;
+} | {
+    damping: number;
+    maxSpeed?: number;
+    curve?: never;
+    time?: never;
+};
+/** A blend override for an optional source and destination camera. */
+export type CustomBlend = {
+    from?: string;
+    to?: string;
+    blend: BlendDefinition;
+};
+/** Used when no blend is given. */
+export declare const DEFAULT_BLEND: BlendDefinition;

package/dist/core/blend/BlendDefinition.js

@@ -0,0 +1,9 @@
+import { BlendCurves } from "./BlendCurves.js";
+//#region src/core/blend/BlendDefinition.ts
+/** Used when no blend is given. */
+var DEFAULT_BLEND = {
+	curve: BlendCurves.easeInOut,
+	time: 2
+};
+//#endregion
+export { DEFAULT_BLEND };

package/dist/core/blend/BlendDriver.d.ts

@@ -0,0 +1,23 @@
+import type { CameraState } from '../CameraState.js';
+import * as blend from './blend.js';
+import type { BlendDefinition } from './BlendDefinition.js';
+import { BlendHints } from './BlendHints.js';
+/** Stateful wrapper over the blend functions, resolving camera states by id. */
+export declare class BlendDriver<Id> {
+    readonly state: blend.BlendState<Id>;
+    private readonly getState;
+    constructor(getState: (id: Id) => CameraState);
+    /** Candidate whose state is currently settled in the output. */
+    get liveId(): Id | null;
+    get isBlending(): boolean;
+    /** Whether the driver has produced a real output at least once. */
+    get hasEverActivated(): boolean;
+    /** Destination of the active blend, or `liveId` when settled. */
+    get blendTargetId(): Id | null;
+    /** Set the transition destination. Retargeting starts from the current output. */
+    setTarget(toId: Id, definition: BlendDefinition, hints?: BlendHints): void;
+    /** Remove a candidate without discarding the current output. */
+    forget(id: Id): void;
+    /** Advance the blend and return the reusable output state. */
+    tick(dt: number): CameraState;
+}

package/dist/core/blend/BlendDriver.js

@@ -0,0 +1,42 @@
+import { BlendHints } from "./BlendHints.js";
+import { create, forget, setTarget, targetId, tick } from "./blend.js";
+//#region src/core/blend/BlendDriver.ts
+/** Stateful wrapper over the blend functions, resolving camera states by id. */
+var BlendDriver = class {
+	state = create();
+	getState;
+	constructor(getState) {
+		this.getState = getState;
+	}
+	/** Candidate whose state is currently settled in the output. */
+	get liveId() {
+		return this.state.liveId;
+	}
+	get isBlending() {
+		return this.state.transition.active;
+	}
+	/** Whether the driver has produced a real output at least once. */
+	get hasEverActivated() {
+		return this.state.hasEverActivated;
+	}
+	/** Destination of the active blend, or `liveId` when settled. */
+	get blendTargetId() {
+		return targetId(this.state);
+	}
+	/** Set the transition destination. Retargeting starts from the current output. */
+	setTarget(toId, definition, hints = BlendHints.none) {
+		if (toId === targetId(this.state)) return;
+		setTarget(this.state, toId, this.getState(toId), definition, hints);
+	}
+	/** Remove a candidate without discarding the current output. */
+	forget(id) {
+		forget(this.state, id);
+	}
+	/** Advance the blend and return the reusable output state. */
+	tick(dt) {
+		const targetId$1 = targetId(this.state);
+		return tick(this.state, dt, targetId$1 !== null ? this.getState(targetId$1) : null);
+	}
+};
+//#endregion
+export { BlendDriver };

package/dist/core/blend/BlendHints.d.ts

@@ -0,0 +1,9 @@
+/** Bitmask controlling how a camera transition is blended. */
+export declare const BlendHints: {
+    readonly none: 0;
+    readonly cylindricalPosition: number;
+    readonly sphericalPosition: number;
+    readonly ignoreTarget: number;
+};
+export type BlendHints = number;
+export declare function hasBlendHint(hints: BlendHints, flag: number): boolean;

package/dist/core/blend/BlendHints.js

@@ -0,0 +1,13 @@
+//#region src/core/blend/BlendHints.ts
+/** Bitmask controlling how a camera transition is blended. */
+var BlendHints = {
+	none: 0,
+	cylindricalPosition: 1,
+	sphericalPosition: 2,
+	ignoreTarget: 8
+};
+function hasBlendHint(hints, flag) {
+	return (hints & flag) !== 0;
+}
+//#endregion
+export { BlendHints, hasBlendHint };

package/dist/core/blend/blend.d.ts

@@ -0,0 +1,41 @@
+import type { CameraState } from '../CameraState.js';
+import type { DamperState } from '../damping/damping.js';
+import type { BlendDefinition, CustomBlend } from './BlendDefinition.js';
+import { BlendHints } from './BlendHints.js';
+/** A transition in flight from a frozen `from` state toward the live `toId` camera. */
+export type BlendTransition<Id> = {
+    active: boolean;
+    from: CameraState;
+    toId: Id | null;
+    definition: BlendDefinition | null;
+    elapsed: number;
+    progress: number;
+    damper: DamperState;
+    hints: BlendHints;
+};
+export type BlendState<Id> = {
+    /** Camera currently settled in the output. */
+    liveId: Id | null;
+    /** Whether a real output has been produced at least once. */
+    hasEverActivated: boolean;
+    transition: BlendTransition<Id>;
+    /** Reusable output, returned by `tick`. */
+    output: CameraState;
+};
+export declare const create: <Id>() => BlendState<Id>;
+/** Destination of the active transition, or `liveId` when settled. */
+export declare const targetId: <Id>(state: BlendState<Id>) => Id | null;
+/**
+ * Start a transition to `toId`, from the current output. The very first target is taken over at once
+ * from `toState`, since there is nothing to blend from yet.
+ */
+export declare function setTarget<Id>(state: BlendState<Id>, toId: Id, toState: CameraState, definition: BlendDefinition, hints?: BlendHints): void;
+/** Drop a camera that went away, keeping the current output. */
+export declare function forget<Id>(state: BlendState<Id>, id: Id): void;
+/**
+ * Advance the transition and composite the output. `targetState` is the state of `targetId(state)`,
+ * or `null` when there is none.
+ */
+export declare function tick<Id>(state: BlendState<Id>, dt: number, targetState: CameraState | null): CameraState;
+/** Resolves the most specific custom blend for a transition. */
+export declare function resolveDefinition(customBlends: CustomBlend[], from: string | null, to: string, defaultBlend: BlendDefinition): BlendDefinition;

package/dist/core/blend/blend.js

@@ -0,0 +1,110 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { BlendHints } from "./BlendHints.js";
+import { lerp as lerp$1 } from "./lerpCameraState.js";
+import { copy, create as create$1 } from "../CameraState.js";
+import { createState, damp, reset } from "../damping/damping.js";
+import { clamp } from "math";
+//#region src/core/blend/blend.ts
+var blend_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	forget: () => forget,
+	resolveDefinition: () => resolveDefinition,
+	setTarget: () => setTarget,
+	targetId: () => targetId,
+	tick: () => tick
+});
+var create = () => ({
+	liveId: null,
+	hasEverActivated: false,
+	transition: {
+		active: false,
+		from: create$1(),
+		toId: null,
+		definition: null,
+		elapsed: 0,
+		progress: 0,
+		damper: createState(),
+		hints: BlendHints.none
+	},
+	output: create$1()
+});
+/** Destination of the active transition, or `liveId` when settled. */
+var targetId = (state) => state.transition.active ? state.transition.toId : state.liveId;
+/**
+* Start a transition to `toId`, from the current output. The very first target is taken over at once
+* from `toState`, since there is nothing to blend from yet.
+*/
+function setTarget(state, toId, toState, definition, hints = BlendHints.none) {
+	if (toId === targetId(state)) return;
+	if (!state.hasEverActivated) {
+		state.hasEverActivated = true;
+		state.liveId = toId;
+		copy(state.output, toState);
+		return;
+	}
+	const transition = state.transition;
+	copy(transition.from, state.output);
+	transition.active = true;
+	transition.toId = toId;
+	transition.definition = definition;
+	transition.elapsed = 0;
+	transition.progress = 0;
+	transition.hints = hints;
+	if (definition.damping !== void 0) {
+		reset(transition.damper);
+		damp(transition.damper, 0, definition.damping, 0);
+	}
+}
+/** Drop a camera that went away, keeping the current output. */
+function forget(state, id) {
+	const transition = state.transition;
+	if (transition.active && transition.toId === id) {
+		transition.active = false;
+		transition.toId = null;
+		state.liveId = null;
+	} else if (state.liveId === id) state.liveId = null;
+}
+/**
+* Advance the transition and composite the output. `targetState` is the state of `targetId(state)`,
+* or `null` when there is none.
+*/
+function tick(state, dt, targetState) {
+	const transition = state.transition;
+	if (transition.active && targetState) {
+		const definition = transition.definition;
+		let t;
+		if (definition.damping !== void 0) {
+			transition.damper.value = transition.progress;
+			transition.progress = damp(transition.damper, 1, definition.damping, dt, definition.maxSpeed).value;
+			t = transition.progress;
+		} else {
+			transition.elapsed += dt;
+			const rawT = definition.time <= 0 ? 1 : clamp(transition.elapsed / definition.time, 0, 1);
+			t = definition.curve(rawT);
+		}
+		lerp$1(state.output, transition.from, targetState, t, transition.hints);
+		if (t >= 1) {
+			state.liveId = transition.toId;
+			transition.active = false;
+			transition.toId = null;
+		}
+	} else if (state.liveId !== null && targetState) copy(state.output, targetState);
+	return state.output;
+}
+/** Resolves the most specific custom blend for a transition. */
+function resolveDefinition(customBlends, from, to, defaultBlend) {
+	let best = null;
+	let bestSpecificity = -1;
+	for (const entry of customBlends) {
+		if (entry.to !== void 0 && entry.to !== to) continue;
+		if (entry.from !== void 0 && entry.from !== from) continue;
+		const specificity = (entry.to !== void 0 ? 2 : 0) + (entry.from !== void 0 ? 1 : 0);
+		if (specificity > bestSpecificity) {
+			best = entry;
+			bestSpecificity = specificity;
+		}
+	}
+	return best ? best.blend : defaultBlend;
+}
+//#endregion
+export { blend_exports, create, forget, resolveDefinition, setTarget, targetId, tick };

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

@@ -0,0 +1,6 @@
+export { BlendDriver } from './BlendDriver.js';
+export * as blend from './blend.js';
+export type { BlendState, BlendTransition } from './blend.js';
+export { DEFAULT_BLEND, type BlendDefinition, type CustomBlend } from './BlendDefinition.js';
+export { BlendHints, hasBlendHint } from './BlendHints.js';
+export { BlendCurves, type Ease } from './BlendCurves.js';

package/dist/core/blend/lerpCameraState.d.ts

@@ -0,0 +1,4 @@
+import type { CameraState } from '../CameraState.js';
+import { BlendHints } from './BlendHints.js';
+/** Interpolates a camera state while preserving blend hints and rotation continuity. */
+export declare function lerp(out: CameraState, a: CameraState, b: CameraState, t: number, hints?: BlendHints): CameraState;

package/dist/core/blend/lerpCameraState.js

@@ -0,0 +1,143 @@
+import { BlendHints, hasBlendHint } from "./BlendHints.js";
+import { clamp, deltaAngle, lerp, mat4, quat, spherical, vec3, vec4 } from "math";
+//#region src/core/blend/lerpCameraState.ts
+/** Reused quaternion for the sign-adjusted destination case. */
+var negatedB = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchOffsetA = [
+	0,
+	0,
+	0
+];
+var scratchOffsetB = [
+	0,
+	0,
+	0
+];
+var scratchSphericalA = [
+	0,
+	0,
+	0
+];
+var scratchSphericalB = [
+	0,
+	0,
+	0
+];
+var scratchSphericalOut = [
+	0,
+	0,
+	0
+];
+var scratchLookMatrix = mat4.create();
+var scratchLookAtCurrent = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchDeltaA = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchDeltaB = [
+	0,
+	0,
+	0,
+	1
+];
+/** Interpolates look-at rotation while preserving each state's additional aim offset. */
+function lerpLookAtRotation(out, a, b, t, current) {
+	quat.multiply(scratchDeltaA, quat.conjugate(scratchDeltaA, lookAtRotation(scratchDeltaA, a)), a.quaternion);
+	quat.multiply(scratchDeltaB, quat.conjugate(scratchDeltaB, lookAtRotation(scratchDeltaB, b)), b.quaternion);
+	lookAtRotation(scratchLookAtCurrent, current);
+	quat.multiply(out, scratchLookAtCurrent, quat.slerp(out, scratchDeltaA, scratchDeltaB, t));
+}
+/** The rotation looking from `state.position` at `state.lookAtTarget`. */
+function lookAtRotation(out, state) {
+	mat4.targetTo(scratchLookMatrix, state.position, state.lookAtTarget, state.referenceUp);
+	return quat.fromMat4(out, scratchLookMatrix);
+}
+/** Below this radius, angular values are not meaningful. */
+var RADIUS_EPSILON = 1e-4;
+/** Keeps the valid side's angle when the other radius is too small. */
+function blendAngle(angleA, radiusA, angleB, radiusB, t) {
+	const validA = radiusA >= RADIUS_EPSILON;
+	if (validA && radiusB >= RADIUS_EPSILON) return angleA + deltaAngle(angleA, angleB) * t;
+	return validA ? angleA : angleB;
+}
+/** Interpolates the camera offset in spherical or cylindrical coordinates. */
+function lerpPositionAroundTarget(out, a, b, t, cylindrical) {
+	vec3.subtract(scratchOffsetA, a.position, a.target);
+	vec3.subtract(scratchOffsetB, b.position, b.target);
+	if (cylindrical) {
+		const radiusA = Math.hypot(scratchOffsetA[0], scratchOffsetA[2]);
+		const radiusB = Math.hypot(scratchOffsetB[0], scratchOffsetB[2]);
+		const angle = blendAngle(Math.atan2(scratchOffsetA[0], scratchOffsetA[2]), radiusA, Math.atan2(scratchOffsetB[0], scratchOffsetB[2]), radiusB, t);
+		const radius = lerp(radiusA, radiusB, t);
+		vec3.set(out, radius * Math.sin(angle), lerp(scratchOffsetA[1], scratchOffsetB[1], t), radius * Math.cos(angle));
+	} else {
+		spherical.setFromVec3(scratchSphericalA, scratchOffsetA);
+		spherical.setFromVec3(scratchSphericalB, scratchOffsetB);
+		const theta = blendAngle(scratchSphericalA[1], scratchSphericalA[0], scratchSphericalB[1], scratchSphericalB[0], t);
+		const phi = blendAngle(scratchSphericalA[2], scratchSphericalA[0], scratchSphericalB[2], scratchSphericalB[0], t);
+		spherical.toVec3(out, spherical.set(scratchSphericalOut, lerp(scratchSphericalA[0], scratchSphericalB[0], t), theta, phi));
+	}
+	out[0] += lerp(a.target[0], b.target[0], t);
+	out[1] += lerp(a.target[1], b.target[1], t);
+	out[2] += lerp(a.target[2], b.target[2], t);
+}
+/** Slerps quaternions without changing the caller-selected sign of `to`. */
+function slerpWithContinuity(out, from, to, t) {
+	const toX = to[0], toY = to[1], toZ = to[2], toW = to[3];
+	const dot = clamp(from[0] * toX + from[1] * toY + from[2] * toZ + from[3] * toW, -1, 1);
+	const fromX = from[0], fromY = from[1], fromZ = from[2], fromW = from[3];
+	if (Math.abs(dot) < .9995) {
+		const theta = Math.acos(dot);
+		const sin = Math.sin(theta);
+		const s = Math.sin((1 - t) * theta) / sin;
+		const u = Math.sin(t * theta) / sin;
+		vec4.set(out, fromX * s + toX * u, fromY * s + toY * u, fromZ * s + toZ * u, fromW * s + toW * u);
+	} else {
+		const s = 1 - t;
+		vec4.set(out, fromX * s + toX * t, fromY * s + toY * t, fromZ * s + toZ * t, fromW * s + toW * t);
+		if (vec4.squaredLength(out) === 0) quat.identity(out);
+		else quat.normalize(out, out);
+	}
+}
+/** Interpolates a camera state while preserving blend hints and rotation continuity. */
+function lerp$1(out, a, b, t, hints = BlendHints.none) {
+	const clamped = clamp(t, 0, 1);
+	const hasTarget = a.hasTarget && b.hasTarget;
+	const hasLookAtTarget = a.hasLookAtTarget && b.hasLookAtTarget;
+	const spherical = hasTarget && hasBlendHint(hints, BlendHints.sphericalPosition);
+	const cylindrical = hasTarget && !spherical && hasBlendHint(hints, BlendHints.cylindricalPosition);
+	const useLookAtRotation = hasLookAtTarget && !hasBlendHint(hints, BlendHints.ignoreTarget);
+	if (spherical || cylindrical) lerpPositionAroundTarget(out.position, a, b, clamped, cylindrical);
+	else vec3.lerp(out.position, a.position, b.position, clamped);
+	if (hasTarget) vec3.lerp(out.target, a.target, b.target, clamped);
+	out.hasTarget = hasTarget;
+	if (hasLookAtTarget) vec3.lerp(out.lookAtTarget, a.lookAtTarget, b.lookAtTarget, clamped);
+	out.hasLookAtTarget = hasLookAtTarget;
+	vec3.normalize(out.referenceUp, vec3.lerp(out.referenceUp, a.referenceUp, b.referenceUp, clamped));
+	quat.identity(out.rotationDampingBypass);
+	if (useLookAtRotation) lerpLookAtRotation(out.quaternion, a, b, clamped, out);
+	else {
+		const bQuaternion = vec4.dot(out.quaternion, b.quaternion) < 0 ? vec4.set(negatedB, -b.quaternion[0], -b.quaternion[1], -b.quaternion[2], -b.quaternion[3]) : b.quaternion;
+		slerpWithContinuity(out.quaternion, a.quaternion, bQuaternion, clamped);
+	}
+	out.fov = lerp(a.fov, b.fov, clamped);
+	out.near = lerp(a.near, b.near, clamped);
+	out.far = lerp(a.far, b.far, clamped);
+	out.viewOffset[0] = lerp(a.viewOffset[0], b.viewOffset[0], clamped);
+	out.viewOffset[1] = lerp(a.viewOffset[1], b.viewOffset[1], clamped);
+	return out;
+}
+//#endregion
+export { lerp$1 as lerp };

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

@@ -0,0 +1,9 @@
+/** Which rotation (if any) a Body applies to its offset before adding it to the target's world position. */
+export declare const BindingModes: {
+    readonly worldSpace: 'worldSpace';
+    readonly lockToTarget: 'lockToTarget';
+    readonly lockToTargetWithWorldUp: 'lockToTargetWithWorldUp';
+    readonly lockToTargetNoRoll: 'lockToTargetNoRoll';
+    readonly lockToTargetOnAssign: 'lockToTargetOnAssign';
+};
+export type BindingMode = (typeof BindingModes)[keyof typeof BindingModes];

package/dist/core/body/BindingModes.js

@@ -0,0 +1,11 @@
+//#region src/core/body/BindingModes.ts
+/** Which rotation (if any) a Body applies to its offset before adding it to the target's world position. */
+var BindingModes = {
+	worldSpace: "worldSpace",
+	lockToTarget: "lockToTarget",
+	lockToTargetWithWorldUp: "lockToTargetWithWorldUp",
+	lockToTargetNoRoll: "lockToTargetNoRoll",
+	lockToTargetOnAssign: "lockToTargetOnAssign"
+};
+//#endregion
+export { BindingModes };

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

@@ -0,0 +1,24 @@
+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 follow from './follow.js';
+import type { BindingMode } from './BindingModes.js';
+import type { FollowParams } from './follow.js';
+export type FollowOptions = Partial<FollowParams>;
+/** Follows a target with an offset rotated according to `bindingMode`. Layers override `readTarget`. */
+export declare class FollowBody<T = TargetPose | null> implements FollowParams {
+    target: T;
+    offset: Vec3;
+    damping: DampingConstant;
+    rotationDamping: DampingConstant;
+    bindingMode: BindingMode;
+    maxSpeed: number;
+    readonly state: follow.FollowState;
+    private lastTarget;
+    constructor(target: T, options?: FollowOptions);
+    update: (out: CameraState, dt: number, justActivated: boolean) => void;
+    primeFrom: (position: Vec3) => void;
+    /** This frame's target pose, or `null` when there is none. */
+    protected readTarget(): TargetPose | null;
+}

package/dist/core/body/FollowBody.js

@@ -0,0 +1,26 @@
+import { createParams, createState, prime, update } from "./follow.js";
+//#region src/core/body/FollowBody.ts
+/** Follows a target with an offset rotated according to `bindingMode`. Layers override `readTarget`. */
+var FollowBody = class {
+	target;
+	state = createState();
+	lastTarget = void 0;
+	constructor(target, options) {
+		this.target = target;
+		Object.assign(this, createParams(options));
+	}
+	update = (out, dt, justActivated) => {
+		if (justActivated || this.target !== this.lastTarget) {
+			this.lastTarget = this.target;
+			this.state.tracker.assigned = false;
+		}
+		update(out, this.state, this, this.readTarget(), dt, justActivated);
+	};
+	primeFrom = (position) => prime(this.state, position);
+	/** This frame's target pose, or `null` when there is none. */
+	readTarget() {
+		return this.target;
+	}
+};
+//#endregion
+export { FollowBody };

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

@@ -0,0 +1,17 @@
+import type { CameraState } from '../CameraState.js';
+import type { TargetPose } from '../TargetPose.js';
+import type { DampingConstant } from '../damping/damping.js';
+import * as hardLockToTarget from './hardLockToTarget.js';
+import type { HardLockToTargetParams } from './hardLockToTarget.js';
+export type HardLockToTargetOptions = Partial<HardLockToTargetParams>;
+/** Locks the camera position to a target. Layers override `readTarget` to read their own targets. */
+export declare class HardLockToTargetBody<T = TargetPose | null> implements HardLockToTargetParams {
+    target: T;
+    damping: DampingConstant;
+    maxSpeed: number;
+    readonly state: hardLockToTarget.HardLockToTargetState;
+    constructor(target: T, options?: HardLockToTargetOptions);
+    update: (out: CameraState, dt: number, justActivated: boolean) => void;
+    /** This frame's target pose, or `null` when there is none. */
+    protected readTarget(): TargetPose | null;
+}

package/dist/core/body/HardLockToTargetBody.js

@@ -0,0 +1,20 @@
+import { createParams, createState, update } from "./hardLockToTarget.js";
+//#region src/core/body/HardLockToTargetBody.ts
+/** Locks the camera position to a target. Layers override `readTarget` to read their own targets. */
+var HardLockToTargetBody = class {
+	target;
+	state = createState();
+	constructor(target, options) {
+		this.target = target;
+		Object.assign(this, createParams(options));
+	}
+	update = (out, dt, justActivated) => {
+		update(out, this.state, this, this.readTarget()?.position ?? null, dt, justActivated);
+	};
+	/** This frame's target pose, or `null` when there is none. */
+	readTarget() {
+		return this.target;
+	}
+};
+//#endregion
+export { HardLockToTargetBody };

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

@@ -0,0 +1,47 @@
+import type { Quat, Vec3 } from 'math';
+import type { CameraState } from '../CameraState.js';
+import type { TargetPose } from '../TargetPose.js';
+import type { DampingConstant } from '../damping/damping.js';
+import type { InputAxisOwner } from '../input/InputAxisOwner.js';
+import * as orbitFollow from './orbitFollow.js';
+import type { BindingMode } from './BindingModes.js';
+import type { OrbitFollowParams, OrbitStyle, RecenteringTarget } from './orbitFollow.js';
+import type { Orbits } from './threeRing.js';
+export type OrbitFollowOptions = Partial<OrbitFollowParams>;
+/**
+ * Orbits a target on a sphere or through three rings, driven by three `InputAxis`: `horizontal`, `vertical` and `radial`.
+ * Layers override `readTarget`.
+ */
+export declare class OrbitFollowBody<T = TargetPose | null> implements OrbitFollowParams, InputAxisOwner {
+    target: T;
+    orbitStyle: OrbitStyle;
+    radius: number;
+    orbits: Orbits;
+    splineCurvature: number;
+    targetOffset: Vec3;
+    bindingMode: BindingMode;
+    damping: DampingConstant;
+    rotationDamping: DampingConstant;
+    maxSpeed: number;
+    recenteringTarget: RecenteringTarget;
+    readonly state: orbitFollow.OrbitFollowState;
+    readonly horizontal: import("../index.js").InputAxis;
+    readonly vertical: import("../index.js").InputAxis;
+    readonly radial: import("../index.js").InputAxis;
+    readonly inputAxes: {
+        horizontal: import("../index.js").InputAxis;
+        vertical: import("../index.js").InputAxis;
+        radial: import("../index.js").InputAxis;
+    };
+    private lastTarget;
+    constructor(target: T, options?: OrbitFollowOptions);
+    update: (out: CameraState, dt: number, justActivated: boolean) => boolean;
+    /** Start from `position`'s direction around the target, keeping the zoom. */
+    primeFrom: (position: Vec3) => void;
+    /** Eases the camera toward `position`'s direction around the target, keeping the zoom. */
+    setFromPosition: (position: Vec3) => void;
+    /** Eases the camera around the target until it looks along `rotation`'s forward, keeping the zoom. */
+    setFromRotation: (rotation: Quat) => void;
+    /** This frame's target pose, or `null` when there is none. */
+    protected readTarget(): TargetPose | null;
+}

package/dist/core/body/OrbitFollowBody.js

@@ -0,0 +1,48 @@
+import { createParams, createState, prime, setFromPosition, setFromRotation, update } from "./orbitFollow.js";
+//#region src/core/body/OrbitFollowBody.ts
+/**
+* Orbits a target on a sphere or through three rings, driven by three `InputAxis`: `horizontal`, `vertical` and `radial`.
+* Layers override `readTarget`.
+*/
+var OrbitFollowBody = class {
+	target;
+	state = createState();
+	horizontal = this.state.horizontal;
+	vertical = this.state.vertical;
+	radial = this.state.radial;
+	inputAxes = {
+		horizontal: this.horizontal,
+		vertical: this.vertical,
+		radial: this.radial
+	};
+	lastTarget = void 0;
+	constructor(target, options) {
+		this.target = target;
+		Object.assign(this, createParams(options));
+	}
+	update = (out, dt, justActivated) => {
+		if (justActivated || this.target !== this.lastTarget) {
+			this.lastTarget = this.target;
+			this.state.tracker.assigned = false;
+		}
+		return update(out, this.state, this, this.readTarget(), dt, justActivated);
+	};
+	/** Start from `position`'s direction around the target, keeping the zoom. */
+	primeFrom = (position) => prime(this.state, position);
+	/** Eases the camera toward `position`'s direction around the target, keeping the zoom. */
+	setFromPosition = (position) => {
+		const pose = this.readTarget();
+		if (pose) setFromPosition(this.state, this, pose, position);
+	};
+	/** Eases the camera around the target until it looks along `rotation`'s forward, keeping the zoom. */
+	setFromRotation = (rotation) => {
+		const pose = this.readTarget();
+		if (pose) setFromRotation(this.state, this, pose, rotation);
+	};
+	/** This frame's target pose, or `null` when there is none. */
+	readTarget() {
+		return this.target;
+	}
+};
+//#endregion
+export { OrbitFollowBody };