@pmndrs/klipp 0.0.0-stage → 0.14.0

package/dist/core/impulse/ImpulseListenerNoise.js

@@ -0,0 +1,29 @@
+import { createParams } from "./impulseListener.js";
+import { vec3 } from "math";
+//#region src/core/impulse/ImpulseListenerNoise.ts
+var scratchOffset = [
+	0,
+	0,
+	0
+];
+/** Applies impulse offsets and optional strength-driven Perlin shake. */
+var ImpulseListenerNoise = class {
+	shake;
+	constructor(options) {
+		Object.assign(this, createParams(options));
+		this.shake = options?.shake;
+	}
+	/** Apply the current impulse effect and report whether events remain active. */
+	update = (out, dt, justActivated, now) => {
+		const strength = this.field.sampleAt(scratchOffset, out.position, this.channelMask, this.gain, now);
+		if (this.cameraSpace) vec3.transformQuat(scratchOffset, scratchOffset, out.quaternion);
+		vec3.add(out.position, out.position, scratchOffset);
+		if (this.shake) {
+			this.shake.amplitudeGain = strength;
+			this.shake.update(out, dt, justActivated);
+		}
+		return this.field.hasEvents;
+	};
+};
+//#endregion
+export { ImpulseListenerNoise };

package/dist/core/impulse/impulseListener.d.ts

@@ -0,0 +1,13 @@
+import { type ImpulseField } from './ImpulseField.js';
+export type ImpulseListenerParams = {
+    /** Impulse field to sample. */
+    field: ImpulseField;
+    /** Only reacts to events where `(event.channel & channelMask) !== 0`. */
+    channelMask: number;
+    /** Multiplies the sampled offset. `0` mutes this listener entirely. */
+    gain: number;
+    /** Whether to apply the impulse direction in camera space. */
+    cameraSpace: boolean;
+};
+/** Every setting from `settings`, or its default. */
+export declare const createParams: (settings?: Partial<ImpulseListenerParams>) => ImpulseListenerParams;

package/dist/core/impulse/impulseListener.js

@@ -0,0 +1,14 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { withDefaults } from "../params.js";
+import { impulseField } from "./ImpulseField.js";
+//#region src/core/impulse/impulseListener.ts
+var impulseListener_exports = /* @__PURE__ */ __exportAll({ createParams: () => createParams });
+/** Every setting from `settings`, or its default. */
+var createParams = (settings) => withDefaults({
+	field: impulseField,
+	channelMask: 1,
+	gain: 1,
+	cameraSpace: false
+}, settings);
+//#endregion
+export { createParams, impulseListener_exports };

package/dist/core/impulse/impulses.d.ts

@@ -0,0 +1,54 @@
+import { type Vec3 } from 'math';
+/** Shared clock value used by impulse generation and sampling. */
+export type ImpulseClockSeconds = number;
+/** Maps normalized impulse progress to amplitude. */
+export type ImpulseShape = (t: number) => number;
+/** Built-in impulse envelope shapes. */
+export declare const ImpulseShapes: {
+    recoil: (t: number) => number;
+    bump: (t: number) => number;
+    explosion: (t: number) => number;
+    rumble: (t: number) => number;
+};
+export type GenerateImpulseOptions = {
+    /** World-space origin of the event. */
+    position: Vec3;
+    /** World-space direction and peak strength of the kick. */
+    direction?: Vec3;
+    /** The envelope's amplitude curve. */
+    shape?: ImpulseShape;
+    /** Seconds `shape` is stretched across. */
+    duration?: number;
+    /** Distance from `position` within which the event is at full strength. */
+    radius?: number;
+    /** Distance beyond `radius` over which strength falls to zero. */
+    dissipationDistance?: number;
+    /** Propagation speed in world units per second. `Infinity` means no delay. */
+    propagationSpeed?: number;
+    /** Bitmask - a listener only reacts if `(channel & listener.channelMask) !== 0`. */
+    channel?: number;
+};
+export type ImpulseEvent = {
+    position: Vec3;
+    direction: Vec3;
+    startTime: ImpulseClockSeconds;
+    shape: ImpulseShape;
+    duration: number;
+    radius: number;
+    dissipationDistance: number;
+    propagationSpeed: number;
+    channel: number;
+    expiresAt: ImpulseClockSeconds;
+};
+export type ImpulseFieldState = {
+    events: ImpulseEvent[];
+};
+export declare const createFieldState: () => ImpulseFieldState;
+/** The default impulse clock, in seconds. */
+export declare const now: () => ImpulseClockSeconds;
+/** Drop expired events in place, without allocating. */
+export declare function prune(state: ImpulseFieldState, now: ImpulseClockSeconds): void;
+/** Register a new impulse event. */
+export declare function generate(state: ImpulseFieldState, options: GenerateImpulseOptions, now: ImpulseClockSeconds): void;
+/** Write the summed offset at `samplePosition` into `outPositionOffset` and return its current strength. */
+export declare function sample(outPositionOffset: Vec3, state: ImpulseFieldState, samplePosition: Vec3, channelMask: number, gain: number, now: ImpulseClockSeconds): number;

