@openglobus/og 0.12.1 → 0.12.3

package/types/camera/Camera.d.ts

@@ -0,0 +1,312 @@
+/**
+ * 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=38] - Camera angle of view. Default is 30.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. Deafult 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 og.Camera#viewchange
+ */
+export class Camera {
+    /**
+     * @param {Renderer} [renderer] - Renderer uses the camera instance.
+     * @param {Object} [options] - Camera options:
+     */
+    constructor(renderer?: Renderer, options?: any);
+    /**
+     * Assigned renderer
+     * @public
+     * @type {Renderer}
+     */
+    public renderer: Renderer;
+    /**
+     * Camera events handler
+     * @public
+     * @type {Events}
+     */
+    public events: Events;
+    /**
+     * Camera position.
+     * @public
+     * @type {Vec3}
+     */
+    public eye: Vec3;
+    /**
+     * Camera RTE high position
+     * @public
+     * @type {Vec3}
+     */
+    public eyeHigh: Vec3;
+    /**
+     * Camera RTE low position
+     * @public
+     * @type {Vec3}
+     */
+    public eyeLow: Vec3;
+    /**
+     * Aspect ratio.
+     * @protected
+     * @type {Number}
+     */
+    protected _aspect: number;
+    /**
+     * Camera view angle in degrees
+     * @protected
+     * @type {Number}
+     */
+    protected _viewAngle: number;
+    /**
+     * Camera normal matrix.
+     * @protected
+     * @type {Mat3}
+     */
+    protected _normalMatrix: Mat3;
+    /**
+     * Camera view matrix.
+     * @protected
+     * @type {Mat4}
+     */
+    protected _viewMatrix: Mat4;
+    /**
+     * Camera right vector.
+     * @protected
+     * @type {Vec3}
+     */
+    protected _r: Vec3;
+    /**
+     * Camera up vector.
+     * @protected
+     * @type {Vec3}
+     */
+    protected _u: Vec3;
+    /**
+     * Camera forward vector.
+     * @protected
+     * @type {Vec3}
+     */
+    protected _b: Vec3;
+    _pu: Vec3;
+    _pv: Vec3;
+    _pn: Vec3;
+    _peye: Vec3;
+    isMoved: boolean;
+    _tanViewAngle_hrad: number;
+    _tanViewAngle_hradOneByHeight: number;
+    frustums: Frustum[];
+    nearFarArr: any[];
+    frustumColors: any[];
+    FARTHEST_FRUSTUM_INDEX: number;
+    _currentFrustum: number;
+    checkMoveEnd(): void;
+    /**
+     * Camera initialization.
+     * @public
+     * @param {Renderer} renderer - OpenGlobus renderer object.
+     * @param {Object} [options] - Camera options:
+     * @param {number} [options.viewAngle] - Camera angle of view. Default is 30.0
+     * @param {number} [options.near] - Camera near plane distance. Default is 1.0
+     * @param {number} [options.far] - Camera far plane distance. Deafult is og.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)
+     */
+    public _init(options?: {
+        viewAngle?: number;
+        near?: number;
+        far?: number;
+        eye?: Vec3;
+        look?: Vec3;
+        up?: Vec3;
+    }): void;
+    getUp(): Vec3;
+    getDown(): Vec3;
+    getRight(): Vec3;
+    getLeft(): Vec3;
+    getForward(): Vec3;
+    getBackward(): Vec3;
+    /**
+     * Updates camera view space
+     * @public
+     * @virtual
+     */
+    public update(): void;
+    /**
+     * Refresh camera matrices
+     * @public
+     */
+    public refresh(): void;
+    /**
+     * Sets aspect ratio
+     * @public
+     * @param {Number} aspect - Camera aspect ratio
+     */
+    public setAspectRatio(aspect: number): void;
+    /**
+     * Returns aspect ratio
+     * @public
+     * @returns {number} - Aspect ratio
+     */
+    public getAspectRatio(): number;
+    /**
+     * Sets up camera projection
+     * @public
+     * @param {nnumber} angle - Camera's view angle
+     * @param {number} aspect - Screen aspect ration
+     */
+    public _setProj(angle: nnumber, aspect: number): void;
+    _projSizeConst: number;
+    /**
+     * Sets camera view angle in degrees
+     * @public
+     * @param {number} angle - View angle
+     */
+    public setViewAngle(angle: number): void;
+    /**
+     * Gets camera view angle in degrees
+     * @public
+     * @returns {number} angle -
+     */
+    public getViewAngle(): 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
+     */
+    public set(eye: Vec3, look: Vec3, up: Vec3): Camera;
+    /**
+     * Sets camera look point
+     * @public
+     * @param {Vec3} look - Look point
+     * @param {Vec3} [up] - Camera up vector otherwise camera current up vector(this._u)
+     */
+    public 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
+     */
+    public slide(du: number, dv: number, dn: number): void;
+    /**
+     * Roll the camera to the angle in degrees
+     * @public
+     * @param {number} angle - Delta roll angle in degrees
+     */
+    public roll(angle: number): void;
+    /**
+     * Pitch the camera to the angle in degrees
+     * @public
+     * @param {number} angle - Delta pitch angle in degrees
+     */
+    public pitch(angle: number): void;
+    /**
+     * Yaw the camera to the angle in degrees
+     * @public
+     * @param {number} angle - Delta yaw angle in degrees
+     */
+    public yaw(angle: number): void;
+    /**
+     * Returns normal vector direction to to the unprojected screen point from camera eye
+     * @public
+     * @param {number} x - Scren X coordinate
+     * @param {number} y - Scren Y coordinate
+     * @returns {Vec3} - Direction vector
+     */
+    public unproject(x: number, y: number): Vec3;
+    /**
+     * Gets projected 3d point to the 2d screen coordiantes
+     * @public
+     * @param {Vec3} v - Cartesian 3d coordiantes
+     * @returns {Vec2} - Screen point coordinates
+     */
+    public project(v: Vec3): 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 {Vecto3} [up] - Camera up vector
+     */
+    public rotateAround(angle: number, isArc: boolean, center: Vec3, up?: Vecto3): void;
+    /**
+     * Rotates camera around center point by horizontal.
+     * @public
+     * @param {number} angle - Rotation angle in radians.
+     * @param {boolaen} 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.
+     */
+    public rotateHorizontal(angle: number, isArc: boolaen, center: Vec3, up?: Vec3): void;
+    /**
+     * Rotates camera around center point by vecrtical.
+     * @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.
+     */
+    public projectedSize(p: Vec3, r: Vec3): number;
+    /**
+     * Returns normal matrix.
+     * @public
+     * @returns {Mat3} - Normal matrix.
+     */
+    public getNormalMatrix(): Mat3;
+    /**
+     * Returns model matrix.
+     * @public
+     * @returns {Mat4} - View matrix.
+     */
+    public getViewMatrix(): Mat4;
+    setCurrentFrustum(k: any): void;
+    getCurrentFrustum(): number;
+    get frustum(): Frustum;
+    /**
+     * Returns projection matrix.
+     * @public
+     * @returns {Mat4} - Projection matrix.
+     */
+    public getProjectionMatrix(): Mat4;
+    /**
+     * Returns projection and model matrix product.
+     * @public
+     * @return {Mat4} - Projection-view matrix.
+     */
+    public getProjectionViewMatrix(): Mat4;
+    /**
+     * Returns inverse projection and model matrix product.
+     * @public
+     * @returns {Mat4} - Inversed projection-view matrix.
+     */
+    public getInverseProjectionViewMatrix(): Mat4;
+    /**
+     * Returns inverse projection matrix.
+     * @public
+     * @returns {Mat4} - Inversed projection-view matrix.
+     */
+    public getInverseProjectionMatrix(): Mat4;
+}
+import { Events } from "../Events.js";
+import { Vec3 } from "../math/Vec3.js";
+import { Mat3 } from "../math/Mat3.js";
+import { Mat4 } from "../math/Mat4.js";
+import { Frustum } from "./Frustum.js";
+import { Vec2 } from "../math/Vec2.js";

