@openglobus/og 0.18.0 → 0.18.2

package/{src/astro/rotation.ts → lib/js/astro/rotation.js}

@@ -1,25 +1,17 @@
 import { PI_TWO } from "../math";
 import { Mat3 } from "../math/Mat3";
 import { Vec3 } from "../math/Vec3";
-
-export function getRotationMatrix(rightAscension: number, declination: number, res?: Mat3): Mat3 {
-    let xAxis = new Vec3(),
-        zAxis = new 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;
@@ -29,6 +21,5 @@ export function getRotationMatrix(rightAscension: number, declination: number, r
     res._m[6] = xAxis.z;
     res._m[7] = yAxis.z;
     res._m[8] = zAxis.z;
-
     return res;
 }

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

@@ -0,0 +1,32 @@
+import { Vec3 } from "../math/Vec3";
+import { 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/{src/bv/Box.ts → lib/js/bv/Box.js}

@@ -1,26 +1,11 @@
-import {Vec3} from "../math/Vec3";
-import {NumberArray6} from "./Sphere";
-import {Ellipsoid} from "../ellipsoid/Ellipsoid";
-import {Extent} from "../Extent";
-
-type Vec3Array8 = [Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3];
-
+import { Vec3 } from "../math/Vec3";
 /**
  * Bounding box class.
  * @class
  * @param {NumberArray6} [boundsArr]
  */
 class Box {
-
-    /**
-     * Vertices array.
-     * @public
-     * @type{Array.<Vec3>}
-     */
-    public vertices: Vec3Array8
-
-    constructor(boundsArr?: NumberArray6) {
-
+    constructor(boundsArr) {
         this.vertices = [
             new Vec3(),
             new Vec3(),
@@ -31,32 +16,22 @@ class Box {
             new Vec3(),
             new Vec3()
         ];
-
         if (boundsArr) {
             this.setFromBoundsArr(boundsArr);
         }
     }
-
-    public copy(bbox: Box) {
+    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]
      */
-    public setFromBoundsArr(bounds: NumberArray6) {
-        let xmin = bounds[0],
-            xmax = bounds[3],
-            ymin = bounds[1],
-            ymax = bounds[4],
-            zmin = bounds[2],
-            zmax = bounds[5];
-
+    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);
@@ -66,16 +41,13 @@ class Box {
         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.
      */
-    public setFromExtent(ellipsoid: Ellipsoid, extent: Extent) {
+    setFromExtent(ellipsoid, extent) {
         this.setFromBoundsArr(extent.getCartesianBounds(ellipsoid));
     }
 }
-
-export {Box};
-
+export { Box };

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

@@ -0,0 +1,37 @@
+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/{src/bv/Sphere.ts → lib/js/bv/Sphere.js}

@@ -1,9 +1,4 @@
-import {Vec3} from "../math/Vec3";
-import {Ellipsoid} from "../ellipsoid/Ellipsoid";
-import {Extent} from "../Extent";
-
-export type NumberArray6 = [number, number, number, number, number, number];
-
+import { Vec3 } from "../math/Vec3";
 /**
  * Bounding sphere class.
  * @class
@@ -11,49 +6,26 @@ export type NumberArray6 = [number, number, number, number, number, number];
  * @param {Vec3} [center] - Bounding sphere coordinates.
  */
 class Sphere {
-    /**
-     * Sphere radius.
-     * @public
-     * @type {Number}
-     */
-    public radius: number;
-
-    /**
-     * Sphere coordinates.
-     * @public
-     * @type {Vec3}
-     */
-    public center: Vec3;
-
-    constructor(radius: number = 0, center?: Vec3) {
-
+    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]
      */
-    public setFromBounds(bounds: NumberArray6) {
+    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.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.
      */
-    public setFromExtent(ellipsoid: Ellipsoid, extent: Extent) {
+    setFromExtent(ellipsoid, extent) {
         this.setFromBounds(extent.getCartesianBounds(ellipsoid));
     }
 }
-
-export {Sphere};
+export { Sphere };

package/{src/bv/index.ts → lib/js/bv/index.d.ts}

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

package/lib/js/bv/index.js

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

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

@@ -0,0 +1,314 @@
+import { EventsHandler } from "../Events";
+import { Frustum } from "./Frustum";
+import { Mat3, NumberArray9 } from "../math/Mat3";
+import { Mat4, NumberArray16 } from "../math/Mat4";
+import { Renderer } from "../renderer/Renderer";
+import { Vec2, NumberArray2 } from "../math/Vec2";
+import { Vec3 } from "../math/Vec3";
+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;
+    /**
+     * Camera normal matrix.
+     * @protected
+     * @type {Mat3}
+     */
+    protected _normalMatrix: Mat3;
+    /**
+     * Camera right vector.
+     * @public
+     * @type {Vec3}
+     */
+    _r: Vec3;
+    /**
+     * Camera up vector.
+     * @public
+     * @type {Vec3}
+     */
+    _u: Vec3;
+    /**
+     * Camera backward vector.
+     * @public
+     * @type {Vec3}
+     */
+    _b: 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;
+    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 degrees
+     * @public
+     * @param {number} angle - Delta roll angle in degrees
+     */
+    roll(angle: number): void;
+    /**
+     * Pitch the camera to the angle in degrees
+     * @public
+     * @param {number} angle - Delta pitch angle in degrees
+     */
+    pitch(angle: number): void;
+    /**
+     * Yaw the camera to the angle in degrees
+     * @public
+     * @param {number} angle - Delta yaw angle in degrees
+     */
+    yaw(angle: number): void;
+    /**
+     * 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
+     */
+    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 {Vec3} [up] - Camera up vector
+     */
+    rotateAround(angle: number, isArc?: boolean, center?: Vec3 | null, up?: Vec3 | null): 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 | null, up?: Vec3 | null): 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;
+    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 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;
+}
+export { Camera };