@pmndrs/klipp 0.0.0-stage → 0.14.0

package/dist/core/aim/hardLookAt.d.ts

@@ -0,0 +1,4 @@
+import { type Vec3 } from 'math';
+import type { CameraState } from '../CameraState.js';
+/** Rotates `out` so `targetPosition` is dead-center. */
+export declare function update(out: CameraState, targetPosition: Vec3): void;

package/dist/core/aim/hardLookAt.js

@@ -0,0 +1,13 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { lookRotation } from "./lookRotation.js";
+import { vec3 } from "math";
+//#region src/core/aim/hardLookAt.ts
+var hardLookAt_exports = /* @__PURE__ */ __exportAll({ update: () => update });
+/** Rotates `out` so `targetPosition` is dead-center. */
+function update(out, targetPosition) {
+	lookRotation(out.quaternion, out.position, targetPosition, out.referenceUp, out.quaternion);
+	vec3.copy(out.lookAtTarget, targetPosition);
+	out.hasLookAtTarget = true;
+}
+//#endregion
+export { hardLookAt_exports, update };

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

@@ -0,0 +1,11 @@
+export * as hardLookAt from './hardLookAt.js';
+export { HardLookAtAim } from './HardLookAtAim.js';
+export * as rotateWithFollowTarget from './rotateWithFollowTarget.js';
+export type { RotateWithFollowTargetParams, RotateWithFollowTargetState } from './rotateWithFollowTarget.js';
+export { RotateWithFollowTargetAim, type RotateWithFollowTargetOptions } from './RotateWithFollowTargetAim.js';
+export * as rotationComposer from './rotationComposer.js';
+export type { RotationComposerParams, RotationComposerState } from './rotationComposer.js';
+export { RotationComposerAim } from './RotationComposerAim.js';
+export * as panTilt from './panTilt.js';
+export type { PanTiltState } from './panTilt.js';
+export { PanTiltAim } from './PanTiltAim.js';

package/dist/core/aim/lookRotation.d.ts

@@ -0,0 +1,6 @@
+import { type Quat, type Vec3 } from 'math';
+/**
+ * The rotation looking from `position` at `target` with `up` on top. Looking along `up`, the screen's top comes
+ * from `previous`, so passing over the pole keeps the view steady.
+ */
+export declare function lookRotation(out: Quat, position: Vec3, target: Vec3, up: Vec3, previous: Quat): Quat;

package/dist/core/aim/lookRotation.js

@@ -0,0 +1,46 @@
+import { mat4, quat, vec3 } from "math";
+//#region src/core/aim/lookRotation.ts
+var yAxis = [
+	0,
+	1,
+	0
+];
+var forwardAxis = [
+	0,
+	0,
+	-1
+];
+var scratchDirection = [
+	0,
+	0,
+	0
+];
+var scratchCross = [
+	0,
+	0,
+	0
+];
+var scratchUp = [
+	0,
+	0,
+	0
+];
+var scratchLookMatrix = mat4.create();
+var isParallel = (direction, up) => vec3.squaredLength(vec3.cross(scratchCross, direction, up)) < 1e-12 * vec3.squaredLength(direction);
+/**
+* The rotation looking from `position` at `target` with `up` on top. Looking along `up`, the screen's top comes
+* from `previous`, so passing over the pole keeps the view steady.
+*/
+function lookRotation(out, position, target, up, previous) {
+	vec3.subtract(scratchDirection, target, position);
+	let screenUp = up;
+	if (isParallel(scratchDirection, up)) {
+		vec3.transformQuat(scratchUp, yAxis, previous);
+		if (isParallel(scratchDirection, scratchUp)) vec3.transformQuat(scratchUp, forwardAxis, previous);
+		screenUp = scratchUp;
+	}
+	mat4.targetTo(scratchLookMatrix, position, target, screenUp);
+	return quat.fromMat4(out, scratchLookMatrix);
+}
+//#endregion
+export { lookRotation };

package/dist/core/aim/panTilt.d.ts

