@openglobus/og 0.15.2 → 0.15.4

package/src/og/shaders/polyline.js

@@ -6,6 +6,188 @@
 
 import { Program } from '../webgl/Program.js';
 
+export function polyline_screen() {
+    return new Program("polyline_screen", {
+        uniforms: {
+            viewport: "vec2",
+            proj: "mat4",
+            view: "mat4",
+            eyePositionHigh: "vec3",
+            eyePositionLow: "vec3",
+            uFloatParams: "vec2",
+            thickness: "float",
+            opacity: "float",
+            depthOffset: "float"
+        },
+        attributes: {
+            prevHigh: "vec3",
+            currentHigh: "vec3",
+            nextHigh: "vec3",
+
+            prevLow: "vec3",
+            currentLow: "vec3",
+            nextLow: "vec3",
+
+            order: "float",
+
+            color: "vec4"
+        },
+
+        vertexShader:
+            `precision highp float;
+
+                attribute vec3 prevHigh;
+                attribute vec3 currentHigh;
+                attribute vec3 nextHigh;
+
+                attribute vec3 prevLow;
+                attribute vec3 currentLow;
+                attribute vec3 nextLow;
+
+                attribute float order;
+
+                attribute vec4 color;
+
+                uniform float thickness;
+                uniform mat4 proj;
+                uniform mat4 view;
+                uniform vec2 viewport;
+                uniform vec3 eyePositionHigh;
+                uniform vec3 eyePositionLow;
+                uniform float opacity;
+                uniform float depthOffset;
+
+                varying vec4 vColor;
+                varying vec3 vPos;
+                varying vec3 uCamPos;
+
+                const float NEAR = -1.0;
+
+                vec2 getIntersection(vec2 start1, vec2 end1, vec2 start2, vec2 end2){
+                    vec2 dir = end2 - start2;
+                    vec2 perp = vec2(-dir.y, dir.x);
+                    float d2 = dot(perp, start2);
+                    float seg = dot(perp, start1) - d2;
+                    float prl = seg - dot(perp, end1) + d2;
+                    if(prl > -1.0 && prl < 1.0){
+                        return start1;
+                    }
+                    float u = seg / prl;
+                    return start1 + u * (end1 - start1);
+                }
+
+                vec2 project(vec4 p){
+                    return (0.5 * p.xyz / p.w + 0.5).xy * viewport;
+                }
+
+                void main(){
+
+                    uCamPos = eyePositionHigh + eyePositionLow;
+
+                    vColor = vec4(color.rgb, color.a * opacity);
+
+                    vec3 current = currentHigh + currentLow;
+
+                    vPos = current;
+
+                    mat4 viewMatrixRTE = view;
+                    viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+                    vec3 highDiff, lowDiff;
+
+                    highDiff = currentHigh - eyePositionHigh;
+                    lowDiff = currentLow - eyePositionLow;
+                    vec4 vCurrent = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+
+                    highDiff = prevHigh - eyePositionHigh;
+                    lowDiff = prevLow - eyePositionLow;
+                    vec4 vPrev = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+
+                    highDiff = nextHigh - eyePositionHigh;
+                    lowDiff = nextLow - eyePositionLow;
+                    vec4 vNext = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+
+                    /*Clip near plane, the point behind view plane*/
+                    if(vCurrent.z > NEAR) {
+                        if(vPrev.z < NEAR && abs(order) == 1.0){
+                            vCurrent = vPrev + (vCurrent - vPrev) * (NEAR - vPrev.z) / (vCurrent.z - vPrev.z);
+                        } else if(vNext.z < NEAR && abs(order) == 2.0){
+                            vCurrent = vNext + (vCurrent - vNext) * (NEAR - vNext.z) / (vCurrent.z - vNext.z);
+                        }
+                    }
+
+                    vec4 dCurrent = proj * vCurrent;
+                    vec2 _next = project(proj * vNext);
+                    vec2 _prev = project(proj * vPrev);
+                    vec2 _current = project(dCurrent);
+
+                    if(_prev == _current){
+                        if(_next == _current){
+                            _next = _current + vec2(1.0, 0.0);
+                            _prev = _current - _next;
+                        }else{
+                            _prev = _current + normalize(_current - _next);
+                        }
+                    }
+
+                    if(_next == _current){
+                        _next = _current + normalize(_current - _prev);
+                    }
+
+                    vec2 sNext = _next,
+                         sCurrent = _current,
+                         sPrev = _prev;
+
+                    vec2 dirNext = normalize(sNext - sCurrent);
+                    vec2 dirPrev = normalize(sPrev - sCurrent);
+                    float dotNP = dot(dirNext, dirPrev);
+
+                    vec2 normalNext = normalize(vec2(-dirNext.y, dirNext.x));
+                    vec2 normalPrev = normalize(vec2(dirPrev.y, -dirPrev.x));
+
+                    float d = thickness * sign(order);
+
+                    vec2 m;
+                    if(dotNP >= 0.99991){
+                        m = sCurrent - normalPrev * d;
+                    }else{
+                        m = getIntersection( sCurrent + normalPrev * d, sPrev + normalPrev * d,
+                                sCurrent + normalNext * d, sNext + normalNext * d );
+
+                        if( dotNP > 0.5 && dot(dirNext + dirPrev, m - sCurrent) < 0.0 ){
+                            float occw = order * sign(dirNext.x * dirPrev.y - dirNext.y * dirPrev.x);
+                            if(occw == -1.0){
+                                m = sCurrent + normalPrev * d;
+                            }else if(occw == 1.0){
+                                m = sCurrent + normalNext * d;
+                            }else if(occw == -2.0){
+                                m = sCurrent + normalNext * d;
+                            }else if(occw == 2.0){
+                                m = sCurrent + normalPrev * d;
+                            }
+                        }else if(distance(sCurrent, m) > min(distance(sCurrent, sNext), distance(sCurrent, sPrev))){
+                            m = sCurrent + normalNext * d;
+                        }
+                    }
+
+                    gl_Position = vec4((2.0 * m / viewport - 1.0) * dCurrent.w, dCurrent.z + depthOffset, dCurrent.w);
+                }`,
+
+        fragmentShader:
+            `precision highp float;
+                uniform vec2 uFloatParams;
+                varying vec3 uCamPos;
+                varying vec4 vColor;
+                varying vec3 vPos;
+                void main() {
+                    vec3 look = vPos - uCamPos;
+                    float lookLength = length(look);
+                    float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));
+                    gl_FragColor = vec4(vColor.rgb, a);
+                }`
+    });
+}
+
 // export function polyline_screen() {
 //     return new Program("polyline_screen", {
 //         uniforms: {
