@pmndrs/klipp 0.0.0-stage → 0.14.0

package/dist/three/VirtualCameraThree.js

@@ -0,0 +1,108 @@
+import { attachTo, prepare } from "../core/internal.js";
+import { VirtualCamera } from "../core/VirtualCamera.js";
+import { isVector3Like, resolveVector3 } from "./resolve/resolveVector3.js";
+import { TargetGroup } from "./extension/TargetGroup.js";
+import { vec4 } from "math";
+import { Quaternion, Vector3 } from "three";
+//#region src/three/VirtualCameraThree.ts
+var isRegistrable = (target) => target != null && !isVector3Like(target);
+var reads = (piece) => "targetSlot" in piece;
+var scratch = new Vector3();
+/** `VirtualCamera` for three.js: points every piece's target at its slot in the `KlippThree`'s registry. */
+var VirtualCameraThree = class extends VirtualCamera {
+	/** The target registry of the `KlippThree` this camera is in. */
+	registry = null;
+	slots = /* @__PURE__ */ new Map();
+	groupSlots = /* @__PURE__ */ new Map();
+	constructor(name, options = {}) {
+		super(name, {
+			...options,
+			initialState: options.initialState && resolveInitialState(options.initialState)
+		});
+	}
+	[attachTo](klipp) {
+		this.releaseSlots();
+		super[attachTo](klipp);
+		this.registry = klipp && "targets" in klipp ? klipp.targets : null;
+	}
+	[prepare](width, height) {
+		super[prepare](width, height);
+		for (const piece of this.pieces) {
+			if (reads(piece)) this.syncSlot(piece);
+			if ("group" in piece && piece.group instanceof TargetGroup) this.syncGroupSlots(piece.group);
+		}
+	}
+	removePiece(piece) {
+		super.removePiece(piece);
+		if (reads(piece)) {
+			const target = this.slots.get(piece);
+			if (target !== void 0) {
+				if (isRegistrable(target)) this.registry?.release(target);
+				this.slots.delete(piece);
+			}
+			piece.targetSlot = null;
+		}
+		if ("group" in piece && piece.group instanceof TargetGroup) this.releaseGroupSlots(piece.group);
+	}
+	releaseSlots() {
+		for (const [piece, target] of this.slots) {
+			if (isRegistrable(target)) this.registry?.release(target);
+			piece.targetSlot = null;
+		}
+		this.slots.clear();
+		for (const group of [...this.groupSlots.keys()]) this.releaseGroupSlots(group);
+	}
+	syncSlot(piece) {
+		if (!this.registry) return;
+		const { target } = piece;
+		if (this.slots.has(piece) && this.slots.get(piece) === target) return;
+		const previous = this.slots.get(piece);
+		if (previous !== void 0 && isRegistrable(previous)) this.registry.release(previous);
+		this.slots.set(piece, target);
+		piece.targetSlot = isRegistrable(target) ? this.registry.acquire(target) : null;
+	}
+	syncGroupSlots(group) {
+		if (!this.registry) return;
+		const previous = this.groupSlots.get(group);
+		const { members } = group;
+		let count = 0;
+		let changed = previous === void 0;
+		for (const member of members) {
+			if (!isRegistrable(member.target)) continue;
+			if (!changed && previous[count] !== member.target) changed = true;
+			count++;
+		}
+		if (!changed && previous.length === count) return;
+		this.releaseGroupSlots(group);
+		const targets = [];
+		const slots = /* @__PURE__ */ new Map();
+		for (const member of members) {
+			if (!isRegistrable(member.target)) continue;
+			targets.push(member.target);
+			slots.set(member.target, this.registry.acquire(member.target));
+		}
+		this.groupSlots.set(group, targets);
+		group.memberSlots = slots;
+	}
+	releaseGroupSlots(group) {
+		const previous = this.groupSlots.get(group);
+		if (!previous) return;
+		for (const target of previous) this.registry?.release(target);
+		this.groupSlots.delete(group);
+		group.memberSlots = /* @__PURE__ */ new Map();
+	}
+};
+/** `initialState` with every vector shorthand resolved to tuples. */
+function resolveInitialState(initialState) {
+	const { position, quaternion, target, lookAtTarget, referenceUp, ...rest } = initialState;
+	const resolved = { ...rest };
+	if (position) resolved.position = resolveVector3(scratch, position).toArray();
+	if (quaternion instanceof Quaternion) resolved.quaternion = quaternion.toArray();
+	else if (quaternion) resolved.quaternion = vec4.clone(quaternion);
+	if (target) resolved.target = resolveVector3(scratch, target).toArray();
+	if (lookAtTarget) resolved.lookAtTarget = resolveVector3(scratch, lookAtTarget).toArray();
+	if (referenceUp) resolved.referenceUp = resolveVector3(scratch, referenceUp).toArray();
+	return resolved;
+}
+//#endregion
+export { VirtualCameraThree };