package/dist/core/impulse/impulses.js

@@ -0,0 +1,84 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { smoothstep, vec3 } from "math";
+//#region src/core/impulse/impulses.ts
+var impulses_exports = /* @__PURE__ */ __exportAll({
+	ImpulseShapes: () => ImpulseShapes,
+	createFieldState: () => createFieldState,
+	generate: () => generate,
+	now: () => now,
+	prune: () => prune,
+	sample: () => sample
+});
+/** Built-in impulse envelope shapes. */
+var ImpulseShapes = {
+	recoil: (t) => 1 - smoothstep(0, 1, t),
+	bump: (t) => Math.min(1, t / .3) * Math.min(1, (1 - t) / .6),
+	explosion: (t) => Math.min(1, t / .1) * Math.min(1, (1 - t) / .5),
+	rumble: (t) => Math.min(1, t / .05) * Math.min(1, (1 - t) / .15)
+};
+var createFieldState = () => ({ events: [] });
+/** The default impulse clock, in seconds. */
+var now = () => performance.now() / 1e3;
+function distanceFalloff(distance, radius, dissipationDistance) {
+	if (dissipationDistance <= 0) return 1;
+	if (distance <= radius) return 1;
+	const t = (distance - radius) / dissipationDistance;
+	return t >= 1 ? 0 : 1 - t;
+}
+/** Drop expired events in place, without allocating. */
+function prune(state, now) {
+	const { events } = state;
+	let writeIndex = 0;
+	for (let readIndex = 0; readIndex < events.length; readIndex++) {
+		const event = events[readIndex];
+		if (now <= event.expiresAt) events[writeIndex++] = event;
+	}
+	events.length = writeIndex;
+}
+/** Register a new impulse event. */
+function generate(state, options, now) {
+	prune(state, now);
+	const duration = options.duration ?? .4;
+	const radius = options.radius ?? 0;
+	const dissipationDistance = options.dissipationDistance ?? 0;
+	const propagationSpeed = options.propagationSpeed ?? Infinity;
+	const maxDelay = Number.isFinite(propagationSpeed) && propagationSpeed > 0 ? (radius + dissipationDistance) / propagationSpeed : 0;
+	state.events.push({
+		position: vec3.clone(options.position),
+		direction: options.direction ? vec3.clone(options.direction) : [
+			0,
+			0,
+			0
+		],
+		startTime: now,
+		shape: options.shape ?? ImpulseShapes.bump,
+		duration,
+		radius,
+		dissipationDistance,
+		propagationSpeed,
+		channel: options.channel ?? 1,
+		expiresAt: now + duration + maxDelay
+	});
+}
+/** Write the summed offset at `samplePosition` into `outPositionOffset` and return its current strength. */
+function sample(outPositionOffset, state, samplePosition, channelMask, gain, now) {
+	vec3.set(outPositionOffset, 0, 0, 0);
+	if (state.events.length === 0) return 0;
+	prune(state, now);
+	let strength = 0;
+	for (const event of state.events) {
+		if ((event.channel & channelMask) === 0) continue;
+		const distance = vec3.distance(samplePosition, event.position);
+		const delay = Number.isFinite(event.propagationSpeed) && event.propagationSpeed > 0 ? distance / event.propagationSpeed : 0;
+		const localTime = now - event.startTime - delay;
+		const t = event.duration > 0 ? localTime / event.duration : -1;
+		if (t < 0 || t > 1) continue;
+		const amplitude = event.shape(t) * distanceFalloff(distance, event.radius, event.dissipationDistance) * gain;
+		if (amplitude <= 0) continue;
+		vec3.scaleAndAdd(outPositionOffset, outPositionOffset, event.direction, amplitude);
+		strength += amplitude;
+	}
+	return strength;
+}
+//#endregion
+export { ImpulseShapes, createFieldState, generate, impulses_exports, now, prune, sample };

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