@@ -0,0 +1,16 @@
+import { type Quat, type Vec3 } from 'math';
+import type { CameraState } from '../CameraState.js';
+import { InputAxis } from '../input/InputAxis.js';
+/** `pan` (yaw, wraps ±180°) and `tilt` (pitch, clamped) in degrees. */
+export type PanTiltState = {
+    pan: InputAxis;
+    tilt: InputAxis;
+};
+export declare const createState: () => PanTiltState;
+/** Advances both axes and writes the resulting rotation to `out`. Returns `true` while an axis still has to move. */
+export declare function update(out: CameraState, state: PanTiltState, targetRotation: Quat | null, dt: number): boolean;
+/**
+ * Seeds `pan`/`tilt` from `rotation`'s forward direction, relative to the reference frame. Call before
+ * any `applyDelta`, since it assumes both axes are still at their raw value.
+ */
+export declare function seed(state: PanTiltState, targetRotation: Quat | null, rotation: Quat, referenceUp: Vec3): void;

package/dist/core/aim/panTilt.js

@@ -0,0 +1,121 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { InputAxis } from "../input/InputAxis.js";
+import { degreesToRadians, quat, radiansToDegrees, vec3 } from "math";
+//#region src/core/aim/panTilt.ts
+var panTilt_exports = /* @__PURE__ */ __exportAll({
+	createState: () => createState,
+	seed: () => seed,
+	update: () => update
+});
+var createState = () => ({
+	pan: new InputAxis({
+		range: [-180, 180],
+		wrap: true
+	}),
+	tilt: new InputAxis({ range: [-90, 90] })
+});
+var worldUp = [
+	0,
+	1,
+	0
+];
+var forwardAxis = [
+	0,
+	0,
+	-1
+];
+var epsilon = 1e-6;
+var scratchFrame = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchRotation = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchAxisRotation = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchEuler = [
+	0,
+	0,
+	0,
+	"yxz"
+];
+var scratchForward = [
+	0,
+	0,
+	0
+];
+var scratchTargetForward = [
+	0,
+	0,
+	0
+];
+var scratchA = [
+	0,
+	0,
+	0
+];
+var scratchB = [
+	0,
+	0,
+	0
+];
+var scratchRight = [
+	0,
+	0,
+	0
+];
+/** The frame pan and tilt are measured in: the target's rotation, or `referenceUp` alone. */
+function referenceFrame(out, targetRotation, referenceUp) {
+	return targetRotation ? quat.copy(out, targetRotation) : quat.rotationTo(out, worldUp, referenceUp);
+}
+function projectOnPlane(out, v, normal) {
+	const lengthSq = vec3.squaredLength(normal);
+	if (lengthSq === 0) return vec3.copy(out, v);
+	return vec3.scaleAndAdd(out, v, normal, -vec3.dot(normal, v) / lengthSq);
+}
+/** Advances both axes and writes the resulting rotation to `out`. Returns `true` while an axis still has to move. */
+function update(out, state, targetRotation, dt) {
+	const panMoving = state.pan.update(dt);
+	const tiltMoving = state.tilt.update(dt);
+	referenceFrame(scratchFrame, targetRotation, out.referenceUp);
+	scratchEuler[0] = -degreesToRadians(state.tilt.value);
+	scratchEuler[1] = -degreesToRadians(state.pan.value);
+	quat.multiply(out.quaternion, scratchFrame, quat.fromEuler(scratchRotation, scratchEuler));
+	return panMoving || tiltMoving;
+}
+/**
+* Seeds `pan`/`tilt` from `rotation`'s forward direction, relative to the reference frame. Call before
+* any `applyDelta`, since it assumes both axes are still at their raw value.
+*/
+function seed(state, targetRotation, rotation, referenceUp) {
+	referenceFrame(scratchFrame, targetRotation, referenceUp);
+	vec3.transformQuat(scratchForward, forwardAxis, scratchFrame);
+	vec3.transformQuat(scratchTargetForward, forwardAxis, rotation);
+	projectOnPlane(scratchA, scratchForward, referenceUp);
+	projectOnPlane(scratchB, scratchTargetForward, referenceUp);
+	let panRawDeg = 0;
+	if (vec3.squaredLength(scratchA) > epsilon && vec3.squaredLength(scratchB) > epsilon) panRawDeg = radiansToDegrees(vec3.signedAngle(scratchA, scratchB, referenceUp));
+	quat.setAxisAngle(scratchAxisRotation, referenceUp, degreesToRadians(panRawDeg));
+	vec3.transformQuat(scratchForward, scratchForward, scratchAxisRotation);
+	vec3.cross(scratchRight, referenceUp, scratchForward);
+	let tiltDeg = 0;
+	if (vec3.squaredLength(scratchRight) > epsilon) {
+		vec3.normalize(scratchRight, scratchRight);
+		tiltDeg = radiansToDegrees(vec3.signedAngle(scratchForward, scratchTargetForward, scratchRight));
+	}
+	const panDeg = -panRawDeg;
+	state.pan.applyDelta(panDeg - state.pan.value);
+	state.tilt.applyDelta(tiltDeg - state.tilt.value);
+}
+//#endregion
+export { createState, panTilt_exports, seed, update };

