@openglobus/og 0.17.2 → 0.18.1

package/lib/js/shaders/polyline.js

@@ -0,0 +1,345 @@
+import { Program } from '../webgl/Program';
+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_picking() {
+    return new Program("polyline_picking", {
+        uniforms: {
+            viewport: "vec2",
+            proj: "mat4",
+            view: "mat4",
+            eyePositionHigh: "vec3",
+            eyePositionLow: "vec3",
+            uFloatParams: "vec2",
+            color: "vec4",
+            thickness: "float",
+            depthOffset: "float"
+        },
+        attributes: {
+            prevHigh: "vec3",
+            currentHigh: "vec3",
+            nextHigh: "vec3",
+            prevLow: "vec3",
+            currentLow: "vec3",
+            nextLow: "vec3",
+            order: "float"
+        },
+        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;
+
+                uniform float thickness;
+                uniform vec4 color;
+                uniform mat4 proj;
+                uniform mat4 view;
+                uniform vec2 viewport;
+                uniform vec3 eyePositionHigh;
+                uniform vec3 eyePositionLow;
+                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 = color;
+
+                    vec3 current = currentHigh + currentLow;
+
+                    vPos = current;                    
+
+                    vec3 highDiff, lowDiff;
+
+                    mat4 viewMatrixRTE = view;
+                    viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+                    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*/
+                    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);
+                }`
+    });
+}

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

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

package/lib/js/shaders/ray.js

@@ -0,0 +1,76 @@
+import { Program } from '../webgl/Program';
+export function rayScreen() {
+    return new Program("rayScreen", {
+        uniforms: {
+            projectionMatrix: "mat4",
+            viewMatrix: "mat4",
+            eyePositionHigh: "vec3",
+            eyePositionLow: "vec3",
+            resolution: "float",
+            uOpacity: "float"
+        },
+        attributes: {
+            a_vertices: "vec2",
+            a_startPosHigh: "vec3",
+            a_startPosLow: "vec3",
+            a_endPosHigh: "vec3",
+            a_endPosLow: "vec3",
+            a_thickness: "float",
+            a_rgba: "vec4"
+        },
+        vertexShader: `precision highp float;
+
+            attribute vec4 a_rgba;
+            attribute vec3 a_startPosHigh;
+            attribute vec3 a_startPosLow;
+            attribute vec3 a_endPosHigh;
+            attribute vec3 a_endPosLow;
+            attribute vec2 a_vertices;
+            attribute float a_thickness;
+
+            varying vec4 v_rgba;
+
+            uniform mat4 viewMatrix;
+            uniform mat4 projectionMatrix;
+            uniform vec3 eyePositionHigh;
+            uniform vec3 eyePositionLow;
+            uniform float resolution;
+            uniform float uOpacity;
+
+            void main() {
+
+                v_rgba = vec4(a_rgba.rgb, a_rgba.a * uOpacity);
+
+                vec3 v = (a_endPosHigh - a_startPosHigh) + (a_endPosLow - a_startPosLow);
+
+                vec3 look = (a_startPosHigh - eyePositionHigh) + (a_startPosLow - eyePositionLow) + v * a_vertices.y;
+                vec3 up = normalize(normalize(v));
+                vec3 right = normalize(cross(look,up));
+ 
+                float dist = dot(look, vec3(viewMatrix[0][2], viewMatrix[1][2], viewMatrix[2][2]));
+                float focalSize = 2.0 * dist * resolution;
+                vec3 vert = right * a_thickness * focalSize * a_vertices.x;
+
+                vec3 highDiff;
+                vec3 lowDiff;
+
+                if(a_vertices.y == 0.0){
+                    highDiff = a_startPosHigh - eyePositionHigh;
+                    vert += a_startPosLow - eyePositionLow;
+                }else{
+                    highDiff = a_endPosHigh - eyePositionHigh;
+                    vert += a_endPosLow - eyePositionLow;
+                }
+
+                mat4 viewMatrixRTE = viewMatrix;
+                viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+                
+                gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + vert, 1.0);
+            }`,
+        fragmentShader: `precision highp float;
+            varying vec4 v_rgba;
+            void main () {
+                gl_FragColor = v_rgba;
+            }`
+    });
+}

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

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

package/lib/js/shaders/screenFrame.js

@@ -0,0 +1,26 @@
+import { Program } from '../webgl/Program';
+export function screenFrame() {
+    return new Program("screenFrame", {
+        uniforms: {
+            texture: "sampler2d"
+        },
+        attributes: {
+            corners: "vec3"
+        },
+        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;
+            uniform sampler2D texture;
+            
+            varying vec2 tc;
+            
+            void main(void) {
+                gl_FragColor = texture2D( texture, tc );
+            }`
+    });
+}

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

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

