@openglobus/og 0.10.4 → 0.11.1

package/types/camera/Camera.d.ts

@@ -0,0 +1,303 @@
+/**
+ * Camera class.
+ * @class
+ * @param {og.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 {og.Vec3} [options.eye=[0,0,0]] - Camera eye position. Default (0,0,0)
+ * @param {og.Vec3} [options.look=[0,0,0]] - Camera look position. Default (0,0,0)
+ * @param {og.Vec3} [options.up=[0,1,0]] - Camera eye position. Default (0,1,0)
+ *
+ * @fires og.Camera#viewchange
+ */
+export class Camera {
+    constructor(renderer: any, options: any);
+    /**
+     * Assigned renderer
+     * @public
+     * @type {og.Renderer}
+     */
+    public renderer: any;
+    /**
+     * Camera events handler
+     * @public
+     * @type {og.Events}
+     */
+    public events: any;
+    /**
+     * Camera position.
+     * @public
+     * @type {og.Vec3}
+     */
+    public eye: any;
+    /**
+     * Camera RTE high position
+     * @public
+     * @type {og.Vec3}
+     */
+    public eyeHigh: any;
+    /**
+     * Camera RTE low position
+     * @public
+     * @type {og.Vec3}
+     */
+    public eyeLow: any;
+    /**
+     * Aspect ratio.
+     * @protected
+     * @type {Number}
+     */
+    protected _aspect: number;
+    /**
+     * Camera view angle in degrees
+     * @protected
+     * @type {Number}
+     */
+    protected _viewAngle: number;
+    /**
+     * Camera normal matrix.
+     * @protected
+     * @type {og.Mat3}
+     */
+    protected _normalMatrix: any;
+    /**
+     * Camera view matrix.
+     * @protected
+     * @type {og.Mat4}
+     */
+    protected _viewMatrix: any;
+    /**
+     * Camera right vector.
+     * @protected
+     * @type {og.Vec3}
+     */
+    protected _u: any;
+    /**
+     * Camera up vector.
+     * @protected
+     * @type {og.Vec3}
+     */
+    protected _v: any;
+    /**
+     * Camera forward vector.
+     * @protected
+     * @type {og.Vec3}
+     */
+    protected _n: any;
+    _pu: any;
+    _pv: any;
+    _pn: any;
+    _peye: any;
+    _moved: 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 {og.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 {og.Vec3} [options.eye] - Camera eye position. Default (0,0,0)
+     * @param {og.Vec3} [options.look] - Camera look position. Default (0,0,0)
+     * @param {og.Vec3} [options.up] - Camera eye position. Default (0,1,0)
+     */
+    public _init(options?: {
+        viewAngle?: number;
+        near?: number;
+        far?: number;
+        eye?: any;
+        look?: any;
+        up?: any;
+    }): void;
+    getUp(): any;
+    getDown(): any;
+    getRight(): any;
+    getLeft(): any;
+    getForward(): any;
+    getBackward(): any;
+    /**
+     * 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: any, 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 {og.Vec3} eye - Camera position
+     * @param {og.Vec3} look - Look point
+     * @param {og.Vec3} up - Camera up vector
+     * @returns {og.Camera} - This camera
+     */
+    public set(eye: any, look: any, up: any): any;
+    /**
+     * Sets camera look point
+     * @public
+     * @param {og.Vec3} look - Look point
+     * @param {og.Vec3} [up] - Camera up vector otherwise camera current up vector(this._v)
+     */
+    public look(look: any, up?: any): 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 {og.Vec3} - Direction vector
+     */
+    public unproject(x: number, y: number): any;
+    /**
+     * Gets projected 3d point to the 2d screen coordiantes
+     * @public
+     * @param {og.Vec3} v - Cartesian 3d coordiantes
+     * @returns {og.Vec2} - Screen point coordinates
+     */
+    public project(v: any): any;
+    /**
+     * 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 {og.Vec3} center - Point that the camera rotates around
+     * @param {og.math.Vecto3} [up] - Camera up vector
+     */
+    public rotateAround(angle: number, isArc: boolean, center: any, up?: any): 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 {og.Vec3} center - Point that the camera rotates around.
+     * @param {og.Vec3} [up] - Camera up vector.
+     */
+    public rotateHorizontal(angle: number, isArc: any, center: any, up?: any): void;
+    /**
+     * Rotates camera around center point by vecrtical.
+     * @param {number} angle - Rotation angle in radians.
+     * @param {og.Vec3} center - Point that the camera rotates around.
+     */
+    rotateVertical(angle: number, center: any): void;
+    /**
+     * Gets 3d size factor. Uses in LOD distance calculation.
+     * @public
+     * @param {og.Vec3} p - Far point.
+     * @param {og.Vec3} r - Far point.
+     * @returns {number} - Size factor.
+     */
+    public projectedSize(p: any, r: any): number;
+    /**
+     * Returns normal matrix.
+     * @public
+     * @returns {og.Mat3} - Normal matrix.
+     */
+    public getNormalMatrix(): any;
+    /**
+     * Returns model matrix.
+     * @public
+     * @returns {og.Mat4} - View matrix.
+     */
+    public getViewMatrix(): any;
+    setCurrentFrustum(k: any): void;
+    getCurrentFrustum(): number;
+    get frustum(): Frustum;
+    /**
+     * Returns projection matrix.
+     * @public
+     * @returns {og.Mat4} - Projection matrix.
+     */
+    public getProjectionMatrix(): any;
+    /**
+     * Returns projection and model matrix product.
+     * @public
+     * @return {og.Mat4} - Projection-view matrix.
+     */
+    public getProjectionViewMatrix(): any;
+    /**
+     * Returns inverse projection and model matrix product.
+     * @public
+     * @returns {og.Mat4} - Inversed projection-view matrix.
+     */
+    public getInverseProjectionViewMatrix(): any;
+    /**
+     * Returns inverse projection matrix.
+     * @public
+     * @returns {og.Mat4} - Inversed projection-view matrix.
+     */
+    public getInverseProjectionMatrix(): any;
+}
+import { Frustum } from "./Frustum.js";

package/types/camera/Frustum.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Frustum object, part of the camera object.
+ * @class
+ */
+export class Frustum {
+    constructor(options?: {});
+    /**
+     * Frustum planes.
+     * @private
+     * @type {Array.<Array.<number>>}
+     */
+    private _f;
+    /**
+     * Camera projection matrix.
+     * @protected
+     * @type {og.Mat4}
+     */
+    protected _projectionMatrix: any;
+    /**
+     * Camera inverse projection matrix.
+     * @protected
+     * @type {og.Mat4}
+     */
+    protected _inverseProjectionMatrix: any;
+    /**
+     * Product of projection and view matrices.
+     * @protected
+     * @type {og.Mat4}
+     */
+    protected _projectionViewMatrix: any;
+    /**
+     * Inverse projectionView Matrix.
+     * @protected
+     * @type {og.Mat4}
+     */
+    protected _inverseProjectionViewMatrix: any;
+    /**
+     * 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(): any;
+    getProjectionMatrix(): any;
+    getInverseProjectionMatrix(): any;
+    /**
+     * 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: any, 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 {og.Vec3} point - Cartesian point.
+     * @returns {boolean} -
+     */
+    public containsPoint(point: any): boolean;
+    /**
+     * Returns true if the frustum contains a bonding sphere, but bottom plane exclude.
+     * @public
+     * @param {og.bv.Sphere} sphere - Bounding sphere.
+     * @returns {boolean} -
+     */
+    public containsSphereBottomExc(sphere: any): boolean;
+    containsSphereButtom(sphere: any): boolean;
+    /**
+     * Returns true if the frustum contains a bonding sphere.
+     * @public
+     * @param {og.bv.Sphere} sphere - Bounding sphere.
+     * @returns {boolean} -
+     */
+    public containsSphere(sphere: any): 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: any, radius: number): boolean;
+    /**
+     * Returns true if the frustum contains a bounding box.
+     * @public
+     * @param {og.bv.Box} box - Bounding box.
+     * @returns {boolean} -
+     */
+    public containsBox(box: any): boolean;
+}

