@openglobus/og 0.22.2 → 0.24.0

package/lib/js/camera/Camera.js

@@ -6,6 +6,8 @@ import { Mat4 } from "../math/Mat4";
 import { Vec2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
 import { Vec4 } from "../math/Vec4";
+import { Quat } from "../math/Quat";
+import { RADIANS } from "../math";
 const EVENT_NAMES = [
     /**
      * When camera has been updated.
@@ -44,10 +46,12 @@ class Camera {
         this._aspect = options.aspect || 1.0;
         this._viewAngle = options.viewAngle || 47.0;
         this._viewMatrix = new Mat4();
+        this._viewMatrixRTE = new Mat4();
         this._normalMatrix = new Mat3();
         this._r = new Vec3(1.0, 0.0, 0.0);
         this._u = new Vec3(0.0, 1.0, 0.0);
         this._b = new Vec3(0.0, 0.0, 1.0);
+        this._f = this._b.negateTo();
         // Previous frame values
         this._pr = this._r.clone();
         this._pu = this._u.clone();
@@ -74,7 +78,7 @@ class Camera {
             }
         }
         else {
-            let near = 1.0, far = 10000.0;
+            let near = 0.1, far = 1000.0;
             let fr = new Frustum({
                 fov: this._viewAngle,
                 aspect: this._aspect,
@@ -88,6 +92,7 @@ class Camera {
         }
         this.FARTHEST_FRUSTUM_INDEX = this.frustums.length - 1;
         this.currentFrustumIndex = 0;
+        this.frustumColorIndex = 0;
         this.isFirstPass = false;
         this._projSizeConst = 0;
         this.set(options.eye || new Vec3(0.0, 0.0, 1.0), options.look || new Vec3(), options.up || new Vec3(0.0, 1.0, 0.0));
@@ -144,7 +149,7 @@ class Camera {
         return this._r.negateTo();
     }
     getForward() {
-        return this._b.negateTo();
+        return this._f.clone();
     }
     getBackward() {
         return this._b.clone();
@@ -163,10 +168,17 @@ class Camera {
             u.z, v.z, n.z, 0.0,
             -eye.dot(u), -eye.dot(v), -eye.dot(n), 1.0
         ]);
+        this._viewMatrixRTE.set([
+            u.x, v.x, n.x, 0.0,
+            u.y, v.y, n.y, 0.0,
+            u.z, v.z, n.z, 0.0,
+            0, 0, 0, 1.0
+        ]);
         // do not clean up, someday it will be using
         //this._normalMatrix = this._viewMatrix.toMatrix3(); // this._viewMatrix.toInverseMatrix3().transposeTo();
         for (let i = 0, len = this.frustums.length; i < len; i++) {
             this.frustums[i].setViewMatrix(this._viewMatrix);
+            this.frustums[i].setProjectionViewRTEMatrix(this._viewMatrixRTE);
         }
         this.events.dispatch(this.events.viewchange, this);
     }
@@ -208,7 +220,7 @@ class Camera {
         this._tanViewAngle_hradOneByHeight =
             this._tanViewAngle_hrad * this.renderer.handler._oneByHeight;
         let c = this.renderer.handler.canvas;
-        this._projSizeConst = Math.min(c.clientWidth < 512 ? 512 : c.clientWidth, c.clientHeight < 512 ? 512 : c.clientHeight) / (angle * math.RADIANS);
+        this._projSizeConst = Math.min(c.clientWidth < 512 ? 512 : c.clientWidth, c.clientHeight < 512 ? 512 : c.clientHeight) / (angle * RADIANS);
         for (let i = 0, len = this.frustums.length; i < len; i++) {
             this.frustums[i].setProjectionMatrix(angle, aspect, this.frustums[i].near, this.frustums[i].far);
         }
@@ -254,6 +266,7 @@ class Camera {
         this._b.normalize();
         this._r.normalize();
         this._u.copy(this._b.cross(this._r));
+        this._f.set(-this._b.x, -this._b.y, -this._b.z);
         return this;
     }
     /**
@@ -266,6 +279,7 @@ class Camera {
         this._b.set(this.eye.x - look.x, this.eye.y - look.y, this.eye.z - look.z);
         this._r.copy((up || this._u).cross(this._b));
         this._b.normalize();
+        this._f.set(-this._b.x, -this._b.y, -this._b.z);
         this._r.normalize();
         this._u.copy(this._b.cross(this._r));
     }
@@ -282,41 +296,82 @@ class Camera {
         this.eye.z += du * this._r.z + dv * this._u.z + dn * this._b.z;
     }
     /**
-     * Roll the camera to the angle in degrees
+     * Roll the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta roll angle in degrees
+     * @param {number} angle - Delta roll angle in radians
      */
-    roll(angle) {
-        let cs = Math.cos(math.RADIANS * angle);
-        let sn = Math.sin(math.RADIANS * angle);
+    setRoll(angle) {
+        let cs = Math.cos(angle);
+        let sn = Math.sin(angle);
         let t = this._r.clone();
         this._r.set(cs * t.x - sn * this._u.x, cs * t.y - sn * this._u.y, cs * t.z - sn * this._u.z);
         this._u.set(sn * t.x + cs * this._u.x, sn * t.y + cs * this._u.y, sn * t.z + cs * this._u.z);
     }
     /**
-     * Pitch the camera to the angle in degrees
+     * Pitch the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta pitch angle in degrees
+     * @param {number} angle - Delta pitch angle in radians
      */
-    pitch(angle) {
-        let cs = Math.cos(math.RADIANS * angle);
-        let sn = Math.sin(math.RADIANS * angle);
-        let t = this._b.clone();
+    setPitch(angle) {
+        let cs = Math.cos(angle);
+        let sn = Math.sin(angle);
+        let t = this._b;
         this._b.set(cs * t.x - sn * this._u.x, cs * t.y - sn * this._u.y, cs * t.z - sn * this._u.z);
         this._u.set(sn * t.x + cs * this._u.x, sn * t.y + cs * this._u.y, sn * t.z + cs * this._u.z);
     }
     /**
-     * Yaw the camera to the angle in degrees
+     * Yaw the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta yaw angle in degrees
+     * @param {number} angle - Delta yaw angle in radians
      */
-    yaw(angle) {
-        let cs = Math.cos(math.RADIANS * angle);
-        let sn = Math.sin(math.RADIANS * angle);
-        let t = this._r.clone();
+    setYaw(angle) {
+        let cs = Math.cos(angle);
+        let sn = Math.sin(angle);
+        let t = this._r;
         this._r.set(cs * t.x - sn * this._b.x, cs * t.y - sn * this._b.y, cs * t.z - sn * this._b.z);
         this._b.set(sn * t.x + cs * this._b.x, sn * t.y + cs * this._b.y, sn * t.z + cs * this._b.z);
     }
+    setPitchYawRoll(pitch, yaw, roll) {
+        let qRot = new Quat();
+        qRot.setPitchYawRoll(pitch, yaw, roll);
+        this.setRotation(qRot);
+    }
+    getPitch() {
+        return this.getRotation().getPitch();
+    }
+    getYaw() {
+        return this.getRotation().getYaw();
+    }
+    getRoll() {
+        return this.getRotation().getRoll();
+    }
+    /**
+     * Returns camera quaternion
+     */
+    getRotation() {
+        return Quat.getLookRotation(this._f, this._u).conjugate();
+    }
+    setRotation(rot, up, right, back) {
+        rot.mulVec3Res(up || new Vec3(0, 1, 0), this._u);
+        rot.mulVec3Res(right || new Vec3(1, 0, 0), this._r);
+        rot.mulVec3Res(back || new Vec3(0, 0, 1), this._b);
+        this._f.set(-this._b.x, -this._b.y, -this._b.z);
+    }
+    rotate(rot) {
+        rot.mulVec3Res(this._u, this._u);
+        rot.mulVec3Res(this._r, this._r);
+        rot.mulVec3Res(this._b, this._b);
+        this._f.set(-this._b.x, -this._b.y, -this._b.z);
+    }
+    /**
+     * 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) {
+        return this.unproject(pos.x, pos.y);
+    }
     /**
      * Returns normal vector direction to the unprojected screen point from camera eye
      * @public
@@ -336,8 +391,19 @@ class Camera {
      * @param {Vec3} v - Cartesian 3d coordinates
      * @returns {Vec2} - Screen point coordinates
      */
-    project(v) {
-        let r = this.frustums[0].projectionViewMatrix.mulVec4(v.toVec4()), c = this.renderer.handler.canvas;
+    project3v(v) {
+        return this.project(v.x, v.y, v.z);
+    }
+    /**
+     * 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, y, z) {
+        let r = this.frustums[0].projectionViewMatrix.mulVec4(new Vec4(x, y, z, 1.0)), c = this.renderer.handler.canvas;
         return new Vec2((1 + r.x / r.w) * c.width * 0.5, (1 - r.y / r.w) * c.height * 0.5);
     }
     /**
@@ -349,17 +415,15 @@ class Camera {
      * @param {Vec3} [center] - Point that the camera rotates around
      * @param {Vec3} [up] - Camera up vector
      */
-    rotateAround(angle, isArc, center, up) {
-        center = center || Vec3.ZERO;
-        up = up || Vec3.UP;
-        let rot = new Mat4().setRotation(isArc ? this._u : up, angle);
-        let tr = new Mat4().setIdentity().translate(center);
-        let ntr = new Mat4().setIdentity().translate(center.negateTo());
-        let trm = tr.mul(rot).mul(ntr);
+    rotateAround(angle, isArc = false, center = Vec3.ZERO, up = Vec3.UP) {
+        up = isArc ? this._u : up;
+        let rot = Mat4.getRotation(angle, up);
+        let trm = Mat4.getRotationAroundPoint(angle, center, up);
         this.eye = trm.mulVec3(this.eye);
         this._u = rot.mulVec3(this._u).normalize();
         this._r = rot.mulVec3(this._r).normalize();
         this._b = rot.mulVec3(this._b).normalize();
+        this._f.set(-this._b.x, -this._b.y, -this._b.z);
     }
     /**
      * Rotates camera around center point by horizontal.
@@ -409,6 +473,7 @@ class Camera {
     }
     setCurrentFrustum(k) {
         this.currentFrustumIndex = k;
+        this.frustumColorIndex = (k + 1) * 10.0 / 255.0;
         this.isFirstPass = k === this.FARTHEST_FRUSTUM_INDEX;
     }
     getCurrentFrustum() {
@@ -441,6 +506,14 @@ class Camera {
     getProjectionViewMatrix() {
         return this.frustum.projectionViewMatrix._m;
     }
+    /**
+     * Returns projection and model RTE matrix product.
+     * @public
+     * @return {Mat4} - Projection-view matrix.
+     */
+    getProjectionViewRTEMatrix() {
+        return this.frustum.projectionViewRTEMatrix._m;
+    }
     /**
      * Returns inverse projection and model matrix product.
      * @public
@@ -457,5 +530,12 @@ class Camera {
     getInverseProjectionMatrix() {
         return this.frustum.inverseProjectionMatrix._m;
     }
+    viewDistance(cartesian, distance = 10000.0) {
+        let p0 = this.eye.add(this.getForward().scaleTo(distance));
+        let _rot = Quat.getRotationBetweenVectors(p0.getNormal(), cartesian.getNormal());
+        let newPos = cartesian.add(this.getBackward().scaleTo(distance));
+        this.set(newPos, cartesian);
+        this.update();
+    }
 }
 export { Camera };

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

@@ -35,6 +35,7 @@ declare class Frustum {
      * @type {Mat4}
      */
     projectionViewMatrix: Mat4;
+    projectionViewRTEMatrix: Mat4;
     /**
      * Inverse projectionView Matrix.
      * @protected
@@ -81,6 +82,7 @@ declare class Frustum {
     getBackwardPlane(): NumberArray4;
     getForwardPlane(): NumberArray4;
     getProjectionViewMatrix(): NumberArray16;
+    getProjectionViewRTEMatrix(): NumberArray16;
     getProjectionMatrix(): NumberArray16;
     getInverseProjectionMatrix(): NumberArray16;
     /**
@@ -92,6 +94,7 @@ declare class Frustum {
      * @param {number} far - Far camera distance.
      */
     setProjectionMatrix(angle: number, aspect: number, near: number, far: number): void;
+    setProjectionViewRTEMatrix(viewRTEMatrix: Mat4): void;
     /**
      * Camera's projection matrix values.
      * @public

package/lib/js/camera/Frustum.js

@@ -19,6 +19,7 @@ class Frustum {
         this.projectionMatrix = new Mat4();
         this.inverseProjectionMatrix = new Mat4();
         this.projectionViewMatrix = new Mat4();
+        this.projectionViewRTEMatrix = new Mat4();
         this.inverseProjectionViewMatrix = new Mat4();
         this.left = 0.0;
         this.right = 0.0;
@@ -50,6 +51,9 @@ class Frustum {
     getProjectionViewMatrix() {
         return this.projectionViewMatrix._m;
     }
+    getProjectionViewRTEMatrix() {
+        return this.projectionViewRTEMatrix._m;
+    }
     getProjectionMatrix() {
         return this.projectionMatrix._m;
     }
@@ -74,6 +78,9 @@ class Frustum {
         this.projectionMatrix.setPerspective(this.left, this.right, this.bottom, this.top, near, far);
         this.projectionMatrix.inverseTo(this.inverseProjectionMatrix);
     }
+    setProjectionViewRTEMatrix(viewRTEMatrix) {
+        this.projectionViewRTEMatrix = this.projectionMatrix.mul(viewRTEMatrix);
+    }
     /**
      * Camera's projection matrix values.
      * @public

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

@@ -228,7 +228,20 @@ declare class PlanetCamera extends Camera {
     checkFly(): void;
     checkTerrainCollision(): Vec3 | undefined;
     getSurfaceVisibleDistance(d: number): number;
+    /**
+     * should be yje same as getYaw
+     */
     getHeading(): number;
     isVisible(poi: Vec3): boolean;
+    getPitch(): number;
+    /**
+     * should be the same as getHeading
+     */
+    getYaw(): number;
+    getRoll(): number;
+    setPitch(a: number): void;
+    setYaw(a: number): void;
+    setRoll(a: number): void;
+    setPitchYawRoll(pitch: number, yaw: number, roll: number): void;
 }
 export { PlanetCamera };

package/lib/js/camera/PlanetCamera.js

@@ -7,6 +7,7 @@ import { Mat4 } from "../math/Mat4";
 import { Quat } from "../math/Quat";
 import { Ray } from "../math/Ray";
 import { Vec3 } from "../math/Vec3";
+import { RADIANS } from "../math";
 /**
  * Planet camera.
  * @class
@@ -167,7 +168,7 @@ class PlanetCamera extends Camera {
         let up = right.cross(direction).normalize();
         let _h = Math.max(Math.abs(up.dot(northWest)), Math.abs(up.dot(southEast)), Math.abs(up.dot(northEast)), Math.abs(up.dot(southWest)));
         let _w = Math.max(Math.abs(right.dot(northWest)), Math.abs(right.dot(southEast)), Math.abs(right.dot(northEast)), Math.abs(right.dot(southWest)));
-        let tanPhi = Math.tan(this._viewAngle * math.RADIANS * 0.5);
+        let tanPhi = Math.tan(this._viewAngle * RADIANS * 0.5);
         let tanTheta = this._aspect * tanPhi;
         let d = Math.max(_w / tanTheta, _h / tanPhi);
         center.normalize();
@@ -329,6 +330,7 @@ class PlanetCamera extends Camera {
         this._framesArr = [];
         this._framesCounter = -1;
         this._frameCallback = null;
+        this.planet.stopDragging();
     }
     /**
      * Returns camera is flying.
@@ -345,7 +347,7 @@ class PlanetCamera extends Camera {
      * @param {boolean} [spin] - If its true rotates around globe spin.
      */
     rotateLeft(angle, spin) {
-        this.rotateHorizontal(angle * math.RADIANS, spin !== true, Vec3.ZERO);
+        this.rotateHorizontal(angle, spin !== true, Vec3.ZERO);
         this.update();
     }
     /**
@@ -355,7 +357,7 @@ class PlanetCamera extends Camera {
      * @param {boolean} [spin] - If its true rotates around globe spin.
      */
     rotateRight(angle, spin) {
-        this.rotateHorizontal(-angle * math.RADIANS, spin !== true, Vec3.ZERO);
+        this.rotateHorizontal(-angle, spin !== true, Vec3.ZERO);
         this.update();
     }
     /**
@@ -364,7 +366,7 @@ class PlanetCamera extends Camera {
      * @param {number} angle - Rotation angle.
      */
     rotateUp(angle) {
-        this.rotateVertical(angle * math.RADIANS, Vec3.ZERO);
+        this.rotateVertical(angle, Vec3.ZERO);
         this.update();
     }
     /**
@@ -373,7 +375,7 @@ class PlanetCamera extends Camera {
      * @param {number} angle - Rotation angle.
      */
     rotateDown(angle) {
-        this.rotateVertical(-angle * math.RADIANS, Vec3.ZERO);
+        this.rotateVertical(-angle, Vec3.ZERO);
         this.update();
     }
     rotateVertical(angle, center, minSlope = 0) {
@@ -398,6 +400,7 @@ class PlanetCamera extends Camera {
                 this._u = u;
                 this._r = r;
                 this._b = b;
+                this._f.set(-b.x, -b.y, -b.z);
             }
         }
         else {
@@ -405,6 +408,7 @@ class PlanetCamera extends Camera {
             this._u = u;
             this._r = r;
             this._b = b;
+            this._f.set(-b.x, -b.y, -b.z);
         }
     }
     /**
@@ -421,6 +425,7 @@ class PlanetCamera extends Camera {
             this._r = this._framesArr[c].u;
             this._u = this._framesArr[c].v;
             this._b = this._framesArr[c].n;
+            this._f.set(-this._b.x, -this._b.y, -this._b.z);
             if (this._frameCallback) {
                 this._frameCallback();
             }
@@ -449,6 +454,9 @@ class PlanetCamera extends Camera {
         let R = this.planet.ellipsoid.equatorialSize;
         return R * Math.acos(R / (R + this._lonLat.height + d));
     }
+    /**
+     * should be yje same as getYaw
+     */
     getHeading() {
         let u = this.eye.getNormal();
         let f = Vec3.proj_b_to_plane(this.slope >= 0.97 ? this.getUp() : this.getForward(), u).normalize(), n = Vec3.proj_b_to_plane(Vec3.NORTH, u).normalize();
@@ -462,5 +470,44 @@ class PlanetCamera extends Camera {
         let e = this.eye.length();
         return this.eye.distance(poi) < Math.sqrt(e * e - this.planet.ellipsoid.equatorialSizeSqr);
     }
+    getPitch() {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        return qFrame.conjugate().inverse().mul(this.getRotation()).getPitch();
+    }
+    /**
+     * should be the same as getHeading
+     */
+    getYaw() {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        return qFrame.conjugate().inverse().mul(this.getRotation()).getYaw();
+    }
+    getRoll() {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        return qFrame.conjugate().inverse().mul(this.getRotation()).getRoll();
+    }
+    setPitch(a) {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        let qRot = new Quat();
+        qRot.setPitchYawRoll(a, this.getYaw(), this.getRoll(), qFrame);
+        this.setRotation(qRot);
+    }
+    setYaw(a) {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        let qRot = new Quat();
+        qRot.setPitchYawRoll(this.getYaw(), a, this.getRoll(), qFrame);
+        this.setRotation(qRot);
+    }
+    setRoll(a) {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        let qRot = new Quat();
+        qRot.setPitchYawRoll(this.getPitch(), this.getYaw(), a, qFrame);
+        this.setRotation(qRot);
+    }
+    setPitchYawRoll(pitch, yaw, roll) {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        let qRot = new Quat();
+        qRot.setPitchYawRoll(pitch, yaw, roll, qFrame).conjugate();
+        this.setRotation(qRot);
+    }
 }
 export { PlanetCamera };

package/lib/js/control/Atmosphere.js

@@ -94,18 +94,22 @@ export class Atmosphere extends Control {
             width: width,
             height: height,
             useDepth: false,
-            filter: "LINEAR",
-            type: "FLOAT",
-            internalFormat: "RGBA16F"
+            targets: [{
+                    filter: "LINEAR",
+                    type: "FLOAT",
+                    internalFormat: "RGBA16F"
+                }]
         });
         this._transmittanceBuffer.init();
         this._scatteringBuffer = new Framebuffer(this.renderer.handler, {
             width: width,
             height: height,
             useDepth: false,
-            filter: "LINEAR",
-            type: "FLOAT",
-            internalFormat: "RGBA16F"
+            targets: [{
+                    filter: "LINEAR",
+                    type: "FLOAT",
+                    internalFormat: "RGBA16F"
+                }]
         });
         this._scatteringBuffer.init();
     }

package/lib/js/control/CameraLock.d.ts

@@ -0,0 +1,38 @@
+import { Control, IControlParams } from "./Control";
+import { LonLat } from "../LonLat";
+import { Vec3 } from "../math/Vec3";
+import { EventsHandler } from "../Events";
+import { Entity } from "../entity/Entity";
+import { IMouseState } from "../renderer/RendererEvents";
+import { Planet } from "../scene/Planet";
+type CameraLockEventsList = ["lockview", "unlockview"];
+interface ICameraLockParams extends IControlParams {
+    planet?: Planet | null;
+}
+export declare class CameraLock extends Control {
+    events: EventsHandler<CameraLockEventsList>;
+    protected _lockDistance: number;
+    protected _isFromTheBack: boolean;
+    protected _lockEntity: Entity | null;
+    protected _viewDir: Vec3;
+    constructor(options?: ICameraLockParams);
+    onactivate(): void;
+    ondeactivate(): void;
+    oninit(): void;
+    flyCartesian(cartesian: Vec3, dist?: number): void;
+    lockView(entity: Entity, fromTheBack?: boolean): void;
+    protected _activateNav(): void;
+    protected _deactivateNav(): void;
+    unlockView(): void;
+    private _getCenterDist;
+    protected _getDistance(entity: Entity, prevEntity?: Entity | null): number;
+    isVisibleDistance(cart: Vec3, C?: number): boolean;
+    get lockEntity(): Entity | null;
+    flyLonLat(lonLat: LonLat, dist?: number): void;
+    protected _activateLockViewEvents(): void;
+    protected _deactivateLockViewEvents(): void;
+    private _onLockViewDraw;
+    protected _onMouseWheel: (e: IMouseState) => void;
+    protected _onMouseMove: (ms: IMouseState) => void;
+}
+export {};