package/dist/three/aim/HardLookAtAimThree.d.ts

@@ -0,0 +1,10 @@
+import { HardLookAtAim } from '../../core/aim/HardLookAtAim.js';
+import type { TargetPose } from '../../core/TargetPose.js';
+import type { Target } from '../resolve/Target.js';
+import type { TargetSlot } from '../resolve/TargetRegistry.js';
+/** Rotates so an `Object3D`, ref or fixed point is dead-center. */
+export declare class HardLookAtAimThree extends HardLookAtAim<Target> {
+    targetSlot: TargetSlot | null;
+    private readonly pose;
+    protected readTarget(): TargetPose | null;
+}

package/dist/three/aim/HardLookAtAimThree.js

@@ -0,0 +1,14 @@
+import { create } from "../../core/TargetPose.js";
+import { HardLookAtAim } from "../../core/aim/HardLookAtAim.js";
+import { readTargetPose } from "../readTargetPose.js";
+//#region src/three/aim/HardLookAtAimThree.ts
+/** Rotates so an `Object3D`, ref or fixed point is dead-center. */
+var HardLookAtAimThree = class extends HardLookAtAim {
+	targetSlot = null;
+	pose = create();
+	readTarget() {
+		return readTargetPose(this.pose, this.target, this.targetSlot, false) ? this.pose : null;
+	}
+};
+//#endregion
+export { HardLookAtAimThree };

package/dist/three/aim/PanTiltAimThree.d.ts

@@ -0,0 +1,10 @@
+import { PanTiltAim } from '../../core/aim/PanTiltAim.js';
+import type { TargetPose } from '../../core/TargetPose.js';
+import type { Target } from '../resolve/Target.js';
+import type { TargetSlot } from '../resolve/TargetRegistry.js';
+/** `PanTiltAim` relative to an optional `Object3D` or ref's rotation. */
+export declare class PanTiltAimThree extends PanTiltAim<Target> {
+    targetSlot: TargetSlot | null;
+    private readonly pose;
+    protected readTarget(): TargetPose;
+}

package/dist/three/aim/PanTiltAimThree.js

@@ -0,0 +1,15 @@
+import { create } from "../../core/TargetPose.js";
+import { PanTiltAim } from "../../core/aim/PanTiltAim.js";
+import { readTargetRotation } from "../readTargetPose.js";
+//#region src/three/aim/PanTiltAimThree.ts
+/** `PanTiltAim` relative to an optional `Object3D` or ref's rotation. */
+var PanTiltAimThree = class extends PanTiltAim {
+	targetSlot = null;
+	pose = create();
+	readTarget() {
+		this.pose.hasRotation = readTargetRotation(this.pose.rotation, this.target, this.targetSlot);
+		return this.pose;
+	}
+};
+//#endregion
+export { PanTiltAimThree };

package/dist/three/aim/RotateWithFollowTargetAimThree.d.ts