package/dist/core/aim/rotateWithFollowTarget.d.ts

@@ -0,0 +1,20 @@
+import type { Quat } from 'math';
+import type { CameraState } from '../CameraState.js';
+import type { DamperState, DampingConstant } from '../damping/damping.js';
+export type RotateWithFollowTargetParams = {
+    /** Spring response time to the target's rotation (or `{into, from}` for asymmetric damping). */
+    damping: DampingConstant;
+    /** Caps how fast `damping` can close the gap, in radians/sec. */
+    maxSpeed: number;
+};
+/** Every setting from `settings`, or its default. */
+export declare const createParams: (settings?: Partial<RotateWithFollowTargetParams>) => RotateWithFollowTargetParams;
+export type RotateWithFollowTargetState = {
+    damper: DamperState;
+    primed: boolean;
+};
+export declare const createState: () => RotateWithFollowTargetState;
+/** Turns `out` toward `targetRotation`, optionally damped. A `null` rotation leaves `out` as is. */
+export declare function update(out: CameraState, state: RotateWithFollowTargetState, params: RotateWithFollowTargetParams, targetRotation: Quat | null, dt: number, justActivated: boolean): void;
+/** Start the next activation from `rotation` instead of snapping to the target. */
+export declare function prime(state: RotateWithFollowTargetState, params: RotateWithFollowTargetParams, rotation: Quat): void;

package/dist/core/aim/rotateWithFollowTarget.js

@@ -0,0 +1,35 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { createState as createState$1, dampQuaternion, reset } from "../damping/damping.js";
+import { withDefaults } from "../params.js";
+//#region src/core/aim/rotateWithFollowTarget.ts
+var rotateWithFollowTarget_exports = /* @__PURE__ */ __exportAll({
+	createParams: () => createParams,
+	createState: () => createState,
+	prime: () => prime,
+	update: () => update
+});
+/** Every setting from `settings`, or its default. */
+var createParams = (settings) => withDefaults({
+	damping: 0,
+	maxSpeed: Infinity
+}, settings);
+var createState = () => ({
+	damper: createState$1(),
+	primed: false
+});
+/** Turns `out` toward `targetRotation`, optionally damped. A `null` rotation leaves `out` as is. */
+function update(out, state, params, targetRotation, dt, justActivated) {
+	if (justActivated) {
+		if (state.primed) state.primed = false;
+		else reset(state.damper);
+	}
+	if (!targetRotation) return;
+	dampQuaternion(state.damper, out.quaternion, targetRotation, params.damping, dt, params.maxSpeed);
+}
+/** Start the next activation from `rotation` instead of snapping to the target. */
+function prime(state, params, rotation) {
+	dampQuaternion(state.damper, rotation, rotation, params.damping, 0);
+	state.primed = true;
+}
+//#endregion
+export { createParams, createState, prime, rotateWithFollowTarget_exports, update };

package/dist/core/aim/rotationComposer.d.ts