package/lib/js/shaders/skybox.js

@@ -0,0 +1,28 @@
+import { Program } from '../webgl/Program';
+import { types } from '../webgl/types';
+export function skybox() {
+    return new Program("skybox", {
+        uniforms: {
+            projectionViewMatrix: { type: types.MAT4 },
+            uSampler: { type: types.SAMPLERCUBE },
+            pos: { type: types.VEC3 }
+        },
+        attributes: {
+            aVertexPosition: { type: types.VEC3, enableArray: true }
+        },
+        vertexShader: `attribute vec3 aVertexPosition;
+            uniform mat4 projectionViewMatrix;
+            uniform vec3 pos;
+            varying vec3 vTextureCoord;
+            void main(void) {
+                vTextureCoord = aVertexPosition;
+                gl_Position = projectionViewMatrix * vec4(aVertexPosition + pos, 1.0);
+            }`,
+        fragmentShader: `precision lowp float;
+            varying vec3 vTextureCoord;
+            uniform samplerCube uSampler;
+            void main(void) {
+                gl_FragColor = textureCube(uSampler, vTextureCoord);
+            }`
+    });
+}

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

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

package/lib/js/shaders/toneMapping.js

@@ -0,0 +1,85 @@
+import { Program } from '../webgl/Program';
+export function toneMapping() {
+    return new Program("toneMapping", {
+        uniforms: {
+            hdrBuffer: "sampler2d",
+            exposure: "float",
+            gamma: "float",
+            whitepoint: "float"
+        },
+        attributes: {
+            corners: "vec3"
+        },
+        vertexShader: `#version 300 es
+            
+            in vec2 corners;
+            
+            out vec2 tc;
+
+            void main(void) {
+                gl_Position = vec4(corners, 0.0, 1.0);
+                tc = corners * 0.5 + 0.5;
+            }`,
+        fragmentShader: `#version 300 es
+
+            precision highp float;
+
+            #ifndef saturate
+                #define saturate(a) clamp(a, 0.0, 1.0)
+            #endif
+
+            uniform sampler2D hdrBuffer;
+
+            uniform float whitepoint;
+            uniform float exposure;
+            uniform float gamma;
+
+            vec3 LinearToneMapping(vec3 color) {
+                return exposure * color;
+            }
+
+            vec3 ReinhardToneMapping2(vec3 color) {
+                return vec3(1.0) - exp(-color * exposure);
+            }
+
+            vec3 ReinhardToneMapping(vec3 color) {
+                color *= exposure;
+                return saturate(color / (vec3(1.0) + color));
+            }
+
+            #define Uncharted2Helper(x) max(((x * (0.15 * x + 0.10 * 0.50) + 0.20 * 0.02) / (x * (0.15 * x + 0.50) + 0.20 * 0.30)) - 0.02 / 0.30, vec3(0.0))
+
+            vec3 Uncharted2ToneMapping(vec3 color) {
+                color *= exposure;
+                return saturate(Uncharted2Helper(color) / Uncharted2Helper(vec3(whitepoint)));
+            }
+
+            vec3 OptimizedCineonToneMapping(vec3 color) {
+                color *= exposure;
+                color = max(vec3(0.0), color - 0.004);
+                return pow((color * (6.2 * color + 0.5)) / (color * (6.2 * color + 1.7) + 0.06), vec3(2.2));
+            }
+
+            vec3 ACESFilmicToneMapping(vec3 color) {
+                color *= exposure;
+                return saturate((color * (2.51 * color + 0.03)) / (color * (2.43 * color + 0.59) + 0.14));
+            }
+
+            in vec2 tc;
+
+            layout(location = 0) out vec4 fragColor;
+            
+            void main(void) {
+                vec4 hdrColor = texture(hdrBuffer, tc).rgba;
+                
+                float oneByGamma = gamma / gamma;
+                float oneByWhitePoint = whitepoint / whitepoint;
+                vec3 mapped = ReinhardToneMapping2(hdrColor.rgb) * oneByGamma * oneByWhitePoint;
+                //vec3 mapped = ACESFilmicToneMapping(hdrColor.rgb) * oneByGamma * oneByWhitePoint;
+
+                mapped = pow(mapped, vec3(1.0 / gamma));
+        
+                fragColor = vec4(mapped, hdrColor.a);
+            }`
+    });
+}

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