@@ -0,0 +1,11 @@
+import { RotateWithFollowTargetAim, type RotateWithFollowTargetOptions } from '../../core/aim/RotateWithFollowTargetAim.js';
+import type { TargetPose } from '../../core/TargetPose.js';
+import type { Target } from '../resolve/Target.js';
+import type { TargetSlot } from '../resolve/TargetRegistry.js';
+export type { RotateWithFollowTargetOptions };
+/** Follows the rotation of an `Object3D` or ref. */
+export declare class RotateWithFollowTargetAimThree extends RotateWithFollowTargetAim<Target> {
+    targetSlot: TargetSlot | null;
+    private readonly pose;
+    protected readTarget(): TargetPose;
+}

package/dist/three/aim/RotateWithFollowTargetAimThree.js

@@ -0,0 +1,15 @@
+import { create } from "../../core/TargetPose.js";
+import { RotateWithFollowTargetAim } from "../../core/aim/RotateWithFollowTargetAim.js";
+import { readTargetRotation } from "../readTargetPose.js";
+//#region src/three/aim/RotateWithFollowTargetAimThree.ts
+/** Follows the rotation of an `Object3D` or ref. */
+var RotateWithFollowTargetAimThree = class extends RotateWithFollowTargetAim {
+	targetSlot = null;
+	pose = create();
+	readTarget() {
+		this.pose.hasRotation = readTargetRotation(this.pose.rotation, this.target, this.targetSlot);
+		return this.pose;
+	}
+};
+//#endregion
+export { RotateWithFollowTargetAimThree };

package/dist/three/aim/RotationComposerAimThree.d.ts

@@ -0,0 +1,26 @@
+import type { RotationComposerParams } from '../../core/aim/rotationComposer.js';
+import { RotationComposerAim } from '../../core/aim/RotationComposerAim.js';
+import type { TargetPose } from '../../core/TargetPose.js';
+import { type Vector3Like } from '../resolve/resolveVector3.js';
+import type { Target } from '../resolve/Target.js';
+import type { TargetSlot } from '../resolve/TargetRegistry.js';
+export type RotationComposerThreeOptions = Partial<Omit<RotationComposerParams, 'targetOffset'>> & {
+    /** Offset from the target, in its local space. */
+    targetOffset?: Vector3Like;
+    /** Target radius used when composing its visible edge. Ignored when `size` is set. */
+    radius?: number;
+    /** Target dimensions used when composing its visible edges. Measured automatically for meshes. */
+    size?: Vector3Like;
+};
+/** Rotates the camera to place an `Object3D`, ref or fixed point at `screenPosition`. */
+export declare class RotationComposerAimThree extends RotationComposerAim<Target> {
+    targetSlot: TargetSlot | null;
+    radius?: number;
+    size?: Vector3Like;
+    private readonly pose;
+    private forceSizeRecalculation;
+    constructor(target: Target, { targetOffset, radius, size, ...options }?: RotationComposerThreeOptions);
+    /** Forces the auto-detected `size` to be re-measured on the next `update()`, then goes back to the cached value. */
+    recalculateSize(): void;
+    protected readTarget(): TargetPose | null;
+}

package/dist/three/aim/RotationComposerAimThree.js