@@ -0,0 +1,58 @@
+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 { PredictorState } from '../damping/predictor.js';
+export type RotationComposerParams = {
+    /** Where the target should land on screen: `[x, y]`, `0` = center, `±1` = edge. */
+    screenPosition: [number, number];
+    /** Viewport width divided by height. */
+    aspect: number;
+    /** Allowed target drift from `screenPosition` before the camera reacts. */
+    deadZone: [number, number];
+    /** Response time when the target leaves the `deadZone`. */
+    damping: DampingConstant;
+    /** Maximum damping speed, in radians/sec. */
+    maxSpeed: number;
+    /** Maximum allowed target drift, enforced immediately. */
+    hardLimit: [number, number];
+    /** Offset from the target, in the target's local space. */
+    targetOffset: Vec3;
+    /** Seconds to aim ahead of the target's current position. */
+    lookaheadTime: number;
+    /** Smoothing time for the lookahead velocity estimate. */
+    lookaheadSmoothing: number;
+    /** Whether lookahead ignores vertical movement. */
+    lookaheadIgnoreY: boolean;
+};
+/** Every setting from `settings`, or its default. */
+export declare const createParams: (settings?: Partial<RotationComposerParams>) => RotationComposerParams;
+export type RotationComposerState = {
+    damper: DamperState;
+    /** Damps the published look-at direction as a rotation to avoid degenerate intermediate points. */
+    lookAtDirectionDamper: DamperState;
+    lookAtDistanceDamper: DamperState;
+    publishedLookRotation: Quat;
+    publishedDistance: number;
+    /** Last desired rotation, kept while the target stays inside the dead zone. */
+    lastActiveDesiredRotation: Quat;
+    hasActiveDesiredRotation: boolean;
+    predictor: PredictorState;
+    primed: boolean;
+    /** Activation seen while the target was unresolved, applied on the first frame that has one. */
+    activationPending: boolean;
+    /** Whether that pending activation was primed. */
+    activationPrimed: boolean;
+};
+export declare const createState: () => RotationComposerState;
+/** Only extents with a dead zone or hard limit are read, so callers can skip resolving them otherwise. */
+export declare const needsExtent: (params: RotationComposerParams) => boolean;
+/**
+ * Rotates `out` to place the target at `screenPosition`. A `null` target leaves `out` as is; a target
+ * without rotation counts as identity for `targetOffset`.
+ */
+export declare function update(out: CameraState, state: RotationComposerState, params: RotationComposerParams, targetPose: TargetPose | null, dt: number, justActivated: boolean): void;
+/** Restart the lookahead history, for when the target switches to a different object. */
+export declare function retarget(state: RotationComposerState): void;
+/** Start the next activation from `rotation` instead of snapping to the target. */
+export declare function prime(state: RotationComposerState, params: RotationComposerParams, rotation: Quat): void;

package/dist/core/aim/rotationComposer.js

