@pmndrs/klipp 0.0.0-stage → 0.14.0

package/dist/core/TargetExtent.js

@@ -0,0 +1,54 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { vec3 } from "math";
+//#region src/core/TargetExtent.ts
+var TargetExtent_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	project: () => project
+});
+var create = () => ({
+	radius: 0,
+	size: [
+		0,
+		0,
+		0
+	],
+	rotation: [
+		0,
+		0,
+		0,
+		1
+	],
+	hasSize: false
+});
+var scratchAxisX = [
+	0,
+	0,
+	0
+];
+var scratchAxisY = [
+	0,
+	0,
+	0
+];
+var scratchAxisZ = [
+	0,
+	0,
+	0
+];
+/** Half-extents of `extent` along two world axes. */
+function project(out, extent, axisA, axisB) {
+	if (!extent.hasSize) {
+		out[0] = extent.radius;
+		out[1] = extent.radius;
+		return out;
+	}
+	const { size, rotation } = extent;
+	vec3.transformQuat(scratchAxisX, vec3.set(scratchAxisX, size[0] * .5, 0, 0), rotation);
+	vec3.transformQuat(scratchAxisY, vec3.set(scratchAxisY, 0, size[1] * .5, 0), rotation);
+	vec3.transformQuat(scratchAxisZ, vec3.set(scratchAxisZ, 0, 0, size[2] * .5), rotation);
+	out[0] = Math.abs(vec3.dot(scratchAxisX, axisA)) + Math.abs(vec3.dot(scratchAxisY, axisA)) + Math.abs(vec3.dot(scratchAxisZ, axisA));
+	out[1] = Math.abs(vec3.dot(scratchAxisX, axisB)) + Math.abs(vec3.dot(scratchAxisY, axisB)) + Math.abs(vec3.dot(scratchAxisZ, axisB));
+	return out;
+}
+//#endregion
+export { TargetExtent_exports, create, project };

package/dist/core/TargetPose.d.ts

@@ -0,0 +1,13 @@
+import type { Quat, Vec3 } from 'math';
+import type { TargetExtent } from './TargetExtent.js';
+/**
+ * A target's world transform and how far it reaches. `rotation` is only meaningful when `hasRotation` is true
+ * (not for fixed points). `extent` is only read by the composers.
+ */
+export type TargetPose = {
+    position: Vec3;
+    rotation: Quat;
+    hasRotation: boolean;
+    extent: TargetExtent;
+};
+export declare const create: () => TargetPose;

package/dist/core/TargetPose.js

@@ -0,0 +1,21 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { create as create$1 } from "./TargetExtent.js";
+//#region src/core/TargetPose.ts
+var TargetPose_exports = /* @__PURE__ */ __exportAll({ create: () => create });
+var create = () => ({
+	position: [
+		0,
+		0,
+		0
+	],
+	rotation: [
+		0,
+		0,
+		0,
+		1
+	],
+	hasRotation: false,
+	extent: create$1()
+});
+//#endregion
+export { TargetPose_exports, create };

package/dist/core/VirtualCamera.d.ts