@@ -0,0 +1 @@
+export declare const UTILS = "\n    float getLerpValue(in float min, in float max, in float between)\n    {\n        return (clamp(between, min, max) - min) / (max - min);\n    }\n    \n    vec3 aces(vec3 color) \n    {\n        float a = 2.51;\n        float b = 0.03;\n        float c = 2.43;\n        float d = 0.59;\n        float e = 0.14;\n        return clamp((color * (a * color + b)) / (color * (c * color + d ) + e), 0.0, 1.0);\n    }\n     \n    bool intersectSphere(vec3 rayOrigin, vec3 rayDirection, float radius, inout float t1, inout float t2) \n    {\n        float b = dot(rayDirection, rayOrigin);\n        float c = dot(rayOrigin, rayOrigin) - radius * radius;\n        float d = b * b - c;\n        if (d < 0.0) {\n            return false;\n        }\n        t1 = -b - sqrt(d);\n        t2 = -b + sqrt(d);\n        return true;\n    }\n    \n    bool intersectSphere(vec3 rayOrigin, vec3 rayDirection, float radius, inout float t) \n    {\n        float b = dot(rayDirection, rayOrigin);\n        float c = dot(rayOrigin, rayOrigin) - radius * radius;\n        float d = b * b - c;\n        if (d < 0.0) {\n            return false;\n        }\n        t = -b - sqrt(d);\n        return true;\n    }\n    \n    bool intersectEllipsoid( in vec3 ro, in vec3 rd, in vec3 ra, inout float t )\n    {\n        vec3 ocn = ro/ra;\n        vec3 rdn = rd/ra;\n        float a = dot( rdn, rdn );\n        float b = dot( ocn, rdn );\n        float c = dot( ocn, ocn );\n        float h = b*b - a*(c-1.0);\n                       \n        if (h < 0.0) \n        { \n            return false; \n        }\n        \n        t = (-b-sqrt(h))/a;\n        \n        return true;\n    }\n    \n    bool intersectEllipsoid( in vec3 ro, in vec3 rd, in vec3 ra, inout float t1, inout float t2)\n    {\n        vec3 ocn = ro/ra;\n        vec3 rdn = rd/ra;\n        float a = dot( rdn, rdn );\n        float b = dot( ocn, rdn );\n        float c = dot( ocn, ocn );\n        float h = b*b - a*(c-1.0);\n                \n        if (h < 0.0) \n        { \n            return false; \n        }\n        \n        h = sqrt(h);\n        t1 = (-b-h)/a;\n        t2 = (-b+h)/a;\n        \n        return true;\n    }\n    \n    vec3 normalEllipsoid( in vec3 pos, in vec3 ra )\n    {\n        return normalize( pos/(ra*ra) );\n    }\n";