package/types/camera/Frustum.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Frustum object, part of the camera object.
+ * @class
+ */
+export class Frustum {
+    /**
+     * @param {*} options
+     */
+    constructor(options?: any);
+    /**
+     * Frustum planes.
+     * @private
+     * @type {Array.<Array.<number>>}
+     */
+    private _f;
+    /**
+     * Camera projection matrix.
+     * @protected
+     * @type {Mat4}
+     */
+    protected _projectionMatrix: Mat4;
+    /**
+     * Camera inverse projection matrix.
+     * @protected
+     * @type {Mat4}
+     */
+    protected _inverseProjectionMatrix: Mat4;
+    /**
+     * Product of projection and view matrices.
+     * @protected
+     * @type {Mat4}
+     */
+    protected _projectionViewMatrix: Mat4;
+    /**
+     * Inverse projectionView Matrix.
+     * @protected
+     * @type {Mat4}
+     */
+    protected _inverseProjectionViewMatrix: Mat4;
+    /**
+     * Projection frustum left value.
+     * @public
+     */
+    public left: number;
+    /**
+     * Projection frustum right value.
+     * @public
+     */
+    public right: number;
+    /**
+     * Projection frustum bottom value.
+     * @public
+     */
+    public bottom: number;
+    /**
+     * Projection frustum top value.
+     * @public
+     */
+    public top: number;
+    /**
+     * Projection frustum near value.
+     * @public
+     */
+    public near: number;
+    /**
+     * Projection frustum far value.
+     * @public
+     */
+    public far: number;
+    _cameraFrustumIndex: any;
+    getRightPlane(): number[];
+    getLeftPlane(): number[];
+    getBottomPlane(): number[];
+    getTopPlane(): number[];
+    getBackwardPlane(): number[];
+    getForwardPlane(): number[];
+    getProjectionViewMatrix(): number[];
+    getProjectionMatrix(): number[];
+    getInverseProjectionMatrix(): number[];
+    /**
+     * Sets up camera projection matrix.
+     * @public
+     * @param {nnumber} angle - Camera's view angle.
+     * @param {number} aspect - Screen aspect ration.
+     * @param {number} near - Near camera distance.
+     * @param {number} far - Far camera distance.
+     */
+    public setProjectionMatrix(angle: nnumber, aspect: number, near: number, far: number): void;
+    /**
+     * Camera's projection matrix values.
+     * @public
+     * @param {Mat4} projectionView - projectionView matrix.
+     */
+    public setViewMatrix(viewMatrix: any): void;
+    /**
+     * Returns true if a point in the frustum.
+     * @public
+     * @param {Vec3} point - Cartesian point.
+     * @returns {boolean} -
+     */
+    public containsPoint(point: Vec3): boolean;
+    /**
+     * Returns true if the frustum contains a bonding sphere, but bottom plane exclude.
+     * @public
+     * @param {Sphere} sphere - Bounding sphere.
+     * @returns {boolean} -
+     */
+    public containsSphereBottomExc(sphere: Sphere): boolean;
+    containsSphereButtom(sphere: any): boolean;
+    /**
+     * Returns true if the frustum contains a bonding sphere.
+     * @public
+     * @param {Sphere} sphere - Bounding sphere.
+     * @returns {boolean} -
+     */
+    public containsSphere(sphere: Sphere): boolean;
+    /**
+     * Returns true if the frustum contains a bonding sphere.
+     * @public
+     * @param {Vec3} center - Sphere center.
+     * @param {number} radius - Sphere radius.
+     * @returns {boolean} -
+     */
+    public containsSphere2(center: Vec3, radius: number): boolean;
+    /**
+     * Returns true if the frustum contains a bounding box.
+     * @public
+     * @param {Box} box - Bounding box.
+     * @returns {boolean} -
+     */
+    public containsBox(box: Box): boolean;
+}
+import { Mat4 } from "../math/Mat4.js";