@@ -0,0 +1,35 @@
+import { create } from "../../core/TargetPose.js";
+import { needsExtent } from "../../core/aim/rotationComposer.js";
+import { RotationComposerAim } from "../../core/aim/RotationComposerAim.js";
+import { optionalVec3 } from "../resolve/resolveVector3.js";
+import { readTargetExtent } from "../readTargetExtent.js";
+import { readTargetPose } from "../readTargetPose.js";
+//#region src/three/aim/RotationComposerAimThree.ts
+/** Rotates the camera to place an `Object3D`, ref or fixed point at `screenPosition`. */
+var RotationComposerAimThree = class extends RotationComposerAim {
+	targetSlot = null;
+	radius;
+	size;
+	pose = create();
+	forceSizeRecalculation = false;
+	constructor(target, { targetOffset, radius, size, ...options } = {}) {
+		super(target, {
+			...options,
+			targetOffset: optionalVec3(targetOffset)
+		});
+		this.radius = radius;
+		this.size = size;
+	}
+	/** Forces the auto-detected `size` to be re-measured on the next `update()`, then goes back to the cached value. */
+	recalculateSize() {
+		this.forceSizeRecalculation = true;
+	}
+	readTarget() {
+		if (!readTargetPose(this.pose, this.target, this.targetSlot, true)) return null;
+		if (needsExtent(this)) readTargetExtent(this.pose.extent, this.target, this.size, this.radius, this.forceSizeRecalculation, this.targetSlot);
+		this.forceSizeRecalculation = false;
+		return this.pose;
+	}
+};
+//#endregion
+export { RotationComposerAimThree };

package/dist/three/body/CameraControlsBodyThree.d.ts

@@ -0,0 +1,30 @@
+import * as THREE from 'three';
+import CameraControls from 'camera-controls';
+import type { CameraState } from '../../core/CameraState.js';
+import { type Vector3Like } from '../resolve/resolveVector3.js';
+import { type Target } from '../resolve/Target.js';
+import type { TargetSlot } from '../resolve/TargetRegistry.js';
+export type CameraControlsOptions = {
+    /** Viewport width divided by height. */
+    aspect?: number;
+    /** Where the camera starts. */
+    initialPosition?: Vector3Like | null;
+    /** A `CameraControls` subclass to use instead. */
+    impl?: typeof CameraControls;
+    /** Animate the internal `camera-controls` calls. */
+    enableTransition?: boolean;
+};
+/** Adapts `camera-controls` orbit and dolly input to the virtual camera pipeline. */
+export declare class CameraControlsBodyThree {
+    target: Target;
+    targetSlot: TargetSlot | null;
+    aspect: number;
+    enableTransition: boolean;
+    readonly controls: CameraControls;
+    readonly initialPosition: THREE.Vector3 | null;
+    private readonly camera;
+    private hasResolvedTargetOnce;
+    private wasResolvedLastFrame;
+    constructor(target: Target, options?: CameraControlsOptions);
+    update: (out: CameraState, dt: number, justActivated: boolean) => void;
+}

package/dist/three/body/CameraControlsBodyThree.js

@@ -0,0 +1,54 @@
+import { resolveVector3 } from "../resolve/resolveVector3.js";
+import { resolveTargetPosition } from "../resolve/Target.js";
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+//#region src/three/body/CameraControlsBodyThree.ts
+CameraControls.install({ THREE });
+var scratchTargetPosition = new THREE.Vector3();
+/** Adapts `camera-controls` orbit and dolly input to the virtual camera pipeline. */
+var CameraControlsBodyThree = class {
+	target;
+	targetSlot = null;
+	aspect;
+	enableTransition;
+	controls;
+	initialPosition;
+	camera;
+	hasResolvedTargetOnce = false;
+	wasResolvedLastFrame = false;
+	constructor(target, options) {
+		this.target = target;
+		this.aspect = options?.aspect ?? 1;
+		this.enableTransition = options?.enableTransition ?? false;
+		this.camera = new THREE.PerspectiveCamera();
+		this.controls = new ((options?.impl) ?? CameraControls)(this.camera);
+		this.initialPosition = options?.initialPosition != null ? resolveVector3(new THREE.Vector3(), options.initialPosition) : null;
+		if (this.initialPosition) {
+			const { x, y, z } = this.initialPosition;
+			this.controls.setPosition(x, y, z, false);
+		}
+	}
+	update = (out, dt, justActivated) => {
+		this.camera.fov = out.fov;
+		this.camera.near = out.near;
+		this.camera.far = out.far;
+		this.camera.aspect = this.aspect;
+		this.camera.updateProjectionMatrix();
+		const resolved = resolveTargetPosition(scratchTargetPosition, this.target, this.targetSlot);
+		if (resolved && (!this.wasResolvedLastFrame || justActivated)) this.controls.normalizeRotations().setTarget(scratchTargetPosition.x, scratchTargetPosition.y, scratchTargetPosition.z, this.enableTransition);
+		else if (resolved) this.controls.moveTo(scratchTargetPosition.x, scratchTargetPosition.y, scratchTargetPosition.z, this.enableTransition);
+		if (resolved) this.hasResolvedTargetOnce = true;
+		this.wasResolvedLastFrame = resolved;
+		this.controls.update(dt);
+		if (this.target == null || resolved || this.hasResolvedTargetOnce || this.initialPosition !== null) {
+			this.camera.position.toArray(out.position);
+			this.camera.quaternion.toArray(out.quaternion);
+		}
+		out.hasTarget = resolved;
+		if (resolved) scratchTargetPosition.toArray(out.target);
+		out.hasLookAtTarget = resolved;
+		if (resolved) scratchTargetPosition.toArray(out.lookAtTarget);
+	};
+};
+//#endregion
+export { CameraControlsBodyThree };