@@ -0,0 +1,6 @@
+export { ImpulseField, impulseField } from './ImpulseField.js';
+export { ImpulseListenerNoise, type ImpulseListenerOptions } from './ImpulseListenerNoise.js';
+export * as impulseListener from './impulseListener.js';
+export type { ImpulseListenerParams } from './impulseListener.js';
+export * as impulses from './impulses.js';
+export { ImpulseShapes, type GenerateImpulseOptions, type ImpulseShape, type ImpulseEvent, type ImpulseFieldState, type ImpulseClockSeconds, } from './impulses.js';

package/dist/core/index.d.ts

@@ -0,0 +1,20 @@
+export { EventDispatcher, type DispatchedEvent, type EventListener } from './EventDispatcher.js';
+export { Klipp, type CameraTransitionEventMap, type FrameUpdate, type KlippMode, type KlippOptions, type VirtualCameraConfig, } from './Klipp.js';
+export { VirtualCamera, type CameraPiece, type CameraStateWriter, type StandbyUpdate, type VirtualCameraOptions, } from './VirtualCamera.js';
+export * as cameraState from './CameraState.js';
+export type { CameraState } from './CameraState.js';
+export * as klippState from './klippState.js';
+export type { KlippCamera, KlippEvent, KlippParams, KlippState } from './klippState.js';
+export * as targetExtent from './TargetExtent.js';
+export type { TargetExtent } from './TargetExtent.js';
+export * as targetPose from './TargetPose.js';
+export type { TargetPose } from './TargetPose.js';
+export * from './aim/index.js';
+export * from './blend/index.js';
+export * from './body/index.js';
+export * from './damping/index.js';
+export * from './debug/index.js';
+export * from './extension/index.js';
+export * from './impulse/index.js';
+export * from './input/index.js';
+export * from './noise/index.js';

package/dist/core/index.js

