@openglobus/og 0.13.7 → 0.13.8

package/src/og/scene/Planet.js

@@ -227,7 +227,7 @@ export class Planet extends RenderNode {
          */
         this.maxCurrZoom = math.MIN;
 
-        this._viewExtent = null;
+        this._viewExtent = new Extent(new LonLat(180, 180), new LonLat(-180, -180));
 
         /**
          * @protected
@@ -1072,7 +1072,8 @@ export class Planet extends RenderNode {
         // clear first
         this._clearRenderedNodeList();
 
-        this._viewExtent = null;
+        this._viewExtent.southWest.set(180, 180);
+        this._viewExtent.northEast.set(-180, -180);
 
         this._visibleNodes = {};
         this._visibleNodesNorth = {};

package/src/og/segment/Segment.js

@@ -1209,14 +1209,6 @@ class Segment {
     _addViewExtent() {
         var ext = this._extentLonLat;
 
-        if (!this.planet._viewExtent) {
-            this.planet._viewExtent = new Extent(
-                new LonLat(ext.southWest.lon, ext.southWest.lat),
-                new LonLat(ext.northEast.lon, ext.northEast.lat)
-            );
-            return;
-        }
-
         var viewExt = this.planet._viewExtent;
 
         if (ext.southWest.lon < viewExt.southWest.lon) {

package/src/og/shaders/label.js

@@ -92,6 +92,7 @@ export function label_webgl2() {
 
                 if(a_texCoord.w == EMPTY) {
                     gl_Position = vec4(0.0);
+                    v_fontIndex = -1;
                     return;
                 }
                
@@ -154,7 +155,6 @@ export function label_webgl2() {
             uniform int isOutlinePass;
             
             precision highp float;
-            precision highp int;
 
             const int MAX_SIZE = 11;
 
@@ -207,51 +207,33 @@ export function label_webgl2() {
                 }
                 return median(msdf.r, msdf.g, msdf.b);
             }
-
-            vec4 getSDFParams() {
-                if(v_fontIndex == 0) {
-                    return sdfParamsArr[0];
-                } else if(v_fontIndex == 1){
-                    return sdfParamsArr[1];
-                } else if(v_fontIndex == 2){
-                    return sdfParamsArr[2];
-                } else if(v_fontIndex == 3){
-                    return sdfParamsArr[3];
-                } else if(v_fontIndex == 4){
-                    return sdfParamsArr[4];
-                } else if(v_fontIndex == 5){
-                    return sdfParamsArr[5];
-                } else if(v_fontIndex == 6){
-                    return sdfParamsArr[6];
-                } else if(v_fontIndex == 7){
-                    return sdfParamsArr[7];
-                } else if(v_fontIndex == 8){
-                    return sdfParamsArr[8];
-                } else if(v_fontIndex == 9){
-                    return sdfParamsArr[9];
-                } else if(v_fontIndex == 10){
-                    return sdfParamsArr[10];
-                }
-            }
                         
             void main () {
-
-                vec4 sdfParams = getSDFParams();
+            
+                if(v_fontIndex == -1) {
+                    return;
+                }
+                
+                vec4 sdfParams = sdfParamsArr[v_fontIndex];
                 float sd = getDistance();             
                 vec2 dxdy = fwidth(v_uv) * sdfParams.xy;
-                float dist = sd + min(0.001, 0.5 - 1.0 / sdfParams.w) - 0.5;
-                float opacity = clamp(dist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);
 
                 if(isOutlinePass == 0){                             
+                    float dist = sd + min(0.001, 0.5 - 1.0 / sdfParams.w) - 0.5;
+                    float opacity = clamp(dist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);
+                    if(opacity <= 0.1){
+                        discard;
+                    }
                     outScreen = vec4(v_rgba.rgb, opacity * v_rgba.a);
-                } else {                
-                    float strokeDist = sd + min(v_outline, 0.5 - 1.0 / sdfParams.w) - 0.5;
-                    float strokeAlpha = v_rgba.a * clamp(strokeDist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);                    
-                    if(strokeAlpha < 0.1){
+                } else {             
+                    float dist = sd + min(v_outline, 0.5 - 1.0 / sdfParams.w) - 0.5;
+                    float opacity = clamp(dist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);                       
+                    if(opacity <= 0.1){
                         discard;
                     }
-                    outScreen = v_rgba * strokeAlpha * (0.5 - opacity) * 2.0;
-                }                
+                    outScreen = vec4(v_rgba.rgb, opacity * v_rgba.a);
+                    //outScreen = v_rgba * strokeAlpha * (0.5 - opacity) * 2.0;
+                }         
             }`
     });
 }
@@ -326,6 +308,7 @@ export function label_screen() {
 
                 if(a_texCoord.w == EMPTY) {
                     gl_Position = vec4(0.0);
+                    v_fontIndex = -1.0;
                     return;
                 }
                
@@ -469,6 +452,10 @@ export function label_screen() {
 
                 fontIndex = v_fontIndex + 0.1;
                 
+                if(v_fontIndex < 0.0){
+                    return;
+                }
+                
                 vec4 sdfParams = getSDFParams();
                 float sd = getDistance();             
                 vec2 dxdy = fwidth(v_uv) * sdfParams.xy;
@@ -476,14 +463,14 @@ export function label_screen() {
                 float opacity = clamp(dist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);
 
                 if(isOutlinePass == 0){                             
-                    gl_FragColor = vec4(v_rgba.rgb, opacity * v_rgba.a);
+                    //gl_FragColor = vec4(v_rgba.rgb, opacity * v_rgba.a);
                 } else {                
                     float strokeDist = sd + min(v_outline, 0.5 - 1.0 / sdfParams.w) - 0.5;
                     float strokeAlpha = v_rgba.a * clamp(strokeDist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);                    
                     if(strokeAlpha < 0.1){
                         discard;
                     }
-                    gl_FragColor = v_rgba * strokeAlpha * (0.5 - opacity) * 2.0;
+                    //gl_FragColor = v_rgba * strokeAlpha * (0.5 - opacity) * 2.0;
                 }
             }`
     });
@@ -549,15 +536,16 @@ export function labelPicking() {
             void main() {
                 vec3 a_positions = a_positionsHigh + a_positionsLow;
                 vec3 cameraPos = eyePositionHigh + eyePositionLow;
-
+                v_rgba = a_rgba;
+                
                 if(a_texCoord.w == EMPTY) {
+                    v_rgba.a = 0.0;
                     gl_Position = vec4(0.0);
                     return;
                 }
 
                 vec3 look = a_positions - cameraPos;
                 float lookDist = length(look);
-                v_rgba = a_rgba;
                 if(opacity * step(lookDist, sqrt(dot(cameraPos,cameraPos) - planetRadius) + sqrt(dot(a_positions,a_positions) - planetRadius)) == 0.0){
                     return;
                 }
@@ -611,7 +599,7 @@ export function labelPicking() {
 
                 vec4 color = v_rgba;
                 if (color.a < 0.05) {
-                    discard;
+                    return;
                 }
 
                 gl_FragColor = vec4(v_rgba.rgb, v_rgba.a);

package/src/og/utils/FontAtlas.js

@@ -7,7 +7,6 @@
 import { Rectangle } from '../Rectangle.js';
 import { TextureAtlas, TextureAtlasNode } from './TextureAtlas.js';
 import { Deferred } from '../Deferred.js';
-import { ARIAL_FONT_B64 } from '../res/images.js';
 
 //TODO: get the value from shader module
 const MAX_SIZE = 11;
@@ -160,7 +159,7 @@ class FontAtlas {
             this._createTexture(atlas, img);
             def.resolve(index);
         };
-        img.src = ARIAL_FONT_B64;
+        img.src = imageBase64;
     }
 
     _createTexture(atlas, img) {

package/src/og/utils/Loader.js

@@ -1,154 +1,161 @@
-'use strict';
-
-import { Events } from '../Events.js';
-
-if (window && !('createImageBitmap' in window)) {
-    window.createImageBitmap = function (blob) {
-        return new Promise((resolve, reject) => {
-            let img = document.createElement('img');
-            img.addEventListener('load', function () {
-                resolve(this);
-            });
-            img.src = URL.createObjectURL(blob);
-        });
-    };
-}
-
-export class Loader {
-
-    constructor(maxRequests = 24) {
-
-        this.MAX_REQUESTS = maxRequests;
-
-        this.events = new Events(["loadend"]);
-
-        this._loading = 0;
-
-        this._queue = [];//new QueueArray();
-
-        this._senderRequestCounter = [];
-
-        this._promises = {
-            'json': r => r.json(),
-            'blob': r => r.blob(),
-            'arrayBuffer': r => r.arrayBuffer(),
-            'imageBitmap': r => r.blob().then(createImageBitmap),
-            'text': r => r.text()
-        };
-    }
-
-    load(params, callback) {
-        if (params.sender) {
-            if (!this._senderRequestCounter[params.sender._id]) {
-                this._senderRequestCounter[params.sender._id] = {
-                    sender: params.sender,
-                    counter: 0,
-                    __requestCounterFrame__: null
-                };
-            }
-            this._senderRequestCounter[params.sender._id].counter++;
-        }
-        this._queue.push({ 'params': params, 'callback': callback });
-        this._exec();
-    }
-
-    fetch(params) {
-        return fetch(
-            params.src,
-            params.options || {}
-        )
-            .then(response => {
-                if (!response.ok) {
-                    throw Error(`Unable to load '${params.src}'`);
-                }
-                return this._promises[params.type || "blob"](response);
-            })
-
-            .then(data => {
-                return { 'status': "ready", 'data': data };
-
-            })
-
-            .catch(err => {
-                return { 'status': "error", 'msg': err.toString() };
-            });
-    }
-
-    _checkLoadend(request, sender) {
-        if (request.counter === 0 && sender._planet._terrainCompletedActivated) {
-            sender.events.dispatch(sender.events.loadend);
-            request.__requestCounterFrame__ = null;
-        } else {
-            request.__requestCounterFrame__ = requestAnimationFrame(() => {
-                this._checkLoadend(request, sender);
-            });
-        }
-    }
-
-    _handleResponse(q, response) {
-        q.callback(response);
-        let sender = q.params.sender;
-        if (sender && sender.events.loadend.handlers.length) {
-            let request = this._senderRequestCounter[sender._id];
-            if (request && request.counter > 0) {
-                request.counter--;
-                cancelAnimationFrame(request.__requestCounterFrame__);
-                request.__requestCounterFrame__ = requestAnimationFrame(() => {
-                    this._checkLoadend(request, sender);
-                });
-            }
-        }
-        this._exec();
-    }
-
-    _exec() {
-
-        if (this._queue.length > 0 && this._loading < this.MAX_REQUESTS) {
-
-            let q = this._queue.pop(),
-                p = q.params;
-
-            if (!p.filter || p.filter(p)) {
-
-                this._loading++;
-
-                return fetch(p.src, p.options || {})
-                    .then(response => {
-                        if (!response.ok) {
-                            throw Error(`Unable to load '${p.src}'`);
-                        }
-                        return this._promises[p.type || "blob"](response);
-                    })
-                    .then(data => {
-                        this._loading--;
-                        this._handleResponse(q, { status: "ready", data: data });
-                    })
-                    .catch(err => {
-                        this._loading--;
-                        this._handleResponse(q, { status: "error", msg: err.toString() });
-                    });
-
-            } else {
-                this._handleResponse(q, { status: "abort" });
-            }
-        } else if (this._loading === 0) {
-            this.events.dispatch(this.events.loadend);
-        }
-    }
-
-    abort() {
-        for (let i = 0, len = this._queue.length; i < len; i++) {
-            let qi = this._queue[i];
-            let sender = qi.params.sender;
-            if (sender && this._senderRequestCounter[sender._id]) {
-                this._senderRequestCounter[sender._id].counter = 0;
-                cancelAnimationFrame(this._senderRequestCounter[sender._id].__requestCounterFrame__);
-                this._senderRequestCounter[sender._id].__requestCounterFrame__ = null;
-            }
-            qi.callback({ 'status': "abort" });
-            this._queue[i] = null;
-        }
-        this._queue = [];
-        this._loading === 0;
-    }
+'use strict';
+
+import { Events } from '../Events.js';
+
+if (window && !('createImageBitmap' in window)) {
+    window.createImageBitmap = function (blob) {
+        return new Promise((resolve, reject) => {
+            let img = document.createElement('img');
+            img.addEventListener('load', function () {
+                resolve(this);
+            });
+            img.src = URL.createObjectURL(blob);
+        });
+    };
+}
+
+export class Loader {
+
+    constructor(maxRequests = 24) {
+
+        this.MAX_REQUESTS = maxRequests;
+
+        this.events = new Events(["loadend", "layerloadend"]);
+
+        this._loading = 0;
+
+        this._queue = [];//new QueueArray();
+
+        this._senderRequestCounter = [];
+
+        this._promises = {
+            'json': r => r.json(),
+            'blob': r => r.blob(),
+            'arrayBuffer': r => r.arrayBuffer(),
+            'imageBitmap': r => r.blob().then(createImageBitmap),
+            'text': r => r.text()
+        };
+    }
+
+    load(params, callback) {
+        if (params.sender) {
+            if (!this._senderRequestCounter[params.sender._id]) {
+                this._senderRequestCounter[params.sender._id] = {
+                    sender: params.sender,
+                    counter: 0,
+                    __requestCounterFrame__: null
+                };
+            }
+            this._senderRequestCounter[params.sender._id].counter++;
+        }
+        this._queue.push({ 'params': params, 'callback': callback });
+        this._exec();
+    }
+
+    fetch(params) {
+        return fetch(
+            params.src,
+            params.options || {}
+        )
+            .then(response => {
+                if (!response.ok) {
+                    throw Error(`Unable to load '${params.src}'`);
+                }
+                return this._promises[params.type || "blob"](response);
+            })
+
+            .then(data => {
+                return { 'status': "ready", 'data': data };
+
+            })
+
+            .catch(err => {
+                return { 'status': "error", 'msg': err.toString() };
+            });
+    }
+
+    isIdle(sender) {
+        let request = this._senderRequestCounter[sender._id];
+        return request && request.counter === 0 && (!sender._planet || sender._planet._terrainCompletedActivated);
+
+    }
+
+    _checkLoadend(request, sender) {
+        if (request.counter === 0 && (sender._planet._terrainCompletedActivated || !sender._planet)) {
+            sender.events.dispatch(sender.events.loadend, sender);
+            this.events.dispatch(this.events.layerloadend, sender);
+            request.__requestCounterFrame__ = null;
+        } else {
+            request.__requestCounterFrame__ = requestAnimationFrame(() => {
+                this._checkLoadend(request, sender);
+            });
+        }
+    }
+
+    _handleResponse(q, response) {
+        q.callback(response);
+        let sender = q.params.sender;
+        if (sender && (sender.events.loadend.handlers.length || this.events.layerloadend.handlers.length)) {
+            let request = this._senderRequestCounter[sender._id];
+            if (request && request.counter > 0) {
+                request.counter--;
+                cancelAnimationFrame(request.__requestCounterFrame__);
+                request.__requestCounterFrame__ = requestAnimationFrame(() => {
+                    this._checkLoadend(request, sender);
+                });
+            }
+        }
+        this._exec();
+    }
+
+    _exec() {
+
+        if (this._queue.length > 0 && this._loading < this.MAX_REQUESTS) {
+
+            let q = this._queue.pop(),
+                p = q.params;
+
+            if (!p.filter || p.filter(p)) {
+
+                this._loading++;
+
+                return fetch(p.src, p.options || {})
+                    .then(response => {
+                        if (!response.ok) {
+                            throw Error(`Unable to load '${p.src}'`);
+                        }
+                        return this._promises[p.type || "blob"](response);
+                    })
+                    .then(data => {
+                        this._loading--;
+                        this._handleResponse(q, { status: "ready", data: data });
+                    })
+                    .catch(err => {
+                        this._loading--;
+                        this._handleResponse(q, { status: "error", msg: err.toString() });
+                    });
+
+            } else {
+                this._handleResponse(q, { status: "abort" });
+            }
+        } else if (this._loading === 0) {
+            this.events.dispatch(this.events.loadend);
+        }
+    }
+
+    abort() {
+        for (let i = 0, len = this._queue.length; i < len; i++) {
+            let qi = this._queue[i];
+            let sender = qi.params.sender;
+            if (sender && this._senderRequestCounter[sender._id]) {
+                this._senderRequestCounter[sender._id].counter = 0;
+                cancelAnimationFrame(this._senderRequestCounter[sender._id].__requestCounterFrame__);
+                this._senderRequestCounter[sender._id].__requestCounterFrame__ = null;
+            }
+            qi.callback({ 'status': "abort" });
+            this._queue[i] = null;
+        }
+        this._queue = [];
+        this._loading = 0;
+    }
 }

package/src/og/utils/VectorTileCreator.js

@@ -237,7 +237,7 @@ export class VectorTileCreator {
                         height = _h;
                     }
 
-                    texture = (material._updateTexture && material._updateTexture) || h.createEmptyTexture_l(width, height);
+                    texture = material._updateTexture || h.createEmptyTexture_l(width, height);
 
                     f.setSize(width, height);