package/types/camera/PlanetCamera.d.ts

@@ -0,0 +1,222 @@
+/**
+ * Planet camera.
+ * @class
+ * @extends {og.Camera}
+ * @param {og.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 {og.Vec3} [options.eye] - Camera eye position. Default (0,0,0)
+ * @param {og.Vec3} [options.look] - Camera look position. Default (0,0,0)
+ * @param {og.Vec3} [options.up] - Camera eye position. Default (0,1,0)
+ */
+export class PlanetCamera {
+    constructor(planet: any, options: any);
+    /**
+     * Assigned camera's planet.
+     * @public
+     * @type {og.scene.Planet}
+     */
+    public planet: any;
+    /**
+     * 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 {og.LonLat}
+     */
+    protected _lonLat: any;
+    /**
+     * Current geographical mercator position.
+     * @protected
+     * @type {og.LonLat}
+     */
+    protected _lonLatMerc: any;
+    /**
+     * Current altitude.
+     * @protected
+     * @type {number}
+     */
+    protected _terrainAltitude: number;
+    /**
+     * Cartesian coordinates on the terrain.
+     * @protected
+     * @type {og.Vec3}
+     */
+    protected _terrainPoint: any;
+    /**
+     * Quad node that camera flies over.
+     * @protected
+     * @type {og.quadTree.Node}
+     */
+    protected _insideSegment: any;
+    /**
+     * 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 {og.LonLat}
+     */
+    protected _insideSegmentPosition: any;
+    slope: number;
+    _keyLock: Key;
+    _framesArr: any[];
+    _framesCounter: number;
+    _numFrames: number;
+    _completeCallback: any;
+    _flying: boolean;
+    /**
+     * Updates camera view space.
+     * @public
+     * @virtual
+     */
+    public update(): void;
+    eyeNorm: any;
+    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 {og.LonLat} lonlat - New camera and camera view position.
+     * @param {og.LonLat} [lookLonLat] - Look up coordinates.
+     * @param {og.Vec3} [up] - Camera UP vector. Default (0,1,0)
+     */
+    public setLonLat(lonlat: any, lookLonLat?: any, up?: any): void;
+    /**
+     * Returns camera geographical position.
+     * @public
+     * @returns {og.LonLat}
+     */
+    public getLonLat(): any;
+    /**
+     * Returns camera height.
+     * @public
+     * @returns {number}
+     */
+    public getHeight(): number;
+    /**
+     * Gets position by viewable extent.
+     * @public
+     * @param {og.Extent} extent - Viewable extent.
+     * @param {Number} height - Camera height
+     * @returns {og.Vec3}
+     */
+    public getExtentPosition(extent: any, height: number): any;
+    /**
+     * View current extent.
+     * @public
+     * @param {og.Extent} extent - Current extent.
+     */
+    public viewExtent(extent: any, height: any): void;
+    /**
+     * Flies to the current extent.
+     * @public
+     * @param {og.Extent} extent - Current extent.
+     * @param {og.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: any, height: any, up?: any, ampl?: number, completeCallback?: any, startCallback?: any, 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 {og.Vec3} cartesian - Finish cartesian coordinates.
+     * @param {og.Vec3} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
+     * @param {og.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: any, look?: any, up?: any, ampl?: number, completeCallback?: any, startCallback?: any, frameCallback?: any): void;
+    _frameCallback: any;
+    /**
+     * Flies to the geo coordiantes.
+     * @public
+     * @param {og.LonLat} lonlat - Finish coordinates.
+     * @param {og.Vec3} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
+     * @param {og.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: any, look?: any, up?: any, ampl?: number, completeCallback?: any, startCallback?: any): 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;
+    rotateVertical(angle: any, center: any, minSlope?: number): void;
+    eye: any;
+    _v: any;
+    _u: any;
+    _n: any;
+    /**
+     * Prepare camera to the frame. Used in render node frame function.
+     * @public
+     */
+    public checkFly(): void;
+    checkTerrainCollision(): void;
+    getSurfaceVisibleDistance(d: any): number;
+    getHeading(): number;
+}
+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;