@@ -0,0 +1,284 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { createState as createState$1, damp, dampQuaternion, reset } from "../damping/damping.js";
+import { project } from "../TargetExtent.js";
+import { lookRotation } from "./lookRotation.js";
+import { withDefaults } from "../params.js";
+import { addPosition, create, predictDelta, reset as reset$1 } from "../damping/predictor.js";
+import { clamp, degreesToRadians, quat, vec3, vec4 } from "math";
+//#region src/core/aim/rotationComposer.ts
+var rotationComposer_exports = /* @__PURE__ */ __exportAll({
+	createParams: () => createParams,
+	createState: () => createState,
+	needsExtent: () => needsExtent,
+	prime: () => prime,
+	retarget: () => retarget,
+	update: () => update
+});
+/** Every setting from `settings`, or its default. */
+var createParams = (settings) => withDefaults({
+	screenPosition: [0, 0],
+	aspect: 1,
+	deadZone: [0, 0],
+	damping: 0,
+	maxSpeed: Infinity,
+	hardLimit: [0, 0],
+	targetOffset: [
+		0,
+		0,
+		0
+	],
+	lookaheadTime: 0,
+	lookaheadSmoothing: 1,
+	lookaheadIgnoreY: false
+}, settings);
+var createState = () => ({
+	damper: createState$1(),
+	lookAtDirectionDamper: createState$1(),
+	lookAtDistanceDamper: createState$1(),
+	publishedLookRotation: [
+		0,
+		0,
+		0,
+		1
+	],
+	publishedDistance: 0,
+	lastActiveDesiredRotation: [
+		0,
+		0,
+		0,
+		1
+	],
+	hasActiveDesiredRotation: false,
+	predictor: create(),
+	primed: false,
+	activationPending: false,
+	activationPrimed: false
+});
+/** Only extents with a dead zone or hard limit are read, so callers can skip resolving them otherwise. */
+var needsExtent = (params) => params.deadZone[0] > 0 || params.deadZone[1] > 0 || params.hardLimit[0] > 0 || params.hardLimit[1] > 0;
+/** Matches `damp`'s own `epsilon`: the gap at which it declares the distance arrived. */
+var DISTANCE_EPSILON = 1e-4;
+var forwardAxis = [
+	0,
+	0,
+	-1
+];
+var rightAxis = [
+	1,
+	0,
+	0
+];
+var upAxis = [
+	0,
+	1,
+	0
+];
+var scratchTarget = [
+	0,
+	0,
+	0
+];
+var scratchTargetRotation = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchLookaheadDelta = [
+	0,
+	0,
+	0
+];
+var scratchOffset = [
+	0,
+	0,
+	0
+];
+var scratchLookRotation = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchDesiredRotation = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchHardLimitRotation = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchInverse = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchLocalDir = [
+	0,
+	0,
+	0
+];
+var scratchDesiredDir = [
+	0,
+	0,
+	0
+];
+var scratchDelta = [
+	0,
+	0,
+	0,
+	1
+];
+var scratchRight = [
+	0,
+	0,
+	0
+];
+var scratchUp = [
+	0,
+	0,
+	0
+];
+var scratchExtents = [0, 0];
+/** `[x, y, depth]` of a world point in the camera's screen space. `depth <= 0` means behind the camera. */
+var scratchScreenPoint = [
+	0,
+	0,
+	0
+];
+function computeScreenPoint(position, rotation, worldPoint, tanHalfFovH, tanHalfFovV) {
+	vec3.subtract(scratchLocalDir, worldPoint, position);
+	vec3.transformQuat(scratchLocalDir, scratchLocalDir, quat.conjugate(scratchInverse, rotation));
+	const depth = -scratchLocalDir[2];
+	scratchScreenPoint[0] = scratchLocalDir[0] / depth / tanHalfFovH;
+	scratchScreenPoint[1] = scratchLocalDir[1] / depth / tanHalfFovV;
+	scratchScreenPoint[2] = depth;
+	return scratchScreenPoint;
+}
+/** Turns `lookAt`, which looks at the target, to place it at screen point `(desiredX, desiredY)` instead. */
+function composeRotationForScreenPoint(out, lookAt, desiredX, desiredY, tanHalfFovH, tanHalfFovV) {
+	quat.copy(out, lookAt);
+	if (desiredX === 0 && desiredY === 0) return;
+	vec3.normalize(scratchDesiredDir, vec3.set(scratchDesiredDir, desiredX * tanHalfFovH, desiredY * tanHalfFovV, -1));
+	vec3.cross(scratchLocalDir, scratchDesiredDir, forwardAxis);
+	const w = vec3.dot(scratchDesiredDir, forwardAxis) + 1;
+	quat.normalize(scratchDelta, quat.set(scratchDelta, scratchLocalDir[0], scratchLocalDir[1], scratchLocalDir[2], w));
+	quat.multiply(out, out, scratchDelta);
+}
+/**
+* Rotates `out` to place the target at `screenPosition`. A `null` target leaves `out` as is; a target
+* without rotation counts as identity for `targetOffset`.
+*/
+function update(out, state, params, targetPose, dt, justActivated) {
+	if (justActivated) {
+		state.activationPending = true;
+		state.activationPrimed = state.primed;
+		state.primed = false;
+	}
+	if (!targetPose) return;
+	const activating = state.activationPending;
+	const skipReset = activating && state.activationPrimed;
+	state.activationPending = false;
+	const { extent } = targetPose;
+	const target = vec3.copy(scratchTarget, targetPose.position);
+	if (activating) reset$1(state.predictor);
+	addPosition(state.predictor, target, dt, params.lookaheadSmoothing);
+	if (params.lookaheadTime > 0) {
+		predictDelta(scratchLookaheadDelta, state.predictor, params.lookaheadTime);
+		if (params.lookaheadIgnoreY) scratchLookaheadDelta[1] = 0;
+		vec3.add(target, target, scratchLookaheadDelta);
+	}
+	if (targetPose.hasRotation) quat.copy(scratchTargetRotation, targetPose.rotation);
+	else quat.identity(scratchTargetRotation);
+	vec3.add(target, target, vec3.transformQuat(scratchOffset, params.targetOffset, scratchTargetRotation));
+	const { position, referenceUp, quaternion: rotation, rotationDampingBypass: bypass } = out;
+	if (!activating && bypass[3] !== 1) {
+		quat.normalize(rotation, quat.multiply(rotation, bypass, rotation));
+		quat.normalize(state.publishedLookRotation, quat.multiply(state.publishedLookRotation, bypass, state.publishedLookRotation));
+		quat.normalize(state.lastActiveDesiredRotation, quat.multiply(state.lastActiveDesiredRotation, bypass, state.lastActiveDesiredRotation));
+	}
+	if (activating) {
+		reset(state.lookAtDirectionDamper);
+		reset(state.lookAtDistanceDamper);
+	}
+	lookRotation(scratchLookRotation, position, target, referenceUp, rotation);
+	dampQuaternion(state.lookAtDirectionDamper, state.publishedLookRotation, scratchLookRotation, params.damping, dt, params.maxSpeed);
+	const targetDistance = vec3.distance(position, target);
+	state.lookAtDistanceDamper.value = state.publishedDistance;
+	state.publishedDistance = damp(state.lookAtDistanceDamper, targetDistance, params.damping, dt).value;
+	if (vec4.exactEquals(state.publishedLookRotation, scratchLookRotation) && Math.abs(state.publishedDistance - targetDistance) < DISTANCE_EPSILON) vec3.copy(out.lookAtTarget, target);
+	else {
+		vec3.transformQuat(out.lookAtTarget, forwardAxis, state.publishedLookRotation);
+		vec3.scaleAndAdd(out.lookAtTarget, position, out.lookAtTarget, state.publishedDistance);
+	}
+	out.hasLookAtTarget = true;
+	const halfFovV = degreesToRadians(out.fov) / 2;
+	const tanHalfFovV = Math.tan(halfFovV);
+	const tanHalfFovH = tanHalfFovV * params.aspect;
+	const { screenPosition, deadZone, hardLimit } = params;
+	let desiredX = screenPosition[0];
+	let desiredY = screenPosition[1];
+	let insideDeadZone = false;
+	if (!activating && (deadZone[0] > 0 || deadZone[1] > 0)) {
+		const [screenX, screenY, depth] = computeScreenPoint(position, rotation, target, tanHalfFovH, tanHalfFovV);
+		if (depth > 1e-6) {
+			const halfWidth = deadZone[0];
+			const halfHeight = deadZone[1];
+			vec3.transformQuat(scratchRight, rightAxis, rotation);
+			vec3.transformQuat(scratchUp, upAxis, rotation);
+			project(scratchExtents, extent, scratchRight, scratchUp);
+			const extentX = Math.min(scratchExtents[0] / depth / tanHalfFovH, halfWidth);
+			const extentY = Math.min(scratchExtents[1] / depth / tanHalfFovV, halfHeight);
+			const errorX = screenX - screenPosition[0];
+			const errorY = screenY - screenPosition[1];
+			const edgeErrorX = errorX + Math.sign(errorX) * extentX;
+			const edgeErrorY = errorY + Math.sign(errorY) * extentY;
+			insideDeadZone = Math.abs(edgeErrorX) <= halfWidth && Math.abs(edgeErrorY) <= halfHeight;
+			if (!insideDeadZone) {
+				desiredX = screenPosition[0] + clamp(edgeErrorX, -halfWidth, halfWidth) - Math.sign(errorX) * extentX;
+				desiredY = screenPosition[1] + clamp(edgeErrorY, -halfHeight, halfHeight) - Math.sign(errorY) * extentY;
+			}
+		}
+	}
+	if (!insideDeadZone) {
+		composeRotationForScreenPoint(scratchDesiredRotation, scratchLookRotation, desiredX, desiredY, tanHalfFovH, tanHalfFovV);
+		quat.copy(state.lastActiveDesiredRotation, scratchDesiredRotation);
+		state.hasActiveDesiredRotation = true;
+	} else if (state.hasActiveDesiredRotation) quat.copy(scratchDesiredRotation, state.lastActiveDesiredRotation);
+	else quat.copy(scratchDesiredRotation, rotation);
+	if (activating && !skipReset) reset(state.damper);
+	dampQuaternion(state.damper, rotation, scratchDesiredRotation, params.damping, dt, params.maxSpeed);
+	if (hardLimit[0] <= 0 && hardLimit[1] <= 0) return;
+	const [screenX, screenY, depth] = computeScreenPoint(position, rotation, target, tanHalfFovH, tanHalfFovV);
+	if (depth <= 1e-6) return;
+	const halfLimitWidth = hardLimit[0];
+	const halfLimitHeight = hardLimit[1];
+	vec3.transformQuat(scratchRight, rightAxis, rotation);
+	vec3.transformQuat(scratchUp, upAxis, rotation);
+	project(scratchExtents, extent, scratchRight, scratchUp);
+	const limitExtentX = Math.min(scratchExtents[0] / depth / tanHalfFovH, halfLimitWidth);
+	const limitExtentY = Math.min(scratchExtents[1] / depth / tanHalfFovV, halfLimitHeight);
+	const errorX = screenX - screenPosition[0];
+	const errorY = screenY - screenPosition[1];
+	const edgeErrorX = errorX + Math.sign(errorX) * limitExtentX;
+	const edgeErrorY = errorY + Math.sign(errorY) * limitExtentY;
+	if (Math.abs(edgeErrorX) <= halfLimitWidth && Math.abs(edgeErrorY) <= halfLimitHeight) return;
+	composeRotationForScreenPoint(scratchHardLimitRotation, scratchLookRotation, screenPosition[0] + clamp(edgeErrorX, -halfLimitWidth, halfLimitWidth) - Math.sign(errorX) * limitExtentX, screenPosition[1] + clamp(edgeErrorY, -halfLimitHeight, halfLimitHeight) - Math.sign(errorY) * limitExtentY, tanHalfFovH, tanHalfFovV);
+	quat.copy(rotation, scratchHardLimitRotation);
+}
+/** Restart the lookahead history, for when the target switches to a different object. */
+function retarget(state) {
+	reset$1(state.predictor);
+}
+/** Start the next activation from `rotation` instead of snapping to the target. */
+function prime(state, params, rotation) {
+	dampQuaternion(state.damper, rotation, rotation, params.damping, 0);
+	state.primed = true;
+}
+//#endregion
+export { createParams, createState, needsExtent, prime, retarget, rotationComposer_exports, update };

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

