@openglobus/og 0.18.0 → 0.18.2

package/{src/shaders/drawnode.ts → lib/js/shaders/drawnode.js}

@@ -1,34 +1,25 @@
 import * as atmos from "./atmos";
-import {Program} from "../webgl/Program";
-import {UTILS} from './utils';
-
+import { Program } from "../webgl/Program";
+import { UTILS } from './utils';
 // REMEMBER!
 // src*(1)+dest*(1-src.alpha)
 // glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 // src*(src.alpha)+dest*(1-src.alpha)
 // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-
 const NIGHT = `const vec3 nightStep = 10.0 * vec3(0.58, 0.48, 0.25);`;
-
 const DEF_BLEND = `#define blend(DEST, SAMPLER, OFFSET, OPACITY) \
                     src = texture( SAMPLER, OFFSET.xy + vTextureCoord.xy * OFFSET.zw );\
                     DEST = DEST * (1.0 - src.a * OPACITY) + src * OPACITY;`;
-
 const DEF_BLEND_WEBGL1 = `#define blend(DEST, SAMPLER, OFFSET, OPACITY) \
                             src = texture2D( SAMPLER, OFFSET.xy + vTextureCoord.xy * OFFSET.zw ); \
                             DEST = DEST * (1.0 - src.a * OPACITY) + src * OPACITY;`;
-
 const DEF_BLEND_PICKING = `#define blendPicking(DEST, OFFSET, SAMPLER, MASK, COLOR, OPACITY) \
     tc = OFFSET.xy + vTextureCoord.xy * OFFSET.zw; \
     t = texture2D(SAMPLER, tc); \
     p = texture2D(MASK, tc); \
-    DEST = mix(DEST, vec4(max(COLOR.rgb, p.rgb), OPACITY), (t.a == 0.0 ? 0.0 : 1.0) * COLOR.a);`
-
-
+    DEST = mix(DEST, vec4(max(COLOR.rgb, p.rgb), OPACITY), (t.a == 0.0 ? 0.0 : 1.0) * COLOR.a);`;
 const SLICE_SIZE = 4;
-
-export function drawnode_screen_nl(): Program {
+export function drawnode_screen_nl() {
     return new Program("drawnode_screen_nl", {
         uniforms: {
             projectionMatrix: "mat4",
@@ -46,9 +37,7 @@ export function drawnode_screen_nl(): Program {
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
-
-        vertexShader:
-            `precision highp float;
+        vertexShader: `precision highp float;
             
             attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
@@ -77,7 +66,6 @@ export function drawnode_screen_nl(): Program {
                 // This is works for Mac Chrome, prevent some weird optimization I suppose
                 gl_Position =  m * vec4(highDiff + lowDiff, 1.0);
             }`,
-
         fragmentShader: `precision highp float;
             #define SLICE_SIZE ${SLICE_SIZE + 1}
             uniform vec4 tileOffsetArr[SLICE_SIZE];
@@ -111,8 +99,7 @@ export function drawnode_screen_nl(): Program {
             }`
     });
 }