package/dist/three/body/FollowBodyThree.d.ts

@@ -0,0 +1,16 @@
+import { FollowBody, type FollowOptions as FollowCoreOptions } from '../../core/body/FollowBody.js';
+import type { TargetPose } from '../../core/TargetPose.js';
+import { type Vector3Like } from '../resolve/resolveVector3.js';
+import type { Target } from '../resolve/Target.js';
+import type { TargetSlot } from '../resolve/TargetRegistry.js';
+export type FollowThreeOptions = Omit<FollowCoreOptions, 'offset'> & {
+    /** Offset from the target, rotated according to `bindingMode`. */
+    offset?: Vector3Like;
+};
+/** Follows an `Object3D`, ref or fixed point with an offset rotated according to `bindingMode`. */
+export declare class FollowBodyThree extends FollowBody<Target> {
+    targetSlot: TargetSlot | null;
+    private readonly pose;
+    constructor(target: Target, { offset, ...options }?: FollowThreeOptions);
+    protected readTarget(): TargetPose | null;
+}

package/dist/three/body/FollowBodyThree.js

@@ -0,0 +1,23 @@
+import { create } from "../../core/TargetPose.js";
+import { needsTargetRotation } from "../../core/body/follow.js";
+import { FollowBody } from "../../core/body/FollowBody.js";
+import { optionalVec3 } from "../resolve/resolveVector3.js";
+import { readTargetPose } from "../readTargetPose.js";
+//#region src/three/body/FollowBodyThree.ts
+/** Follows an `Object3D`, ref or fixed point with an offset rotated according to `bindingMode`. */
+var FollowBodyThree = class extends FollowBody {
+	targetSlot = null;
+	pose = create();
+	constructor(target, { offset, ...options } = {}) {
+		super(target, {
+			...options,
+			offset: optionalVec3(offset)
+		});
+	}
+	readTarget() {
+		const withRotation = needsTargetRotation(this.state, this);
+		return readTargetPose(this.pose, this.target, this.targetSlot, withRotation) ? this.pose : null;
+	}
+};
+//#endregion
+export { FollowBodyThree };

package/dist/three/body/HardLockToTargetBodyThree.d.ts

@@ -0,0 +1,11 @@
+import { HardLockToTargetBody, type HardLockToTargetOptions } from '../../core/body/HardLockToTargetBody.js';
+import type { TargetPose } from '../../core/TargetPose.js';
+import type { Target } from '../resolve/Target.js';
+import type { TargetSlot } from '../resolve/TargetRegistry.js';
+export type { HardLockToTargetOptions };
+/** Locks the camera position to an `Object3D`, ref or fixed point, optionally with damping. */
+export declare class HardLockToTargetBodyThree extends HardLockToTargetBody<Target> {
+    targetSlot: TargetSlot | null;
+    private readonly pose;
+    protected readTarget(): TargetPose | null;
+}