@@ -0,0 +1,102 @@
+import type { CameraState } from './CameraState.js';
+import { EventDispatcher } from './EventDispatcher.js';
+import { attachTo, prepare, run, skip } from './internal.js';
+import type { CameraTransitionEventMap, Klipp } from './Klipp.js';
+import { BlendHints } from './blend/BlendHints.js';
+import type { InputAxisData } from './input/axis.js';
+import { type InputAxisOwner } from './input/InputAxisOwner.js';
+/** Writes `out` for one frame. Return `true` when more work remains for a later frame. */
+export type CameraStateWriter = (out: CameraState, dt: number, justActivated: boolean) => boolean | void;
+/** A Body, Aim, Extension or Noise: anything with an `update` that writes the camera state. */
+export type CameraPiece = {
+    update: CameraStateWriter;
+};
+/** How a camera updates while another one is on screen: every frame, one camera per frame in turn, or not at all. */
+export type StandbyUpdate = 'always' | 'roundRobin' | 'never';
+export type VirtualCameraOptions = {
+    /** The active camera with the highest priority is on screen. */
+    priority?: number;
+    /** Whether this camera takes part in arbitration and updates. */
+    active?: boolean;
+    /** Blend hints for transitions involving this camera. */
+    hints?: BlendHints;
+    /** Starting pose and lens, applied over the `Klipp`'s `initialCameraState` when first added. */
+    initialState?: Partial<CameraState>;
+    /** How this camera updates while another one is on screen. */
+    standbyUpdate?: StandbyUpdate;
+};
+/** One shot: its state, the pieces that write it, and its place in a `Klipp`'s arbitration. */
+export declare class VirtualCamera extends EventDispatcher<CameraTransitionEventMap> implements InputAxisOwner {
+    /** This camera's own state, written by its pieces every frame. */
+    readonly state: CameraState;
+    /** How this camera updates while another one is on screen. */
+    standbyUpdate: StandbyUpdate;
+    /** Every piece, in no particular order. */
+    protected readonly pieces: Set<CameraPiece>;
+    private readonly initialState;
+    private _name;
+    private _priority;
+    private _hints;
+    private _active;
+    private _klipp;
+    private seeded;
+    private stopTracking;
+    private unregister;
+    private justActivated;
+    private hasRun;
+    private skippedTime;
+    private _body;
+    private _aim;
+    private removeBody;
+    private removeAim;
+    private readonly extensions;
+    private readonly noises;
+    private _inputAxes;
+    constructor(name: string, options?: VirtualCameraOptions);
+    /** The `Klipp` this camera was added to, if any. */
+    get klipp(): Klipp | null;
+    get name(): string;
+    /** Renaming a registered camera registers it again under the new name. */
+    set name(name: string);
+    get priority(): number;
+    set priority(priority: number);
+    get hints(): BlendHints;
+    set hints(hints: BlendHints);
+    /** Whether this camera takes part. Turning it back on starts it fresh, like a first activation. */
+    get active(): boolean;
+    set active(active: boolean);
+    /** Every input axis of this camera's pieces, by name. A new object whenever the pieces change. */
+    get inputAxes(): Record<string, InputAxisData>;
+    get body(): CameraPiece | null;
+    /** Replace the Body. */
+    set body(body: CameraPiece | null);
+    get aim(): CameraPiece | null;
+    /** Replace the Aim. */
+    set aim(aim: CameraPiece | null);
+    /** Add the Body. A second one replaces it with a warning. Returns a function that removes it, unless replaced. */
+    setBody(body: CameraPiece | null): () => void;
+    /** Add the Aim. Like `setBody`, a second one replaces it with a warning. */
+    setAim(aim: CameraPiece | null): () => void;
+    /** Add an Extension. They run in the order added. Returns a function that removes it. */
+    addExtension(extension: CameraPiece): () => void;
+    /** Add a Noise. They run in the order added, after every Extension. Returns a function that removes it. */
+    addNoise(noise: CameraPiece): () => void;
+    /** Join `klipp`'s arbitration, or leave it with `null`. Only `Klipp.add` and `remove` call this. */
+    [attachTo](klipp: Klipp | null): void;
+    /** Pass the viewport size, once known, on to pieces that frame by it. Called by `Klipp` before the frame. */
+    [prepare](width: number, height: number): void;
+    /** Run the pieces for one frame, if registered. Returns `true` while one is still moving. Called by `Klipp`. */
+    [run](dt: number): boolean;
+    /** Skip this frame, adding its time to the next run. Called by `Klipp` for cameras in standby. */
+    [skip](dt: number): void;
+    /** Called when a piece is removed, for layers that hold per-piece resources. */
+    protected removePiece(piece: CameraPiece): void;
+    private addPiece;
+    private collectInputAxes;
+    private registration;
+    private syncRegistration;
+    /** Re-dispatch events for this camera only when it participates in the transition. */
+    private trackEvents;
+    /** Run every piece against `out` once, in order. Each frame runs it with the camera's own state. */
+    update: (out: CameraState, dt: number, justActivated: boolean) => boolean;
+}

package/dist/core/VirtualCamera.js

