@openglobus/og 0.24.2 → 0.25.0

package/lib/js/astro/orbit.js

@@ -1,104 +0,0 @@
-import * as math from "../math";
-import { Mat3 } from "../math/Mat3";
-export function getEccentricAnomaly(M, ecc) {
-    if (ecc === 0.0) {
-        // Circular orbit
-        return M;
-    }
-    else if (ecc < 0.2) {
-        // Low eccentricity, so use the standard iteration technique
-        return math.solve_iteration_fixed(solveKeplerFunc1(ecc, M), M, 5);
-    }
-    else if (ecc < 0.9) {
-        // Higher eccentricity elliptical orbit; use a more complex but
-        // much faster converging iteration.
-        return math.solve_iteration_fixed(solveKeplerFunc2(ecc, M), M, 6);
-    }
-    else if (ecc < 1.0) {
-        // Extremely stable Laguerre-Conway method for solving Kepler's
-        // equation.  Only use this for high-eccentricity orbits, as it
-        // requires more calculation.
-        let E = M + 0.85 * ecc * Math.sign(Math.sin(M));
-        return math.solve_iteration_fixed(solveKeplerLaguerreConway(ecc, M), E, 8);
-    }
-    else if (ecc === 1.0) {
-        // TODO: Parabolic orbit
-        return M;
-    }
-    else {
-        // Laguerre-Conway method for hyperbolic (ecc > 1) orbits.
-        let E = Math.log((2 * M) / ecc + 1.85);
-        return math.solve_iteration_fixed(solveKeplerLaguerreConwayHyp(ecc, M), E, 30);
-    }
-}
-// Standard iteration for solving Kepler's Equation
-function solveKeplerFunc1(ecc, M) {
-    return function (x) {
-        return M + ecc * Math.sin(x);
-    };
-}
-// Faster converging iteration for Kepler's Equation; more efficient
-// than above for orbits with eccentricities greater than 0.3.  This
-// is from Jean Meeus's _Astronomical Algorithms_ (2nd ed), p. 199
-function solveKeplerFunc2(ecc, M) {
-    return function (x) {
-        return x + (M + ecc * Math.sin(x) - x) / (1 - ecc * Math.cos(x));
-    };
-}
-function solveKeplerLaguerreConway(ecc, M) {
-    return function (x) {
-        const s = ecc * Math.sin(x);
-        const c = ecc * Math.cos(x);
-        const f = x - s - M;
-        const f1 = 1 - c;
-        x += (-5 * f) / (f1 + Math.sign(f1) * Math.sqrt(Math.abs(16 * f1 * f1 - 20 * f * s)));
-        return x;
-    };
-}
-function solveKeplerLaguerreConwayHyp(ecc, M) {
-    return function (x) {
-        const s = ecc * Math.sinh(x);
-        const c = ecc * Math.cosh(x);
-        const f = s - x - M;
-        const f1 = c - 1;
-        x += (-5 * f) / (f1 + Math.sign(f1) * Math.sqrt(Math.abs(16 * f1 * f1 - 20 * f * s)));
-        return x;
-    };
-}
-export function getEllipticalEccentricAnomaly(meanAnomaly, eccentricity) {
-    const tol = 0.00000001745;
-    let iterations = 20;
-    let e = meanAnomaly - 2.0 * Math.PI * ((meanAnomaly / (2.0 * Math.PI)) | 0);
-    let err = 1;
-    while (Math.abs(err) > tol && iterations > 0) {
-        err = e - eccentricity * Math.sin(e) - meanAnomaly;
-        let delta = err / (1 - eccentricity * Math.cos(e));
-        e -= delta;
-        iterations--;
-    }
-    return e;
-}
-export function getTrueAnomaly(eccentricAnomaly, eccentricity) {
-    const revs = Math.floor(eccentricAnomaly / math.TWO_PI);
-    eccentricAnomaly -= revs * math.TWO_PI;
-    let trueAnomaly = Math.atan2(Math.sin(eccentricAnomaly) * Math.sqrt(1 - eccentricity * eccentricity), Math.cos(eccentricAnomaly) - eccentricity);
-    trueAnomaly = math.zeroTwoPI(trueAnomaly);
-    if (eccentricAnomaly < 0) {
-        trueAnomaly -= math.TWO_PI;
-    }
-    return trueAnomaly + revs * math.TWO_PI;
-}
-export function getPerifocalToCartesianMatrix(argumentOfPeriapsis, inclination, rightAscension) {
-    let res = new Mat3();
-    let cosap = Math.cos(argumentOfPeriapsis), sinap = Math.sin(argumentOfPeriapsis), cosi = Math.cos(inclination), sini = Math.sin(inclination), cosraan = Math.cos(rightAscension), sinraan = Math.sin(rightAscension);
-    res._m[0] = cosraan * cosap - sinraan * sinap * cosi;
-    res._m[1] = sinraan * cosap + cosraan * sinap * cosi;
-    res._m[2] = sinap * sini;
-    res._m[3] = -cosraan * sinap - sinraan * cosap * cosi;
-    res._m[4] = -sinraan * sinap + cosraan * cosap * cosi;
-    res._m[5] = cosap * sini;
-    res._m[6] = sinraan * sini;
-    res._m[7] = -cosraan * sini;
-    res._m[8] = cosi;
-    return res;
-}