@@ -34,19 +216,21 @@ import { Program } from '../webgl/Program.js';
 //         },
 //
 //         vertexShader:
-//             `precision highp float;
+//             `#version 300 es
 //
-//                 attribute vec3 prevHigh;
-//                 attribute vec3 currentHigh;
-//                 attribute vec3 nextHigh;
+//                 precision highp float;
 //
-//                 attribute vec3 prevLow;
-//                 attribute vec3 currentLow;
-//                 attribute vec3 nextLow;
+//                 in vec3 prevHigh;
+//                 in vec3 currentHigh;
+//                 in vec3 nextHigh;
 //
-//                 attribute float order;
+//                 in vec3 prevLow;
+//                 in vec3 currentLow;
+//                 in vec3 nextLow;
 //
-//                 attribute vec4 color;
+//                 in float order;
+//
+//                 in vec4 color;
 //
 //                 uniform float thickness;
 //                 uniform mat4 proj;
@@ -57,9 +241,9 @@ import { Program } from '../webgl/Program.js';
 //                 uniform float opacity;
 //                 uniform float depthOffset;
 //
-//                 varying vec4 vColor;
-//                 varying vec3 vPos;
-//                 varying vec3 uCamPos;
+//                 out vec4 vColor;
+//                 out vec3 vPos;
+//                 out vec3 uCamPos;
 //
 //                 const float NEAR = -1.0;
 //
@@ -174,215 +358,31 @@ import { Program } from '../webgl/Program.js';
 //                 }`,
 //
 //         fragmentShader:
-//             `precision highp float;
+//             `#version 300 es
+//
+//                 precision highp float;
+//
 //                 uniform vec2 uFloatParams;
-//                 varying vec3 uCamPos;
-//                 varying vec4 vColor;
-//                 varying vec3 vPos;
+//
+//                 layout(location = 0) out vec4 diffuseColor;
+//                 layout(location = 1) out vec4 normalColor;
+//                 layout(location = 2) out vec4 distanceColor;
+//
+//                 in vec3 uCamPos;
+//                 in vec4 vColor;
+//                 in vec3 vPos;
+//
 //                 void main() {
 //                     vec3 look = vPos - uCamPos;
 //                     float lookLength = length(look);
 //                     float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));
