@openglobus/og 0.23.0 → 0.24.1

package/lib/js/Clock.d.ts

@@ -1,5 +1,5 @@
-import { EventsHandler } from "./Events";
-import { JulianDate } from "./astro/jd";
+import { type EventsHandler } from "./Events";
+import type { JulianDate } from "./astro/jd";
 import { Handler } from "./webgl/Handler";
 type ClockEventsList = ["tick", "end", "start", "stop"];
 export interface IClockParams {

package/lib/js/Globe.d.ts

@@ -2,14 +2,15 @@ import { Control } from "./control/Control";
 import { Ellipsoid } from "./ellipsoid/Ellipsoid";
 import { EmptyTerrain } from "./terrain/EmptyTerrain";
 import { Layer } from "./layer/Layer";
-import { NumberArray2 } from "./math/Vec2";
-import { NumberArray4 } from "./math/Vec4";
+import type { NumberArray2 } from "./math/Vec2";
+import type { NumberArray4 } from "./math/Vec4";
 import { Planet } from "./scene/Planet";
 import { Sun } from "./control/Sun";
-import { HTMLDivElementExt, Renderer } from "./renderer/Renderer";
+import { Renderer } from "./renderer/Renderer";
+import type { HTMLDivElementExt } from "./renderer/Renderer";
 import { RenderNode } from "./scene/RenderNode";
 import { Extent } from "./Extent";
-import { IAtmosphereParams } from "./control/Atmosphere";
+import type { IAtmosphereParams } from "./control/Atmosphere";
 export interface IGlobeParams {
     attributionContainer?: HTMLElement;
     target?: string | HTMLElement;
@@ -33,7 +34,6 @@ export interface IGlobeParams {
     transitionOpacityEnabled?: boolean;
     terrain?: EmptyTerrain;
     controls?: Control[];
-    useEarthNavigation?: boolean;
     minSlope?: number;
     sun?: {
         active?: boolean;
@@ -48,6 +48,10 @@ export interface IGlobeParams {
     gamma?: number;
     exposure?: number;
 }
+/**
+ * @typedef {Array<number>} LonLatCoordinate
+ * @typedef {Array<LonLatCoordinate>} ExtentBoundingBox
+ */
 /**
  * Creates a WebGL context with globe.
  * @class
@@ -79,7 +83,7 @@ export interface IGlobeParams {
  * @param {EmptyTerrain} [options.terrain] - Terrain provider. Default no terrain - og.terrain.EmptyTerrain.
  * @param {Array.<Control>} [options.controls] - Renderer controls array.
  * @param {Array.<Layer>} [options.layers] - Planet layers.
- * @param {Extent| [[number, number],[number, number]]} [options.viewExtent] - Viewable starting extent.
+ * @param {Extent | ExtentBoundingBox} [options.viewExtent] [options.viewExtent] - Viewable starting extent.
  * @param {boolean} [options.autoActivate=true] - Globe rendering auto activation flag. True is default.
  * @param {HTMLElement} [options.attributionContainer] - Container for attribution list.
  * @param {number} [options.maxGridSize=128] = Maximal segment grid size. 128 is default

package/lib/js/Globe.js

@@ -1,7 +1,6 @@
-// #StandWithUkraine
+// #StandWith
 import { CompassButton } from "./control/CompassButton";
 import { EarthCoordinates } from "./control/EarthCoordinates";
-import { EarthNavigation } from "./control/EarthNavigation";
 import { EmptyTerrain } from "./terrain/EmptyTerrain";
 import { Handler } from "./webgl/Handler";
 import { isEmpty } from "./utils/shared";
@@ -17,6 +16,10 @@ const DEFAULT_SPEC_SRC = `/spec.png`;
 const DEFAULT_RESOURCES_SRC = '/res';
 /** @const {string} */
 const PLANET_NAME_PREFIX = "globus_planet_";
+/**
+ * @typedef {Array<number>} LonLatCoordinate
+ * @typedef {Array<LonLatCoordinate>} ExtentBoundingBox
+ */
 /**
  * Creates a WebGL context with globe.
  * @class
@@ -48,7 +51,7 @@ const PLANET_NAME_PREFIX = "globus_planet_";
  * @param {EmptyTerrain} [options.terrain] - Terrain provider. Default no terrain - og.terrain.EmptyTerrain.
  * @param {Array.<Control>} [options.controls] - Renderer controls array.
  * @param {Array.<Layer>} [options.layers] - Planet layers.
- * @param {Extent| [[number, number],[number, number]]} [options.viewExtent] - Viewable starting extent.
+ * @param {Extent | ExtentBoundingBox} [options.viewExtent] [options.viewExtent] - Viewable starting extent.
  * @param {boolean} [options.autoActivate=true] - Globe rendering auto activation flag. True is default.
  * @param {HTMLElement} [options.attributionContainer] - Container for attribution list.
  * @param {number} [options.maxGridSize=128] = Maximal segment grid size. 128 is default
@@ -178,7 +181,7 @@ class Globe {
         else {
             this.planet.addControls([
                 new ZoomControl(),
-                options.useEarthNavigation ? new EarthNavigation() : new MouseNavigation({ minSlope: options.minSlope }),
+                new MouseNavigation(),
                 new TouchNavigation(),
                 new EarthCoordinates(),
                 new ScaleControl(),
@@ -262,6 +265,9 @@ class Globe {
                 t.appendChild(this.$inner);
             }
         }
+        else {
+            console.warn(`Target container not found. Provided target: ${target}`);
+        }
     }
     detach() {
         if (this.$target) {

package/lib/js/LonLat.d.ts

@@ -1,5 +1,5 @@
-import { NumberArray2 } from "./math/Vec2";
-import { NumberArray3 } from "./math/Vec3";
+import type { NumberArray2 } from "./math/Vec2";
+import type { NumberArray3 } from "./math/Vec3";
 /**
  * Represents a geographical point with a certain latitude, longitude and height.
  * @class

package/lib/js/Object3d.d.ts

@@ -1,5 +1,6 @@
-import { TypedArray } from './utils/shared';
-import { NumberArray3, Vec3 } from './math/Vec3';
+import type { TypedArray } from './utils/shared';
+import { Vec3 } from './math/Vec3';
+import type { NumberArray3 } from './math/Vec3';
 import { Mat4 } from "./math/Mat4";
 interface IObject3dParams {
     name?: string;

package/lib/js/Popup.d.ts

@@ -1,9 +1,12 @@
-import { EventsHandler } from "./Events";
+import type { EventsHandler } from "./Events";
 import { LonLat } from "./LonLat";
 import { Planet } from "./scene/Planet";
-import { NumberArray2, Vec2 } from "./math/Vec2";
-import { NumberArray3, Vec3 } from "./math/Vec3";
-import { View, IViewParams, ViewEventsList } from './ui/View';
+import { Vec2 } from "./math/Vec2";
+import { Vec3 } from "./math/Vec3";
+import type { NumberArray2 } from "./math/Vec2";
+import type { NumberArray3 } from "./math/Vec3";
+import { View } from './ui/View';
+import type { IViewParams, ViewEventsList } from './ui/View';
 interface IPopupParams extends IViewParams {
     planet: Planet;
     title?: string;

package/lib/js/Popup.js

@@ -117,7 +117,7 @@ class Popup extends View {
             let look = cart.sub(cam.eye), v = Math.sqrt((f + g) * (f + g) - f * f);
             if (v > look.length() && cam.getForward().dot(look.normalize()) > 0.0) {
                 this.el.style.display = "block";
-                this.setScreen(cam.project(cart));
+                this.setScreen(cam.project3v(cart));
             }
             else {
                 this.el.style.display = "none";

package/lib/js/astro/astro.d.ts

@@ -1,4 +1,4 @@
-import { JulianDate } from "./jd";
+import { type JulianDate } from "./jd";
 /**
  * Angle between J2000 mean equator and the ecliptic plane.
  * 23 deg 26' 21".448 (Seidelmann, _Explanatory Supplement to the

package/lib/js/astro/earth.d.ts

@@ -1,5 +1,5 @@
 import { Vec3 } from "../math/Vec3";
-import { JulianDate } from "./jd";
+import type { JulianDate } from "./jd";
 /**
  * Returns Sun position in the geocentric coordinate system by the time.
  * @param {JulianDate} jDate - Julian date time.

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

@@ -1,5 +1,5 @@
 import { Vec3 } from "../math/Vec3";
-import { NumberArray6 } from "./Sphere";
+import type { NumberArray6 } from "./Sphere";
 import { Ellipsoid } from "../ellipsoid/Ellipsoid";
 import { Extent } from "../Extent";
 type Vec3Array8 = [Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3];

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

@@ -1,11 +1,15 @@
-import { EventsHandler } from "../Events";
+import { type EventsHandler } from "../Events";
 import { Frustum } from "./Frustum";
-import { Mat3, NumberArray9 } from "../math/Mat3";
-import { Mat4, NumberArray16 } from "../math/Mat4";
+import { Mat3 } from "../math/Mat3";
+import type { NumberArray9 } from "../math/Mat3";
+import { Mat4 } from "../math/Mat4";
+import type { NumberArray16 } from "../math/Mat4";
 import { Renderer } from "../renderer/Renderer";
-import { Vec2, NumberArray2 } from "../math/Vec2";
+import { Vec2 } from "../math/Vec2";
+import type { NumberArray2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
 import { Sphere } from "../bv/Sphere";
+import { Quat } from "../math/Quat";
 type CameraEvents = ["viewchange", "moveend"];
 export interface ICameraParams {
     eye?: Vec3;
@@ -89,22 +93,28 @@ declare class Camera {
     protected _normalMatrix: Mat3;
     /**
      * Camera right vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _r: Vec3;
     /**
      * Camera up vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _u: Vec3;
     /**
      * Camera backward vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _b: Vec3;
+    /**
+     * Camera forward vector.
+     * @protected
+     * @type {Vec3}
+     */
+    _f: Vec3;
     protected _pr: Vec3;
     protected _pu: Vec3;
     protected _pb: Vec3;
@@ -208,23 +218,40 @@ declare class Camera {
      */
     slide(du: number, dv: number, dn: number): void;
     /**
-     * Roll the camera to the angle in degrees
+     * Roll the camera to the angle in radians
+     * @public
+     * @param {number} angle - Delta roll angle in radians
+     */
+    setRoll(angle: number): void;
+    /**
+     * Pitch the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta roll angle in degrees
+     * @param {number} angle - Delta pitch angle in radians
      */
-    roll(angle: number): void;
+    setPitch(angle: number): void;
     /**
-     * Pitch the camera to the angle in degrees
+     * Yaw the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta pitch angle in degrees
+     * @param {number} angle - Delta yaw angle in radians
+     */
+    setYaw(angle: number): void;
+    setPitchYawRoll(pitch: number, yaw: number, roll: number): void;
+    getPitch(): number;
+    getYaw(): number;
+    getRoll(): number;
+    /**
+     * Returns camera quaternion
      */
-    pitch(angle: number): void;
+    getRotation(): Quat;
+    setRotation(rot: Quat, up?: Vec3, right?: Vec3, back?: Vec3): void;
+    rotate(rot: Quat): void;
     /**
-     * Yaw the camera to the angle in degrees
+     * Returns normal vector direction to the unprojected screen point from camera eye
      * @public
-     * @param {number} angle - Delta yaw angle in degrees
+     * @param {Vec2} pos - Screen X coordinate
+     * @returns {Vec3} - Direction vector
      */
-    yaw(angle: number): void;
+    unproject2v(pos: Vec2): Vec3;
     /**
      * Returns normal vector direction to the unprojected screen point from camera eye
      * @public
@@ -239,7 +266,16 @@ declare class Camera {
      * @param {Vec3} v - Cartesian 3d coordinates
      * @returns {Vec2} - Screen point coordinates
      */
-    project(v: Vec3): Vec2;
+    project3v(v: Vec3): Vec2;
+    /**
+     * 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: number, y: number, z: number): Vec2;
     /**
      * Rotates camera around center point
      * @public
@@ -249,7 +285,7 @@ declare class Camera {
      * @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;
+    rotateAround(angle: number, isArc?: boolean, center?: Vec3, up?: Vec3): void;
     /**
      * Rotates camera around center point by horizontal.
      * @public
@@ -259,7 +295,7 @@ declare class Camera {
      * @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;
+    rotateHorizontal(angle: number, isArc?: boolean, center?: Vec3, up?: Vec3): void;
     /**
      * Rotates camera around center point by vertical.
      * @param {number} angle - Rotation angle in radians.

package/lib/js/camera/Camera.js

@@ -7,6 +7,7 @@ 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.
@@ -50,6 +51,7 @@ class Camera {
         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();
@@ -147,7 +149,7 @@ class Camera {
         return this._r.negateTo();
     }
     getForward() {
-        return this._b.negateTo();
+        return this._f.clone();
     }
     getBackward() {
         return this._b.clone();
@@ -218,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);
         }
@@ -264,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;
     }
     /**
@@ -276,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));
     }
@@ -292,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
@@ -346,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);
     }
     /**
@@ -359,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.

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

@@ -1,6 +1,6 @@
 import { Box } from "../bv/Box";
-import { Mat4, NumberArray16 } from "../math/Mat4";
-import { NumberArray4 } from "../math/Vec4";
+import { Mat4, type NumberArray16 } from "../math/Mat4";
+import type { NumberArray4 } from "../math/Vec4";
 import { Sphere } from "../bv/Sphere";
 import { Vec3 } from "../math/Vec3";
 interface IFrustumParams {

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

@@ -1,4 +1,4 @@
-import { Camera, ICameraParams } from "./Camera";
+import { Camera, type ICameraParams } from "./Camera";
 import { Key } from "../Lock";
 import { LonLat } from "../LonLat";
 import { Planet } from "../scene/Planet";
@@ -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 };