@@ -0,0 +1,19 @@
+/** Maps linear progress `t` in `[0, 1]` to eased progress. */
+export type Ease = (t: number) => number;
+/** Named blend curves. Pass a custom `Ease` for other shapes. */
+export declare const BlendCurves: {
+    /** Snaps at the end of the blend. */
+    readonly cut: Ease;
+    /** Constant-rate blend. */
+    readonly linear: Ease;
+    /** Smooth S-shaped blend. */
+    readonly easeInOut: Ease;
+    /** Eased departure, fast arrival. */
+    readonly easeIn: Ease;
+    /** Fast departure, eased arrival. */
+    readonly easeOut: Ease;
+    /** Abrupt departure, smooth arrival. */
+    readonly cubicOut: Ease;
+    /** Smooth departure, abrupt arrival. */
+    readonly cubicIn: Ease;
+};

package/dist/core/blend/BlendCurves.js

@@ -0,0 +1,22 @@
+import { smoothstep } from "math";
+import { easing } from "math/time";
+//#region src/core/blend/BlendCurves.ts
+/** Named blend curves. Pass a custom `Ease` for other shapes. */
+var BlendCurves = {
+	/** Snaps at the end of the blend. */
+	cut: ((t) => t < 1 ? 0 : 1),
+	/** Constant-rate blend. */
+	linear: easing.linear,
+	/** Smooth S-shaped blend. */
+	easeInOut: ((t) => smoothstep(0, 1, t)),
+	/** Eased departure, fast arrival. */
+	easeIn: ((t) => t * t),
+	/** Fast departure, eased arrival. */
+	easeOut: ((t) => t * (2 - t)),
+	/** Abrupt departure, smooth arrival. */
+	cubicOut: easing.cubicOut,
+	/** Smooth departure, abrupt arrival. */
+	cubicIn: easing.cubicIn
+};
+//#endregion
+export { BlendCurves };