package/dist/three/body/HardLockToTargetBodyThree.js

@@ -0,0 +1,14 @@
+import { create } from "../../core/TargetPose.js";
+import { HardLockToTargetBody } from "../../core/body/HardLockToTargetBody.js";
+import { readTargetPose } from "../readTargetPose.js";
+//#region src/three/body/HardLockToTargetBodyThree.ts
+/** Locks the camera position to an `Object3D`, ref or fixed point, optionally with damping. */
+var HardLockToTargetBodyThree = class extends HardLockToTargetBody {
+	targetSlot = null;
+	pose = create();
+	readTarget() {
+		return readTargetPose(this.pose, this.target, this.targetSlot, false) ? this.pose : null;
+	}
+};
+//#endregion
+export { HardLockToTargetBodyThree };

package/dist/three/body/OrbitFollowBodyThree.d.ts

@@ -0,0 +1,16 @@
+import { OrbitFollowBody, type OrbitFollowOptions } from '../../core/body/OrbitFollowBody.js';
+import type { TargetPose } from '../../core/TargetPose.js';
+import { type Vector3Like } from '../resolve/resolveVector3.js';
+import type { Target } from '../resolve/Target.js';
+import type { TargetSlot } from '../resolve/TargetRegistry.js';
+export type OrbitFollowThreeOptions = Omit<OrbitFollowOptions, 'targetOffset'> & {
+    /** Center of the orbit relative to the target, rotated according to `bindingMode`. */
+    targetOffset?: Vector3Like;
+};
+/** Orbits an `Object3D`, ref or fixed point, driven by `horizontal`, `vertical` and `radial`. */
+export declare class OrbitFollowBodyThree extends OrbitFollowBody<Target> {
+    targetSlot: TargetSlot | null;
+    private readonly pose;
+    constructor(target: Target, { targetOffset, ...options }?: OrbitFollowThreeOptions);
+    protected readTarget(): TargetPose | null;
+}

package/dist/three/body/OrbitFollowBodyThree.js

@@ -0,0 +1,23 @@
+import { create } from "../../core/TargetPose.js";
+import { needsTargetRotation } from "../../core/body/orbitFollow.js";
+import { OrbitFollowBody } from "../../core/body/OrbitFollowBody.js";
+import { optionalVec3 } from "../resolve/resolveVector3.js";
+import { readTargetPose } from "../readTargetPose.js";
+//#region src/three/body/OrbitFollowBodyThree.ts
+/** Orbits an `Object3D`, ref or fixed point, driven by `horizontal`, `vertical` and `radial`. */
+var OrbitFollowBodyThree = class extends OrbitFollowBody {
+	targetSlot = null;
+	pose = create();
+	constructor(target, { targetOffset, ...options } = {}) {
+		super(target, {
+			...options,
+			targetOffset: optionalVec3(targetOffset)
+		});
+	}
+	readTarget() {
+		const withRotation = needsTargetRotation(this.state, this);
+		return readTargetPose(this.pose, this.target, this.targetSlot, withRotation) ? this.pose : null;
+	}
+};
+//#endregion
+export { OrbitFollowBodyThree };

package/dist/three/body/OrbitFollowHelperThree.d.ts