@@ -0,0 +1,290 @@
+import { EventDispatcher } from "./EventDispatcher.js";
+import { BlendHints } from "./blend/BlendHints.js";
+import { copy, create, merge } from "./CameraState.js";
+import { attachTo, checkName, prepare, register, run, setHints, setPriority, skip } from "./internal.js";
+import { isInputAxisOwner } from "./input/InputAxisOwner.js";
+import { quat } from "math";
+//#region src/core/VirtualCamera.ts
+/** Warn when a second Body or Aim replaces an existing one. */
+function warnDoubleRegistration(slot, name) {
+	console.warn(`Virtual camera "${name}": a second ${slot} replaced the first. A camera runs one ${slot}.`);
+}
+var noop = () => {};
+/** One shot: its state, the pieces that write it, and its place in a `Klipp`'s arbitration. */
+var VirtualCamera = class extends EventDispatcher {
+	/** This camera's own state, written by its pieces every frame. */
+	state;
+	/** How this camera updates while another one is on screen. */
+	standbyUpdate;
+	/** Every piece, in no particular order. */
+	pieces = /* @__PURE__ */ new Set();
+	initialState;
+	_name;
+	_priority;
+	_hints;
+	_active;
+	_klipp = null;
+	seeded = false;
+	stopTracking = null;
+	unregister = null;
+	justActivated = true;
+	hasRun = false;
+	skippedTime = 0;
+	_body = null;
+	_aim = null;
+	removeBody = noop;
+	removeAim = noop;
+	extensions = /* @__PURE__ */ new Set();
+	noises = /* @__PURE__ */ new Set();
+	_inputAxes = null;
+	constructor(name, options = {}) {
+		super();
+		this._name = name;
+		this._priority = options.priority ?? 0;
+		this._hints = options.hints ?? BlendHints.none;
+		this._active = options.active ?? true;
+		this.standbyUpdate = options.standbyUpdate ?? "roundRobin";
+		this.initialState = options.initialState;
+		this.state = merge(create(), options.initialState ?? {});
+	}
+	/** The `Klipp` this camera was added to, if any. */
+	get klipp() {
+		return this._klipp;
+	}
+	get name() {
+		return this._name;
+	}
+	/** Renaming a registered camera registers it again under the new name. */
+	set name(name) {
+		if (name === this._name) return;
+		this._name = name;
+		this._klipp?.[checkName](this);
+		if (this.unregister) {
+			this.unregister();
+			this.unregister = this._klipp[register](this.registration());
+		}
+	}
+	get priority() {
+		return this._priority;
+	}
+	set priority(priority) {
+		this._priority = priority;
+		if (this.unregister) this._klipp[setPriority](this._name, priority);
+	}
+	get hints() {
+		return this._hints;
+	}
+	set hints(hints) {
+		this._hints = hints;
+		if (this.unregister) this._klipp[setHints](this._name, hints);
+	}
+	/** Whether this camera takes part. Turning it back on starts it fresh, like a first activation. */
+	get active() {
+		return this._active;
+	}
+	set active(active) {
+		this._active = active;
+		this.syncRegistration();
+	}
+	/** Every input axis of this camera's pieces, by name. A new object whenever the pieces change. */
+	get inputAxes() {
+		return this._inputAxes ??= this.collectInputAxes();
+	}
+	get body() {
+		return this._body;
+	}
+	/** Replace the Body. */
+	set body(body) {
+		this.removeBody();
+		this.setBody(body);
+	}
+	get aim() {
+		return this._aim;
+	}
+	/** Replace the Aim. */
+	set aim(aim) {
+		this.removeAim();
+		this.setAim(aim);
+	}
+	/** Add the Body. A second one replaces it with a warning. Returns a function that removes it, unless replaced. */
+	setBody(body) {
+		if (this._body) {
+			if (body) warnDoubleRegistration("Body", this._name);
+			this.removePiece(this._body);
+		}
+		this._body = body;
+		if (!body) return this.removeBody = noop;
+		this.addPiece(body);
+		if (!this.hasRun && this.initialState?.position && "primeFrom" in body) body.primeFrom(this.state.position);
+		return this.removeBody = () => {
+			if (this._body !== body) return;
+			this.removePiece(body);
+			this._body = null;
+			this.removeBody = noop;
+		};
+	}
+	/** Add the Aim. Like `setBody`, a second one replaces it with a warning. */
+	setAim(aim) {
+		if (this._aim) {
+			if (aim) warnDoubleRegistration("Aim", this._name);
+			this.removePiece(this._aim);
+		}
+		this._aim = aim;
+		if (!aim) return this.removeAim = noop;
+		this.addPiece(aim);
+		if (!this.hasRun && this.initialState?.quaternion && "primeFrom" in aim) aim.primeFrom(this.state.quaternion, this.state.referenceUp);
+		return this.removeAim = () => {
+			if (this._aim !== aim) return;
+			this.removePiece(aim);
+			this._aim = null;
+			this.removeAim = noop;
+		};
+	}
+	/** Add an Extension. They run in the order added. Returns a function that removes it. */
+	addExtension(extension) {
+		this.addPiece(extension);
+		this.extensions.add(extension);
+		return () => this.removePiece(extension);
+	}
+	/** Add a Noise. They run in the order added, after every Extension. Returns a function that removes it. */
+	addNoise(noise) {
+		this.addPiece(noise);
+		this.noises.add(noise);
+		return () => this.removePiece(noise);
+	}
+	/** Join `klipp`'s arbitration, or leave it with `null`. Only `Klipp.add` and `remove` call this. */
+	[attachTo](klipp) {
+		this.stopTracking?.();
+		this.stopTracking = null;
+		this._klipp = klipp;
+		if (klipp) {
+			if (!this.seeded) {
+				copy(this.state, klipp.initialCameraState);
+				if (this.initialState) merge(this.state, this.initialState);
+				this.seeded = true;
+			}
+			this.stopTracking = this.trackEvents(klipp);
+		}
+		this.syncRegistration();
+	}
+	/** Pass the viewport size, once known, on to pieces that frame by it. Called by `Klipp` before the frame. */
+	[prepare](width, height) {
+		if (width <= 0 || height <= 0) return;
+		for (const piece of this.pieces) {
+			if ("aspect" in piece) piece.aspect = width / height;
+			if ("viewportWidth" in piece) {
+				piece.viewportWidth = width;
+				piece.viewportHeight = height;
+			}
+		}
+	}
+	/** Run the pieces for one frame, if registered. Returns `true` while one is still moving. Called by `Klipp`. */
+	[run](dt) {
+		if (!this.unregister) return false;
+		const stillInFlight = this.update(this.state, dt + this.skippedTime, this.justActivated);
+		this.skippedTime = 0;
+		this.justActivated = false;
+		this.hasRun = true;
+		return stillInFlight;
+	}
+	/** Skip this frame, adding its time to the next run. Called by `Klipp` for cameras in standby. */
+	[skip](dt) {
+		if (this.unregister) this.skippedTime += dt;
+	}
+	/** Called when a piece is removed, for layers that hold per-piece resources. */
+	removePiece(piece) {
+		this.pieces.delete(piece);
+		this.extensions.delete(piece);
+		this.noises.delete(piece);
+		this._inputAxes = null;
+	}
+	addPiece(piece) {
+		this.pieces.add(piece);
+		this._inputAxes = null;
+	}
+	collectInputAxes() {
+		const axes = {};
+		for (const piece of this.pieces) {
+			if (!isInputAxisOwner(piece)) continue;
+			for (const name in piece.inputAxes) if (name in axes) console.warn(`Virtual camera "${this._name}": two pieces have an input axis named "${name}". Using the first.`);
+			else axes[name] = piece.inputAxes[name];
+		}
+		return axes;
+	}
+	registration() {
+		return {
+			id: this._name,
+			priority: this._priority,
+			state: this.state,
+			hints: this._hints
+		};
+	}
+	syncRegistration() {
+		const shouldRegister = this._klipp !== null && this._active;
+		if (shouldRegister && !this.unregister) {
+			this.unregister = this._klipp[register](this.registration());
+			this.justActivated = true;
+			this.skippedTime = 0;
+		} else if (!shouldRegister && this.unregister) {
+			this.unregister();
+			this.unregister = null;
+		}
+	}
+	/** Re-dispatch events for this camera only when it participates in the transition. */
+	trackEvents(core) {
+		const onActivated = (event) => {
+			if (event.incoming === this.name) this.dispatchEvent({
+				type: "activated",
+				...event
+			});
+		};
+		const onDeactivated = (event) => {
+			if (event.outgoing === this.name) this.dispatchEvent({
+				type: "deactivated",
+				...event
+			});
+		};
+		const onBlendCreated = (event) => {
+			if (event.incoming === this.name || event.outgoing === this.name) this.dispatchEvent({
+				type: "blendCreated",
+				...event
+			});
+		};
+		const onBlendFinished = (event) => {
+			if (event.liveId === this.name) this.dispatchEvent({
+				type: "blendFinished",
+				...event
+			});
+		};
+		const onCut = (event) => {
+			if (event.incoming === this.name || event.outgoing === this.name) this.dispatchEvent({
+				type: "cut",
+				...event
+			});
+		};
+		core.addEventListener("activated", onActivated);
+		core.addEventListener("deactivated", onDeactivated);
+		core.addEventListener("blendCreated", onBlendCreated);
+		core.addEventListener("blendFinished", onBlendFinished);
+		core.addEventListener("cut", onCut);
+		return () => {
+			core.removeEventListener("activated", onActivated);
+			core.removeEventListener("deactivated", onDeactivated);
+			core.removeEventListener("blendCreated", onBlendCreated);
+			core.removeEventListener("blendFinished", onBlendFinished);
+			core.removeEventListener("cut", onCut);
+		};
+	}
+	/** Run every piece against `out` once, in order. Each frame runs it with the camera's own state. */
+	update = (out, dt, justActivated) => {
+		let stillInFlight = false;
+		quat.identity(out.rotationDampingBypass);
+		if (this._body?.update(out, dt, justActivated) === true) stillInFlight = true;
+		if (this._aim?.update(out, dt, justActivated) === true) stillInFlight = true;
+		for (const extension of this.extensions) if (extension.update(out, dt, justActivated) === true) stillInFlight = true;
+		for (const noise of this.noises) if (noise.update(out, dt, justActivated) === true) stillInFlight = true;
+		return stillInFlight;
+	};
+};
+//#endregion
+export { VirtualCamera };

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

