@tolokoban/tgd/lib/dist/camera/camera.d.ts

ToloGameDev library for WebGL2

import { TgdMat4, type TgdQuat, TgdTransfo, type TgdTransfoOptions, type TgdVec3, TgdVec4 } from "../math";
import type { ArrayNumber3, ArrayNumber4 } from "../types";
import type { TgdInterfaceTransformable } from "../interface";
export interface TgdCameraOptions {
    near?: number;
    /** Can be Infinity for perspective camera (`Number.POSITIVE_INFINITY`) */
    far?: number;
    name?: string;
    zoom?: number;
    transfo?: Partial<TgdTransfoOptions> | TgdTransfo;
}
export interface TgdCameraState {
    spaceHeightAtTarget: number;
    distance: number;
    zoom: number;
    orientation: TgdQuat;
    position: TgdVec3;
}
export declare abstract class TgdCamera implements TgdInterfaceTransformable {
    private static incrementalId;
    readonly name: string;
    readonly transfo: TgdTransfo;
    private _screenWidth;
    private _screenHeight;
    private _screenAspectRatio;
    /** Do we need recalculation? */
    private _dirtyModelView;
    private dirtyModelViewInverse;
    private _dirtyAxis;
    protected _dirtyProjection: boolean;
    protected dirtyProjectionInverse: boolean;
    protected _near: number;
    protected _far: number;
    private readonly _matrixModelView;
    private readonly _matrixProjectionInverse;
    private _zoom;
    constructor(options?: TgdCameraOptions);
    abstract clone(): TgdCamera;
    getCurrentState(): Readonly<TgdCameraState>;
    setCurrentState(state: Readonly<TgdCameraState>): void;
    get near(): number;
    set near(v: number);
    get far(): number;
    set far(v: number);
    /**
     * Size in space of a screen pixel at target.
     * Useful for scalebars (mostly in Orthographic mode).
     */
    get spacePerPixel(): number;
    get screenAspectRatio(): number;
    get screenWidth(): number;
    set screenWidth(v: number);
    get screenHeight(): number;
    set screenHeight(v: number);
    get spaceHeightAtTarget(): number;
    set spaceHeightAtTarget(v: number);
    get spaceWidthAtTarget(): number;
    set spaceWidthAtTarget(v: number);
    /**
     * Adapt the camera position so that a rectangle of `width` and `height`,
     * centered at the camera target, can be the biggest without being cut.
     * @param width width in space units.
     * @param height height in space units.
     */
    fitSpaceAtTarget(width: number, height: number, cover?: boolean): void;
    from(camera: TgdCamera): this;
    fromTransfo(transfo: Readonly<TgdTransfo>): this;
    apply(point: ArrayNumber3 | TgdVec3 | ArrayNumber4 | TgdVec4): TgdVec4;
    /**
     * Useful for LOD. If an object takes a small space on the screen,
     * we can display its low res version.
     * @returns The surface of the bounding square in screen space of a space bbox.
     * Or 0 if the bounding box is out of the frustrum.
     */
    computeBoundingBoxVisibleSurface(bbox: Readonly<{
        min: Readonly<ArrayNumber3 | TgdVec3>;
        max: Readonly<ArrayNumber3 | TgdVec3>;
    }>): number;
    /**
     * @param screenX -1 is the left edge, 0 id the center and +1 is the right edge.
     * @param screenY -1 is the bottom edge, 0 id the center and +1 is the top edge.
     * @returns The __normalized__ ray vector that goes from the camera position
     * to the point designed on the screen.
     */
    abstract castRay(screenX: number, screenY: number): Readonly<{
        origin: TgdVec3;
        direction: TgdVec3;
    }>;
    abstract copyProjectionFrom(camera: TgdCamera): this;
    /**
     * This matrix will transform a world coordinate into a camera coordinate.
     */
    get matrixModelView(): Readonly<TgdMat4>;
    abstract get matrixProjection(): Readonly<TgdMat4>;
    get matrixProjectionInverse(): Readonly<TgdMat4>;
    get zoom(): number;
    set zoom(v: number);
    toCode(caption?: string): string;
    debug(caption?: string): void;
    protected abstract getSpaceHeightAtTarget(): number;
    protected abstract setSpaceHeightAtTarget(v: number): void;
    private get dirtyModelView();
    private set dirtyModelView(value);
    protected get dirtyProjection(): boolean;
    protected set dirtyProjection(v: boolean);
}
//# sourceMappingURL=camera.d.ts.map