import { type Scene } from "../scene.js";
import { Vector3 } from "../Maths/math.vector.js";
import { type InterpolatingBehavior } from "../Behaviors/Cameras/interpolatingBehavior.js";
/**
 * Holds all logic related to converting input pixel deltas into current frame deltas, taking speed / framerate into account
 * to ensure smooth frame-rate-independent movement
 */
export declare class CameraMovement {
    protected _cameraPosition: Vector3;
    protected _behavior?: InterpolatingBehavior | undefined;
    protected _scene: Scene;
    /**
     * Should be set by input classes to indicates whether there is active input this frame
     * This helps us differentiate between 0 pixel delta due to no input vs user actively holding still
     */
    activeInput: boolean;
    /**
     * ------------ Speed ----------------
     * Speed defines the amount of camera movement expected per input pixel movement
     * -----------------------------------
     */
    /**
     * Desired coordinate unit movement per input pixel when zooming
     */
    zoomSpeed: number;
    /**
     * Desired coordinate unit movement per input pixel when panning
     */
    panSpeed: number;
    /**
     * Desired radians movement per input pixel when rotating along x axis
     */
    rotationXSpeed: number;
    /**
     * Desired radians movement per input pixel when rotating along y axis
     */
    rotationYSpeed: number;
    /**
     * ----------- Speed multipliers ---------------
     * Multipliers allow movement classes to modify the effective speed dynamically per-frame
     * (ex: scale zoom based on distance from target)
     * -----------------------------------
     */
    /**
     * Multiplied atop zoom speed. Used to dynamically adjust zoom speed based on per-frame context (ex: zoom faster when further from target)
     */
    protected _zoomSpeedMultiplier: number;
    /**
     * Multiplied atop pan speed. Used to dynamically adjust pan speed based on per-frame context (ex: pan slowly when close to target)
     */
    protected _panSpeedMultiplier: number;
    /**
     * ---------- Inertia ----------------
     * Inertia represents the decay factor per-frame applied to the velocity when there is no user input.
     * 0 = No inertia, instant stop (velocity immediately becomes 0)
     * 0.5 = Strong decay, velocity halves every frame at 60fps
     * 0.9 = Moderate inertia, velocity retains 90% per frame at 60fps
     * 0.95 = High inertia, smooth glide, velocity retains 95% per frame at 60fps
     * 1 = Infinite inertia, never stops (velocity never decays)
     * -----------------------------------
     */
    /**
     * Inertia applied to the zoom velocity when there is no user input.
     * Higher inertia === slower decay, velocity retains more of its value each frame
     */
    zoomInertia: number;
    /**
     * Inertia applied to the panning velocity when there is no user input.
     * Higher inertia === slower decay, velocity retains more of its value each frame
     */
    panInertia: number;
    /**
     * Inertia applied to the rotation velocity when there is no user input.
     * Higher inertia === slower decay, velocity retains more of its value each frame
     */
    rotationInertia: number;
    /**
     * ---------- Accumulated Pixel Deltas -----------
     * Pixel inputs accumulated throughout the frame by input classes (reset each frame after processing)
     * -----------------------------------
     */
    /**
     * Accumulated pixel delta (by input classes) for zoom this frame
     * Read by computeCurrentFrameDeltas() function and converted into zoomDeltaCurrentFrame (taking speed into account)
     * Reset to zero after each frame
     */
    zoomAccumulatedPixels: number;
    /**
     * Accumulated pixel delta (by input classes) for panning this frame
     * Read by computeCurrentFrameDeltas() function and converted into panDeltaCurrentFrame (taking speed into account)
     * Reset to zero after each frame
     */
    panAccumulatedPixels: Vector3;
    /**
     * Accumulated pixel delta (by input classes) for rotation this frame
     * Read by computeCurrentFrameDeltas() function and converted into rotationDeltaCurrentFrame (taking speed into account)
     * Reset to zero after each frame
     */
    rotationAccumulatedPixels: Vector3;
    /**
     * ---------- Current Frame Movement Deltas -----------
     * Deltas read on each frame by camera class in order to move the camera
     * -----------------------------------
     */
    /**
     * Zoom delta to apply to camera this frame, computed by computeCurrentFrameDeltas() from zoomPixelDelta (taking speed into account)
     */
    zoomDeltaCurrentFrame: number;
    /**
     * Pan delta to apply to camera this frame, computed by computeCurrentFrameDeltas() from panPixelDelta (taking speed into account)
     */
    panDeltaCurrentFrame: Vector3;
    /**
     * Rotation delta to apply to camera this frame, computed by computeCurrentFrameDeltas() from rotationPixelDelta (taking speed into account)
     */
    rotationDeltaCurrentFrame: Vector3;
    /**
     * ---------- Velocity -----------
     * Used to track velocity between frames for inertia calculation
     * -----------------------------------
     */
    /**
     * Zoom pixel velocity used for inertia calculations (pixels / ms).
     */
    protected _zoomVelocity: number;
    /**
     * Pan velocity used for inertia calculations (movement / time)
     */
    private _panVelocity;
    /**
     * Rotation velocity used for inertia calculations (movement / time)
     */
    private _rotationVelocity;
    /**
     * Used when calculating inertial decay. Default to 60fps
     */
    private _prevFrameTimeMs;
    constructor(scene: Scene, _cameraPosition: Vector3, _behavior?: InterpolatingBehavior | undefined);
    /**
     * When called, will take the accumulated pixel deltas set by input classes and convert them into current frame deltas, stored in currentFrameMovementDelta properties
     * Takes speed, scaling, inertia, and framerate into account to ensure smooth movement
     * Zeros out pixelDeltas before returning
     */
    computeCurrentFrameDeltas(): void;
    get isInterpolating(): boolean;
    private _calculateCurrentVelocity;
}