@openglobus/og 0.15.4 → 0.16.0

package/src/og/utils/objParser.js

@@ -0,0 +1,227 @@
+export function objParser(text){
+    const objPositions = [[0, 0, 0]];
+    const objTexcoords = [[0, 0]];
+    const objNormals = [[0, 0, 0]];
+
+    // same order as `f` indices
+    const objVertexData = [
+        objPositions,
+        objTexcoords,
+        objNormals,
+    ];
+
+    // same order as `f` indices
+    let vertexData = [
+        [],   // positions
+        [],   // texcoords
+        [],   // normals
+    ];
+
+    const materialLibs = [];
+    const geometries = [];
+    let geometry;
+    let groups = ['default'];
+    let material = 'default';
+    let object = 'default';
+
+    const noop = () => {};
+
+    function newGeometry() {
+        // If there is an existing geometry and it's
+        // not empty then start a new one.
+        if (geometry && geometry.data.vertices.length) {
+            geometry = undefined;
+        }
+    }
+
+    function setGeometry() {
+        if (!geometry) {
+            const vertices = [];
+            const textures = [];
+            const normals = [];
+            vertexData = [
+                vertices,
+                textures,
+                normals,
+            ];
+            geometry = {
+                object,
+                groups,
+                material,
+                data: {
+                    vertices,
+                    textures,
+                    normals,
+                },
+            };
+            geometries.push(geometry);
+        }
+    }
+
+    function addVertex(vert) {
+        const ptn = vert.split('/');
+        ptn.forEach((objIndexStr, i) => {
+            if (!objIndexStr) {
+                return;
+            }
+            const objIndex = parseInt(objIndexStr);
+            const index = objIndex + (objIndex >= 0 ? 0 : objVertexData[i].length);
+            vertexData[i].push(...objVertexData[i][index]);
+        });
+    }
+
+    const keywords = {
+        v(parts) {
+            objPositions.push(parts.map(parseFloat));
+        },
+        vn(parts) {
+            objNormals.push(parts.map(parseFloat));
+        },
+        vt(parts) {
+            // should check for missing v and extra w?
+            objTexcoords.push(parts.map(parseFloat));
+        },
+        f(parts) {
+            setGeometry();
+            const numTriangles = parts.length - 2;
+            for (let tri = 0; tri < numTriangles; ++tri) {
+                addVertex(parts[0]);
+                addVertex(parts[tri + 1]);
+                addVertex(parts[tri + 2]);
+            }
+        },
+        s: noop,    // smoothing group
+        mtllib(parts, unparsedArgs) {
+            // the spec says there can be multiple filenames here
+            // but many exist with spaces in a single filename
+            materialLibs.push(unparsedArgs);
+        },
+        usemtl(parts, unparsedArgs) {
+            material = unparsedArgs;
+            newGeometry();
+        },
+        g(parts) {
+            groups = parts;
+            newGeometry();
+        },
+        o(parts, unparsedArgs) {
+            object = unparsedArgs;
+            newGeometry();
+        },
+    };
+
+    const keywordRE = /(\w*)(?: )*(.*)/;
+    const lines = text.split('\n');
+    for (let lineNo = 0; lineNo < lines.length; ++lineNo) {
+        const line = lines[lineNo].trim();
+        if (line === '' || line.startsWith('#')) {
+            continue;
+        }
+        const m = keywordRE.exec(line);
+        if (!m) {
+            continue;
+        }
+        const [, keyword, unparsedArgs] = m;
+        const parts = line.split(/\s+/).slice(1);
+        const handler = keywords[keyword];
+        if (!handler) {
+            console.warn('unhandled keyword:', keyword);  // eslint-disable-line no-console
+            continue;
+        }
+        handler(parts, unparsedArgs);
+    }
+
+    // remove any arrays that have no entries.
+    for (const geometry of geometries) {
+        geometry.data = Object.fromEntries(
+            Object.entries(geometry.data).filter(([, array]) => array.length > 0));
+    }
+
+    return {
+        geometries,
+        materialLibs,
+    };
+}
+
+export function transformLeftToRightCoordinateSystem(objData) {
+    const convertedGeometries = objData.geometries.map(geometry => {
+        const vertices = geometry.data.vertices;
+        const normals = geometry.data.normals;
+        const textures = geometry.data.textures;
+        rotateObject(geometry.data, 0)
+        const convertedVertices = [];
+        const convertedNormals = [];
+        const convertedTextures = [];
+
+        // Convert positions
+        for (let i = 0; i < vertices.length; i += 3) {
+            const x = vertices[i];
+            const y = vertices[i + 1];
+            const z = vertices[i + 2];
+            convertedVertices.push(x, y, z);
+        }
+
+        // Convert normals
+        for (let i = 0; i < normals.length; i += 3) {
+            const x = normals[i];
+            const y = normals[i + 1];
+            const z = normals[i + 2];
+            convertedNormals.push(x, y, -z);
+        }
+
+        // Convert textures
+        for (let i = 0; i < textures.length; i += 2) {
+            const s = textures[i];
+            const t = 1 - textures[i + 1];
+            convertedTextures.push(s, t);
+        }
+
+        return {
+            object: geometry.object,
+            groups: geometry.groups,
+            material: geometry.material,
+            data: {
+                vertices: convertedVertices,
+                normals: convertedNormals,
+                textures: convertedTextures
+            }
+        };
+    });
+
+    return {
+        geometries: convertedGeometries,
+        materialLibs: objData.materialLibs
+    };
+}
+
+function rotateObject(obj, angle) {
+    const cosA = Math.cos(angle);
+    const sinA = Math.sin(angle);
+
+    const vertices = obj.vertices;
+    const normals = obj.normals;
+
+    for (let i = 0; i < vertices.length; i += 3) {
+        const x = vertices[i];
+        const y = vertices[i + 1];
+        const z = vertices[i + 2];
+
+        vertices[i] = x * cosA + z * sinA;
+        vertices[i + 1] = y;
+        vertices[i + 2] = -x * sinA + z * cosA;
+
+        const nx = normals[i];
+        const ny = normals[i + 1];
+        const nz = normals[i + 2];
+
+        normals[i] = nx * cosA + nz * sinA;
+        normals[i + 1] = ny;
+        normals[i + 2] = -nx * sinA + nz * cosA;
+    }
+
+    return {
+        vertices: vertices,
+        normals: normals
+    };
+}
+