@@ -0,0 +1,52 @@
+import { EventDispatcher } from "./EventDispatcher.js";
+import { BlendHints, hasBlendHint } from "./blend/BlendHints.js";
+import { CameraState_exports } from "./CameraState.js";
+import { damping_exports } from "./damping/damping.js";
+import { blend_exports } from "./blend/blend.js";
+import { klippState_exports } from "./klippState.js";
+import { isInputAxisOwner } from "./input/InputAxisOwner.js";
+import { VirtualCamera } from "./VirtualCamera.js";
+import { BlendCurves } from "./blend/BlendCurves.js";
+import { DEFAULT_BLEND } from "./blend/BlendDefinition.js";
+import { Klipp } from "./Klipp.js";
+import { TargetExtent_exports } from "./TargetExtent.js";
+import { TargetPose_exports } from "./TargetPose.js";
+import { hardLookAt_exports } from "./aim/hardLookAt.js";
+import { HardLookAtAim } from "./aim/HardLookAtAim.js";
+import { rotateWithFollowTarget_exports } from "./aim/rotateWithFollowTarget.js";
+import { RotateWithFollowTargetAim } from "./aim/RotateWithFollowTargetAim.js";
+import { predictor_exports } from "./damping/predictor.js";
+import { rotationComposer_exports } from "./aim/rotationComposer.js";
+import { RotationComposerAim } from "./aim/RotationComposerAim.js";
+import { axis_exports } from "./input/axis.js";
+import { InputAxis } from "./input/InputAxis.js";
+import { panTilt_exports } from "./aim/panTilt.js";
+import { PanTiltAim } from "./aim/PanTiltAim.js";
+import { BlendDriver } from "./blend/BlendDriver.js";
+import { BindingModes } from "./body/BindingModes.js";
+import { hardLockToTarget_exports } from "./body/hardLockToTarget.js";
+import { HardLockToTargetBody } from "./body/HardLockToTargetBody.js";
+import { tracker_exports } from "./body/tracker.js";
+import { follow_exports } from "./body/follow.js";
+import { FollowBody } from "./body/FollowBody.js";
+import { threeRing_exports } from "./body/threeRing.js";
+import { orbitFollow_exports } from "./body/orbitFollow.js";
+import { OrbitFollowBody } from "./body/OrbitFollowBody.js";
+import { positionComposer_exports } from "./body/positionComposer.js";
+import { PositionComposerBody } from "./body/PositionComposerBody.js";
+import { Damper } from "./damping/Damper.js";
+import { groupFraming_exports } from "./extension/groupFraming.js";
+import { debugZones_exports } from "./debug/debugZones.js";
+import { lens_exports } from "./extension/lens.js";
+import { LensExtension } from "./extension/LensExtension.js";
+import { GroupFramingExtension } from "./extension/GroupFramingExtension.js";
+import { ImpulseShapes, impulses_exports } from "./impulse/impulses.js";
+import { ImpulseField, impulseField } from "./impulse/ImpulseField.js";
+import { impulseListener_exports } from "./impulse/impulseListener.js";
+import { ImpulseListenerNoise } from "./impulse/ImpulseListenerNoise.js";
+import { consumedInput_exports } from "./input/consumedInput.js";
+import { inputMapping_exports } from "./input/inputMapping.js";
+import { InputController } from "./input/InputController.js";
+import { perlinNoise_exports } from "./noise/perlinNoise.js";
+import { BasicMultiChannelPerlinNoise } from "./noise/BasicMultiChannelPerlinNoise.js";
+export { BasicMultiChannelPerlinNoise, BindingModes, BlendCurves, BlendDriver, BlendHints, DEFAULT_BLEND, Damper, EventDispatcher, FollowBody, GroupFramingExtension, HardLockToTargetBody, HardLookAtAim, ImpulseField, ImpulseListenerNoise, ImpulseShapes, InputAxis, InputController, Klipp, LensExtension, OrbitFollowBody, PanTiltAim, PositionComposerBody, RotateWithFollowTargetAim, RotationComposerAim, VirtualCamera, blend_exports as blend, CameraState_exports as cameraState, consumedInput_exports as consumedInput, damping_exports as damping, debugZones_exports as debugZones, follow_exports as follow, groupFraming_exports as groupFraming, hardLockToTarget_exports as hardLockToTarget, hardLookAt_exports as hardLookAt, hasBlendHint, impulseField, impulseListener_exports as impulseListener, impulses_exports as impulses, axis_exports as inputAxis, inputMapping_exports as inputMapping, isInputAxisOwner, klippState_exports as klippState, lens_exports as lens, orbitFollow_exports as orbitFollow, panTilt_exports as panTilt, perlinNoise_exports as perlinNoise, positionComposer_exports as positionComposer, predictor_exports as predictor, rotateWithFollowTarget_exports as rotateWithFollowTarget, rotationComposer_exports as rotationComposer, TargetExtent_exports as targetExtent, TargetPose_exports as targetPose, threeRing_exports as threeRing, tracker_exports as tracker };

package/dist/core/input/InputAxis.d.ts

@@ -0,0 +1,29 @@
+import * as damping from '../damping/damping.js';
+import type { DampingConstant } from '../damping/damping.js';
+import type { InputAxisData, InputAxisParams, InputAxisRecentering } from './axis.js';
+/** Shapes an input value with range, wrapping, damping, and recentering. */
+export declare class InputAxis implements InputAxisData {
+    value: number;
+    center: number;
+    range: [number, number] | null;
+    wrap: boolean;
+    recentering: InputAxisRecentering;
+    damping: DampingConstant;
+    maxSpeed: number;
+    autoNormalize: boolean;
+    held: boolean;
+    rawValue: number;
+    idleTime: number;
+    hadDelta: boolean;
+    readonly damper: damping.DamperState;
+    constructor(options?: Partial<InputAxisParams>);
+    applyDelta: (delta: number) => void;
+    /** Jump straight to `value`, without easing and without counting as input. */
+    setValue: (value: number) => void;
+    /** Advance the axis and apply damping or recentering. Returns `true` while it still has to move. */
+    update: (dt: number) => boolean;
+    /** Reset damping so the next update snaps to the raw value. */
+    reset: () => void;
+    /** Wrap `value` and `rawValue` back into `range`. */
+    normalize: () => void;
+}

package/dist/core/input/InputAxis.js