-
-export function drawnode_screen_wl_webgl1NoAtmos(): Program {
+export function drawnode_screen_wl_webgl1NoAtmos() {
     return new Program("drawnode_screen_wl", {
         uniforms: {
             projectionMatrix: "mat4",
@@ -120,10 +107,8 @@ export function drawnode_screen_wl_webgl1NoAtmos(): Program {
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
             height: "float",
-
             uGlobalTextureCoord: "vec4",
             uNormalMapBias: "vec3",
-
             samplerCount: "int",
             tileOffsetArr: "vec4",
             layerOpacityArr: "float",
@@ -136,7 +121,6 @@ export function drawnode_screen_wl_webgl1NoAtmos(): Program {
             diffuse: "vec3",
             ambient: "vec3",
             specular: "vec4",
-
             camHeight: "float",
             nightTextureCoefficient: "float"
         }, attributes: {
@@ -144,9 +128,7 @@ export function drawnode_screen_wl_webgl1NoAtmos(): Program {
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
-
-        vertexShader:
-            `
+        vertexShader: `
             attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
             attribute vec2 aTextureCoord;
@@ -188,9 +170,7 @@ export function drawnode_screen_wl_webgl1NoAtmos(): Program {
                             
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
-
-        fragmentShader:
-            `
+        fragmentShader: `
             precision highp float;
             
             #define MAX_POINT_LIGHTS 1
@@ -296,8 +276,7 @@ export function drawnode_screen_wl_webgl1NoAtmos(): Program {
             }`
     });
 }
-
-export function drawnode_screen_wl_webgl2NoAtmos(): Program {
+export function drawnode_screen_wl_webgl2NoAtmos() {
     return new Program("drawnode_screen_wl", {
         uniforms: {
             projectionMatrix: "mat4",
@@ -305,10 +284,8 @@ export function drawnode_screen_wl_webgl2NoAtmos(): Program {
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
             height: "float",
-
             uGlobalTextureCoord: "vec4",
             uNormalMapBias: "vec3",
-
             samplerCount: "int",
             tileOffsetArr: "vec4",
             layerOpacityArr: "float",
@@ -321,7 +298,6 @@ export function drawnode_screen_wl_webgl2NoAtmos(): Program {
             diffuse: "vec3",
             ambient: "vec3",
             specular: "vec4",
-
             camHeight: "float",
             nightTextureCoefficient: "float"
         }, attributes: {
@@ -329,9 +305,7 @@ export function drawnode_screen_wl_webgl2NoAtmos(): Program {
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
-
-        vertexShader:
-            `#version 300 es
+        vertexShader: `#version 300 es
 
             precision highp float;
 
@@ -376,9 +350,7 @@ export function drawnode_screen_wl_webgl2NoAtmos(): Program {
                             
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
-
-        fragmentShader:
-            `#version 300 es
+        fragmentShader: `#version 300 es
 
             precision highp float;
             
@@ -488,9 +460,7 @@ export function drawnode_screen_wl_webgl2NoAtmos(): Program {
             }`
     });
 }
-
-
-export function drawnode_screen_wl_webgl2Atmos(): Program {
+export function drawnode_screen_wl_webgl2Atmos() {
     return new Program("drawnode_screen_wl", {
         uniforms: {
             projectionMatrix: "mat4",
@@ -498,10 +468,8 @@ export function drawnode_screen_wl_webgl2Atmos(): Program {
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
             height: "float",
-
             uGlobalTextureCoord: "vec4",
             uNormalMapBias: "vec3",
-
             samplerCount: "int",
             tileOffsetArr: "vec4",
             layerOpacityArr: "float",
@@ -514,7 +482,6 @@ export function drawnode_screen_wl_webgl2Atmos(): Program {
             diffuse: "vec3",
             ambient: "vec3",
             specular: "vec4",
-
             transmittanceTexture: "sampler2D",
             scatteringTexture: "sampler2D",
             camHeight: "float",
@@ -525,9 +492,7 @@ export function drawnode_screen_wl_webgl2Atmos(): Program {
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
-
-        vertexShader:
-            `#version 300 es
+        vertexShader: `#version 300 es
 
             precision highp float;
 
@@ -572,9 +537,7 @@ export function drawnode_screen_wl_webgl2Atmos(): Program {
                             
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
-
-        fragmentShader:
-            `#version 300 es
+        fragmentShader: `#version 300 es
 
             precision highp float;
             
@@ -820,8 +783,7 @@ export function drawnode_screen_wl_webgl2Atmos(): Program {
             }`
     });
 }
-
-export function drawnode_colorPicking(): Program {
+export function drawnode_colorPicking() {
     return new Program("drawnode_colorPicking", {
         uniforms: {
             projectionMatrix: "mat4",
@@ -837,9 +799,7 @@ export function drawnode_colorPicking(): Program {
         }, attributes: {
             aVertexPositionHigh: "vec3", aVertexPositionLow: "vec3", aTextureCoord: "vec2"
         },
-
-        vertexShader:
-            `precision highp float;
+        vertexShader: `precision highp float;
             
             attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
@@ -869,9 +829,7 @@ export function drawnode_colorPicking(): Program {
 
                 gl_Position = m * vec4(highDiff + lowDiff, 1.0);
             }`,
-
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
             #define SLICE_SIZE ${SLICE_SIZE + 1}
             uniform vec4 tileOffsetArr[SLICE_SIZE];
             uniform vec4 pickingColorArr[SLICE_SIZE];
@@ -906,8 +864,7 @@ export function drawnode_colorPicking(): Program {
             }`
     });
 }
-
-export function drawnode_heightPicking(): Program {
+export function drawnode_heightPicking() {
     return new Program("drawnode_heightPicking", {
         uniforms: {
             projectionMatrix: "mat4",
@@ -918,9 +875,7 @@ export function drawnode_heightPicking(): Program {
         }, attributes: {
             aVertexPositionHigh: "vec3", aVertexPositionLow: "vec3"
         },
-
-        vertexShader:
-            `precision highp float;
+        vertexShader: `precision highp float;
 
             attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
@@ -954,9 +909,7 @@ export function drawnode_heightPicking(): Program {
                 
                 gl_Position =  m * vec4(highDiff + lowDiff, 1.0);         
             }`,
-
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
 
             varying vec3 eyePosition;
             varying vec3 vertexPosition;
@@ -979,8 +932,7 @@ export function drawnode_heightPicking(): Program {
             }`
     });
 }
-
-export function drawnode_depth(): Program {
+export function drawnode_depth() {
     return new Program("drawnode_depth", {
         uniforms: {
             projectionMatrix: "mat4",
@@ -992,9 +944,7 @@ export function drawnode_depth(): Program {
         }, attributes: {
             aVertexPositionHigh: "vec3", aVertexPositionLow: "vec3"
         },
-
-        vertexShader:
-            `precision highp float;
+        vertexShader: `precision highp float;
 
             attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
@@ -1026,9 +976,7 @@ export function drawnode_depth(): Program {
                 
                 gl_Position =  m * vec4(highDiff + lowDiff, 1.0);    
             }`,
-
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
             uniform vec3 frustumPickingColor;
 
             void main(void) {

package/lib/js/shaders/geoObject.d.ts

@@ -0,0 +1,3 @@
+import { Program } from "../webgl/Program";
+export declare const geo_object: () => Program;
+export declare const geo_object_picking: () => Program;

package/{src/shaders/geoObject.ts → lib/js/shaders/geoObject.js}

@@ -1,38 +1,30 @@
-import {Program} from "../webgl/Program";
-
-export const geo_object = (): Program =>
-    new Program("geo_object", {
-        uniforms: {
-            viewMatrix: "mat4",
-            projectionMatrix: "mat4",
-
-            uScaleByDistance: "vec3",
-
-            eyePositionHigh: "vec3",
-            eyePositionLow: "vec3",
-
-            lightsPositions: "vec3",
-            lightsParamsv: "vec3",
-            lightsParamsf: "float",
-
-            uTexture: "sampler2d",
-            uUseTexture: "float"
-        },
-        attributes: {
-            aVertexPosition: "vec3",
-            aVertexNormal: "vec3",
-            aTexCoord: "vec2",
-
-            aPositionHigh: {type: "vec3", divisor: 1},
-            aPositionLow: {type: "vec3", divisor: 1},
-            aDirection: {type: "vec3", divisor: 1},
-            aPitchRoll: {type: "vec2", divisor: 1},
-            aColor: {type: "vec4", divisor: 1},
-            aScale: {type: "float", divisor: 1},
-            aDispose: {type: "float", divisor: 1}
-        },
-        vertexShader:
-            `precision highp float;
+import { Program } from "../webgl/Program";
+export const geo_object = () => new Program("geo_object", {
+    uniforms: {
+        viewMatrix: "mat4",
+        projectionMatrix: "mat4",
+        uScaleByDistance: "vec3",
+        eyePositionHigh: "vec3",
+        eyePositionLow: "vec3",
+        lightsPositions: "vec3",
+        lightsParamsv: "vec3",
+        lightsParamsf: "float",
+        uTexture: "sampler2d",
+        uUseTexture: "float"
+    },
+    attributes: {
+        aVertexPosition: "vec3",
+        aVertexNormal: "vec3",
+        aTexCoord: "vec2",
+        aPositionHigh: { type: "vec3", divisor: 1 },
+        aPositionLow: { type: "vec3", divisor: 1 },
+        aDirection: { type: "vec3", divisor: 1 },
+        aPitchRoll: { type: "vec2", divisor: 1 },
+        aColor: { type: "vec4", divisor: 1 },
+        aScale: { type: "float", divisor: 1 },
+        aDispose: { type: "float", divisor: 1 }
+    },
+    vertexShader: `precision highp float;
             
             attribute vec3 aVertexPosition;
             attribute vec3 aVertexNormal; 
@@ -125,8 +117,7 @@ export const geo_object = (): Program =>
                                
                 gl_Position = projectionMatrix * viewMatrixRTE  * vec4(highDiff + vert, 1.0);
             }`,
-
-        fragmentShader: `precision highp float;
+    fragmentShader: `precision highp float;
 
                 #define MAX_POINT_LIGHTS 1
                 
@@ -159,29 +150,27 @@ export const geo_object = (): Program =>
                         gl_FragColor = vec4(vColor.rgb * lightWeighting, vColor.a);
                     }
                 }`
-    });
-
-export const geo_object_picking = (): Program =>
-    new Program("geo_object_picking", {
-        uniforms: {
-            viewMatrix: "mat4",
-            projectionMatrix: "mat4",
-            uScaleByDistance: "vec3",
-            eyePositionHigh: "vec3",
-            eyePositionLow: "vec3",
-            pickingScale: "float"
-        },
-        attributes: {
-            aVertexPosition: "vec3",
-            aPositionHigh: {type: "vec3", divisor: 1},
-            aPositionLow: {type: "vec3", divisor: 1},
-            aDirection: {type: "vec3", divisor: 1},
-            aPitchRoll: {type: "vec2", divisor: 1},
-            aPickingColor: {type: "vec3", divisor: 1},
-            aScale: {type: "float", divisor: 1},
-            aDispose: {type: "float", divisor: 1}
-        },
-        vertexShader: `precision highp float;
+});
+export const geo_object_picking = () => new Program("geo_object_picking", {
+    uniforms: {
+        viewMatrix: "mat4",
+        projectionMatrix: "mat4",
+        uScaleByDistance: "vec3",
+        eyePositionHigh: "vec3",
+        eyePositionLow: "vec3",
+        pickingScale: "float"
+    },
+    attributes: {
+        aVertexPosition: "vec3",
+        aPositionHigh: { type: "vec3", divisor: 1 },
+        aPositionLow: { type: "vec3", divisor: 1 },
+        aDirection: { type: "vec3", divisor: 1 },
+        aPitchRoll: { type: "vec2", divisor: 1 },
+        aPickingColor: { type: "vec3", divisor: 1 },
+        aScale: { type: "float", divisor: 1 },
+        aDispose: { type: "float", divisor: 1 }
+    },
+    vertexShader: `precision highp float;
 
             attribute vec3 aVertexPosition;
             attribute vec3 aPositionHigh;
@@ -259,10 +248,9 @@ export const geo_object_picking = (): Program =>
                                 
                  gl_Position = projectionMatrix * viewMatrixRTE  * vec4(highDiff + vert, 1.0);
             }`,
-        fragmentShader:
-            `precision highp float;
+    fragmentShader: `precision highp float;
             varying vec3 vColor;
             void main () {
                 gl_FragColor = vec4(vColor, 1.0);
             }`
-    });
+});

package/lib/js/shaders/label.d.ts

@@ -0,0 +1,4 @@
+import { Program } from '../webgl/Program';
+export declare function label_webgl2(): Program;
+export declare function label_screen(): Program;
+export declare function labelPicking(): Program;

package/{src/shaders/label.ts → lib/js/shaders/label.js}

@@ -1,20 +1,15 @@
-import {Program} from '../webgl/Program';
-
+import { Program } from '../webgl/Program';
 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;
                 }`;
-
-const ROTATE2D =
-    `mat2 rotate2d(float angle) {
+const ROTATE2D = `mat2 rotate2d(float angle) {
         return mat2(cos(angle), -sin(angle),
            sin(angle), cos(angle));
      }`;
-
-export function label_webgl2(): Program {
+export function label_webgl2() {
     return new Program("label", {
         uniforms: {
             viewport: "vec2",
@@ -43,8 +38,7 @@ export function label_webgl2(): Program {
             a_offset: "vec3",
             a_fontIndex: "float"
         },
-        vertexShader:
-            `#version 300 es
+        vertexShader: `#version 300 es
             
             ${DEFINE}
             
@@ -143,8 +137,7 @@ export function label_webgl2(): Program {
 
                 gl_Position = vec4((2.0 * v / viewport - 1.0) * projPos.w, projPos.z, projPos.w);
             }`,
-        fragmentShader:
-            `#version 300 es
+        fragmentShader: `#version 300 es
 
             uniform int isOutlinePass;
             
@@ -231,8 +224,7 @@ export function label_webgl2(): Program {
             }`
     });
 }
-
-export function label_screen(): Program {
+export function label_screen() {
     return new Program("label", {
         uniforms: {
             viewport: "vec2",
@@ -261,8 +253,7 @@ export function label_screen(): Program {
             a_offset: "vec3",
             a_fontIndex: "float"
         },
-        vertexShader:
-            `            
+        vertexShader: `            
             ${DEFINE}
                         
             attribute float a_outline;
@@ -359,8 +350,7 @@ export function label_screen(): Program {
                 
                 gl_Position = vec4((2.0 * v / viewport - 1.0) * projPos.w, projPos.z, projPos.w);
             }`,
-        fragmentShader:
-            `#extension GL_OES_standard_derivatives : enable
+        fragmentShader: `#extension GL_OES_standard_derivatives : enable
 
             precision highp float;
             precision highp int;
@@ -469,8 +459,7 @@ export function label_screen(): Program {
             }`
     });
 }
-
-export function labelPicking(): Program {
+export function labelPicking() {
     return new Program("labelPicking", {
         uniforms: {
             viewport: "vec2",
@@ -494,8 +483,7 @@ export function labelPicking(): Program {
             a_rotation: "float",
             a_rgba: "vec4"
         },
-        vertexShader:
-            `
+        vertexShader: `
             
             ${DEFINE}
             
@@ -582,8 +570,7 @@ export function labelPicking(): Program {
                                 
                 gl_Position = vec4((2.0 * v / viewport - 1.0) * projPos.w, projPos.z, projPos.w);
             }`,
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
 
             varying vec4 v_rgba;
 
@@ -599,4 +586,4 @@ export function labelPicking(): Program {
                 gl_FragColor = vec4(v_rgba.rgb, v_rgba.a);
             }`
     });
-}
+}

package/lib/js/shaders/lumFilter.d.ts

@@ -0,0 +1,2 @@
+import { Program } from '../webgl/Program';
+export declare function lumFilter(): Program;

package/{src/shaders/lumFilter.ts → lib/js/shaders/lumFilter.js}

@@ -1,6 +1,5 @@
 import { Program } from '../webgl/Program';
-
-export function lumFilter(): Program {
+export function lumFilter() {
     return new Program("lumFilter", {
         uniforms: {
             texture: "sampler2d",
@@ -9,16 +8,14 @@ export function lumFilter(): Program {
         attributes: {
             corners: "vec3"
         },
-        vertexShader:
-            `attribute vec2 corners;
+        vertexShader: `attribute vec2 corners;
             
             varying vec2 tc;
             void main(void) {
                 gl_Position = vec4(corners, 0.0, 1.0);
                 tc = corners * 0.5 + 0.5;
             }`,
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
             uniform sampler2D texture;
 
             uniform float threshold;
@@ -36,4 +33,4 @@ export function lumFilter(): Program {
                     gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
             }`
     });
-}
+}

package/lib/js/shaders/pickingMask.d.ts

@@ -0,0 +1,2 @@
+import { Program } from '../webgl/Program';
+export declare function pickingMask(): Program;

package/{src/shaders/pickingMask.ts → lib/js/shaders/pickingMask.js}

@@ -1,6 +1,5 @@
-import {Program} from '../webgl/Program';
-
-export function pickingMask(): Program {
+import { Program } from '../webgl/Program';
+export function pickingMask() {
     return new Program("pickingMask", {
         uniforms: {
             offset: "vec2"
@@ -8,18 +7,16 @@ export function pickingMask(): Program {
         attributes: {
             coordinates: "vec2"
         },
-        vertexShader:
-            `attribute vec2 coordinates;
+        vertexShader: `attribute vec2 coordinates;
             uniform vec2 offset;
             void main() {
             
                 gl_Position = vec4(coordinates + offset, 0.0, 1.0);
                 gl_PointSize = 5.0;
             }`,
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
             void main(void) {
                 gl_FragColor = vec4(1.0);
             }`
     });
-}
+}

package/lib/js/shaders/pointCloud.d.ts

@@ -0,0 +1,2 @@
+import { Program } from '../webgl/Program';
+export declare function pointCloud(): Program;

package/{src/shaders/pointCloud.ts → lib/js/shaders/pointCloud.js}

@@ -1,7 +1,6 @@
 import { Program } from '../webgl/Program';
-
 //Picking is the same
-export function pointCloud(): Program {
+export function pointCloud() {
     return new Program("pointCloud", {
         uniforms: {
             projectionViewMatrix: "mat4",
@@ -12,8 +11,7 @@ export function pointCloud(): Program {
             coordinates: "vec3",
             colors: "vec3"
         },
-        vertexShader:
-            `attribute vec3 coordinates;
+        vertexShader: `attribute vec3 coordinates;
             attribute vec4 colors;
             uniform mat4 projectionViewMatrix;
             uniform float opacity;
@@ -25,11 +23,10 @@ export function pointCloud(): Program {
                 gl_Position = projectionViewMatrix * vec4(coordinates, 1.0);
                 gl_PointSize = pointSize;
             }`,
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
             varying vec4 color;
             void main(void) {
                 gl_FragColor = color;
             }`
     });
-}
+}

package/lib/js/shaders/polyline.d.ts

@@ -0,0 +1,3 @@
+import { Program } from '../webgl/Program';
+export declare function polyline_screen(): Program;
+export declare function polyline_picking(): Program;