package/src/og/utils/shared.js

@@ -958,4 +958,13 @@ export async function loadImage(url) {
         image.src = url;
         return image;
     });
+}
+
+/**
+ * Gets image is loaded
+ * @param {HTMLImageElement} image
+ * @returns {boolean} Returns true is the image is loaded
+ */
+export function isImageLoaded(image) {
+    return image.complete && image.naturalHeight !== 0;
 }

package/src/og/webgl/Handler.js

@@ -291,7 +291,7 @@ class Handler {
     /**
      * Creates NEAREST filter texture.
      * @public
-     * @param {Object} image - Image or Canvas object.
+     * @param {HTMLCanvasElement | Image} image - Image or Canvas object.
      * @returns {Object} - WebGL texture object.
      */
     createTexture_n_webgl1(image, internalFormat, texture) {
@@ -934,8 +934,6 @@ class Handler {
      */
     start() {
         if (!this._requestAnimationFrameId && this._initialized) {
-            this._lastAnimationFrameTime = window.performance.now();
-            this.defaultClock.setDate(new Date());
             this._animationFrameCallback();
         }
     }

package/types/Globe.d.ts

@@ -43,6 +43,8 @@
  * @param {Number} [options.minEqualZoomCameraSlope=0.8] - Minimal camera slope above te globe where segments on the screen bacame the same zoom level
  * @param {Number} [options.loadingBatchSize=12] -
  * @param {Number} [options.quadTreeStrategyPrototype] - Prototype of quadTree. QuadTreeStrategy for Earth is default.
+ * @param {Number} [options.msaa] - MSAA antialiasing parameter: 2,4,8,16. Default is 4.
+ * @param {Number} [options.dpi] - Device pixel ratio. Default is current screen DPI.
  */
 export class Globe {
     static set _staticCounter(arg: any);

package/types/LonLat.d.ts

@@ -20,6 +20,12 @@ export class LonLat {
      * @returns {LonLat} -
      */
     static createFromArray(arr: Array<number>): LonLat;
+    /**
+     *  Create array from lonlat
+     * @param lonLat
+     * @returns {number[]}
+     */
+    static toArray(lonLat: any): number[];
     /**
      * Converts degrees to mercator coordinates.
      * @static
@@ -29,6 +35,14 @@ export class LonLat {
      * @returns {LonLat} -
      */
     static forwardMercator(lon: number, lat: number, height?: number): LonLat;
+    /**
+     * Converts degrees to mercator coordinates.
+     * @static
+     * @param {LonLat} lonLat - Input geodetic degree coordinates
+     * @param {LonLat} res - Output mercator coordinates
+     * @returns {LonLat} - Output mercator coordinates
+     */
+    static forwardMercatorRes(lonLat: LonLat, res: LonLat): LonLat;
     /**
      * Converts mercator to degrees coordinates.
      * @static
@@ -63,6 +77,11 @@ export class LonLat {
      */
     public height: number;
     isZero(): boolean;
+    /**
+     *  Create array from lonlat
+     * @returns {number[]}
+     */
+    toArray(): number[];
     /**
      * Sets coordinates.
      * @public
@@ -80,7 +99,7 @@ export class LonLat {
      */
     public copy(lonLat?: LonLat): LonLat;
     /**
-     * Clone the coordiante.
+     * Clone the coordinates.
      * @public
      * @returns {LonLat} -
      */

package/types/Object3d.d.ts

@@ -9,6 +9,7 @@ export class Object3d {
     static createCylinder(radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number, heightSegments?: number, isTop?: boolean, isBottom?: boolean, offsetX?: number, offsetY?: number, offsetZ?: number): Object3d;
     static createCube(length?: number, height?: number, depth?: number, xOffset?: number, yOffset?: number, zOffset?: number): Object3d;
     static createArrow(back?: number, height?: number, front?: number): Object3d;
+    static loadObj(src: any): Promise<any>;
     constructor(data: any);
     _name: any;
     _vertices: any;
@@ -23,6 +24,7 @@ export class Object3d {
     color: any[] | Float32Array;
     _indices: any;
     _normals: any;
+    set src(arg: string);
     get src(): string;
     get name(): any;
     get vertices(): any;

package/types/Popup.d.ts

@@ -25,5 +25,5 @@ export class Popup extends View {
     setContent(content: any): void;
     clear(): void;
 }
-import { View } from "./ui/View.js";
+import { View } from './ui/View.js';
 import { Vec3 } from "./math/Vec3.js";

package/types/bv/index.d.ts

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

package/types/camera/PlanetCamera.d.ts

@@ -68,13 +68,6 @@ export class PlanetCamera extends Camera {
      * @type {quadTree.Node}
      */
     protected _insideSegment: quadTree.Node;
-    /**
-     * 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 {LonLat}
-     */
-    protected _insideSegmentPosition: LonLat;
     slope: number;
     _keyLock: Key;
     _framesArr: any[];
@@ -215,7 +208,7 @@ export class PlanetCamera extends Camera {
      * @public
      */
     public checkFly(): void;
-    checkTerrainCollision(): void;
+    checkTerrainCollision(): Vec3;
     getSurfaceVisibleDistance(d: any): number;
     getHeading(): number;
     isVisible(poi: any): boolean;

package/types/camera/index.d.ts

@@ -1,3 +1,3 @@
-import { Camera } from "./Camera.js";
-import { PlanetCamera } from "./PlanetCamera.js";
+import { Camera } from './Camera.js';
+import { PlanetCamera } from './PlanetCamera.js';
 export { Camera, PlanetCamera };

package/types/control/GeoImageDragControl.d.ts

@@ -10,5 +10,5 @@ export class GeoImageDragControl extends Control {
     _onMouseLeave(): void;
     _onMouseMove(ms: any): void;
 }
-import { Control } from "./Control.js";
+import { Control } from './Control.js';
 import { ToggleButton } from "../ui/ToggleButton.js";

package/types/control/LayerAnimation.d.ts

@@ -70,4 +70,4 @@ export class LayerAnimation extends Control {
     _setCurrentIndexAsync(index: number, forceVisibility?: boolean, stopPropagation?: boolean): void;
 }
 import { Control } from "./Control.js";
-import { Events } from "../Events.js";
+import { Events } from '../Events.js';

package/types/control/Lighting.d.ts

@@ -36,6 +36,6 @@ export class Lighting extends Control {
 }
 import { Control } from "./Control.js";
 import { ToggleButton } from "../ui/ToggleButton.js";
-import { Dialog } from "../ui/Dialog.js";
-import { View } from "../ui/View.js";
+import { Dialog } from '../ui/Dialog.js';
+import { View } from '../ui/View.js';
 import { Slider } from "../ui/Slider.js";

package/types/control/heightRuler/HeightRulerScene.d.ts

@@ -20,4 +20,4 @@ export class HeightRulerScene extends RulerScene {
 }
 import { RulerScene } from "../ruler/RulerScene.js";
 import { Vector } from "../../layer/Vector.js";
-import { Entity } from "../../entity/Entity.js";
+import { Entity } from '../../entity/Entity.js';

package/types/control/index.d.ts

@@ -1,6 +1,6 @@
 import { Control } from "./Control.js";
 import { CompassButton } from "./CompassButton.js";
-import { DebugInfo } from "./DebugInfo";
+import { DebugInfo } from "./DebugInfo.js";
 import { EarthNavigation } from "./EarthNavigation.js";
 import { EarthCoordinates } from "./EarthCoordinates.js";
 import { GeoImageDragControl } from "./GeoImageDragControl.js";
@@ -21,4 +21,5 @@ import { HeightRuler } from "./heightRuler/HeightRuler.js";
 import { SimpleSkyBackground } from "./SimpleSkyBackground.js";
 import { Selection } from "./selection/Selection.js";
 import { LayerAnimation } from "./LayerAnimation.js";
-export { Control, CompassButton, DebugInfo, EarthNavigation, EarthCoordinates, GeoImageDragControl, KeyboardNavigation, LayerSwitcher, MouseNavigation, ToggleWireframe, TouchNavigation, SimpleNavigation, ShowFps, ScaleControl, Sun, ZoomControl, MouseWheelZoomControl, Lighting, Ruler, HeightRuler, SimpleSkyBackground, Selection, LayerAnimation };
+import { TimelineControl } from "./timeline/TimelineControl.js";
+export { Control, CompassButton, DebugInfo, EarthNavigation, EarthCoordinates, GeoImageDragControl, KeyboardNavigation, LayerSwitcher, MouseNavigation, ToggleWireframe, TouchNavigation, SimpleNavigation, ShowFps, ScaleControl, Sun, ZoomControl, MouseWheelZoomControl, Lighting, Ruler, HeightRuler, SimpleSkyBackground, Selection, LayerAnimation, TimelineControl };

package/types/control/ruler/RulerScene.d.ts

@@ -37,6 +37,7 @@ export class RulerScene extends RenderNode {
     _onCornerEnter(e: any): void;
     _onCornerLeave(e: any): void;
     _onLdblclick(): void;
+    setVisibility(visibility: any): void;
     _onLclick(e: any): void;
     _timeout: any;
     _drawLine(startLonLat: any, endLonLat: any, startPos: any): void;
@@ -45,7 +46,7 @@ export class RulerScene extends RenderNode {
     isCornersPositionChanged(): boolean;
     get ellipsoid(): any;
 }
-import { RenderNode } from "../../scene/RenderNode.js";
-import { Vec2 } from "../../math/Vec2.js";
-import { Vector } from "../../layer/Vector.js";
-import { Entity } from "../../entity/Entity.js";
+import { RenderNode } from '../../scene/RenderNode.js';
+import { Vec2 } from '../../math/Vec2.js';
+import { Vector } from '../../layer/Vector.js';
+import { Entity } from '../../entity/Entity.js';

package/types/control/selection/SelectionScene.d.ts

@@ -28,6 +28,6 @@ export class SelectionScene extends RenderNode {
     clear(): void;
     get ellipsoid(): any;
 }
-import { RenderNode } from "../../scene/RenderNode.js";
-import { Entity } from "../../entity/Entity.js";
-import { Vector } from "../../layer/Vector.js";
+import { RenderNode } from '../../scene/RenderNode.js';
+import { Entity } from '../../entity/Entity.js';
+import { Vector } from '../../layer/Vector.js';

package/types/control/timeline/TimelineControl.d.ts

@@ -0,0 +1,10 @@
+export class TimelineControl extends Control {
+    constructor(options?: {});
+    _timelineView: TimelineView;
+    _toggleBtn: ToggleButton;
+    _dialog: Dialog;
+}
+import { Control } from '../Control.js';
+import { TimelineView } from './TimelineView.js';
+import { ToggleButton } from "../../ui/ToggleButton.js";
+import { Dialog } from "../../ui/Dialog.js";

package/types/control/timeline/TimelineModel.d.ts

@@ -0,0 +1,33 @@
+export class TimelineModel {
+    constructor(options?: {});
+    _events: Events;
+    _current: any;
+    _rangeStart: any;
+    _rangeEnd: any;
+    _range: number;
+    _minDate: any;
+    _maxDate: any;
+    multiplier: any;
+    _requestAnimationFrameId: number;
+    _prevNow: number;
+    dt: number;
+    on(eventName: any, callback: any, sender: any): void;
+    off(eventName: any, callback: any): void;
+    play(): void;
+    stop(): void;
+    stopped(): boolean;
+    _animationFrameCallback(): void;
+    _frame(): void;
+    set current(arg: any);
+    get current(): any;
+    get range(): number;
+    set(rangeStart: any, rangeEnd: any): void;
+    set rangeStart(arg: any);
+    get rangeStart(): any;
+    set rangeEnd(arg: any);
+    get rangeEnd(): any;
+    get rangeStartTime(): any;
+    get rangeEndTime(): any;
+    get currentTime(): any;
+}
+import { Events } from '../../Events.js';

package/types/control/timeline/TimelineView.d.ts

@@ -0,0 +1,57 @@
+export class TimelineView extends View {
+    fillStyle: any;
+    _frameEl: any;
+    _currentEl: any;
+    _canvasEl: HTMLCanvasElement;
+    _ctx: CanvasRenderingContext2D;
+    _isMouseOver: boolean;
+    _isDragging: boolean;
+    _isCurrentDragging: boolean;
+    _isCurrentMouseOver: boolean;
+    _minWidth: number;
+    _canvasScale: number;
+    _millisecondsInPixel: number;
+    _clickPosX: number;
+    _clickRangeStart: Date;
+    _clickRangeEnd: Date;
+    _clickCurrentDate: Date;
+    _clickTime: number;
+    _clickDelay: number;
+    _onResizeObserver_: any;
+    _resizeObserver: ResizeObserver;
+    _pauseBtn: ToggleButton;
+    _playBtn: ToggleButton;
+    _buttons: ButtonGroup;
+    _visibility: any;
+    _onResizeObserver(): void;
+    set canvasScale(arg: number);
+    get canvasScale(): number;
+    resize(): void;
+    render(): TimelineView;
+    $controls: any;
+    setVisibility(visibility: any): void;
+    reset(): void;
+    play(): void;
+    pause(): void;
+    playBack(): void;
+    _onMouseWheel(e: any): void;
+    _onMouseWheelFF(e: any): void;
+    _zoom(pointerTime: any, pointerCenterOffsetX: any, dir: any): void;
+    _onMouseDown(e: any): void;
+    _onMouseUp(e: any): void;
+    _onMouseEnter(): void;
+    _onMouseOut(): void;
+    _onCurrentMouseEnter(): void;
+    _onCurrentMouseOut(): void;
+    _onMouseMove(e: any): void;
+    get clientWidth(): number;
+    get clientHeight(): number;
+    _resize(): void;
+    getOffsetbyTime(milliseconds: any): number;
+    _clearCanvas(): void;
+    _drawCurrent(): void;
+    draw(): void;
+}
+import { View } from '../../ui/View.js';
+import { ToggleButton } from "../../ui/ToggleButton.js";
+import { ButtonGroup } from "../../ui/ButtonGroup.js";

package/types/control/timeline/timelineUtils.d.ts

@@ -0,0 +1,9 @@
+export function addSeconds(date: any, seconds: any): Date;
+export function dateToStr(date: any, showTime?: boolean, showMilliseconds?: boolean): string;
+export function createCanvasHTML(): HTMLCanvasElement;
+export function getNearestTimeLeft(t: any, div: any): number;
+export function drawNotch(ctx: any, xOffset?: number, size?: number, thickness?: number, color?: string): void;
+export function drawText(ctx: any, text: any, x: any, y: any, font: string, fillStyle: string, align: string, baseLine: string, rotDeg: any): void;
+export function getScale(seconds: any): number[];
+export const SCALES: number[][];
+export const MONTHS: string[];

package/types/ellipsoid/Ellipsoid.d.ts

@@ -5,6 +5,13 @@
  * @param {number} polarSize - Polar ellipsoid size.
  */
 export class Ellipsoid {
+    /**
+     * Returns angle between to bearin angles
+     * @param {number} a - First bearing angle
+     * @param {number} b - Second bearing angle
+     * @returns {number}
+     */
+    static getAngleBetweenTwoBearings(a: number, b: number): number;
     static getRelativeBearing(a: any, b: any): number;
     /**
      * Returns the midpoint between two points on the great circle.
@@ -88,22 +95,22 @@ export class Ellipsoid {
      */
     public getPolarSize(): number;
     /**
-     * Gets cartesian ECEF from Wgs84 geodetic coordiantes.
+     * Gets cartesian ECEF from Wgs84 geodetic coordinates.
      * @public
-     * @param {LonLat} lonlat - Degrees geodetic coordiantes.
+     * @param {LonLat} lonlat - Degrees geodetic coordinates.
      * @returns {Vec3} -
      */
     public lonLatToCartesian(lonlat: LonLat): Vec3;
     /**
-     * Gets cartesian ECEF from Wgs84 geodetic coordiantes.
+     * Gets cartesian ECEF from Wgs84 geodetic coordinates.
      * @public
-     * @param {LonLat} lonlat - Degrees geodetic coordiantes.
+     * @param {LonLat} lonlat - Degrees geodetic coordinates.
      * @param {Vec3} res - Output result.
      * @returns {Vec3} -
      */
     public lonLatToCartesianRes(lonlat: LonLat, res: Vec3): Vec3;
     /**
-     * Gets cartesian ECEF from Wgs84 geodetic coordiantes.
+     * Gets cartesian ECEF from Wgs84 geodetic coordinates.
      * @public
      * @param {Number} lon - Longitude.
      * @param {Number} lat - Latitude.
@@ -112,17 +119,29 @@ export class Ellipsoid {
      */
     public geodeticToCartesian(lon: number, lat: number, height?: number): Vec3;
     /**
-     * Gets Wgs84 geodetic coordiantes from cartesian ECEF.
+     * Gets Wgs84 geodetic coordinates from cartesian ECEF.
      * @public
      * @param {Vec3} p - Cartesian coordinates.
      * @returns {LonLat} -
      */
     public projToSurface(p: Vec3): LonLat;
-    cartesianToLonLat(cart: any): LonLat;
+    /**
+     * Converts 3d cartesian coordinates to geodetic
+     * @param {Vec3} cart - Cartesian coordinates
+     * @returns {LonLat} - Geodetic coordinates
+     */
+    cartesianToLonLat(cart: Vec3): LonLat;
+    /**
+     * Converts 3d cartesian coordinates to geodetic
+     * @param {Vec3} cart - Cartesian coordinates
+     * @param {LonLat} res - Link geodetic coordinates variable
+     * @returns {LonLat} - Geodetic coordinates
+     */
+    cartesianToLonLatRes(cart: Vec3, res: LonLat): LonLat;
     /**
      * Gets ellipsoid surface normal.
      * @public
-     * @param {Vec3} coord - Spatial coordiantes.
+     * @param {Vec3} coord - Spatial coordinates.
      * @return {Vec3} -
      */
     public getSurfaceNormal3v(coord: Vec3): Vec3;

package/types/ellipsoid/index.d.ts

@@ -1,3 +1,3 @@
-import { Ellipsoid } from "./Ellipsoid.js";
-import { wgs84 } from "./wgs84.js";
+import { Ellipsoid } from './Ellipsoid.js';
+import { wgs84 } from './wgs84.js';
 export { Ellipsoid, wgs84 };