@@ -0,0 +1,23 @@
+import { BufferGeometry, Color, LineBasicMaterial, LineSegments } from 'three';
+import type { OrbitFollowBody } from '../../core/body/OrbitFollowBody.js';
+/**
+ * Draws an `OrbitFollowBody`'s orbit around its tracked point: the circle the camera moves along with `horizontal`,
+ * the arc it moves along with `vertical`, and for `threeRing` also the three rings.
+ */
+export declare class OrbitFollowHelperThree extends LineSegments<BufferGeometry, LineBasicMaterial> {
+    readonly colors: {
+        horizontal: Color;
+        vertical: Color;
+        rings: Color;
+    };
+    private readonly positions;
+    private readonly vertexColors;
+    private vertexCount;
+    constructor();
+    /** Redraws the orbit from `body`'s last update. */
+    sync(body: OrbitFollowBody<unknown>): void;
+    dispose(): void;
+    private circle;
+    /** Adds the segment from `previous` to `next`, then moves `previous` to `next`. */
+    private segment;
+}

package/dist/three/body/OrbitFollowHelperThree.js

@@ -0,0 +1,85 @@
+import { point } from "../../core/body/orbitFollow.js";
+import { BufferAttribute, BufferGeometry, Color, LineBasicMaterial, LineSegments } from "three";
+//#region src/three/body/OrbitFollowHelperThree.ts
+var circleSegments = 64;
+var arcSegments = 32;
+var maxVertices = 576;
+var defaultRange = [-90, 90];
+var previous = [
+	0,
+	0,
+	0
+];
+var next = [
+	0,
+	0,
+	0
+];
+/**
+* Draws an `OrbitFollowBody`'s orbit around its tracked point: the circle the camera moves along with `horizontal`,
+* the arc it moves along with `vertical`, and for `threeRing` also the three rings.
+*/
+var OrbitFollowHelperThree = class extends LineSegments {
+	colors = {
+		horizontal: new Color("#ff9f1c"),
+		vertical: new Color("#2ec4f1"),
+		rings: new Color("#9a9aa8")
+	};
+	positions = new Float32Array(maxVertices * 3);
+	vertexColors = new Float32Array(maxVertices * 3);
+	vertexCount = 0;
+	constructor() {
+		super(new BufferGeometry(), new LineBasicMaterial({
+			vertexColors: true,
+			toneMapped: false
+		}));
+		this.geometry.setAttribute("position", new BufferAttribute(this.positions, 3));
+		this.geometry.setAttribute("color", new BufferAttribute(this.vertexColors, 3));
+		this.frustumCulled = false;
+	}
+	/** Redraws the orbit from `body`'s last update. */
+	sync(body) {
+		const { horizontal, vertical } = body.state;
+		const [min, max] = vertical.range ?? defaultRange;
+		this.vertexCount = 0;
+		if (body.orbitStyle === "threeRing") {
+			this.circle(body, min, this.colors.rings);
+			this.circle(body, (min + max) / 2, this.colors.rings);
+			this.circle(body, max, this.colors.rings);
+		}
+		this.circle(body, vertical.value, this.colors.horizontal);
+		point(previous, body.state, body, horizontal.value, min);
+		for (let i = 1; i <= arcSegments; i++) {
+			point(next, body.state, body, horizontal.value, min + (max - min) * i / arcSegments);
+			this.segment(this.colors.vertical);
+		}
+		this.geometry.getAttribute("position").needsUpdate = true;
+		this.geometry.getAttribute("color").needsUpdate = true;
+		this.geometry.setDrawRange(0, this.vertexCount);
+	}
+	dispose() {
+		this.geometry.dispose();
+		this.material.dispose();
+	}
+	circle(body, vertical, color) {
+		point(previous, body.state, body, 0, vertical);
+		for (let i = 1; i <= circleSegments; i++) {
+			point(next, body.state, body, 360 * i / circleSegments, vertical);
+			this.segment(color);
+		}
+	}
+	/** Adds the segment from `previous` to `next`, then moves `previous` to `next`. */
+	segment(color) {
+		const offset = this.vertexCount * 3;
+		this.positions.set(previous, offset);
+		this.positions.set(next, offset + 3);
+		color.toArray(this.vertexColors, offset);
+		color.toArray(this.vertexColors, offset + 3);
+		this.vertexCount += 2;
+		previous[0] = next[0];
+		previous[1] = next[1];
+		previous[2] = next[2];
+	}
+};
+//#endregion
+export { OrbitFollowHelperThree };

