@openglobus/og 0.17.2 → 0.18.1

package/lib/js/camera/Frustum.js

@@ -0,0 +1,238 @@
+import { Mat4 } from "../math/Mat4";
+function planeNormalize(plane) {
+    let t = 1.0 / Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]);
+    plane[0] *= t;
+    plane[1] *= t;
+    plane[2] *= t;
+    plane[3] *= t;
+}
+/**
+ * Frustum object, part of the camera object.
+ * @class
+ * @param {*} options
+ */
+class Frustum {
+    constructor(options = {}) {
+        this._pickingColorU = new Float32Array([0, 0, 0]);
+        this._f = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]];
+        this.projectionMatrix = new Mat4();
+        this.inverseProjectionMatrix = new Mat4();
+        this.projectionViewMatrix = new Mat4();
+        this.inverseProjectionViewMatrix = new Mat4();
+        this.left = 0.0;
+        this.right = 0.0;
+        this.bottom = 0.0;
+        this.top = 0.0;
+        this.near = 0.0;
+        this.far = 0.0;
+        this.cameraFrustumIndex = options.cameraFrustumIndex != undefined ? options.cameraFrustumIndex : -1;
+        this.setProjectionMatrix(options.fov || 30.0, options.aspect || 1.0, options.near || 1.0, options.far || 1000.0);
+    }
+    getRightPlane() {
+        return this._f[0];
+    }
+    getLeftPlane() {
+        return this._f[1];
+    }
+    getBottomPlane() {
+        return this._f[2];
+    }
+    getTopPlane() {
+        return this._f[3];
+    }
+    getBackwardPlane() {
+        return this._f[4];
+    }
+    getForwardPlane() {
+        return this._f[5];
+    }
+    getProjectionViewMatrix() {
+        return this.projectionViewMatrix._m;
+    }
+    getProjectionMatrix() {
+        return this.projectionMatrix._m;
+    }
+    getInverseProjectionMatrix() {
+        return this.inverseProjectionMatrix._m;
+    }
+    /**
+     * Sets up camera projection matrix.
+     * @public
+     * @param {number} angle - Camera's view angle.
+     * @param {number} aspect - Screen aspect ration.
+     * @param {number} near - Near camera distance.
+     * @param {number} far - Far camera distance.
+     */
+    setProjectionMatrix(angle, aspect, near, far) {
+        this.top = near * Math.tan((angle * Math.PI) / 360);
+        this.bottom = -this.top;
+        this.right = this.top * aspect;
+        this.left = -this.right;
+        this.near = near;
+        this.far = far;
+        this.projectionMatrix.setPerspective(this.left, this.right, this.bottom, this.top, near, far);
+        this.projectionMatrix.inverseTo(this.inverseProjectionMatrix);
+    }
+    /**
+     * Camera's projection matrix values.
+     * @public
+     * @param {Mat4} viewMatrix - View matrix.
+     */
+    setViewMatrix(viewMatrix) {
+        this.projectionViewMatrix = this.projectionMatrix.mul(viewMatrix);
+        this.projectionViewMatrix.inverseTo(this.inverseProjectionViewMatrix);
+        let m = this.projectionViewMatrix._m;
+        /* Right */
+        this._f[0][0] = m[3] - m[0];
+        this._f[0][1] = m[7] - m[4];
+        this._f[0][2] = m[11] - m[8];
+        this._f[0][3] = m[15] - m[12];
+        planeNormalize(this._f[0]);
+        /* Left */
+        this._f[1][0] = m[3] + m[0];
+        this._f[1][1] = m[7] + m[4];
+        this._f[1][2] = m[11] + m[8];
+        this._f[1][3] = m[15] + m[12];
+        planeNormalize(this._f[1]);
+        /* Bottom */
+        this._f[2][0] = m[3] + m[1];
+        this._f[2][1] = m[7] + m[5];
+        this._f[2][2] = m[11] + m[9];
+        this._f[2][3] = m[15] + m[13];
+        planeNormalize(this._f[2]);
+        /* Top */
+        this._f[3][0] = m[3] - m[1];
+        this._f[3][1] = m[7] - m[5];
+        this._f[3][2] = m[11] - m[9];
+        this._f[3][3] = m[15] - m[13];
+        planeNormalize(this._f[3]);
+        /* Backward */
+        this._f[4][0] = m[3] - m[2];
+        this._f[4][1] = m[7] - m[6];
+        this._f[4][2] = m[11] - m[10];
+        this._f[4][3] = m[15] - m[14];
+        planeNormalize(this._f[4]);
+        /* Forward */
+        this._f[5][0] = m[3] + m[2];
+        this._f[5][1] = m[7] + m[6];
+        this._f[5][2] = m[11] + m[10];
+        this._f[5][3] = m[15] + m[14];
+        planeNormalize(this._f[5]);
+    }
+    /**
+     * Returns true if a point in the frustum.
+     * @public
+     * @param {Vec3} point - Cartesian point.
+     * @returns {boolean} -
+     */
+    containsPoint(point) {
+        for (let p = 0; p < 6; p++) {
+            let d = point.dotArr(this._f[p]) + this._f[p][3];
+            if (d <= 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Returns true if the frustum contains a bonding sphere, but bottom plane exclude.
+     * @public
+     * @param {Sphere} sphere - Bounding sphere.
+     * @returns {boolean} -
+     */
+    containsSphereBottomExc(sphere) {
+        let r = -sphere.radius, f = this._f;
+        if (sphere.center.dotArr(f[0]) + f[0][3] <= r)
+            return false;
+        if (sphere.center.dotArr(f[1]) + f[1][3] <= r)
+            return false;
+        if (sphere.center.dotArr(f[3]) + f[3][3] <= r)
+            return false;
+        if (sphere.center.dotArr(f[4]) + f[4][3] <= r)
+            return false;
+        if (sphere.center.dotArr(f[5]) + f[5][3] <= r)
+            return false;
+        return true;
+    }
+    containsSphereButtom(sphere) {
+        let r = -sphere.radius, f = this._f;
+        if (sphere.center.dotArr(f[2]) + f[2][3] <= r)
+            return false;
+        return true;
+    }
+    /**
+     * Returns true if the frustum contains a bonding sphere.
+     * @public
+     * @param {Sphere} sphere - Bounding sphere.
+     * @returns {boolean} -
+     */
+    containsSphere(sphere) {
+        let r = -sphere.radius, f = this._f;
+        if (sphere.center.dotArr(f[0]) + f[0][3] <= r)
+            return false;
+        if (sphere.center.dotArr(f[1]) + f[1][3] <= r)
+            return false;
+        if (sphere.center.dotArr(f[2]) + f[2][3] <= r)
+            return false;
+        if (sphere.center.dotArr(f[3]) + f[3][3] <= r)
+            return false;
+        if (sphere.center.dotArr(f[4]) + f[4][3] <= r)
+            return false;
+        if (sphere.center.dotArr(f[5]) + f[5][3] <= r)
+            return false;
+        return true;
+    }
+    /**
+     * Returns true if the frustum contains a bonding sphere.
+     * @public
+     * @param {Vec3} center - Sphere center.
+     * @param {number} radius - Sphere radius.
+     * @returns {boolean} -
+     */
+    containsSphere2(center, radius) {
+        let r = -radius;
+        if (center.dotArr(this._f[0]) + this._f[0][3] <= r)
+            return false;
+        if (center.dotArr(this._f[1]) + this._f[1][3] <= r)
+            return false;
+        if (center.dotArr(this._f[2]) + this._f[2][3] <= r)
+            return false;
+        if (center.dotArr(this._f[3]) + this._f[3][3] <= r)
+            return false;
+        if (center.dotArr(this._f[4]) + this._f[4][3] <= r)
+            return false;
+        if (center.dotArr(this._f[5]) + this._f[5][3] <= r)
+            return false;
+        return true;
+    }
+    /**
+     * Returns true if the frustum contains a bounding box.
+     * @public
+     * @param {Box} box - Bounding box.
+     * @returns {boolean} -
+     */
+    containsBox(box) {
+        let result = true, cout, cin;
+        for (let i = 0; i < 6; i++) {
+            cout = 0;
+            cin = 0;
+            for (let k = 0; k < 8 && (cin === 0 || cout === 0); k++) {
+                let d = box.vertices[k].dotArr(this._f[i]) + this._f[i][3];
+                if (d < 0) {
+                    cout++;
+                }
+                else {
+                    cin++;
+                }
+            }
+            if (cin === 0) {
+                return false;
+            }
+            else if (cout > 0) {
+                result = true;
+            }
+        }
+        return result;
+    }
+}
+export { Frustum };

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

@@ -0,0 +1,234 @@
+import { Camera, ICameraParams } from "./Camera";
+import { Key } from "../Lock";
+import { LonLat } from "../LonLat";
+import { Planet } from "../scene/Planet";
+import { Vec3 } from "../math/Vec3";
+import { Extent } from "../Extent";
+import { Segment } from "../segment/Segment";
+interface IPlanetCameraParams extends ICameraParams {
+    minAltitude?: number;
+    maxAltitude?: number;
+}
+type CameraFrame = {
+    eye: Vec3;
+    n: Vec3;
+    u: Vec3;
+    v: Vec3;
+};
+/**
+ * Planet camera.
+ * @class
+ * @extends {Camera}
+ * @param {Planet} planet - Planet render node.
+ * @param {IPlanetCameraParams} [options] - Planet camera options:
+ * @param {string} [options.name] - Camera name.
+ * @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 og.math.MAX
+ * @param {number} [options.minAltitude] - Minimal altitude for the camera. Default is 5
+ * @param {number} [options.maxAltitude] - Maximal altitude for the camera. Default 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)
+ */
+declare class PlanetCamera extends Camera {
+    /**
+     * Assigned camera's planet.
+     * @public
+     * @type {Planet}
+     */
+    planet: Planet;
+    /**
+     * Minimal altitude that camera can reach over the terrain.
+     * @public
+     * @type {number}
+     */
+    minAltitude: number;
+    /**
+     * Maximal altitude that camera can reach over the globe.
+     * @public
+     * @type {number}
+     */
+    maxAltitude: number;
+    /**
+     * Current geographical degree position.
+     * @public
+     * @type {LonLat}
+     */
+    _lonLat: LonLat;
+    /**
+     * Current geographical mercator position.
+     * @public
+     * @type {LonLat}
+     */
+    _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 {Segment}
+     */
+    _insideSegment: Segment | null;
+    slope: number;
+    protected _keyLock: Key;
+    protected _framesArr: CameraFrame[];
+    protected _framesCounter: number;
+    protected _numFrames: number;
+    protected _completeCallback: Function | null;
+    protected _frameCallback: Function | null;
+    protected _flying: boolean;
+    protected _checkTerrainCollision: boolean;
+    eyeNorm: Vec3;
+    constructor(planet: Planet, options?: IPlanetCameraParams);
+    setTerrainCollisionActivity(isActive: boolean): void;
+    /**
+     * Updates camera view space.
+     * @public
+     * @virtual
+     */
+    update(): void;
+    updateGeodeticPosition(): void;
+    /**
+     * Sets altitude over the terrain.
+     * @public
+     * @param {number} alt - Altitude over the terrain.
+     */
+    setAltitude(alt: number): void;
+    /**
+     * Gets altitude over the terrain.
+     * @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)
+     */
+    setLonLat(lonlat: LonLat, lookLonLat?: LonLat, up?: Vec3): void;
+    /**
+     * Returns camera geographical position.
+     * @public
+     * @returns {LonLat}
+     */
+    getLonLat(): LonLat;
+    /**
+     * Returns camera height.
+     * @public
+     * @returns {number}
+     */
+    getHeight(): number;
+    /**
+     * Gets position by viewable extent.
+     * @public
+     * @param {Extent} extent - Viewable extent.
+     * @param {Number} height - Camera height
+     * @returns {Vec3}
+     */
+    getExtentPosition(extent: Extent, height?: number): Vec3;
+    /**
+     * View current extent.
+     * @public
+     * @param {Extent} extent - Current extent.
+     * @param {number} [height]
+     */
+    viewExtent(extent: Extent, height?: number): void;
+    /**
+     * Flies to the current extent.
+     * @public
+     * @param {Extent} extent - Current extent.
+     * @param {number} [height] - Destination height.
+     * @param {Vec3} [up] - Camera UP in the end of flying. Default - (0,1,0)
+     * @param {Number} [ampl] - Altitude amplitude factor.
+     * @param {Function} [completeCallback] - Callback that calls after flying when flying is finished.
+     * @param {Function} [startCallback] - Callback that calls before the flying begins.
+     * @param {Function} [frameCallback] - Each frame callback
+     */
+    flyExtent(extent: Extent, height?: number, up?: Vec3, ampl?: number, completeCallback?: Function, startCallback?: Function, frameCallback?: Function): void;
+    viewDistance(cartesian: Vec3, distance?: number): void;
+    flyDistance(cartesian: Vec3, distance?: number, ampl?: number, completeCallback?: Function, startCallback?: Function, frameCallback?: Function): 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 {Function} [completeCallback] - Callback that calls after flying when flying is finished.
+     * @param {Function} [startCallback] - Callback that calls before the flying begins.
+     * @param {Function} [frameCallback] - Each frame callback
+     */
+    flyCartesian(cartesian: Vec3, look?: Vec3 | LonLat | null, up?: Vec3 | null, ampl?: number, completeCallback?: Function | null, startCallback?: Function | null, frameCallback?: Function | null): void;
+    /**
+     * Flies to the geo coordinates.
+     * @public
+     * @param {LonLat} lonlat - Finish coordinates.
+     * @param {Vec3 | LonLat} [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 {Function} [completeCallback] - Callback that calls after flying when flying is finished.
+     * @param {Function} [startCallback] - Callback that calls befor the flying begins.
+     * @param {Function} [frameCallback] - each frame callback
+     */
+    flyLonLat(lonlat: LonLat, look?: Vec3 | LonLat, up?: Vec3, ampl?: number, completeCallback?: Function, startCallback?: Function, frameCallbak?: Function): void;
+    /**
+     * Breaks the flight.
+     * @public
+     */
+    stopFlying(): void;
+    /**
+     * Returns camera is flying.
+     * @public
+     * @returns {boolean}
+     */
+    isFlying(): boolean;
+    /**
+     * Rotates around planet to the left.
+     * @public
+     * @param {number} angle - Rotation angle.
+     * @param {boolean} [spin] - If its true rotates around globe spin.
+     */
+    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.
+     */
+    rotateRight(angle: number, spin: boolean): void;
+    /**
+     * Rotates around planet to the North Pole.
+     * @public
+     * @param {number} angle - Rotation angle.
+     */
+    rotateUp(angle: number): void;
+    /**
+     * Rotates around planet to the South Pole.
+     * @public
+     * @param {number} angle - Rotation angle.
+     */
+    rotateDown(angle: number): void;
+    rotateVertical(angle: number, center: Vec3, minSlope?: number): void;
+    /**
+     * Prepare camera to the frame. Used in render node frame function.
+     * @public
+     */
+    checkFly(): void;
+    checkTerrainCollision(): Vec3 | undefined;
+    getSurfaceVisibleDistance(d: number): number;
+    getHeading(): number;
+    isVisible(poi: Vec3): boolean;
+}
+export { PlanetCamera };