@openglobus/og 0.13.4 → 0.13.7

package/src/og/scene/Planet.js

@@ -88,7 +88,13 @@ const EVENT_NAMES = [
      * Triggered when all data is loaded
      * @event og.scene.Planet#rendercompleted
      */
-    "rendercompleted"
+    "rendercompleted",
+
+    /**
+     * Triggered when all data is loaded
+     * @event og.scene.Planet#terraincompleted
+     */
+    "terraincompleted"
 ];
 
 /**
@@ -428,6 +434,10 @@ export class Planet extends RenderNode {
         this.always = [];
 
         this._renderCompleted = false;
+        this._renderCompletedActivated = false;
+
+        this._terrainCompleted = false;
+        this._terrainCompletedActivated = false;
     }
 
     static getBearingNorthRotationQuat(cartesian) {
@@ -454,6 +464,7 @@ export class Planet extends RenderNode {
         this._minLodSize = minLodSize || this._minLodSize;
         this._curLodSize = currentLodSize || this._curLodSize;
         this._renderCompletedActivated = false;
+        this._terrainCompletedActivated = false;
     }
 
     /**
@@ -571,6 +582,7 @@ export class Planet extends RenderNode {
      */
     setHeightFactor(factor) {
         this._renderCompletedActivated = false;
+        this._terrainCompletedActivated = false;
 
         if (this._heightFactor !== factor) {
             this._heightFactor = factor;
@@ -593,6 +605,7 @@ export class Planet extends RenderNode {
      */
     setTerrain(terrain) {
         this._renderCompletedActivated = false;
+        this._terrainCompletedActivated = false;
 
         if (this._initialized) {
             this.memClear();
@@ -613,21 +626,36 @@ export class Planet extends RenderNode {
             this._quadTree.destroyBranches();
         }
 
-        if (terrain._geoid) {
-            if (!terrain._geoid.model) {
-                terrain._geoid.model = null;
-                Geoid.loadModel(terrain._geoid.src)
-                    .then((m) => {
-                        terrain.getGeoid().setModel(m);
-                        this._plainSegmentWorker.setGeoid(terrain.getGeoid());
-                    })
-                    .catch((err) => {
-                        console.log(err);
-                    });
-            } else {
-                this._plainSegmentWorker.setGeoid(terrain.getGeoid());
-            }
+        //if (terrain._geoid) {
+
+        if (terrain._geoid.model) {
+            this._plainSegmentWorker.setGeoid(terrain.getGeoid());
+            terrain._isReady = true;
+        } else {
+            Geoid.loadModel(terrain._geoid.src)
+                .then((m) => {
+                    terrain.getGeoid().setModel(m);
+                    this._plainSegmentWorker.setGeoid(terrain.getGeoid());
+                    terrain._isReady = true;
+                })
+                .catch((err) => {
+                    console.log(err);
+                });
         }
+
+        // if (!terrain._geoid.model) {
+        //     Geoid.loadModel(terrain._geoid.src)
+        //         .then((m) => {
+        //             terrain.getGeoid().setModel(m);
+        //             this._plainSegmentWorker.setGeoid(terrain.getGeoid());
+        //         })
+        //         .catch((err) => {
+        //             console.log(err);
+        //         });
+        // } else {
+        //     this._plainSegmentWorker.setGeoid(terrain.getGeoid());
+        // }
+        //}
     }
 
     /**
@@ -677,10 +705,10 @@ export class Planet extends RenderNode {
                 !this._indexesCache[i][j] && (this._indexesCache[i][j] = new Array(TABLESIZE));
                 for (var k = 0; k <= TABLESIZE; k++) {
                     !this._indexesCache[i][j][k] &&
-                    (this._indexesCache[i][j][k] = new Array(TABLESIZE));
+                        (this._indexesCache[i][j][k] = new Array(TABLESIZE));
                     for (var m = 0; m <= TABLESIZE; m++) {
                         !this._indexesCache[i][j][k][m] &&
-                        (this._indexesCache[i][j][k][m] = new Array(TABLESIZE));
+                            (this._indexesCache[i][j][k][m] = new Array(TABLESIZE));
                         for (var q = 0; q <= TABLESIZE; q++) {
                             let ptr = {
                                 buffer: null
@@ -708,6 +736,7 @@ export class Planet extends RenderNode {
 
         this.renderer.events.on("resize", () => {
             this._renderCompletedActivated = false;
+            this._terrainCompletedActivated = false;
         });
 
         // Initialize texture coordinates buffer pool
@@ -917,15 +946,7 @@ export class Planet extends RenderNode {
             }
         }
 
-        if (this.renderer) {
-            if (html.length) {
-                this.renderer.div.attributions.style.display = "block";
-                this.renderer.div.attributions.innerHTML = "<ul>" + html + "</ul>";
-            } else {
-                this.renderer.div.attributions.style.display = "none";
-                this.renderer.div.attributions.innerHTML = "";
-            }
-        }
+        this._applyAttribution(html)
     }
 
     /**
@@ -971,17 +992,28 @@ export class Planet extends RenderNode {
             }
         }
 
+        this._applyAttribution(html);
+
+        this._sortLayers();
+    }
+
+    /**
+     * Apply to render list of layer attributions
+     * @private
+     */
+    _applyAttribution(html) {
         if (this.renderer) {
             if (html.length) {
-                this.renderer.div.attributions.style.display = "block";
-                this.renderer.div.attributions.innerHTML = "<ul>" + html + "</ul>";
+                html = "<ul>" + html + "</ul>";
+                if (this.renderer.div.attributions.innerHTML !== html) {
+                    this.renderer.div.attributions.style.display = "block";
+                    this.renderer.div.attributions.innerHTML = html;
+                }
             } else {
                 this.renderer.div.attributions.style.display = "none";
                 this.renderer.div.attributions.innerHTML = "";
             }
         }
-
-        this._sortLayers();
     }
 
     /**
@@ -1138,6 +1170,17 @@ export class Planet extends RenderNode {
             this._renderCompletedActivated = false;
         }
         this._renderCompleted = true;
+
+        if (this._terrainCompleted) {
+            if (!this._terrainCompletedActivated) {
+                this._terrainCompletedActivated = true;
+                this.events.dispatch(this.events.terraincompleted, true);
+            }
+        } else {
+            this._terrainCompletedActivated = false;
+        }
+
+        this._terrainCompleted = true;
     }
 
     /**
@@ -1789,4 +1832,20 @@ export class Planet extends RenderNode {
             }
         }
     }
+
+    async getHeightDefault(lonLat) {
+        return new Promise((resolve, reject) => {
+            this.terrain.getHeightAsync(lonLat.clone(), (alt) => {
+                resolve(alt);
+            });
+        });
+    }
+
+    async getHeightAboveELL(lonLat) {
+        return new Promise((resolve, reject) => {
+            this.terrain.getHeightAsync(lonLat.clone(), (alt) => {
+                resolve(alt + this.terrain.geoid.getHeightLonLat(lonLat));
+            });
+        });
+    }
 }

package/src/og/segment/Segment.js

@@ -1488,6 +1488,7 @@ class Segment {
 
                 if (!m.isReady) {
                     this.planet._renderCompleted = false;
+                    this.planet._terrainReady = false;
                 }
 
                 slice.append(li, m);

package/src/og/shaders/label.js

@@ -6,6 +6,10 @@
 
 import { Program } from '../webgl/Program.js';
 
+const DEFINE = `
+#define EMPTY -1.0
+#define RTL 1.0`;
+
 const PROJECT = `vec2 project(vec4 p) {
                     return (0.5 * p.xyz / p.w + 0.5).xy * viewport;
                 }`;
@@ -47,7 +51,9 @@ export function label_webgl2() {
         },
         vertexShader:
             `#version 300 es
-
+            
+            ${DEFINE}
+            
             in float a_outline;
             in vec4 a_gliphParam;
             in vec2 a_vertices;
@@ -77,14 +83,14 @@ export function label_webgl2() {
             uniform float depthOffset;
 
             const vec3 ZERO3 = vec3(0.0);
-
+           
             ${PROJECT}
 
             ${ROTATE2D}
 
             void main() {
 
-                if(a_texCoord.z == -1.0) {
+                if(a_texCoord.w == EMPTY) {
                     gl_Position = vec4(0.0);
                     return;
                 }
@@ -95,7 +101,7 @@ export function label_webgl2() {
                 v_outline = a_outline;
 
                 v_fontIndex = int(a_fontIndex);
-                v_uv = vec2(a_texCoord.xy);
+                v_uv = a_texCoord.xy;
                 vec3 look = a_positions - cameraPos;
                 float lookDist = length(look);
                 v_rgba = a_rgba;
@@ -127,8 +133,18 @@ export function label_webgl2() {
                 projPos.z += depthOffset + a_offset.z;
                                
                 vec2 screenPos = project(projPos);
-
-                vec2 v = screenPos + rotate2d(a_rotation) * ((a_vertices * a_gliphParam.xy + a_gliphParam.zw + vec2(a_texCoord.z, 0.0) + vec2(a_texCoord.w, 0.0)) * a_size * scd + a_offset.xy);
+                
+                vec2 vert = a_vertices;                
+                vec4 gp = a_gliphParam;                                
+                if(a_texCoord.w == RTL){
+                    vert.x = step(vert.x * 0.5 + 1.0, 1.0);
+                    gp.x = -a_gliphParam.x;
+                    gp.z = -(a_gliphParam.z + a_texCoord.z);
+                }else{
+                    gp.z = a_gliphParam.z + a_texCoord.z;
+                }
+                                
+                vec2 v = screenPos + rotate2d(a_rotation) * ((vert * gp.xy + gp.zw) * a_size * scd + a_offset.xy);
 
                 gl_Position = vec4((2.0 * v / viewport - 1.0) * projPos.w, projPos.z, projPos.w);
             }`,
@@ -270,7 +286,9 @@ export function label_screen() {
             a_fontIndex: "float"
         },
         vertexShader:
-            `
+            `            
+            ${DEFINE}
+                        
             attribute float a_outline;
             attribute vec4 a_gliphParam;
             attribute vec2 a_vertices;
@@ -306,7 +324,7 @@ export function label_screen() {
 
             void main() {
 
-                if(a_texCoord.z == -1.0) {
+                if(a_texCoord.w == EMPTY) {
                     gl_Position = vec4(0.0);
                     return;
                 }
@@ -349,9 +367,19 @@ export function label_screen() {
                 projPos.z += depthOffset + a_offset.z;
                                
                 vec2 screenPos = project(projPos);
-
-                vec2 v = screenPos + rotate2d(a_rotation) * ((a_vertices * a_gliphParam.xy + a_gliphParam.zw + vec2(a_texCoord.z, 0.0) + vec2(a_texCoord.w, 0.0)) * a_size * scd + a_offset.xy);
-
+                
+                vec2 vert = a_vertices;                
+                vec4 gp = a_gliphParam;                                
+                if(a_texCoord.w == RTL){
+                    vert.x = step(vert.x * 0.5 + 1.0, 1.0);
+                    gp.x = -a_gliphParam.x;
+                    gp.z = -(a_gliphParam.z + a_texCoord.z);
+                }else{
+                    gp.z = a_gliphParam.z + a_texCoord.z;
+                }
+                                
+                vec2 v = screenPos + rotate2d(a_rotation) * ((vert * gp.xy + gp.zw) * a_size * scd + a_offset.xy);
+                
                 gl_Position = vec4((2.0 * v / viewport - 1.0) * projPos.w, projPos.z, projPos.w);
             }`,
         fragmentShader:
@@ -487,6 +515,9 @@ export function labelPicking() {
         },
         vertexShader:
             `
+            
+            ${DEFINE}
+            
             attribute vec4 a_gliphParam;
             attribute vec2 a_vertices;
             attribute vec4 a_texCoord;
@@ -519,7 +550,7 @@ export function labelPicking() {
                 vec3 a_positions = a_positionsHigh + a_positionsLow;
                 vec3 cameraPos = eyePositionHigh + eyePositionLow;
 
-                if(a_texCoord.z == -1.0){
+                if(a_texCoord.w == EMPTY) {
                     gl_Position = vec4(0.0);
                     return;
                 }
@@ -554,7 +585,19 @@ export function labelPicking() {
                 projPos.z += depthOffset + a_offset.z;
                 
                 vec2 screenPos = project(projPos);
-                vec2 v = screenPos + rotate2d(a_rotation) * ((a_vertices * a_gliphParam.xy + a_gliphParam.zw + vec2(a_texCoord.z, 0.0) + vec2(a_texCoord.w, 0.0)) * a_size * scd + a_offset.xy);
+                
+                vec2 vert = a_vertices;                
+                vec4 gp = a_gliphParam;                                
+                if(a_texCoord.w == RTL){
+                    vert.x = step(vert.x * 0.5 + 1.0, 1.0);
+                    gp.x = -a_gliphParam.x;
+                    gp.z = -(a_gliphParam.z + a_texCoord.z);
+                }else{
+                    gp.z = a_gliphParam.z + a_texCoord.z;
+                }
+                                
+                vec2 v = screenPos + rotate2d(a_rotation) * ((vert * gp.xy + gp.zw) * a_size * scd + a_offset.xy);
+                                
                 gl_Position = vec4((2.0 * v / viewport - 1.0) * projPos.w, projPos.z, projPos.w);
             }`,
         fragmentShader:

package/src/og/terrain/EmptyTerrain.js

@@ -1,148 +1,166 @@
-/**
- * @module og/terrainProvider/EmptyTerrain
- */
-
-"use strict";
-
-import { binarySearchFast } from "../utils/shared.js";
-
-/**
- * Class represents terrain provider without elevation data.
- * @class
- */
-class EmptyTerrain {
-    constructor(options = {}) {
-        this.equalizeVertices = false;
-
+/**
+ * @module og/terrainProvider/EmptyTerrain
+ */
+
+"use strict";
+
+import { binarySearchFast } from "../utils/shared.js";
+import { Geoid } from "./Geoid.js";
+
+/**
+ * Class represents terrain provider without elevation data.
+ * @class
+ */
+class EmptyTerrain {
+    constructor(options = {}) {
+        this.equalizeVertices = false;
+
         this.equalizeNormals = false;
 
-        this.isEmpty = true;
-
-        /**
-         * Provider name is "empty"
-         * @public
-         * @type {string}
-         */
-        this.name = "empty";
-
-        /**
-         * Minimal z-index value for segment elevation data handling.
-         * @public
-         * @type {number}
-         */
-        this.minZoom = 1000000;
-
-        /**
-         * Maximal z-index value for segment elevation data handling.
-         * @public
-         * @type {number}
-         */
-        this.maxZoom = 21;
-
-        /**
-         * @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
-        ];
-        //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;
-
-        /**
-         * Elevation grid size. Currend is 2x2 is the smallest grid size.
-         * @public
-         * @type {number}
-         */
-        this.plainGridSize = 2;
-
-        /**
-         * Planet node.
-         * @protected
-         * @type {Planet}
-         */
-        this._planet = null;
-
-        this._geoid = null;
-
-        // const _ellToAltFn = [
-        //     (lon, lat, alt, callback) => callback(alt),
-        //     (lon, lat, alt, callback) => callback(alt - this._geoid.getHeight(lon, lat)),
-        //     (lon, lat, alt, callback) => {
-
-        //         let x = mercator.getTileX(lon, zoom),
-        //             y = mercator.getTileY(lat, zoom);
-
-        //         let mslAlt = alt - this._geoid.getHeight(lon, lat);
-
-        //         if (true) {
-
-        //         } else {
-
-        //         }
-
-        //         return callback(mslAlt);
-        //     },
-        // ];
-    }
-
-    static checkNoDataValue(noDataValues, value) {
-        return binarySearchFast(noDataValues, value) !== -1;
-    }
-
-    isBlur() {
-        return false;
-    }
-
-    set maxNodeZoom(val) {
-        if (val > this.gridSizeByZoom.length - 1) {
-            val = this.gridSizeByZoom.length - 1;
-        }
-        this._maxNodeZoom = val;
-    }
-
-    get maxNodeZoom() {
-        return this._maxNodeZoom;
-    }
-
-    set geoid(geoid) {
-        this._geoid = geoid;
-    }
-
-    get geoid() {
-        return this._geoid;
-    }
-
-    /**
-     * Loads or creates segment elevation data.
-     * @public
-     * @virtual
-     * @param {Segment} segment - Segment to create elevation data.
-     */
-    handleSegmentTerrain(segment) {
-        segment.terrainIsLoading = false;
-        segment.terrainReady = true;
-        segment.terrainExists = true;
-    }
-
-    isReady() {
-        return (this._geoid && this._geoid.model) || !this._geoid;
-    }
-
-    /**
-     * Abstract function
-     * @public
-     * @abstract
-     */
-    abortLoading() {}
-
-    /**
-     * Abstract function
-     * @public
-     * @abstract
-     */
-    clearCache() {}
-}
-
-export { EmptyTerrain };
+        this.isEmpty = true;
+
+        /**
+         * Provider name is "empty"
+         * @public
+         * @type {string}
+         */
+        this.name = "empty";
+
+        /**
+         * Minimal z-index value for segment elevation data handling.
+         * @public
+         * @type {number}
+         */
+        this.minZoom = 1000000;
+
+        /**
+         * Maximal z-index value for segment elevation data handling.
+         * @public
+         * @type {number}
+         */
+        this.maxZoom = 21;
+
+        /**
+         * @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
+        ];
+        //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;
+
+        /**
+         * Elevation grid size. Currend is 2x2 is the smallest grid size.
+         * @public
+         * @type {number}
+         */
+        this.plainGridSize = 2;
+
+        /**
+         * Planet node.
+         * @protected
+         * @type {Planet}
+         */
+        this._planet = null;
+
+        this._geoid =
+            options.geoid ||
+            new Geoid({
+                src: options.geoidSrc || null
+            });
+
+        this._isReady = false;
+
+        // const _ellToAltFn = [
+        //     (lon, lat, alt, callback) => callback(alt),
+        //     (lon, lat, alt, callback) => callback(alt - this._geoid.getHeight(lon, lat)),
+        //     (lon, lat, alt, callback) => {
+
+        //         let x = mercator.getTileX(lon, zoom),
+        //             y = mercator.getTileY(lat, zoom);
+
+        //         let mslAlt = alt - this._geoid.getHeight(lon, lat);
+
+        //         if (true) {
+
+        //         } else {
+
+        //         }
+
+        //         return callback(mslAlt);
+        //     },
+        // ];
+    }
+
+    static checkNoDataValue(noDataValues, value) {
+        return binarySearchFast(noDataValues, value) !== -1;
+    }
+
+    isBlur() {
+        return false;
+    }
+
+    set maxNodeZoom(val) {
+        if (val > this.gridSizeByZoom.length - 1) {
+            val = this.gridSizeByZoom.length - 1;
+        }
+        this._maxNodeZoom = val;
+    }
+
+    get maxNodeZoom() {
+        return this._maxNodeZoom;
+    }
+
+    set geoid(geoid) {
+        this._geoid = geoid;
+    }
+
+    get geoid() {
+        return this._geoid;
+    }
+
+    getGeoid() {
+        return this._geoid;
+    }
+
+    /**
+     * Loads or creates segment elevation data.
+     * @public
+     * @virtual
+     * @param {Segment} segment - Segment to create elevation data.
+     */
+    handleSegmentTerrain(segment) {
+        segment.terrainIsLoading = false;
+        segment.terrainReady = true;
+        segment.terrainExists = true;
+    }
+
+    isReady() {
+        return this._isReady;
+    }
+
+    /**
+     * Abstract function
+     * @public
+     * @abstract
+     */
+    abortLoading() {
+    }
+
+    /**
+     * Abstract function
+     * @public
+     * @abstract
+     */
+    clearCache() {
+    }
+
+    getHeightAsync(lonLat, callback) {
+        callback(0);
+        return true;
+    }
+}
+
+export { EmptyTerrain };