package/dist/three/body/PositionComposerBodyThree.d.ts

@@ -0,0 +1,24 @@
+import type { PositionComposerParams } from '../../core/body/positionComposer.js';
+import { PositionComposerBody } from '../../core/body/PositionComposerBody.js';
+import type { TargetPose } from '../../core/TargetPose.js';
+import type { Vector3Like } from '../resolve/resolveVector3.js';
+import type { Target } from '../resolve/Target.js';
+import type { TargetSlot } from '../resolve/TargetRegistry.js';
+export type PositionComposerThreeOptions = Partial<PositionComposerParams> & {
+    /** Target radius used when composing its visible edge. Ignored when `size` is set. */
+    radius?: number;
+    /** Target dimensions used when composing its visible edges. Measured automatically for meshes. */
+    size?: Vector3Like;
+};
+/** Positions the camera around an `Object3D`, ref or fixed point, measuring its size from geometry. */
+export declare class PositionComposerBodyThree extends PositionComposerBody<Target> {
+    targetSlot: TargetSlot | null;
+    radius?: number;
+    size?: Vector3Like;
+    private readonly pose;
+    private forceSizeRecalculation;
+    constructor(target: Target, options?: PositionComposerThreeOptions);
+    /** Forces the auto-detected `size` to be re-measured on the next `update()`, then goes back to the cached value. */
+    recalculateSize(): void;
+    protected readTarget(): TargetPose | null;
+}

package/dist/three/body/PositionComposerBodyThree.js

@@ -0,0 +1,31 @@
+import { create } from "../../core/TargetPose.js";
+import { needsExtent } from "../../core/body/positionComposer.js";
+import { PositionComposerBody } from "../../core/body/PositionComposerBody.js";
+import { readTargetExtent } from "../readTargetExtent.js";
+import { readTargetPose } from "../readTargetPose.js";
+//#region src/three/body/PositionComposerBodyThree.ts
+/** Positions the camera around an `Object3D`, ref or fixed point, measuring its size from geometry. */
+var PositionComposerBodyThree = class extends PositionComposerBody {
+	targetSlot = null;
+	radius;
+	size;
+	pose = create();
+	forceSizeRecalculation = false;
+	constructor(target, options) {
+		super(target, options);
+		this.radius = options?.radius;
+		this.size = options?.size;
+	}
+	/** Forces the auto-detected `size` to be re-measured on the next `update()`, then goes back to the cached value. */
+	recalculateSize() {
+		this.forceSizeRecalculation = true;
+	}
+	readTarget() {
+		if (!readTargetPose(this.pose, this.target, this.targetSlot, false)) return null;
+		if (needsExtent(this)) readTargetExtent(this.pose.extent, this.target, this.size, this.radius, this.forceSizeRecalculation, this.targetSlot);
+		this.forceSizeRecalculation = false;
+		return this.pose;
+	}
+};
+//#endregion
+export { PositionComposerBodyThree };

package/dist/three/camera.d.ts

@@ -0,0 +1,10 @@
+import type { Object3D, PerspectiveCamera } from 'three';
+import type { CameraState } from '../core/CameraState.js';
+/** Read a perspective camera's transform and lens into `out`. */
+export declare function copyCameraStateFromCamera(out: CameraState, camera: PerspectiveCamera): CameraState;
+/** Write a camera state's position and rotation to a camera. */
+export declare function writeCameraTransform(camera: Object3D, state: CameraState): void;
+/** Write a camera state's lens and view offset to a perspective camera. */
+export declare function writeCameraLens(camera: PerspectiveCamera, state: CameraState, viewportWidth: number, viewportHeight: number): void;
+/** Apply a camera state to a perspective camera. */
+export declare function applyCameraState(camera: PerspectiveCamera, state: CameraState, viewportWidth: number, viewportHeight: number): void;