@@ -0,0 +1,10 @@
+import type { CameraState } from '../CameraState.js';
+import type { TargetPose } from '../TargetPose.js';
+/** Rotates so the target is dead-center. Layers override `readTarget` to read their own targets. */
+export declare class HardLookAtAim<T = TargetPose | null> {
+    target: T;
+    constructor(target: T);
+    update: (out: CameraState) => void;
+    /** This frame's target pose, or `null` when there is none. */
+    protected readTarget(): TargetPose | null;
+}

package/dist/core/aim/HardLookAtAim.js

@@ -0,0 +1,19 @@
+import { update } from "./hardLookAt.js";
+//#region src/core/aim/HardLookAtAim.ts
+/** Rotates so the target is dead-center. Layers override `readTarget` to read their own targets. */
+var HardLookAtAim = class {
+	target;
+	constructor(target) {
+		this.target = target;
+	}
+	update = (out) => {
+		const pose = this.readTarget();
+		if (pose) update(out, pose.position);
+	};
+	/** This frame's target pose, or `null` when there is none. */
+	readTarget() {
+		return this.target;
+	}
+};
+//#endregion
+export { HardLookAtAim };

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

@@ -0,0 +1,26 @@
+import type { Quat, Vec3 } from 'math';
+import type { CameraState } from '../CameraState.js';
+import type { TargetPose } from '../TargetPose.js';
+import type { InputAxisOwner } from '../input/InputAxisOwner.js';
+import * as panTilt from './panTilt.js';
+/** Rotation from two `InputAxis`: `pan` (yaw) and `tilt` (pitch), relative to an optional target's rotation. */
+export declare class PanTiltAim<T = TargetPose | null> implements InputAxisOwner {
+    readonly state: panTilt.PanTiltState;
+    readonly pan: import("../index.js").InputAxis;
+    readonly tilt: import("../index.js").InputAxis;
+    readonly inputAxes: {
+        pan: import("../index.js").InputAxis;
+        tilt: import("../index.js").InputAxis;
+    };
+    /** Makes `pan` and `tilt` relative to this target's rotation. */
+    target: T;
+    constructor(target?: T);
+    update: (out: CameraState, dt: number) => boolean;
+    /** Seeds `pan`/`tilt` from `rotation`'s forward direction, relative to the current reference frame. */
+    setFromRotation: (rotation: Quat, referenceUp: Vec3) => void;
+    /** Start facing `rotation`, with both axes settled there instead of easing in. */
+    primeFrom: (rotation: Quat, referenceUp: Vec3) => void;
+    /** This frame's target pose, or `null` when there is none. Only its rotation is read. */
+    protected readTarget(): TargetPose | null;
+    private targetRotation;
+}

