@openglobus/og 0.15.4 → 0.16.0

package/src/og/segment/Segment.js

@@ -174,12 +174,6 @@ class Segment {
          */
         this.normalMapReady = false;
 
-        /**
-         * Parent normal map is made allready(optimization parameter).
-         * @type {boolean}
-         */
-        this.parentNormalMapReady = false;
-
         /**
          * Terrain is allready applied flag.
          * @type {boolean}
@@ -254,11 +248,10 @@ class Segment {
      * @public
      * @param {Entity} entity - Entity.
      * @param {Vec3} res - Point coordinates.
-     * @param {Vec3} [normal] - Terrain point normal.
      * @returns {Vec3} -
      */
-    getEntityTerrainPoint(entity, res, normal) {
-        return this.getTerrainPoint(entity._cartesian, entity._lonlatMerc, res, normal);
+    getEntityTerrainPoint(entity, res) {
+        return this.getTerrainPoint(entity._cartesian, entity._lonlatMerc, res);
     }
 
     isEntityInside(e) {
@@ -274,80 +267,74 @@ class Segment {
      * @param {Vec3} [normal] - Terrain point normal.
      * @returns {number} -
      */
-    getTerrainPoint(xyz, insideSegmentPosition, res, normal) {
-        var verts = this.tempVertices;
+    getTerrainPoint(xyz, insideSegmentPosition, res) {
+        let verts = this.tempVertices;
 
-        _ray.set(xyz, xyz.negateTo());
+        if (verts && verts.length) {
+            let norm = this.planet.ellipsoid.getSurfaceNormal3v(xyz);
+            _ray.set(xyz, norm.negateTo());
 
-        if (verts) {
-            var ne = this._extent.northEast,
+            let ne = this._extent.northEast,
                 sw = this._extent.southWest,
                 size = Math.sqrt(verts.length / 3) - 1;
 
-            var xmax = ne.lon,
+            let xmax = ne.lon,
                 ymax = ne.lat,
                 xmin = sw.lon,
                 ymin = sw.lat,
                 x = insideSegmentPosition.lon,
                 y = insideSegmentPosition.lat;
 
-            var sxn = xmax - xmin,
+            let sxn = xmax - xmin,
                 syn = ymax - ymin;
 
-            var qx = sxn / size,
+            let qx = sxn / size,
                 qy = syn / size;
 
-            var xn = x - xmin,
+            let xn = x - xmin,
                 yn = y - ymin;
 
-            var indX = Math.floor(xn / qx),
+            let indX = Math.floor(xn / qx),
                 indY = Math.floor(size - yn / qy);
 
-            if (verts && verts.length) {
-                var ind_v0 = ((size + 1) * indY + indX) * 3;
-                var ind_v2 = ((size + 1) * (indY + 1) + indX) * 3;
+            let ind_v0 = ((size + 1) * indY + indX) * 3;
+            let ind_v2 = ((size + 1) * (indY + 1) + indX) * 3;
 
-                _v0.set(verts[ind_v0], verts[ind_v0 + 1], verts[ind_v0 + 2]);
-                _v1.set(verts[ind_v0 + 3], verts[ind_v0 + 4], verts[ind_v0 + 5]);
-                _v2.set(verts[ind_v2], verts[ind_v2 + 1], verts[ind_v2 + 2]);
+            _v0.set(verts[ind_v0], verts[ind_v0 + 1], verts[ind_v0 + 2]);
+            _v1.set(verts[ind_v0 + 3], verts[ind_v0 + 4], verts[ind_v0 + 5]);
+            _v2.set(verts[ind_v2], verts[ind_v2 + 1], verts[ind_v2 + 2]);
 
-                let d = _ray.hitTriangle(_v0, _v1, _v2, res, normal);
+            let d = _ray.hitTriangle(_v0, _v1, _v2, res);
 
+            if (d === Ray.INSIDE) {
+                return xyz.distance(res);
+            } else if (d === Ray.AWAY) {
+                _rayEx.set(xyz, norm);
+                let d = _rayEx.hitTriangle(_v0, _v1, _v2, res);
                 if (d === Ray.INSIDE) {
-                    return xyz.distance(res);
-                } else if (d === Ray.AWAY) {
-                    _rayEx.set(xyz, this.planet.ellipsoid.getSurfaceNormal3v(xyz));
-                    let d = _rayEx.hitTriangle(_v0, _v1, _v2, res, normal);
-                    if (d === Ray.INSIDE) {
-                        return -xyz.distance(res);
-                    }
+                    return -xyz.distance(res);
                 }
+            }
 
-                _v3.set(verts[ind_v2 + 3], verts[ind_v2 + 4], verts[ind_v2 + 5]);
+            _v3.set(verts[ind_v2 + 3], verts[ind_v2 + 4], verts[ind_v2 + 5]);
 
-                d = _ray.hitTriangle(_v1, _v3, _v2, res, normal);
+            d = _ray.hitTriangle(_v1, _v3, _v2, res);
+            if (d === Ray.INSIDE) {
+                return xyz.distance(res);
+            } else if (d === Ray.AWAY) {
+                _rayEx.set(xyz, norm);
+                let d = _rayEx.hitTriangle(_v1, _v3, _v2, res);
                 if (d === Ray.INSIDE) {
-                    return xyz.distance(res);
-                } else if (d === Ray.AWAY) {
-                    _rayEx.set(xyz, this.planet.ellipsoid.getSurfaceNormal3v(xyz));
-                    let d = _rayEx.hitTriangle(_v1, _v3, _v2, res, normal);
-                    if (d === Ray.INSIDE) {
-                        return -xyz.distance(res);
-                    }
-                }
-
-                if (d === Ray.AWAY) {
                     return -xyz.distance(res);
                 }
+            }
 
-                return xyz.distance(res);
+            if (d === Ray.AWAY) {
+                return -xyz.distance(res);
             }
 
-            res.copy(this.planet.ellipsoid.hitRay(_ray.origin, _ray.direction));
-            normal && normal.copy(xyz.normal());
             return xyz.distance(res);
         } else {
-            normal && normal.copy(xyz.normal());
             return xyz.distance(this.planet.ellipsoid.hitRay(_ray.origin, _ray.direction));
         }
     }
@@ -367,7 +354,7 @@ class Segment {
      * @param {boolean} forceLoading
      */
     loadTerrain(forceLoading) {
-        if (this.tileZoom < this.planet.terrain.minZoom) {
+        if (this.tileZoom < this.planet.terrain.minZoom || this.planet.terrain.isEmpty) {
             this.terrainIsLoading = true;
 
             this.elevationsNotExists();
@@ -381,6 +368,9 @@ class Segment {
             } else if (!this.terrainIsLoading && !this.terrainReady) {
                 this.planet.terrain.loadTerrain(this, forceLoading);
             }
+            // if (!this.terrainIsLoading && !this.terrainReady) {
+            //     this.planet.terrain.loadTerrain(this, forceLoading);
+            // }
         }
     }
 
@@ -389,9 +379,8 @@ class Segment {
      * @param {Float32Array} elevations - Elevation data.
      */
     elevationsExists(elevations) {
-        const segment = this;
         if (this.plainReady && this.terrainIsLoading) {
-            this.planet._terrainWorker.make(segment, elevations);
+            this.planet._terrainWorker.make(this, elevations);
 
             this.plainVerticesHigh = null;
             this.plainVerticesLow = null;
@@ -406,6 +395,63 @@ class Segment {
         }
     }
 
+    /**
+     * Keep plain elevation segment for rendering
+     *
+     * 'this.tileZoom <= this.planet.terrain.maxZoom' it means, that the segment is plain
+     *
+     */
+    elevationsNotExists() {
+        if (this.planet && this.tileZoom <= this.planet.terrain.maxNativeZoom) {
+            if (this.plainReady && this.terrainIsLoading) {
+                this.terrainIsLoading = false;
+
+                let n = this.node;
+                n.appliedTerrainNodeId = this.node.nodeId;
+                n.equalizedSideWithNodeId[N] = n.equalizedSideWithNodeId[E] = n.equalizedSideWithNodeId[S] =
+                    n.equalizedSideWithNodeId[W] = n.appliedTerrainNodeId;
+
+                if (this.planet.lightEnabled && !this._inTheQueue) {
+                    this.planet._normalMapCreator.queue(this);
+                }
+
+                this.readyToEngage = true;
+            }
+
+            // plain terrain only
+            this.terrainVertices = this.plainVertices;
+            this.terrainVerticesHigh = this.plainVerticesHigh;
+            this.terrainVerticesLow = this.plainVerticesLow;
+
+            this.tempVertices = this.terrainVertices;
+            this.tempVerticesHigh = this.terrainVerticesHigh;
+            this.tempVerticesLow = this.terrainVerticesLow;
+
+            this.noDataVertices = null;
+
+            this.fileGridSize = Math.sqrt(this.terrainVertices.length / 3) - 1;
+            this.gridSize = this.fileGridSize;
+            this.terrainReady = true;
+            this.terrainExists = false;
+        } else {
+
+            if (this.plainReady && this.terrainIsLoading) {
+                this.terrainIsLoading = false;
+
+                let n = this.node;
+                n.appliedTerrainNodeId = this.node.nodeId;
+                n.equalizedSideWithNodeId[N] = n.equalizedSideWithNodeId[E] = n.equalizedSideWithNodeId[S] =
+                    n.equalizedSideWithNodeId[W] = n.appliedTerrainNodeId;
+
+                this.readyToEngage = true;
+                this.terrainReady = true;
+                this.passReady = true;
+
+                this.terrainExists = false;
+            }
+        }
+    }
+
     _checkEqualization(neighborSide, neigborNode) {
         return neigborNode && this.tileZoom >= neigborNode.segment.tileZoom &&
             this.node.equalizedSideWithNodeId[neighborSide] !== neigborNode.equalizedSideWithNodeId[OPSIDE[neighborSide]];
@@ -589,33 +635,6 @@ class Segment {
         this.createCoordsBuffers(this.tempVerticesHigh, this.tempVerticesLow, this.gridSize);
     }
 
-    _plainSegmentWorkerCallback(data) {
-        this.plainProcessing = false;
-
-        if (this.initialized && !this.terrainReady) {
-            this.plainVertices = data.plainVertices;
-            this.plainVerticesHigh = data.plainVerticesHigh;
-            this.plainVerticesLow = data.plainVerticesLow;
-
-            this.plainNormals = data.plainNormals;
-
-            this.normalMapNormals = data.normalMapNormals;
-            this.normalMapVertices = data.normalMapVertices;
-            this.normalMapVerticesHigh = data.normalMapVerticesHigh;
-            this.normalMapVerticesLow = data.normalMapVerticesLow;
-
-            this.terrainVertices = this.plainVertices;
-            this.terrainVerticesHigh = this.plainVerticesHigh;
-            this.terrainVerticesLow = this.plainVerticesLow;
-
-            this.fileGridSize = Math.sqrt(data.normalMapVertices.length / 3) - 1;
-
-            this._plainRadius = data.plainRadius;
-
-            this.plainReady = true;
-        }
-    }
-
     _terrainWorkerCallback(data) {
         if (this.plainReady) {
             this.readyToEngage = true;
@@ -661,7 +680,6 @@ class Segment {
 
             this.terrainReady = true;
             this.terrainIsLoading = false;
-            this.parentNormalMapReady = true;
             this.terrainExists = true;
 
             if (!this.normalMapTexturePtr) {
@@ -678,43 +696,6 @@ class Segment {
         }
     }
 
-    /**
-     * Terrain is not obtained or not exists on the server.
-     */
-    elevationsNotExists() {
-        if (this.planet && this.tileZoom <= this.planet.terrain.maxZoom) {
-            if (this.plainReady && this.terrainIsLoading) {
-                this.terrainIsLoading = false;
-
-                let n = this.node;
-                n.appliedTerrainNodeId = this.node.nodeId;
-                n.equalizedSideWithNodeId[N] = n.equalizedSideWithNodeId[E] = n.equalizedSideWithNodeId[S] =
-                    n.equalizedSideWithNodeId[W] = n.appliedTerrainNodeId;
-
-                if (this.planet.lightEnabled && !this._inTheQueue) {
-                    this.planet._normalMapCreator.queue(this);
-                }
-
-                this.readyToEngage = true;
-            }
-
-            this.terrainVertices = this.plainVertices;
-            this.terrainVerticesHigh = this.plainVerticesHigh;
-            this.terrainVerticesLow = this.plainVerticesLow;
-
-            this.tempVertices = this.terrainVertices;
-            this.tempVerticesHigh = this.terrainVerticesHigh;
-            this.tempVerticesLow = this.terrainVerticesLow;
-
-            this.noDataVertices = null;
-
-            this.fileGridSize = Math.sqrt(this.terrainVertices.length / 3) - 1;
-            this.gridSize = this.fileGridSize;
-            this.terrainReady = true;
-            this.terrainExists = false;
-        }
-    }
-
     _normalMapEdgeEqualize(side) {
         let nn = this.node.neighbors;
         let n = nn[side][0];
@@ -874,7 +855,6 @@ class Segment {
             this.handler.gl.deleteTexture(this.normalMapTexture);
         }
         this.normalMapReady = false;
-        this.parentNormalMapReady = false;
         this._appliedNeighborsZoom = [0, 0, 0, 0];
         this.normalMapTextureBias[0] = 0;
         this.normalMapTextureBias[1] = 0;
@@ -1263,12 +1243,37 @@ class Segment {
         let p = this.planet,
             t = p.terrain;
 
-        if (t.isReady() && this.tileZoom <= t.maxZoom && !this.plainReady) {
+        if (t.isReady() && !this.plainReady && this.tileZoom <= t.maxZoom) {
             this.plainProcessing = true;
             p._plainSegmentWorker.make(this);
         }
     }
 
+    _plainSegmentWorkerCallback(data) {
+        this.plainProcessing = false;
+
+        if (this.initialized && !this.terrainReady) {
+            this.plainReady = true;
+
+            this.plainVertices = data.plainVertices;
+            this.plainVerticesHigh = data.plainVerticesHigh;
+            this.plainVerticesLow = data.plainVerticesLow;
+            this.plainNormals = data.plainNormals;
+            this._plainRadius = data.plainRadius;
+
+            this.normalMapNormals = data.normalMapNormals;
+            this.normalMapVertices = data.normalMapVertices;
+            this.normalMapVerticesHigh = data.normalMapVerticesHigh;
+            this.normalMapVerticesLow = data.normalMapVerticesLow;
+
+            //this.terrainVertices = this.plainVertices;
+            //this.terrainVerticesHigh = this.plainVerticesHigh;
+            //this.terrainVerticesLow = this.plainVerticesLow;
+
+            this.fileGridSize = Math.sqrt(data.normalMapVertices.length / 3) - 1;
+        }
+    }
+
     createPlainSegment() {
         this.initialize();
         this._createPlainVertices();
@@ -1597,7 +1602,7 @@ class Segment {
             shu = sh.uniforms;
 
         var currHeight;
-        if (layerSlice.length) {
+        if (layerSlice && layerSlice.length) {
             currHeight = layerSlice[0]._height;
         } else {
             currHeight = 0;

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