package/lib/js/astro/rotation.d.ts

@@ -1,2 +0,0 @@
-import { Mat3 } from "../math/Mat3";
-export declare function getRotationMatrix(rightAscension: number, declination: number, res?: Mat3): Mat3;

package/lib/js/astro/rotation.js

@@ -1,25 +0,0 @@
-import { PI_TWO } from "../math";
-import { Mat3 } from "../math/Mat3";
-import { Vec3 } from "../math/Vec3";
-export function getRotationMatrix(rightAscension, declination, res) {
-    let xAxis = new Vec3(), zAxis = new Vec3();
-    res = res || new Mat3();
-    xAxis.x = Math.cos(rightAscension + PI_TWO);
-    xAxis.y = Math.sin(rightAscension + PI_TWO);
-    xAxis.z = 0.0;
-    let cosDec = Math.cos(declination);
-    zAxis.x = cosDec * Math.cos(rightAscension);
-    zAxis.y = cosDec * Math.sin(rightAscension);
-    zAxis.z = Math.sin(declination);
-    let yAxis = zAxis.cross(xAxis);
-    res._m[0] = xAxis.x;
-    res._m[1] = yAxis.x;
-    res._m[2] = zAxis.x;
-    res._m[3] = xAxis.y;
-    res._m[4] = yAxis.y;
-    res._m[5] = zAxis.y;
-    res._m[6] = xAxis.z;
-    res._m[7] = yAxis.z;
-    res._m[8] = zAxis.z;
-    return res;
-}

package/lib/js/bv/Box.d.ts

@@ -1,32 +0,0 @@
-import { Vec3 } from "../math/Vec3";
-import type { NumberArray6 } from "./Sphere";
-import { Ellipsoid } from "../ellipsoid/Ellipsoid";
-import { Extent } from "../Extent";
-type Vec3Array8 = [Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3];
-/**
- * Bounding box class.
- * @class
- * @param {NumberArray6} [boundsArr]
- */
-declare class Box {
-    /**
-     * Vertices array.
-     * @public
-     * @type{Array.<Vec3>}
-     */
-    vertices: Vec3Array8;
-    constructor(boundsArr?: NumberArray6);
-    copy(bbox: Box): void;
-    /**
-     * Sets bounding box coordinates by the bounds array.
-     * @param {NumberArray6} bounds - Bounds is an array where [minX, minY, minZ, maxX, maxY, maxZ]
-     */
-    setFromBoundsArr(bounds: NumberArray6): void;
-    /**
-     * Sets bounding box coordinates by ellipsoid geodetic extend.
-     * @param {Ellipsoid} ellipsoid - Ellipsoid.
-     * @param {Extent} extent - Geodetic extent.
-     */
-    setFromExtent(ellipsoid: Ellipsoid, extent: Extent): void;
-}
-export { Box };

package/lib/js/bv/Box.js

