@openglobus/og 0.13.12 → 0.14.2

package/src/og/segment/Segment.js

@@ -14,6 +14,10 @@ import * as segmentHelper from "../segment/segmentHelper.js";
 import { getMatrixSubArray } from "../utils/shared.js";
 import { Slice } from "./Slice.js";
 
+export const TILEGROUP_COMMON = 0;
+export const TILEGROUP_NORTH = 1;
+export const TILEGROUP_SOUTH = 2;
+
 var _tempHigh = new Vec3();
 var _tempLow = new Vec3();
 
@@ -57,7 +61,7 @@ class Segment {
     constructor(node, planet, tileZoom, extent) {
         this.isPole = false;
 
-        this._tileGroup = 0;
+        this._tileGroup = TILEGROUP_COMMON;
 
         this._projection = EPSG3857;
 
@@ -246,6 +250,10 @@ class Segment {
         this.plainProcessing = false;
     }
 
+    checkZoom() {
+        return this.tileZoom < this.planet.terrain._maxNodeZoom;
+    }
+
     /**
      * Returns entity terrain point.
      * @public
@@ -890,19 +898,10 @@ class Segment {
         this.deleteElevations();
     }
 
-    /**
-     * Removes cache records.
-     */
-    _freeCache() {
-        this.planet._quadTreeNodesCacheMerc[this.tileIndex] = null;
-        delete this.planet._quadTreeNodesCacheMerc[this.tileIndex];
-    }
-
     /**
      * Clear and destroy all segment data.
      */
     destroySegment() {
-        this._freeCache();
 
         this.clearSegment();
 
@@ -1206,7 +1205,9 @@ class Segment {
     }
 
     _assignTileIndexes() {
-        this._tileGroup = 0;
+
+        this._tileGroup = TILEGROUP_COMMON;
+
         var tileZoom = this.tileZoom;
         var extent = this._extent;
         var pole = mercator.POLE;
@@ -1224,25 +1225,17 @@ class Segment {
         this.tileYS = this.tileY + 1;
 
         this.tileIndex = Layer.getTileIndex(this.tileX, this.tileY, tileZoom);
-        this.planet._quadTreeNodesCacheMerc[this.tileIndex] = this.node;
     }
 
     initialize() {
         var p = this.planet;
         var n = this.node;
 
-        n.sideSize[0] =
-            n.sideSize[1] =
-                n.sideSize[2] =
-                    n.sideSize[3] =
-                        this.gridSize =
-                            p.terrain.gridSizeByZoom[this.tileZoom] || p.terrain.plainGridSize;
+        this.gridSize =
+            p.terrain.gridSizeByZoom[this.tileZoom] || p.terrain.plainGridSize;
 
-        n.sideSizeLog2[0] =
-            n.sideSizeLog2[1] =
-                n.sideSizeLog2[2] =
-                    n.sideSizeLog2[3] =
-                        Math.log2(p.terrain.gridSizeByZoom[this.tileZoom] || p.terrain.plainGridSize);
+        n.sideSizeLog2[0] = n.sideSizeLog2[1] = n.sideSizeLog2[2] = n.sideSizeLog2[3] =
+            Math.log2(this.gridSize);
 
         if (this.tileZoom <= p.terrain.maxZoom) {
             var nmc = this.planet._normalMapCreator;
@@ -1628,8 +1621,8 @@ class Segment {
     }
 
     _getIndexBuffer() {
-        var s = this.node.sideSizeLog2;
-        var cache = this.planet._indexesCache[Math.log2(this.gridSize)][s[0]][s[1]][s[2]][s[3]];
+        let s = this.node.sideSizeLog2;
+        let cache = this.planet._indexesCache[Math.log2(this.gridSize)][s[0]][s[1]][s[2]][s[3]];
         if (!cache.buffer) {
             let indexes = segmentHelper.getInstance().createSegmentIndexes(Math.log2(this.gridSize), [s[0], s[1], s[2], s[3]]);
             cache.buffer = this.planet.renderer.handler.createElementArrayBuffer(indexes, 1);

package/src/og/segment/SegmentLonLat.js

@@ -7,11 +7,10 @@ import { Vec3 } from "../math/Vec3.js";
 import * as mercator from "../mercator.js";
 import { EPSG4326 } from "../proj/EPSG4326.js";
 import * as quadTree from "../quadTree/quadTree.js";
-import { Segment } from "./Segment.js";
+import { Segment, TILEGROUP_NORTH, TILEGROUP_SOUTH } from "./Segment.js";
 
-const _heightLat = 90.0 - mercator.MAX_LAT;
-const _maxPoleZoom = 7;
-const _pieceSize = _heightLat / Math.pow(2, _maxPoleZoom);
+const MAX_POLE_ZOOM = 7;
+export const POLE_PIECE_SIZE = (90.0 - mercator.MAX_LAT) / Math.pow(2, MAX_POLE_ZOOM);
 
 let _tempHigh = new Vec3(),
     _tempLow = new Vec3();
@@ -35,16 +34,19 @@ class SegmentLonLat extends Segment {
     constructor(node, planet, tileZoom, extent) {
         super(node, planet, tileZoom, extent);
 
-        // TODO:
-        // be carefull with functions in constructor _assignTileIndexes
-        // this._isNorth = false;
-
         this._projection = EPSG4326;
 
         this._extentMerc = new Extent(
             extent.southWest.forwardMercatorEPS01(),
             extent.northEast.forwardMercatorEPS01()
         );
+
+        if (this._extent.northEast.lat > 0) {
+            this._isNorth = true;
+        } else {
+            this._isNorth = false;
+        }
+
         this.isPole = true;
     }
 
@@ -64,56 +66,56 @@ class SegmentLonLat extends Segment {
         return xyz.length() - res.length();
     }
 
-    acceptForRendering(camera) {
-        var maxPoleZoom;
-        var lat = this._extent.northEast.lat;
+    _getMaxZoom() {
+        let maxPoleZoom = 0;
         if (this._isNorth) {
             //north pole limits
-            let Yz = Math.floor((90.0 - lat) / _pieceSize);
+            let Yz = Math.floor((90.0 - this._extent.northEast.lat) / POLE_PIECE_SIZE);
             maxPoleZoom = Math.floor(Yz / 16) + 7;
         } else {
             //south pole limits
-            let Yz = Math.floor((mercator.MIN_LAT - lat) / _pieceSize);
+            let Yz = Math.floor((mercator.MIN_LAT - this._extent.northEast.lat) / POLE_PIECE_SIZE);
             maxPoleZoom = 12 - Math.floor(Yz / 16);
         }
-        return (
-            Segment.prototype.acceptForRendering.call(this, camera) || this.tileZoom >= maxPoleZoom
-        );
+        return maxPoleZoom;
+    }
+
+    checkZoom() {
+        return super.checkZoom() && this.tileZoom <= this._getMaxZoom();
     }
 
     _assignTileIndexes() {
-        var tileZoom = this.tileZoom;
-        var extent = this._extent;
+        this._assignTileXIndexes(this._extent);
+        this._assignTileYIndexes(this._extent);
+        this.tileIndex = Layer.getTileIndex(this.tileX, this.tileY, this.tileZoom);
+    }
 
+    _assignTileXIndexes(extent) {
         this.tileX = Math.round(
             Math.abs(-180.0 - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon)
         );
 
-        var lat = extent.northEast.lat;
+        let p2 = 1 << this.tileZoom;
+        this.tileXE = (this.tileX + 1) % p2;
+        this.tileXW = (p2 + this.tileX - 1) % p2;
+    }
 
+    _assignTileYIndexes(extent) {
+        var lat = extent.northEast.lat;
         if (lat > 0) {
-            //north pole
-            this._isNorth = true;
-            this._tileGroup = 1;
+            this._tileGroup = TILEGROUP_NORTH;
             this.tileY = Math.round((90.0 - lat) / (extent.northEast.lat - extent.southWest.lat));
         } else {
-            //south pole
-            this._tileGroup = 2;
+            this._tileGroup = TILEGROUP_SOUTH;
             this.tileY = Math.round(
                 (mercator.MIN_LAT - lat) / (extent.northEast.lat - extent.southWest.lat)
             );
         }
-
-        var p2 = 1 << tileZoom;
-        this.tileXE = (this.tileX + 1) % p2;
-        this.tileXW = (p2 + this.tileX - 1) % p2;
-
         this.tileYN = this.tileY - 1;
         this.tileYS = this.tileY + 1;
-
-        this.tileIndex = Layer.getTileIndex(this.tileX, this.tileY, tileZoom);
     }
 
+
     _createPlainVertices() {
         var gridSize = this.planet.terrain.gridSizeByZoom[this.tileZoom];
 
@@ -292,4 +294,5 @@ class SegmentLonLat extends Segment {
         //empty for a time
     }
 }
+
 export { SegmentLonLat };

package/src/og/segment/SegmentLonLatWgs84.js

@@ -0,0 +1,41 @@
+"use strict";
+
+import { POLE_PIECE_SIZE, SegmentLonLat } from "./SegmentLonLat.js";
+import { Segment, TILEGROUP_COMMON } from "./Segment.js";
+import * as mercator from "../mercator.js";
+
+export class SegmentLonLatWgs84 extends SegmentLonLat {
+    constructor(node, planet, tileZoom, extent) {
+        super(node, planet, tileZoom, extent);
+        this.isPole = false;
+        this._tileGroup = TILEGROUP_COMMON;
+    }
+
+    _getMaxZoom() {
+        return 150;
+        // let lat = 0;
+        // if (this._isNorth) {
+        //     lat = this._extent.northEast.lat;
+        // } else {
+        //     lat = Math.abs(this._extent.southWest.lat);
+        // }
+        // let Yz = Math.floor((90 - lat) / POLE_PIECE_SIZE);
+        // return Math.floor(Yz / 16) + 7;
+    }
+
+    _assignTileYIndexes(extent) {
+        this.tileY = Math.round((90.0 - extent.northEast.lat) / (extent.northEast.lat - extent.southWest.lat));
+        this.tileYN = this.tileY - 1;
+        this.tileYS = this.tileY + 1;
+    }
+
+    _assignTileXIndexes(extent) {
+        this.tileX = Math.round(
+            Math.abs(-180.0 - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon)
+        );
+
+        let p2 = (1 << this.tileZoom) * 2;
+        this.tileXE = (this.tileX + 1) % p2;
+        this.tileXW = (p2 + this.tileX - 1) % p2;
+    }
+}

package/src/og/shaders/ray.js

@@ -22,7 +22,6 @@ export function rayScreen() {
             a_startPosLow: "vec3",
             a_endPosHigh: "vec3",
             a_endPosLow: "vec3",
-            a_length: "float",
             a_thickness: "float",
             a_rgba: "vec4"
         },
@@ -34,7 +33,6 @@ export function rayScreen() {
             attribute vec3 a_endPosHigh;
             attribute vec3 a_endPosLow;
             attribute float a_thickness;
-            attribute float a_length;
             attribute vec4 a_rgba;
 
             varying vec4 v_rgba;
@@ -53,8 +51,9 @@ export function rayScreen() {
                 vec3 camPos = eyePositionHigh + eyePositionLow;
 
                 vec3 startPos = a_startPosHigh + a_startPosLow;
+                float length = length((a_endPosHigh + a_endPosLow) - startPos);
                 vec3 direction = normalize((a_endPosHigh + a_endPosLow) - startPos);
-                vec3 vertPos = startPos + a_vertices.y * direction * a_length;
+                vec3 vertPos = startPos + a_vertices.y * direction * length;
 
                 vec3 look = vertPos - camPos;
                 vec3 up = normalize(direction);
@@ -62,10 +61,18 @@ export function rayScreen() {
  
                 float dist = dot(camPos - vertPos, vec3(viewMatrix[0][2], viewMatrix[1][2], viewMatrix[2][2]));
                 float focalSize = 2.0 * dist * resolution;
-                vec3 rr = right * a_thickness * focalSize * a_vertices.x + up * a_length * a_vertices.y;
+                vec3 rr = right * a_thickness * focalSize * a_vertices.x;
 
-                vec3 highDiff = a_startPosHigh - eyePositionHigh;
-                vec3 lowDiff = a_startPosLow + rr - eyePositionLow;
+                vec3 highDiff = -eyePositionHigh;
+                vec3 lowDiff = rr - eyePositionLow;
+
+                if(a_vertices.y == 0.0){
+                    highDiff += a_startPosHigh;
+                    lowDiff += a_startPosLow;
+                }else{
+                    highDiff += a_endPosHigh;
+                    lowDiff += a_endPosLow;
+                }
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);

package/src/og/shaders/toneMapping.js

@@ -75,16 +75,16 @@ export function toneMapping() {
             layout(location = 0) out vec4 fragColor;
             
             void main(void) {
-                vec3 hdrColor = texture(hdrBuffer, tc).rgb;
+                vec4 hdrColor = texture(hdrBuffer, tc).rgba;
                 
                 float oneByGamma = gamma / gamma;
                 float oneByWhitePoint = whitepoint / whitepoint;
-                vec3 mapped = ReinhardToneMapping2(hdrColor) * oneByGamma * oneByWhitePoint;
-                //vec3 mapped = ACESFilmicToneMapping(hdrColor) * oneByGamma * oneByWhitePoint;
+                vec3 mapped = ReinhardToneMapping2(hdrColor.rgb) * oneByGamma * oneByWhitePoint;
+                //vec3 mapped = ACESFilmicToneMapping(hdrColor.rgb) * oneByGamma * oneByWhitePoint;
 
                 mapped = pow(mapped, vec3(1.0 / gamma));
-
-                fragColor = vec4(mapped, 1.0);
+        
+                fragColor = vec4(mapped, hdrColor.a);
             }`
     });
 }

package/src/og/terrain/GlobusTerrain.js

@@ -369,7 +369,8 @@ class GlobusTerrain extends EmptyTerrain {
                                 let heights = this._createHeights(response.data,
                                     segment.tileIndex,
                                     segment.tileX, segment.tileY, segment.tileZoom,
-                                    segment.getExtent()
+                                    segment.getExtent(),
+                                    segment.tileZoom === this.maxZoom
                                 );
 
                                 this._elevationCache[segment.tileIndex] = {
@@ -399,7 +400,7 @@ class GlobusTerrain extends EmptyTerrain {
 
     _getSubdomain() {
         this._requestCount++;
-        return  this._s[Math.floor(this._requestCount % (this._requestsPeerSubdomian * this._s.length) / this._requestsPeerSubdomian)];
+        return this._s[Math.floor(this._requestCount % (this._requestsPeerSubdomian * this._s.length) / this._requestsPeerSubdomian)];
     }
 
     _buildURL(x, y, z) {