package/lib/js/shaders/utils.js

@@ -0,0 +1,86 @@
+export const UTILS = `
+    float getLerpValue(in float min, in float max, in float between)
+    {
+        return (clamp(between, min, max) - min) / (max - min);
+    }
+    
+    vec3 aces(vec3 color) 
+    {
+        float a = 2.51;
+        float b = 0.03;
+        float c = 2.43;
+        float d = 0.59;
+        float e = 0.14;
+        return clamp((color * (a * color + b)) / (color * (c * color + d ) + e), 0.0, 1.0);
+    }
+     
+    bool intersectSphere(vec3 rayOrigin, vec3 rayDirection, float radius, inout float t1, inout float t2) 
+    {
+        float b = dot(rayDirection, rayOrigin);
+        float c = dot(rayOrigin, rayOrigin) - radius * radius;
+        float d = b * b - c;
+        if (d < 0.0) {
+            return false;
+        }
+        t1 = -b - sqrt(d);
+        t2 = -b + sqrt(d);
+        return true;
+    }
+    
+    bool intersectSphere(vec3 rayOrigin, vec3 rayDirection, float radius, inout float t) 
+    {
+        float b = dot(rayDirection, rayOrigin);
+        float c = dot(rayOrigin, rayOrigin) - radius * radius;
+        float d = b * b - c;
+        if (d < 0.0) {
+            return false;
+        }
+        t = -b - sqrt(d);
+        return true;
+    }
+    
+    bool intersectEllipsoid( in vec3 ro, in vec3 rd, in vec3 ra, inout float t )
+    {
+        vec3 ocn = ro/ra;
+        vec3 rdn = rd/ra;
+        float a = dot( rdn, rdn );
+        float b = dot( ocn, rdn );
+        float c = dot( ocn, ocn );
+        float h = b*b - a*(c-1.0);
+                       
+        if (h < 0.0) 
+        { 
+            return false; 
+        }
+        
+        t = (-b-sqrt(h))/a;
+        
+        return true;
+    }
+    
+    bool intersectEllipsoid( in vec3 ro, in vec3 rd, in vec3 ra, inout float t1, inout float t2)
+    {
+        vec3 ocn = ro/ra;
+        vec3 rdn = rd/ra;
+        float a = dot( rdn, rdn );
+        float b = dot( ocn, rdn );
+        float c = dot( ocn, ocn );
+        float h = b*b - a*(c-1.0);
+                
+        if (h < 0.0) 
+        { 
+            return false; 
+        }
+        
+        h = sqrt(h);
+        t1 = (-b-h)/a;
+        t2 = (-b+h)/a;
+        
+        return true;
+    }
+    
+    vec3 normalEllipsoid( in vec3 pos, in vec3 ra )
+    {
+        return normalize( pos/(ra*ra) );
+    }
+`;

package/lib/js/terrain/BilTerrain.d.ts

@@ -0,0 +1,18 @@
+import { GlobusTerrain, IGlobusTerrainParams } from "./GlobusTerrain";
+import { Segment } from "../segment/Segment";
+import { Extent } from "../Extent";
+import { TypedArray } from "../utils/shared";
+interface IBilTerrainParams extends IGlobusTerrainParams {
+    layers?: string;
+    imageSize?: number;
+}
+declare class BilTerrain extends GlobusTerrain {
+    protected _format: string;
+    protected _layers: string;
+    protected _imageSize: number;
+    constructor(options?: IBilTerrainParams);
+    isBlur(segment: Segment): boolean;
+    protected _createUrl(segment: Segment): string;
+    protected _createHeights(data: number[], tileIndex: string, tileX: number, tileY: number, tileZoom: number, extent: Extent, preventChildren: boolean): TypedArray | number[];
+}
+export { BilTerrain };