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

ToloGameDev library for WebGL2

import { TgdQuat, TgdVec3, TgdMat4, TgdTransfo, TgdTransfoOptions } from "../math";
import { 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);
    getCurrentState(): Readonly<TgdCameraState>;
    get near(): number;
    set near(v: number);
    get far(): number;
    set far(v: 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);
    from(camera: TgdCamera): this;
    fromTransfo(transfo: Readonly<TgdTransfo>): this;
    /**
     * @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);
    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