@@ -0,0 +1,28 @@
+import { createState, damp } from "../damping/damping.js";
+import { applyDelta, createParams, normalize, reset, setValue, update } from "./axis.js";
+//#region src/core/input/InputAxis.ts
+/** Shapes an input value with range, wrapping, damping, and recentering. */
+var InputAxis = class {
+	held = false;
+	rawValue;
+	idleTime = 0;
+	hadDelta = false;
+	damper = createState();
+	constructor(options) {
+		Object.assign(this, createParams(options));
+		this.rawValue = this.value;
+		this.damper.value = this.value;
+		damp(this.damper, this.value, 0, 0);
+	}
+	applyDelta = (delta) => applyDelta(this, delta);
+	/** Jump straight to `value`, without easing and without counting as input. */
+	setValue = (value) => setValue(this, value);
+	/** Advance the axis and apply damping or recentering. Returns `true` while it still has to move. */
+	update = (dt) => update(this, dt);
+	/** Reset damping so the next update snaps to the raw value. */
+	reset = () => reset(this);
+	/** Wrap `value` and `rawValue` back into `range`. */
+	normalize = () => normalize(this);
+};
+//#endregion
+export { InputAxis };

package/dist/core/input/InputAxisOwner.d.ts

@@ -0,0 +1,6 @@
+import type { InputAxisData } from './axis.js';
+/** A camera piece exposing named axes for input to drive. */
+export type InputAxisOwner = {
+    readonly inputAxes: Record<string, InputAxisData>;
+};
+export declare const isInputAxisOwner: (value: object) => value is InputAxisOwner;

package/dist/core/input/InputAxisOwner.js

@@ -0,0 +1,4 @@
+//#region src/core/input/InputAxisOwner.ts
+var isInputAxisOwner = (value) => "inputAxes" in value && typeof value.inputAxes === "object" && value.inputAxes !== null;
+//#endregion
+export { isInputAxisOwner };

package/dist/core/input/InputController.d.ts

@@ -0,0 +1,15 @@
+import type { ConsumedInput } from './consumedInput.js';
+import type { InputControllerConfig } from './inputMapping.js';
+/** Maps per-frame input onto axes. Layers override `readInput`. */
+export declare class InputController {
+    config: InputControllerConfig;
+    /** Whether input deltas are applied to the configured axes. */
+    enabled: boolean;
+    /** This frame's input. */
+    readonly input: ConsumedInput;
+    constructor(config: InputControllerConfig);
+    /** Feeds every configured source's shaped delta and hold state into its axes. */
+    update: () => void;
+    /** This frame's input, read from wherever the layer gets it. */
+    protected readInput(): ConsumedInput;
+}

package/dist/core/input/InputController.js

@@ -0,0 +1,24 @@
+import { create } from "./consumedInput.js";
+import { feedAxes } from "./inputMapping.js";
+//#region src/core/input/InputController.ts
+/** Maps per-frame input onto axes. Layers override `readInput`. */
+var InputController = class {
+	config;
+	/** Whether input deltas are applied to the configured axes. */
+	enabled = true;
+	/** This frame's input. */
+	input = create();
+	constructor(config) {
+		this.config = config;
+	}
+	/** Feeds every configured source's shaped delta and hold state into its axes. */
+	update = () => {
+		feedAxes(this.config, this.readInput(), this.enabled);
+	};
+	/** This frame's input, read from wherever the layer gets it. */
+	readInput() {
+		return this.input;
+	}
+};
+//#endregion
+export { InputController };

package/dist/core/input/axis.d.ts