@@ -1,53 +0,0 @@
-import { Vec3 } from "../math/Vec3";
-/**
- * Bounding box class.
- * @class
- * @param {NumberArray6} [boundsArr]
- */
-class Box {
-    constructor(boundsArr) {
-        this.vertices = [
-            new Vec3(),
-            new Vec3(),
-            new Vec3(),
-            new Vec3(),
-            new Vec3(),
-            new Vec3(),
-            new Vec3(),
-            new Vec3()
-        ];
-        if (boundsArr) {
-            this.setFromBoundsArr(boundsArr);
-        }
-    }
-    copy(bbox) {
-        for (let i = 0, len = this.vertices.length; i < len; i++) {
-            this.vertices[i].copy(bbox.vertices[i]);
-        }
-    }
-    /**
-     * Sets bounding box coordinates by the bounds array.
-     * @param {NumberArray6} bounds - Bounds is an array where [minX, minY, minZ, maxX, maxY, maxZ]
-     */
-    setFromBoundsArr(bounds) {
-        let xmin = bounds[0], xmax = bounds[3], ymin = bounds[1], ymax = bounds[4], zmin = bounds[2], zmax = bounds[5];
-        let v = this.vertices;
-        v[0].set(xmin, ymin, zmin);
-        v[1].set(xmax, ymin, zmin);
-        v[2].set(xmax, ymin, zmax);
-        v[3].set(xmin, ymin, zmax);
-        v[4].set(xmin, ymax, zmin);
-        v[5].set(xmax, ymax, zmin);
-        v[6].set(xmax, ymax, zmax);
-        v[7].set(xmin, ymax, zmax);
-    }
-    /**
-     * Sets bounding box coordinates by ellipsoid geodetic extend.
-     * @param {Ellipsoid} ellipsoid - Ellipsoid.
-     * @param {Extent} extent - Geodetic extent.
-     */
-    setFromExtent(ellipsoid, extent) {
-        this.setFromBoundsArr(extent.getCartesianBounds(ellipsoid));
-    }
-}
-export { Box };

package/lib/js/bv/Sphere.d.ts

@@ -1,37 +0,0 @@
-import { Vec3 } from "../math/Vec3";
-import { Ellipsoid } from "../ellipsoid/Ellipsoid";
-import { Extent } from "../Extent";
-export type NumberArray6 = [number, number, number, number, number, number];
-/**
- * Bounding sphere class.
- * @class
- * @param {Number} [radius] - Bounding sphere radius.
- * @param {Vec3} [center] - Bounding sphere coordinates.
- */
-declare class Sphere {
-    /**
-     * Sphere radius.
-     * @public
-     * @type {Number}
-     */
-    radius: number;
-    /**
-     * Sphere coordinates.
-     * @public
-     * @type {Vec3}
-     */
-    center: Vec3;
-    constructor(radius?: number, center?: Vec3);
-    /**
-     * Sets bounding sphere coordinates by the bounds array.
-     * @param {Array.<number>} bounds - Bounds is an array where [minX, minY, minZ, maxX, maxY, maxZ]
-     */
-    setFromBounds(bounds: NumberArray6): void;
-    /**
-     * Sets bounding sphere coordinates by ellipsoid geodetic extend.
-     * @param {Ellipsoid} ellipsoid - Ellipsoid.
-     * @param {Extent} extent - Geodetic extent.
-     */
-    setFromExtent(ellipsoid: Ellipsoid, extent: Extent): void;
-}
-export { Sphere };

package/lib/js/bv/Sphere.js

@@ -1,31 +0,0 @@
-import { Vec3 } from "../math/Vec3";
-/**
- * Bounding sphere class.
- * @class
- * @param {Number} [radius] - Bounding sphere radius.
- * @param {Vec3} [center] - Bounding sphere coordinates.
- */
-class Sphere {
-    constructor(radius = 0, center) {
-        this.radius = radius;
-        this.center = center ? center.clone() : new Vec3();
-    }
-    /**
-     * Sets bounding sphere coordinates by the bounds array.
-     * @param {Array.<number>} bounds - Bounds is an array where [minX, minY, minZ, maxX, maxY, maxZ]
-     */
-    setFromBounds(bounds) {
-        let m = new Vec3(bounds[0], bounds[1], bounds[2]);
-        this.center.set(m.x + (bounds[3] - m.x) * 0.5, m.y + (bounds[3] - m.y) * 0.5, m.z + (bounds[5] - m.z) * 0.5);
-        this.radius = this.center.distance(m);
-    }
-    /**
-     * Sets bounding sphere coordinates by ellipsoid geodetic extend.
-     * @param {Ellipsoid} ellipsoid - Ellipsoid.
-     * @param {Extent} extent - Geodetic extent.
-     */
-    setFromExtent(ellipsoid, extent) {
-        this.setFromBounds(extent.getCartesianBounds(ellipsoid));
-    }
-}
-export { Sphere };