package/dist/core/aim/PanTiltAim.js

@@ -0,0 +1,38 @@
+import { createState, seed, update } from "./panTilt.js";
+//#region src/core/aim/PanTiltAim.ts
+/** Rotation from two `InputAxis`: `pan` (yaw) and `tilt` (pitch), relative to an optional target's rotation. */
+var PanTiltAim = class {
+	state = createState();
+	pan = this.state.pan;
+	tilt = this.state.tilt;
+	inputAxes = {
+		pan: this.pan,
+		tilt: this.tilt
+	};
+	/** Makes `pan` and `tilt` relative to this target's rotation. */
+	target;
+	constructor(target = null) {
+		this.target = target;
+	}
+	update = (out, dt) => update(out, this.state, this.targetRotation(), dt);
+	/** Seeds `pan`/`tilt` from `rotation`'s forward direction, relative to the current reference frame. */
+	setFromRotation = (rotation, referenceUp) => {
+		seed(this.state, this.targetRotation(), rotation, referenceUp);
+	};
+	/** Start facing `rotation`, with both axes settled there instead of easing in. */
+	primeFrom = (rotation, referenceUp) => {
+		this.setFromRotation(rotation, referenceUp);
+		this.pan.reset();
+		this.tilt.reset();
+	};
+	/** This frame's target pose, or `null` when there is none. Only its rotation is read. */
+	readTarget() {
+		return this.target;
+	}
+	targetRotation() {
+		const pose = this.readTarget();
+		return pose?.hasRotation ? pose.rotation : null;
+	}
+};
+//#endregion
+export { PanTiltAim };

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