@@ -0,0 +1,52 @@
+import type { DamperState, DampingConstant } from '../damping/damping.js';
+export type InputAxisRecentering = {
+    enabled: boolean;
+    /** Seconds of no delta/hold before recentering starts. */
+    wait: number;
+    /** Seconds to ease back to `center` once recentering starts. */
+    time: number;
+};
+/** An input axis's settings. */
+export type InputAxisParams = {
+    /** The current value. */
+    value: number;
+    /** The value `recentering` returns to. */
+    center: number;
+    /** `[min, max]` limits, or `null` for none. */
+    range: [number, number] | null;
+    /** Loop around at the edges of `range` instead of stopping. */
+    wrap: boolean;
+    /** Return to `center` after a while without input. */
+    recentering: InputAxisRecentering;
+    /** Response time to the input. */
+    damping: DampingConstant;
+    /** Maximum change per second. */
+    maxSpeed: number;
+    /** Whether to normalize a wrapped axis after it settles. */
+    autoNormalize: boolean;
+};
+/** Every setting from `settings`, or its default. */
+export declare const createParams: (settings?: Partial<InputAxisParams>) => InputAxisParams;
+/** An input axis as plain data: settings plus the state the functions below advance. */
+export type InputAxisData = InputAxisParams & {
+    /** Whether the input source is currently held. */
+    held: boolean;
+    /** Target the value eases toward. Internal. */
+    rawValue: number;
+    /** Seconds without input. Internal. */
+    idleTime: number;
+    /** Whether a delta arrived since the last update. Internal. */
+    hadDelta: boolean;
+    /** Internal. */
+    damper: DamperState;
+};
+/** Add an input delta to the axis target. */
+export declare function applyDelta(axis: InputAxisData, delta: number): void;
+/** Jump straight to `value`, without easing and without counting as input. */
+export declare function setValue(axis: InputAxisData, value: number): void;
+/** Wrap `value` and `rawValue` back into `range`. */
+export declare function normalize(axis: InputAxisData): void;
+/** Advance the axis and apply damping or recentering. Returns `true` while it still has to move. */
+export declare function update(axis: InputAxisData, dt: number): boolean;
+/** Reset damping so the next update snaps to the raw value. */
+export declare function reset(axis: InputAxisData): void;

package/dist/core/input/axis.js

@@ -0,0 +1,89 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { damp, reset as reset$1 } from "../damping/damping.js";
+import { withDefaults } from "../params.js";
+import { shortestWrappedDelta } from "./shortestWrappedDelta.js";
+import { clamp, repeat } from "math";
+//#region src/core/input/axis.ts
+var axis_exports = /* @__PURE__ */ __exportAll({
+	applyDelta: () => applyDelta,
+	createParams: () => createParams,
+	normalize: () => normalize,
+	reset: () => reset,
+	setValue: () => setValue,
+	update: () => update
+});
+/** Every setting from `settings`, or its default. */
+var createParams = (settings) => withDefaults({
+	value: 0,
+	center: 0,
+	range: null,
+	wrap: false,
+	recentering: {
+		enabled: false,
+		wait: 1,
+		time: 1
+	},
+	damping: 0,
+	maxSpeed: Infinity,
+	autoNormalize: false
+}, settings);
+var clampToRange = (axis, value) => axis.range ? clamp(value, axis.range[0], axis.range[1]) : value;
+/** Add an input delta to the axis target. */
+function applyDelta(axis, delta) {
+	if (delta === 0) return;
+	axis.rawValue = axis.wrap ? axis.rawValue + delta : clampToRange(axis, axis.rawValue + delta);
+	axis.idleTime = 0;
+	axis.hadDelta = true;
+}
+/** Jump straight to `value`, without easing and without counting as input. */
+function setValue(axis, value) {
+	const next = axis.wrap ? value : clampToRange(axis, value);
+	axis.value = next;
+	axis.rawValue = next;
+	axis.damper.velocity = 0;
+	axis.damper.previousDistance = 0;
+}
+/** Wrap `value` and `rawValue` back into `range`. */
+function normalize(axis) {
+	if (!axis.wrap || !axis.range) return;
+	const [min, max] = axis.range;
+	const span = max - min;
+	axis.value = min + repeat(axis.value - min, span);
+	axis.rawValue = min + repeat(axis.rawValue - min, span);
+}
+/** Whether the axis still has to move: easing toward its target, or a recentering yet to finish. */
+function isMoving(axis) {
+	if (axis.value !== axis.rawValue) return true;
+	if (axis.held || !axis.recentering.enabled) return false;
+	const offCenter = axis.wrap && axis.range ? shortestWrappedDelta(axis.value, axis.center, axis.range) : axis.center - axis.value;
+	return Math.abs(offCenter) > 1e-9;
+}
+/** Advance the axis and apply damping or recentering. Returns `true` while it still has to move. */
+function update(axis, dt) {
+	const active = axis.held || axis.hadDelta;
+	axis.hadDelta = false;
+	if (active) axis.idleTime = 0;
+	else axis.idleTime += dt;
+	const isRecentering = !active && axis.recentering.enabled && axis.idleTime >= axis.recentering.wait;
+	let dampTarget;
+	let dampTime;
+	if (isRecentering) {
+		dampTarget = axis.wrap && axis.range ? axis.value + shortestWrappedDelta(axis.value, axis.center, axis.range) : axis.center;
+		dampTime = axis.recentering.time;
+	} else {
+		dampTarget = axis.rawValue;
+		dampTime = axis.damping;
+	}
+	axis.damper.value = axis.value;
+	const eased = damp(axis.damper, dampTarget, dampTime, dt, axis.maxSpeed).value;
+	axis.value = axis.wrap ? eased : clampToRange(axis, eased);
+	if (isRecentering) axis.rawValue = axis.value;
+	if (axis.autoNormalize && axis.value === axis.rawValue) normalize(axis);
+	return isMoving(axis);
+}
+/** Reset damping so the next update snaps to the raw value. */
+function reset(axis) {
+	reset$1(axis.damper);
+}
+//#endregion
+export { applyDelta, axis_exports, createParams, normalize, reset, setValue, update };

