@openglobus/og 0.15.5 → 0.16.1

package/src/og/terrain/EmptyTerrain.js

@@ -9,11 +9,18 @@ import { Geoid } from "./Geoid.js";
 
 /**
  * Class represents terrain provider without elevation data.
- * @class
+ * @param {Object} [options] - Provider options:
+ * @param {string} [options.name="empty"] - Provider name.
+ * @param {number} [options.minZoom=2] - Minimal visible zoom index when terrain handler works.
+ * @param {number} [options.minZoom=50] - Maximal visible zoom index when terrain handler works.
+ * @param {number} [options.minNativeZoom=50] - Maximal available terrain zoom level.
+ * @param {Array.<number>} [options.gridSizeByZoom] - Array of segment triangulation grid sizes where array index agreed to the segment zoom index.
+ * @param {Array.<number>} [gridSizeByZoom] - Array of values, where each value corresponds to the size of a tile(or segment) on the globe. Each value must be power of two.
  */
 class EmptyTerrain {
     constructor(options = {}) {
-        this.equalizeVertices = false;
+
+        this.equalizeVertices = options.equalizeVertices || false;
 
         this.equalizeNormals = false;
 
@@ -24,30 +31,35 @@ class EmptyTerrain {
          * @public
          * @type {string}
          */
-        this.name = "empty";
+        this.name = options.name || "empty";
 
         /**
          * Minimal z-index value for segment elevation data handling.
          * @public
          * @type {number}
          */
-        this.minZoom = 1000000;
+        this.minZoom = options.minZoom || 2;
 
         /**
          * Maximal z-index value for segment elevation data handling.
          * @public
          * @type {number}
          */
-        this.maxZoom = 21;
+        this.maxZoom = options.maxZoom || 50;
+
+        /**
+         * Maximal existent available zoom
+         * @type {number}
+         */
+        this.maxNativeZoom = options.maxNativeZoom || this.maxZoom;
 
         /**
          * @public
          * @type {Array.<number>}
          */
         this.gridSizeByZoom = options.gridSizeByZoom || [
-            32, 16, 16, 8, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
+            64, 32, 16, 8, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
         ];
-        //this.gridSizeByZoom = options.gridSizeByZoom || [32, 16, 16, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2];
 
         this._maxNodeZoom = this.gridSizeByZoom.length - 1;
 

package/src/og/terrain/GlobusTerrain.js

@@ -39,6 +39,7 @@ const EVENT_NAMES = [
  * @param {Object} [options] - Provider options:
  * @param {number} [options.minZoom=3] - Minimal visible zoom index when terrain handler works.
  * @param {number} [options.minZoom=14] - Maximal visible zoom index when terrain handler works.
+ * @param {number} [options.minNativeZoom=14] - Maximal available terrain zoom level.
  * @param {string} [options.url="//openglobus.org/heights/srtm3/{z}/{y}/{x}.ddm"] - Terrain source path url template. Default is openglobus ddm elevation file.
  * @param {Array.<number>} [options.gridSizeByZoom] - Array of segment triangulation grid sizes where array index agreed to the segment zoom index.
  * @param {number} [options.plainGridSize=32] - Elevation grid size. Default is 32x32. Must be power of two.
@@ -54,8 +55,14 @@ class GlobusTerrain extends EmptyTerrain {
      * @param {*} [options]
      */
     constructor(name, options = {}) {
-        super({ geoidSrc: "//openglobus.org/geoid/egm84-30.pgm", ...options });
+        super({
+            geoidSrc: "//openglobus.org/geoid/egm84-30.pgm",
+            maxNativeZoom: options.maxNativeZoom || 14,
+            ...options
+        });
+
         this._s = options.subdomains || ["a", "b", "c"];
+
         /**
          * Events handler.
          * @public
@@ -78,20 +85,6 @@ class GlobusTerrain extends EmptyTerrain {
          */
         this.name = name || "openglobus";
 
-        /**
-         * Minimal visible zoom index when terrain handler works.
-         * @public
-         * @type {number}
-         */
-        this.minZoom = options.minZoom || 2;
-
-        /**
-         * Maximal visible zoom index when terrain handler works.
-         * @public
-         * @type {number}
-         */
-        this.maxZoom = options.maxZoom || 14;
-
         /**
          * Terrain source path url template.
          * @public
@@ -169,13 +162,15 @@ class GlobusTerrain extends EmptyTerrain {
         return false;
     }
 
-    getHeightAsync(lonLat, callback, zoom) {
+    getHeightAsync(lonLat, callback, zoom, firstAttempt) {
         if (!lonLat || lonLat.lat > mercator.MAX_LAT || lonLat.lat < mercator.MIN_LAT) {
             callback(0);
             return true;
         }
 
-        let z = zoom || this.maxZoom,
+        firstAttempt = firstAttempt != undefined ? firstAttempt : true;
+
+        let z = zoom || this.maxNativeZoom,
             z2 = Math.pow(2, z),
             size = mercator.POLE2 / z2,
             merc = mercator.forward(lonLat),
@@ -214,12 +209,22 @@ class GlobusTerrain extends EmptyTerrain {
                     this._elevationCache[tileIndex] = cache;
                     callback(this._getGroundHeightMerc(merc, cache));
                 } else if (response.status === "error") {
+
+                    if (firstAttempt && z > this.maxZoom) {
+                        firstAttempt = false;
+                        this.getHeightAsync(lonLat, callback, this.maxZoom, false);
+                        return;
+                    }
+
                     let cache = {
                         heights: null,
                         extent: extent
                     };
+
                     this._elevationCache[tileIndex] = cache;
+
                     callback(0);
+
                 } else {
                     this._fetchCache[tileIndex] = null;
                     delete this._fetchCache[tileIndex];
@@ -475,4 +480,4 @@ class GlobusTerrain extends EmptyTerrain {
     }
 }
 
-export { GlobusTerrain };
+export { GlobusTerrain };

package/src/og/terrain/MapboxTerrain.js

@@ -13,21 +13,20 @@ const rgb2Height = (r, g, b) => {
 
 class MapboxTerrain extends GlobusTerrain {
     constructor(name, options = {}) {
-        super(name || "mapbox", options);
-
-        this.equalizeVertices =
-            options.equalizeVertices != undefined ? options.equalizeVertices : true;
+        super(name || "mapbox", {
+            equalizeVertices: options.equalizeVertices != undefined ? options.equalizeVertices : true,
+            maxZoom: options.maxZoom || 17,
+            ...options
+        });
 
         this.equalizeNormals = options.equalizeNormals || false;
 
-        this.minZoom = options.minZoom != undefined ? options.minZoom : 2;
-
-        this.maxZoom = options.maxZoom != undefined ? options.maxZoom : 17;
-
         this.gridSizeByZoom = options.gridSizeByZoom || [
             64, 32, 16, 8, 8, 8, 8, 16, 16, 16, 16, 16, 32, 16, 32, 16, 32, 16, 32, 16, 8, 4
         ];
 
+        "//{s}.srtm3.openglobus.org/{z}/{y}/{x}.ddm";
+
         this.url =
             options.url != undefined
                 ? options.url

package/src/og/terrain/index.js

@@ -1,6 +1,6 @@
-import { BilTerrain } from './BilTerrain';
-import { EmptyTerrain } from './EmptyTerrain';
-import { GlobusTerrain } from './GlobusTerrain';
-import { MapboxTerrain } from './MapboxTerrain';
+import { BilTerrain } from './BilTerrain.js';
+import { EmptyTerrain } from './EmptyTerrain.js';
+import { GlobusTerrain } from './GlobusTerrain.js';
+import { MapboxTerrain } from './MapboxTerrain.js';
 
 export { EmptyTerrain, GlobusTerrain, MapboxTerrain, BilTerrain };

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
@@ -71,6 +77,11 @@ export class LonLat {
      */
     public height: number;
     isZero(): boolean;
+    /**
+     *  Create array from lonlat
+     * @returns {number[]}
+     */
+    toArray(): number[];
     /**
      * Sets coordinates.
      * @public
@@ -88,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[];

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";