@@ -0,0 +1,19 @@
+import type { Quat } from 'math';
+import type { CameraState } from '../CameraState.js';
+import type { TargetPose } from '../TargetPose.js';
+import type { DampingConstant } from '../damping/damping.js';
+import * as rotateWithFollowTarget from './rotateWithFollowTarget.js';
+import type { RotateWithFollowTargetParams } from './rotateWithFollowTarget.js';
+export type RotateWithFollowTargetOptions = Partial<RotateWithFollowTargetParams>;
+/** Follows the target's rotation. Layers override `readTarget` to read their own targets. */
+export declare class RotateWithFollowTargetAim<T = TargetPose | null> implements RotateWithFollowTargetParams {
+    target: T;
+    damping: DampingConstant;
+    maxSpeed: number;
+    readonly state: rotateWithFollowTarget.RotateWithFollowTargetState;
+    constructor(target: T, options?: RotateWithFollowTargetOptions);
+    update: (out: CameraState, dt: number, justActivated: boolean) => void;
+    primeFrom: (rotation: Quat) => void;
+    /** This frame's target pose, or `null` when there is none. Only its rotation is read. */
+    protected readTarget(): TargetPose | null;
+}

package/dist/core/aim/RotateWithFollowTargetAim.js

@@ -0,0 +1,23 @@
+import { createParams, createState, prime, update } from "./rotateWithFollowTarget.js";
+//#region src/core/aim/RotateWithFollowTargetAim.ts
+/** Follows the target's rotation. Layers override `readTarget` to read their own targets. */
+var RotateWithFollowTargetAim = class {
+	target;
+	state = createState();
+	constructor(target, options) {
+		this.target = target;
+		Object.assign(this, createParams(options));
+	}
+	update = (out, dt, justActivated) => {
+		const pose = this.readTarget();
+		const rotation = pose?.hasRotation ? pose.rotation : null;
+		update(out, this.state, this, rotation, dt, justActivated);
+	};
+	primeFrom = (rotation) => prime(this.state, this, rotation);
+	/** This frame's target pose, or `null` when there is none. Only its rotation is read. */
+	readTarget() {
+		return this.target;
+	}
+};
+//#endregion
+export { RotateWithFollowTargetAim };

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

@@ -0,0 +1,27 @@
+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 * as rotationComposer from './rotationComposer.js';
+import type { RotationComposerParams } from './rotationComposer.js';
+/** Rotates the camera to place a target at `screenPosition`. Layers override `readTarget`. */
+export declare class RotationComposerAim<T = TargetPose | null> implements RotationComposerParams {
+    target: T;
+    screenPosition: [number, number];
+    aspect: number;
+    deadZone: [number, number];
+    damping: DampingConstant;
+    maxSpeed: number;
+    hardLimit: [number, number];
+    targetOffset: Vec3;
+    lookaheadTime: number;
+    lookaheadSmoothing: number;
+    lookaheadIgnoreY: boolean;
+    readonly state: rotationComposer.RotationComposerState;
+    private lastTarget;
+    constructor(target: T, options?: Partial<RotationComposerParams>);
+    primeFrom: (rotation: Quat) => 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/aim/RotationComposerAim.js

@@ -0,0 +1,27 @@
+import { createParams, createState, prime, retarget, update } from "./rotationComposer.js";
+//#region src/core/aim/RotationComposerAim.ts
+/** Rotates the camera to place a target at `screenPosition`. Layers override `readTarget`. */
+var RotationComposerAim = class {
+	target;
+	state = createState();
+	lastTarget = void 0;
+	constructor(target, options) {
+		this.target = target;
+		Object.assign(this, createParams(options));
+	}
+	primeFrom = (rotation) => prime(this.state, this, rotation);
+	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 { RotationComposerAim };