package/lib/js/bv/index.d.ts

@@ -1,3 +0,0 @@
-import { Box } from './Box';
-import { Sphere } from './Sphere';
-export { Box, Sphere };

package/lib/js/bv/index.js

@@ -1,3 +0,0 @@
-import { Box } from './Box';
-import { Sphere } from './Sphere';
-export { Box, Sphere };

package/lib/js/camera/Camera.d.ts

@@ -1,361 +0,0 @@
-import { type EventsHandler } from "../Events";
-import { Frustum } from "./Frustum";
-import { Mat3 } from "../math/Mat3";
-import type { NumberArray9 } from "../math/Mat3";
-import { Mat4 } from "../math/Mat4";
-import type { NumberArray16 } from "../math/Mat4";
-import { Renderer } from "../renderer/Renderer";
-import { Vec2 } from "../math/Vec2";
-import type { NumberArray2 } from "../math/Vec2";
-import { Vec3 } from "../math/Vec3";
-import { Sphere } from "../bv/Sphere";
-import { Quat } from "../math/Quat";
-type CameraEvents = ["viewchange", "moveend"];
-export interface ICameraParams {
-    eye?: Vec3;
-    aspect?: number;
-    viewAngle?: number;
-    look?: Vec3;
-    up?: Vec3;
-    frustums?: NumberArray2[];
-}
-/**
- * Camera class.
- * @class
- * @param {Renderer} [renderer] - Renderer uses the camera instance.
- * @param {Object} [options] - Camera options:
- * @param {Object} [options.name] - Camera name.
- * @param {number} [options.viewAngle=47] - Camera angle of view. Default is 47.0
- * @param {number} [options.near=1] - Camera near plane distance. Default is 1.0
- * @param {number} [options.far=og.math.MAX] - Camera far plane distance. Default is og.math.MAX
- * @param {Vec3} [options.eye=[0,0,0]] - Camera eye position. Default (0,0,0)
- * @param {Vec3} [options.look=[0,0,0]] - Camera look position. Default (0,0,0)
- * @param {Vec3} [options.up=[0,1,0]] - Camera eye position. Default (0,1,0)
- *
- * @fires EventsHandler<CameraEvents>#viewchange
- * @fires EventsHandler<CameraEvents>#moveend
- */
-declare class Camera {
-    /**
-     * Assigned renderer
-     * @public
-     * @type {Renderer}
-     */
-    renderer: Renderer | null;
-    /**
-     * Camera events handler
-     * @public
-     * @type {Events}
-     */
-    events: EventsHandler<CameraEvents>;
-    /**
-     * Camera position.
-     * @public
-     * @type {Vec3}
-     */
-    eye: Vec3;
-    /**
-     * Camera RTE high position
-     * @public
-     * @type {Float32Array}
-     */
-    eyeHigh: Float32Array;
-    /**
-     * Camera RTE low position
-     * @public
-     * @type {Float32Array}
-     */
-    eyeLow: Float32Array;
-    /**
-     * Aspect ratio.
-     * @protected
-     * @type {Number}
-     */
-    protected _aspect: number;
-    /**
-     * Camera view angle in degrees
-     * @protected
-     * @type {Number}
-     */
-    protected _viewAngle: number;
-    /**
-     * Camera view matrix.
-     * @protected
-     * @type {Mat4}
-     */
-    protected _viewMatrix: Mat4;
-    protected _viewMatrixRTE: Mat4;
-    /**
-     * Camera normal matrix.
-     * @protected
-     * @type {Mat3}
-     */
-    protected _normalMatrix: Mat3;
-    /**
-     * Camera right vector.
-     * @protected
-     * @type {Vec3}
-     */
-    _r: Vec3;
-    /**
-     * Camera up vector.
-     * @protected
-     * @type {Vec3}
-     */
-    _u: Vec3;
-    /**
-     * Camera backward vector.
-     * @protected
-     * @type {Vec3}
-     */
-    _b: Vec3;
-    /**
-     * Camera forward vector.
-     * @protected
-     * @type {Vec3}
-     */
-    _f: Vec3;
-    protected _pr: Vec3;
-    protected _pu: Vec3;
-    protected _pb: Vec3;
-    protected _peye: Vec3;
-    isMoving: boolean;
-    protected _tanViewAngle_hrad: number;
-    _tanViewAngle_hradOneByHeight: number;
-    protected _projSizeConst: number;
-    frustums: Frustum[];
-    frustumColors: number[];
-    FARTHEST_FRUSTUM_INDEX: number;
-    currentFrustumIndex: number;
-    frustumColorIndex: number;
-    isFirstPass: boolean;
-    constructor(renderer: Renderer | null, options?: ICameraParams);
-    checkMoveEnd(): void;
-    bindRenderer(renderer: Renderer): void;
-    /**
-     * Camera initialization.
-     * @public
-     * @param {Object} [options] - Camera options:
-     * @param {number} [options.viewAngle] - Camera angle of view.
-     * @param {number} [options.near] - Camera near plane distance. Default is 1.0
-     * @param {number} [options.far] - Camera far plane distance. Default is math.MAX
-     * @param {Vec3} [options.eye] - Camera eye position. Default (0,0,0)
-     * @param {Vec3} [options.look] - Camera look position. Default (0,0,0)
-     * @param {Vec3} [options.up] - Camera eye position. Default (0,1,0)
-     */
-    protected _init(options: ICameraParams): void;
-    getUp(): Vec3;
-    getDown(): Vec3;
-    getRight(): Vec3;
-    getLeft(): Vec3;
-    getForward(): Vec3;
-    getBackward(): Vec3;
-    /**
-     * Updates camera view space
-     * @public
-     * @virtual
-     */
-    update(): void;
-    /**
-     * Refresh camera matrices
-     * @public
-     */
-    refresh(): void;
-    /**
-     * Sets aspect ratio
-     * @public
-     * @param {Number} aspect - Camera aspect ratio
-     */
-    setAspectRatio(aspect: number): void;
-    /**
-     * Returns aspect ratio
-     * @public
-     * @returns {number} - Aspect ratio
-     */
-    getAspectRatio(): number;
-    /**
-     * Sets up camera projection
-     * @public
-     * @param {number} angle - Camera view angle
-     * @param {number} aspect - Screen aspect ratio
-     */
-    protected _setProj(angle: number, aspect: number): void;
-    /**
-     * Sets camera view angle in degrees
-     * @public
-     * @param {number} angle - View angle
-     */
-    setViewAngle(angle: number): void;
-    /**
-     * Gets camera view angle in degrees
-     * @public
-     * @returns {number} angle -
-     */
-    getViewAngle(): number;
-    get viewAngle(): number;
-    /**
-     * Sets camera to eye position
-     * @public
-     * @param {Vec3} eye - Camera position
-     * @param {Vec3} look - Look point
-     * @param {Vec3} up - Camera up vector
-     * @returns {Camera} - This camera
-     */
-    set(eye: Vec3, look?: Vec3, up?: Vec3): this;
-    /**
-     * Sets camera look point
-     * @public
-     * @param {Vec3} look - Look point
-     * @param {Vec3} [up] - Camera up vector otherwise camera current up vector(this._u)
-     */
-    look(look: Vec3, up?: Vec3): void;
-    /**
-     * Slides camera to vector d - (du, dv, dn)
-     * @public
-     * @param {number} du - delta X
-     * @param {number} dv - delta Y
-     * @param {number} dn - delta Z
-     */
-    slide(du: number, dv: number, dn: number): void;
-    /**
-     * Roll the camera to the angle in radians
-     * @public
-     * @param {number} angle - Delta roll angle in radians
-     */
-    setRoll(angle: number): void;
-    /**
-     * Pitch the camera to the angle in radians
-     * @public
-     * @param {number} angle - Delta pitch angle in radians
-     */
-    setPitch(angle: number): void;
-    /**
-     * Yaw the camera to the angle in radians
-     * @public
-     * @param {number} angle - Delta yaw angle in radians
-     */
-    setYaw(angle: number): void;
-    setPitchYawRoll(pitch: number, yaw: number, roll: number): void;
-    getPitch(): number;
-    getYaw(): number;
-    getRoll(): number;
-    /**
-     * Returns camera quaternion
-     */
-    getRotation(): Quat;
-    setRotation(rot: Quat, up?: Vec3, right?: Vec3, back?: Vec3): void;
-    rotate(rot: Quat): void;
-    /**
-     * Returns normal vector direction to the unprojected screen point from camera eye
-     * @public
-     * @param {Vec2} pos - Screen X coordinate
-     * @returns {Vec3} - Direction vector
-     */
-    unproject2v(pos: Vec2): Vec3;
-    /**
-     * Returns normal vector direction to the unprojected screen point from camera eye
-     * @public
-     * @param {number} x - Screen X coordinate
-     * @param {number} y - Screen Y coordinate
-     * @returns {Vec3} - Direction vector
-     */
-    unproject(x: number, y: number): Vec3;
-    /**
-     * Gets projected 3d point to the 2d screen coordinates
-     * @public
-     * @param {Vec3} v - Cartesian 3d coordinates
-     * @returns {Vec2} - Screen point coordinates
-     */
-    project3v(v: Vec3): Vec2;
-    /**
-     * Gets projected 3d point to the 2d screen coordinates
-     * @public
-     * @param {number} x - X coordinate
-     * @param {number} y - Y coordinate
-     * @param {number} z - Z coordinate
-     * @returns {Vec2} - Screen point coordinates
-     */
-    project(x: number, y: number, z: number): Vec2;
-    /**
-     * Rotates camera around center point
-     * @public
-     * @param {number} angle - Rotation angle in radians
-     * @param {boolean} [isArc] - If true camera up vector gets from current up vector every frame,
-     * otherwise up is always input parameter.
-     * @param {Vec3} [center] - Point that the camera rotates around
-     * @param {Vec3} [up] - Camera up vector
-     */
-    rotateAround(angle: number, isArc?: boolean, center?: Vec3, up?: Vec3): void;
-    /**
-     * Rotates camera around center point by horizontal.
-     * @public
-     * @param {number} angle - Rotation angle in radians.
-     * @param {boolean} [isArc] - If true camera up vector gets from current up vector every frame,
-     * otherwise up is always input parameter.
-     * @param {Vec3} [center] - Point that the camera rotates around.
-     * @param {Vec3} [up] - Camera up vector.
-     */
-    rotateHorizontal(angle: number, isArc?: boolean, center?: Vec3, up?: Vec3): void;
-    /**
-     * Rotates camera around center point by vertical.
-     * @param {number} angle - Rotation angle in radians.
-     * @param {Vec3} [center] - Point that the camera rotates around.
-     */
-    rotateVertical(angle: number, center?: Vec3): void;
-    /**
-     * Gets 3d size factor. Uses in LOD distance calculation.
-     * @public
-     * @param {Vec3} p - Far point.
-     * @param {Vec3} r - Far point.
-     * @returns {number} - Size factor.
-     */
-    projectedSize(p: Vec3, r: number): number;
-    /**
-     * Returns model matrix.
-     * @public
-     * @returns {NumberArray16} - View matrix.
-     */
-    getViewMatrix(): NumberArray16;
-    /**
-     * Returns normal matrix.
-     * @public
-     * @returns {NumberArray9} - Normal matrix.
-     */
-    getNormalMatrix(): NumberArray9;
-    setCurrentFrustum(k: number): void;
-    getCurrentFrustum(): number;
-    containsSphere(sphere: Sphere): boolean;
-    get frustum(): Frustum;
-    /**
-     * Returns projection matrix.
-     * @public
-     * @returns {Mat4} - Projection matrix.
-     */
-    getProjectionMatrix(): NumberArray16;
-    /**
-     * Returns projection and model matrix product.
-     * @public
-     * @return {Mat4} - Projection-view matrix.
-     */
-    getProjectionViewMatrix(): NumberArray16;
-    /**
-     * Returns projection and model RTE matrix product.
-     * @public
-     * @return {Mat4} - Projection-view matrix.
-     */
-    getProjectionViewRTEMatrix(): NumberArray16;
-    /**
-     * Returns inverse projection and model matrix product.
-     * @public
-     * @returns {Mat4} - Inverse projection-view matrix.
-     */
-    getInverseProjectionViewMatrix(): NumberArray16;
-    /**
-     * Returns inverse projection matrix.
-     * @public
-     * @returns {Mat4} - Inverse projection-view matrix.
-     */
-    getInverseProjectionMatrix(): NumberArray16;
-    viewDistance(cartesian: Vec3, distance?: number): void;
-}
-export { Camera };