package/dist/core/input/consumedInput.d.ts

@@ -0,0 +1,37 @@
+/** Input gathered since the last frame, as plain numbers. */
+export type ConsumedInput = {
+    leftDx: number;
+    leftDy: number;
+    middleDx: number;
+    middleDy: number;
+    rightDx: number;
+    rightDy: number;
+    /** Single-finger touch movement. */
+    touchOneDx: number;
+    touchOneDy: number;
+    /** Two-finger centroid movement. */
+    touchTwoDx: number;
+    touchTwoDy: number;
+    /** Three-finger centroid movement. */
+    touchThreeDx: number;
+    touchThreeDy: number;
+    /** Two-finger twist in radians. */
+    touchRotateDelta: number;
+    /** Pinch with two fingers or on a trackpad, as the change in `ln(scale)`. Spreading is positive. */
+    pinchDelta: number;
+    /** Wheel scrolling in pixels, as the browser reports it: right and down are positive. */
+    wheelDeltaX: number;
+    wheelDeltaY: number;
+    /** Raw mouse movement while Pointer Lock is active and no button is held. */
+    lockedDx: number;
+    lockedDy: number;
+    /** Current hold state for the source. */
+    leftHeld: boolean;
+    middleHeld: boolean;
+    rightHeld: boolean;
+    touchOneHeld: boolean;
+    touchTwoHeld: boolean;
+    touchThreeHeld: boolean;
+};
+/** Reusable zero-valued input buffer. */
+export declare function create(): ConsumedInput;

package/dist/core/input/consumedInput.js

@@ -0,0 +1,34 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+//#region src/core/input/consumedInput.ts
+var consumedInput_exports = /* @__PURE__ */ __exportAll({ create: () => create });
+/** Reusable zero-valued input buffer. */
+function create() {
+	return {
+		leftDx: 0,
+		leftDy: 0,
+		middleDx: 0,
+		middleDy: 0,
+		rightDx: 0,
+		rightDy: 0,
+		touchOneDx: 0,
+		touchOneDy: 0,
+		touchTwoDx: 0,
+		touchTwoDy: 0,
+		touchThreeDx: 0,
+		touchThreeDy: 0,
+		touchRotateDelta: 0,
+		pinchDelta: 0,
+		wheelDeltaX: 0,
+		wheelDeltaY: 0,
+		lockedDx: 0,
+		lockedDy: 0,
+		leftHeld: false,
+		middleHeld: false,
+		rightHeld: false,
+		touchOneHeld: false,
+		touchTwoHeld: false,
+		touchThreeHeld: false
+	};
+}
+//#endregion
+export { consumedInput_exports, create };

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

@@ -0,0 +1,9 @@
+export { InputAxis } from './InputAxis.js';
+export { isInputAxisOwner, type InputAxisOwner } from './InputAxisOwner.js';
+export * as inputAxis from './axis.js';
+export type { InputAxisData, InputAxisParams, InputAxisRecentering } from './axis.js';
+export * as consumedInput from './consumedInput.js';
+export type { ConsumedInput } from './consumedInput.js';
+export { InputController } from './InputController.js';
+export * as inputMapping from './inputMapping.js';
+export type { InputAxisMapping, InputAxisPair, InputControllerConfig, InputInvert, InputSourceMapping, } from './inputMapping.js';