-//                     gl_FragColor = vec4(vColor.rgb, a);
+//                     diffuseColor = vec4(vColor.rgb, a);
+//                     normalColor = vec4(1.0);
+//                     distanceColor = vec4(1.0);
 //                 }`
 //     });
 // }
 
-export function polyline_screen() {
-    return new Program("polyline_screen", {
-        uniforms: {
-            viewport: "vec2",
-            proj: "mat4",
-            view: "mat4",
-            eyePositionHigh: "vec3",
-            eyePositionLow: "vec3",
-            uFloatParams: "vec2",
-            thickness: "float",
-            opacity: "float",
-            depthOffset: "float"
-        },
-        attributes: {
-            prevHigh: "vec3",
-            currentHigh: "vec3",
-            nextHigh: "vec3",
-
-            prevLow: "vec3",
-            currentLow: "vec3",
-            nextLow: "vec3",
-
-            order: "float",
-
-            color: "vec4"
-        },
-
-        vertexShader:
-            `#version 300 es
-                
-                precision highp float;
-                
-                in vec3 prevHigh;
-                in vec3 currentHigh;
-                in vec3 nextHigh;
-                
-                in vec3 prevLow;
-                in vec3 currentLow;
-                in vec3 nextLow;
-
-                in float order;
-
-                in vec4 color;
-
-                uniform float thickness;
-                uniform mat4 proj;
-                uniform mat4 view;
-                uniform vec2 viewport;
-                uniform vec3 eyePositionHigh;
-                uniform vec3 eyePositionLow;
-                uniform float opacity;
-                uniform float depthOffset;
-
-                out vec4 vColor;
-                out vec3 vPos;
-                out vec3 uCamPos;
-                
-                const float NEAR = -1.0;
-                
-                vec2 getIntersection(vec2 start1, vec2 end1, vec2 start2, vec2 end2){
-                    vec2 dir = end2 - start2;
-                    vec2 perp = vec2(-dir.y, dir.x);
-                    float d2 = dot(perp, start2);
-                    float seg = dot(perp, start1) - d2;
-                    float prl = seg - dot(perp, end1) + d2;
-                    if(prl > -1.0 && prl < 1.0){
-                        return start1;
-                    }
-                    float u = seg / prl;
-                    return start1 + u * (end1 - start1);
-                }
-                
-                vec2 project(vec4 p){
-                    return (0.5 * p.xyz / p.w + 0.5).xy * viewport;
-                }
-                
-                void main(){
-
-                    uCamPos = eyePositionHigh + eyePositionLow;
-
-                    vColor = vec4(color.rgb, color.a * opacity);
-
-                    vec3 current = currentHigh + currentLow;
-
-                    vPos = current;                    
-
-                    mat4 viewMatrixRTE = view;
-                    viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
-
-                    vec3 highDiff, lowDiff;
-
-                    highDiff = currentHigh - eyePositionHigh;
-                    lowDiff = currentLow - eyePositionLow;
-                    vec4 vCurrent = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
-
-                    highDiff = prevHigh - eyePositionHigh;
-                    lowDiff = prevLow - eyePositionLow;    
-                    vec4 vPrev = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
-
-                    highDiff = nextHigh - eyePositionHigh;
-                    lowDiff = nextLow - eyePositionLow;    
-                    vec4 vNext = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
-
-                    /*Clip near plane, the point behind view plane*/
-                    if(vCurrent.z > NEAR) {
-                        if(vPrev.z < NEAR && abs(order) == 1.0){
-                            vCurrent = vPrev + (vCurrent - vPrev) * (NEAR - vPrev.z) / (vCurrent.z - vPrev.z);
-                        } else if(vNext.z < NEAR && abs(order) == 2.0){
-                            vCurrent = vNext + (vCurrent - vNext) * (NEAR - vNext.z) / (vCurrent.z - vNext.z);
-                        }
-                    }
-                    
-                    vec4 dCurrent = proj * vCurrent;
-                    vec2 _next = project(proj * vNext);
-                    vec2 _prev = project(proj * vPrev);
-                    vec2 _current = project(dCurrent);
-
-                    if(_prev == _current){
-                        if(_next == _current){
-                            _next = _current + vec2(1.0, 0.0);
-                            _prev = _current - _next;
-                        }else{
-                            _prev = _current + normalize(_current - _next);
-                        }
-                    }
-
-                    if(_next == _current){
-                        _next = _current + normalize(_current - _prev);
-                    }
-                    
-                    vec2 sNext = _next,
-                         sCurrent = _current,
-                         sPrev = _prev;
-
-                    vec2 dirNext = normalize(sNext - sCurrent);
-                    vec2 dirPrev = normalize(sPrev - sCurrent);
-                    float dotNP = dot(dirNext, dirPrev);
-                    
-                    vec2 normalNext = normalize(vec2(-dirNext.y, dirNext.x));
-                    vec2 normalPrev = normalize(vec2(dirPrev.y, -dirPrev.x));
-                    
-                    float d = thickness * sign(order);
-                    
-                    vec2 m;
-                    if(dotNP >= 0.99991){
-                        m = sCurrent - normalPrev * d;
-                    }else{
-                        m = getIntersection( sCurrent + normalPrev * d, sPrev + normalPrev * d,
-                                sCurrent + normalNext * d, sNext + normalNext * d );
-                        
-                        if( dotNP > 0.5 && dot(dirNext + dirPrev, m - sCurrent) < 0.0 ){
-                            float occw = order * sign(dirNext.x * dirPrev.y - dirNext.y * dirPrev.x);
-                            if(occw == -1.0){
-                                m = sCurrent + normalPrev * d;
-                            }else if(occw == 1.0){
-                                m = sCurrent + normalNext * d;
-                            }else if(occw == -2.0){
-                                m = sCurrent + normalNext * d;
-                            }else if(occw == 2.0){
-                                m = sCurrent + normalPrev * d;
-                            }
-                        }else if(distance(sCurrent, m) > min(distance(sCurrent, sNext), distance(sCurrent, sPrev))){
-                            m = sCurrent + normalNext * d;
-                        }
-                    }
-                                            
-                    gl_Position = vec4((2.0 * m / viewport - 1.0) * dCurrent.w, dCurrent.z + depthOffset, dCurrent.w);
-                }`,
-
-        fragmentShader:
-            `#version 300 es
-                
-                precision highp float;
-                
-                uniform vec2 uFloatParams;
-                
-                layout(location = 0) out vec4 diffuseColor;
-                layout(location = 1) out vec4 normalColor;
-                layout(location = 2) out vec4 distanceColor;
-                
-                in vec3 uCamPos;
-                in vec4 vColor;
-                in vec3 vPos;
-                
-                void main() {
-                    vec3 look = vPos - uCamPos;
-                    float lookLength = length(look);
-                    float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));                    
-                    diffuseColor = vec4(vColor.rgb, a);
-                    normalColor = vec4(1.0);
-                    distanceColor = vec4(1.0);                    
-                }`
-    });
-}
-
 export function polyline_picking() {
     return new Program("polyline_picking", {
         uniforms: {

package/src/og/utils/GeoImageCreator.js

@@ -4,6 +4,7 @@ import { LonLat } from '../LonLat.js';
 import * as utils from '../utils/shared.js';
 import { Framebuffer } from '../webgl/Framebuffer.js';
 import { Program } from '../webgl/Program.js';
+import { doubleToTwoFloats2 } from "../math/coder.js";
 
 export class GeoImageCreator {
 
@@ -32,35 +33,67 @@ export class GeoImageCreator {
      * @return{WebGLBuffer} Grid coordinates buffer.
      */
     createGridBuffer(c, toMerc) {
-        var gs = this._gridSize;
+        let gs = this._gridSize;
 
-        var v03 = new LonLat((c[3].lon - c[0].lon) / gs, (c[3].lat - c[0].lat) / gs),
+        let v03 = new LonLat((c[3].lon - c[0].lon) / gs, (c[3].lat - c[0].lat) / gs),
             v12 = new LonLat((c[2].lon - c[1].lon) / gs, (c[2].lat - c[1].lat) / gs),
             v01 = new LonLat((c[1].lon - c[0].lon) / gs, (c[1].lat - c[0].lat) / gs),
             v32 = new LonLat((c[2].lon - c[3].lon) / gs, (c[2].lat - c[3].lat) / gs);
 
-        var grid = new Float32Array((gs + 1) * (gs + 1) * 2);
-        var k = 0;
+        const size = (gs + 1) * (gs + 1) * 2,
+            halfSize = size / 2;
+
+        let gridHigh = new Float32Array(size),
+            gridLow = new Float32Array(size);
+
+        let lonLatArr = new Array(halfSize);
+
+        let kh = 0,
+            kl = 0,
+            k = 0;
+
+        let tempArr = new Float32Array(2);
+
         for (let i = 0; i <= gs; i++) {
-            var P03i = new LonLat(c[0].lon + i * v03.lon, c[0].lat + i * v03.lat),
+
+            let P03i = new LonLat(c[0].lon + i * v03.lon, c[0].lat + i * v03.lat),
                 P12i = new LonLat(c[1].lon + i * v12.lon, c[1].lat + i * v12.lat);
+
             for (let j = 0; j <= gs; j++) {
-                var P01j = new LonLat(c[0].lon + j * v01.lon, c[0].lat + j * v01.lat),
+                let P01j = new LonLat(c[0].lon + j * v01.lon, c[0].lat + j * v01.lat),
                     P32j = new LonLat(c[3].lon + j * v32.lon, c[3].lat + j * v32.lat);
-                var xx = utils.getLinesIntersectionLonLat(P03i, P12i, P01j, P32j);
-                grid[k++] = xx.lon;
-                grid[k++] = xx.lat;
+                let xx = utils.getLinesIntersectionLonLat(P03i, P12i, P01j, P32j);
+                doubleToTwoFloats2(xx.lon, tempArr);
+                gridHigh[kh++] = tempArr[0];
+                gridLow[kl++] = tempArr[1];
+                doubleToTwoFloats2(xx.lat, tempArr);
+                gridHigh[kh++] = tempArr[0];
+                gridLow[kl++] = tempArr[1];
+
+                lonLatArr[k++] = xx;
             }
         }
 
         if (toMerc) {
-            for (let i = 0; i < grid.length; i += 2) {
-                let c = new LonLat(grid[i], grid[i + 1]).forwardMercator();
-                grid[i] = c.lon;
-                grid[i + 1] = c.lat;
+            for (let i = 0; i < halfSize; i++) {
+                let c = lonLatArr[i].forwardMercator();
+                doubleToTwoFloats2(c.lon, tempArr);
+                gridHigh[i * 2] = tempArr[0];
+                gridLow[i * 2] = tempArr[1];
+
+                doubleToTwoFloats2(c.lat, tempArr);
+                gridHigh[i * 2 + 1] = tempArr[0];
+                gridLow[i * 2 + 1] = tempArr[1];
+
+                //grid[i] = c.lon;
+                //grid[i + 1] = c.lat;
             }
         }
-        return this._planet.renderer.handler.createArrayBuffer(grid, 2, grid.length / 2);
+
+        return [
+            this._planet.renderer.handler.createArrayBuffer(gridHigh, 2, halfSize),
+            this._planet.renderer.handler.createArrayBuffer(gridLow, 2, halfSize)
+        ];
     }
 
     frame() {
@@ -133,20 +166,27 @@ export class GeoImageCreator {
         this._planet.renderer.handler.addProgram(new Program("geoImageTransform", {
             uniforms: {
                 sourceTexture: "sampler2d",
-                extentParams: "vec4",
+                extentParamsHigh: "vec4",
+                extentParamsLow: "vec4",
                 isFullExtent: "bool"
             },
             attributes: {
-                corners: "vec2",
+                cornersHigh: "vec2",
+                cornersLow: "vec2",
                 texCoords: "vec2"
             },
-            vertexShader: `attribute vec2 corners; 
+            vertexShader:
+                `attribute vec2 cornersHigh; 
+                     attribute vec2 cornersLow;
                       attribute vec2 texCoords; 
-                      varying vec2 v_texCoords; 
-                      uniform vec4 extentParams; 
-                      void main() { 
+                      uniform vec4 extentParamsHigh; 
+                      uniform vec4 extentParamsLow; 
+                      varying vec2 v_texCoords;
+                      void main() {                                                             
                           v_texCoords = texCoords; 
-                          gl_Position = vec4((-1.0 + (corners - extentParams.xy) * extentParams.zw) * vec2(1.0, -1.0), 0.0, 1.0); 
+                          vec2 highDiff = cornersHigh - extentParamsHigh.xy;
+                          vec2 lowDiff = cornersLow - extentParamsLow.xy;                                        
+                          gl_Position = vec4((-1.0 + (highDiff + lowDiff) * extentParamsHigh.zw) * vec2(1.0, -1.0), 0.0, 1.0); 
                       }`,
             fragmentShader:
                 `precision highp float;