package/types/camera/PlanetCamera.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Planet camera.
+ * @class
+ * @extends {Camera}
+ * @param {RenderNode} planet - Planet render node.
+ * @param {Object} [options] - Planet camera options:
+ * @param {Object} [options.name] - Camera name.
+ * @param {number} [options.viewAngle=37] - Camera angle of view. Default is 35.0
+ * @param {number} [options.near] - Camera near plane distance. Default is 1.0
+ * @param {number} [options.far] - Camera far plane distance. Deafult is og.math.MAX
+ * @param {number} [options.minAltitude] - Minimal altitude for the camera. Deafult is 1
+ * @param {number} [options.maxAltitude] - Maximal altitude for the camera. Deafult is 20000000
+ * @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)
+ */
+export class PlanetCamera extends Camera {
+    /**
+     * @param {RenderNode} planet - Planet render node.
+     * @param {Object} [options] - Planet camera options:
+     */
+    constructor(planet: RenderNode, options?: any);
+    /**
+     * Assigned camera's planet.
+     * @public
+     * @type {Planet}
+     */
+    public planet: Planet;
+    /**
+     * Minimal alltitude that camera can reach over the terrain.
+     * @public
+     * @type {number}
+     */
+    public minAltitude: number;
+    /**
+     * Maximal alltitude that camera can reach over the globe.
+     * @public
+     * @type {number}
+     */
+    public maxAltitude: number;
+    /**
+     * Current geographical degree position.
+     * @protected
+     * @type {LonLat}
+     */
+    protected _lonLat: LonLat;
+    /**
+     * Current geographical mercator position.
+     * @protected
+     * @type {LonLat}
+     */
+    protected _lonLatMerc: LonLat;
+    /**
+     * Current altitude.
+     * @protected
+     * @type {number}
+     */
+    protected _terrainAltitude: number;
+    /**
+     * Cartesian coordinates on the terrain.
+     * @protected
+     * @type {Vec3}
+     */
+    protected _terrainPoint: Vec3;
+    /**
+     * Quad node that camera flies over.
+     * @protected
+     * @type {quadTree.Node}
+     */
+    protected _insideSegment: quadTree.Node;
+    /**
+     * Coordinates that depends on what segment class we are fling over.
+     * It can be WGS84 or Mercator coordinates. Gets in og.quadTree.Node
+     * @protected
+     * @type {LonLat}
+     */
+    protected _insideSegmentPosition: LonLat;
+    slope: number;
+    _keyLock: Key;
+    _framesArr: any[];
+    _framesCounter: number;
+    _numFrames: number;
+    _completeCallback: any;
+    _flying: boolean;
+    eyeNorm: Vec3;
+    updateGeodeticPosition(): void;
+    /**
+     * Sets altitude over the terrain.
+     * @public
+     * @param {number} alt - Altitude over the terrain.
+     */
+    public setAltitude(alt: number): void;
+    /**
+     * Gets altitude over the terrain.
+     * @public
+     */
+    public getAltitude(): number;
+    /**
+     * Places camera to view to the geographical point.
+     * @public
+     * @param {LonLat} lonlat - New camera and camera view position.
+     * @param {LonLat} [lookLonLat] - Look up coordinates.
+     * @param {Vec3} [up] - Camera UP vector. Default (0,1,0)
+     */
+    public setLonLat(lonlat: LonLat, lookLonLat?: LonLat, up?: Vec3): void;
+    /**
+     * Returns camera geographical position.
+     * @public
+     * @returns {LonLat}
+     */
+    public getLonLat(): LonLat;
+    /**
+     * Returns camera height.
+     * @public
+     * @returns {number}
+     */
+    public getHeight(): number;
+    /**
+     * Gets position by viewable extent.
+     * @public
+     * @param {Extent} extent - Viewable extent.
+     * @param {Number} height - Camera height
+     * @returns {Vec3}
+     */
+    public getExtentPosition(extent: Extent, height: number): Vec3;
+    /**
+     * View current extent.
+     * @public
+     * @param {Extent} extent - Current extent.
+     */
+    public viewExtent(extent: Extent, height: any): void;
+    /**
+     * Flies to the current extent.
+     * @public
+     * @param {Extent} extent - Current extent.
+     * @param {Vec3} [up] - Camera UP in the end of flying. Default - (0,1,0)
+     * @param {Number} [ampl] - Altitude amplitude factor.
+     * @param {cameraCallback} [completeCallback] - Callback that calls after flying when flying is finished.
+     * @param {cameraCallback} [startCallback] - Callback that calls befor the flying begins.
+     * @param [frameCallback]
+     */
+    public flyExtent(extent: Extent, height: any, up?: Vec3, ampl?: number, completeCallback?: cameraCallback, startCallback?: cameraCallback, frameCallback?: any): void;
+    viewDistance(cartesian: any, distance?: number): void;
+    flyDistance(cartesian: any, distance: number, ampl: number, completeCallback: any, startCallback: any, frameCallback: any): void;
+    /**
+     * Flies to the cartesian coordinates.
+     * @public
+     * @param {Vec3} cartesian - Finish cartesian coordinates.
+     * @param {Vec3} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
+     * @param {Vec3} [up] - Camera UP vector in the end of flying. Default - (0,1,0)
+     * @param {Number} [ampl=1.0] - Altitude amplitude factor.
+     * @param {cameraCallback} [completeCallback] - Callback that calls after flying when flying is finished.
+     * @param {cameraCallback} [startCallback] - Callback that calls befor the flying begins.
+     * @param [frameCallback]
+     */
+    public flyCartesian(cartesian: Vec3, look?: Vec3, up?: Vec3, ampl?: number, completeCallback?: cameraCallback, startCallback?: cameraCallback, frameCallback?: any): void;
+    _frameCallback: any;
+    /**
+     * Flies to the geo coordiantes.
+     * @public
+     * @param {LonLat} lonlat - Finish coordinates.
+     * @param {Vec3} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
+     * @param {Vec3} [up] - Camera UP vector in the end of flying. Default - (0,1,0)
+     * @param {Number} [ampl] - Altitude amplitude factor.
+     * @param {cameraCallback} [completeCallback] - Callback that calls after flying when flying is finished.
+     * @param {cameraCallback} [startCallback] - Callback that calls befor the flying begins.
+     */
+    public flyLonLat(lonlat: LonLat, look?: Vec3, up?: Vec3, ampl?: number, completeCallback?: cameraCallback, startCallback?: cameraCallback): void;
+    /**
+     * Breaks the flight.
+     * @public
+     */
+    public stopFlying(): void;
+    /**
+     * Returns camera is flying.
+     * @public
+     * @returns {boolean}
+     */
+    public isFlying(): boolean;
+    /**
+     * Rotates around planet to the left.
+     * @public
+     * @param {number} angle - Rotation angle.
+     * @param {boolean} [spin] - If its true rotates around globe spin.
+     */
+    public rotateLeft(angle: number, spin?: boolean): void;
+    /**
+     * Rotates around planet to the right.
+     * @public
+     * @param {number} angle - Rotation angle.
+     * @param {boolean} [spin] - If its true rotates around globe spin.
+     */
+    public rotateRight(angle: number, spin?: boolean): void;
+    /**
+     * Rotates around planet to the north pole.
+     * @public
+     * @param {number} angle - Rotation angle.
+     */
+    public rotateUp(angle: number): void;
+    /**
+     * Rotates around planet to the south pole.
+     * @public
+     * @param {number} angle - Rotation angle.
+     */
+    public rotateDown(angle: number): void;
+    /**
+     * Prepare camera to the frame. Used in render node frame function.
+     * @public
+     */
+    public checkFly(): void;
+    checkTerrainCollision(): void;
+    getSurfaceVisibleDistance(d: any): number;
+    getHeading(): number;
+    isVisible(poi: any): boolean;
+}
+import { Camera } from "./Camera.js";
+import { LonLat } from "../LonLat.js";
+import { Vec3 } from "../math/Vec3.js";
+import { Key } from "../Lock.js";

package/types/camera/index.d.ts

@@ -0,0 +1,3 @@
+import { Camera } from "./Camera.js";
+import { PlanetCamera } from "./PlanetCamera.js";
+export { Camera, PlanetCamera };

package/types/cons.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Console logging singleton object.
+ * @class
+ */
+export class Cons {
+    _container: HTMLDivElement;
+    _visibility: boolean;
+    getVisibility(): boolean;
+    setVisibility(visibility: any): void;
+    /**
+     * Show console panel.
+     * @public
+     */
+    public show(): void;
+    /**
+     * Hide console panel.
+     * @public
+     */
+    public hide(): void;
+    /**
+     * Adds error text in the console.
+     * @public
+     * @param {string} str - Error text.
+     */
+    public logErr(str: string): void;
+    /**
+     * Adds warning text in the console.
+     * @public
+     * @param {string} str - Warning text.
+     */
+    public logWrn(str: string): void;
+    /**
+     * Adds log text in the console.
+     * @public
+     * @param {string} str - Log text.
+     * @param {Object} [style] - HTML style.
+     */
+    public log(str: string, style?: any): void;
+}
+export const cons: Cons;