@openglobus/og 0.15.2 → 0.15.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openglobus/og",
-  "version": "0.15.2",
+  "version": "0.15.3",
   "description": "[OpenGlobus](https://www.openglobus.org/) is a javascript library designed to display interactive 3d maps and planets with map tiles, imagery and vector data, markers and 3d objects. It uses the WebGL technology, open source and completely free.",
   "directories": {
     "example": "./sandbox"

package/src/og/renderer/Renderer.js

@@ -494,8 +494,6 @@ class Renderer {
 
             this.handler.addPrograms([depth()]);
 
-            this.handler.addProgram(pickingMask());
-
             this.sceneFramebuffer = new Multisample(this.handler, {
                 size: 1,
                 msaa: this._msaa,
@@ -527,6 +525,8 @@ class Renderer {
             };
         }
 
+        this.handler.addProgram(pickingMask());
+
         this.handler.ONCANVASRESIZE = () => {
             this._resizeStart();
             this.events.dispatch(this.events.resize, this.handler.canvas);

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: {