@openglobus/og 0.17.2 → 0.18.1

package/lib/js/shaders/atmos.js

@@ -0,0 +1,312 @@
+import { Program } from '../webgl/Program';
+import { UTILS } from './utils';
+export const COMMON = `
+    
+    ${UTILS}
+    
+    #define PI 3.1415926538
+    #define ATMOS_HEIGHT 100000.0
+    #define RAYLEIGH_SCALE 0.08
+    #define MIE_SCALE 0.012
+    
+    #define SAMPLE_COUNT 16
+    #define SQRT_SAMPLE_COUNT 4
+            
+    const float GROUND_ALBEDO = 0.05 / PI;
+
+    // Sphere
+    const float BOTTOM_RADIUS = 6356752.3142451793;
+    const float TOP_RADIUS = 6356752.3142451793 + ATMOS_HEIGHT;
+        
+    // Ellipsoid
+    const vec3 bottomRadii = vec3(6378137.0, 6378137.0, 6356752.3142451793);           
+    const vec3 topRadii = bottomRadii + ATMOS_HEIGHT;
+    
+    const vec3 SPHERE_TO_ELLIPSOID_SCALE = vec3(BOTTOM_RADIUS) / bottomRadii;           
+    
+    const vec2 rayleighMieHeights = vec2(RAYLEIGH_SCALE, MIE_SCALE) * ATMOS_HEIGHT;
+     
+    const vec3 rayleighScatteringCoefficient = vec3(5.802, 13.558, 33.100) * 1e-6;
+    
+    const float mieScatteringCoefficient = 3.996e-06;
+    const float mieExtinctionCoefficient = 4.440e-06;
+    const vec3 ozoneAbsorptionCoefficient = vec3(0.650, 1.881, 0.085) * 1e-6;
+    
+    const float SUN_ANGULAR_RADIUS = 0.004685;
+    const float SUN_INTENSITY = 1.0;        
+    
+    vec3 sunWithBloom(vec3 rayDir, vec3 sunDir) 
+    {
+        float minSunCosTheta = cos(SUN_ANGULAR_RADIUS);            
+        float cosTheta = dot(rayDir, sunDir);
+        if (cosTheta >= minSunCosTheta) return vec3(1.0);                
+        float offset = minSunCosTheta - cosTheta;
+        float gaussianBloom = exp(-offset*15000.0)*0.7;
+        float invBloom = 1.0/(0.09 + offset*200.0)*0.01;
+        return vec3(gaussianBloom + invBloom);
+    }
+    
+    float rayleighPhase(float angle) 
+    {
+        return 3.0 / (16.0 * PI) * (1.0 + (angle * angle));
+    }
+    
+    float miePhase(float angle) 
+    {
+        float g = 0.8;
+        return 3.0 / (8.0 * PI) * ((1.0 - g * g) * (1.0 + angle * angle)) / ((2.0 + g * g) * pow(1.0 + g * g - 2.0 * g * angle, 1.5));
+    }
+        
+    vec3 opticalDepth(float height, float angle) 
+    {
+        vec3 rayOrigin = vec3(0.0, BOTTOM_RADIUS + height, 0.0);
+        vec3 rayDirection = vec3(sqrt(1.0 - angle * angle), angle, 0.0);
+        float t1, t2;
+        intersectSphere(rayOrigin, rayDirection, TOP_RADIUS, t1, t2);
+        float segmentLength = t2 / float(SAMPLE_COUNT);
+        
+        float t = segmentLength * 0.5;
+        vec3 opticalDepth = vec3(0.0);
+        
+        for (int i = 0; i < SAMPLE_COUNT; i++) 
+        {
+            vec3 position = rayOrigin + t * rayDirection;
+            float height = length(position) - BOTTOM_RADIUS;
+            opticalDepth.xy += exp(-height / rayleighMieHeights) * segmentLength;
+            
+            // density of the ozone layer is modeled as a triangular 
+            // function that is 30 km wide and centered at 25 km altitude
+            opticalDepth.z += (1.0 - min(abs(height - 25e3) / 15e3, 1.0)) * segmentLength;  
+            t += segmentLength;
+        }
+        
+        return opticalDepth;
+    }
+    
+    vec3 transmittance(float height, float angle) 
+    {
+        vec3 opticalDepth = opticalDepth(height, angle);
+        return exp(-(rayleighScatteringCoefficient * opticalDepth.x + mieExtinctionCoefficient * opticalDepth.y + ozoneAbsorptionCoefficient * opticalDepth.z));
+    }`;
+export function transmittance() {
+    return new Program("transmittance", {
+        uniforms: {
+            iResolution: "vec2"
+        },
+        attributes: {
+            a_position: "vec2"
+        },
+        vertexShader: `
+            attribute vec2 a_position;
+            
+            void main(void) 
+            {
+                gl_Position = vec4(a_position, 0.0, 1.0);
+            }`,
+        fragmentShader: `
+            precision highp float;
+            
+            ${COMMON}
+                       
+            uniform vec2 iResolution;
+                        
+            void main(void) 
+            {
+                vec2 uv = gl_FragCoord.xy / iResolution.xy;
+                float height = uv.y * ATMOS_HEIGHT;
+                float angle = uv.x * 2.0 - 1.0;
+                gl_FragColor = vec4(transmittance(height, angle), 1.0);
+            }`
+    });
+}
+export function scattering() {
+    return new Program("scattering", {
+        uniforms: {
+            iResolution: "vec2",
+            transmittanceTexture: "sampler2d"
+        },
+        attributes: {
+            a_position: "vec2"
+        },
+        vertexShader: `            
+            attribute vec2 a_position;  
+                      
+            void main(void) 
+            {
+                gl_Position = vec4(a_position, 0.0, 1.0);
+            }`,
+        fragmentShader: `            
+            precision highp float;
+            
+            uniform sampler2D transmittanceTexture;
+            uniform vec2 iResolution;
+            
+            ${COMMON}
+            
+            vec3 transmittanceFromTexture(float height, float angle) 
+            {
+                float u = (angle + 1.0) * 0.5;
+                float v = height / ATMOS_HEIGHT;
+                return texture2D(transmittanceTexture, vec2(u, v)).xyz;
+            }
+                                   
+            void main(void) 
+            {
+                vec2 uv = gl_FragCoord.xy / iResolution.xy;
+                
+                float height = uv.y * ATMOS_HEIGHT;
+                float angle = uv.x * 2.0 - 1.0;
+                
+                vec3 rayOrigin = vec3(0.0, BOTTOM_RADIUS + height, 0.0);
+                vec3 up = rayOrigin / length(rayOrigin);
+                vec3 lightDirection = vec3(sqrt(1.0 - angle * angle), angle, 0.0);
+                                
+                const float isotropicPhase = 1.0 / (4.0 * PI);
+                
+                vec3 light = vec3(0.0);
+                vec3 lightTransferFactor = vec3(0.0);
+                
+                for (int i = 0; i < SQRT_SAMPLE_COUNT; i++)
+                {
+                    for (int j = 0; j < SQRT_SAMPLE_COUNT; j++)
+                    {
+                        float u = ((0.5 + float(i)) / float(SQRT_SAMPLE_COUNT)) * 2.0 - 1.0;
+                        float v = (0.5 + float(j)) / float(SQRT_SAMPLE_COUNT);
+                        float r = sqrt(1.0 - u * u);
+                        float theta = 2.0 * PI * v;
+                        vec3 rayDirection = vec3(cos(theta) * r, sin(theta) * r, u);
+                                                
+                        float rayAngle = dot(up, rayDirection);
+                        bool cameraBelow = rayAngle < 0.0;
+                        
+                        vec3 transmittanceFromCameraToSpace = transmittanceFromTexture(height, cameraBelow ? -rayAngle : rayAngle);
+                        
+                        float offset = 0.0;
+                        float distanceToSpace = 0.0;
+                        
+                        intersectSphere(rayOrigin, rayDirection, TOP_RADIUS, offset, distanceToSpace);
+                        
+                        float distanceToGround = 0.0;
+                        bool hitGround = intersectSphere(rayOrigin, rayDirection, BOTTOM_RADIUS, distanceToGround) && distanceToGround > 0.0;                        
+                        float segmentLength = (hitGround ? distanceToGround : distanceToSpace) / float(SAMPLE_COUNT);
+                        float t = segmentLength * 0.5;
+                        
+                        vec3 transmittanceCamera;
+                        vec3 transmittanceLight;
+                         
+                        for (int k = 0; k < SAMPLE_COUNT; k++) 
+                        {
+                            vec3 position = rayOrigin + t * rayDirection;
+                            float height = length(position) - BOTTOM_RADIUS;
+                            vec3 up = position / length(position);
+                            float rayAngle = dot(up, rayDirection);
+                            float lightAngle = dot(up, lightDirection);
+                            
+                            float distanceToGround;
+                            float shadow = intersectSphere(position, lightDirection, BOTTOM_RADIUS, distanceToGround) && distanceToGround >= 0.0 ? 0.0 : 1.0;
+                            vec3 transmittanceToSpace = transmittanceFromTexture(height, cameraBelow ? -rayAngle : rayAngle);
+                            
+                            transmittanceCamera = cameraBelow ? (transmittanceToSpace / transmittanceFromCameraToSpace) : (transmittanceFromCameraToSpace / transmittanceToSpace);
+                            transmittanceLight = transmittanceFromTexture(height, lightAngle);
+                            
+                            vec2 opticalDensity = exp(-height / rayleighMieHeights);        
+                            vec3 scatteredLight = transmittanceLight * (rayleighScatteringCoefficient * opticalDensity.x + mieScatteringCoefficient * opticalDensity.y) * isotropicPhase;
+                            
+                            light += shadow * transmittanceCamera * scatteredLight * segmentLength;
+                            lightTransferFactor += transmittanceCamera * (rayleighScatteringCoefficient * opticalDensity.x + mieScatteringCoefficient * opticalDensity.y) * segmentLength;
+                            
+                            t += segmentLength;
+                        }
+                    
+                        if (hitGround) 
+                        {
+                            vec3 hitPoint = rayOrigin + rayDirection * distanceToGround;
+                            vec3 normal = normalize(hitPoint);
+                            float diffuseAngle = max(dot(normal, lightDirection), 0.0); 
+                            float earthAlbedo = 0.05;
+                            light += transmittanceCamera * transmittanceLight * (earthAlbedo / PI) * diffuseAngle;
+                        }
+                    }
+                }
+                
+                light /= float(SAMPLE_COUNT);
+                lightTransferFactor /= float(SAMPLE_COUNT);
+                vec3 color = light / (1.0 - lightTransferFactor);                 
+                gl_FragColor = vec4(color, 1.0);
+            }`
+    });
+}
+// const vec3 solar_irradiance = vec3(1.474000,1.850400,1.911980);
+// float GetTextureCoordFromUnitRange(float x, int texture_size) {
+//     return 0.5 / float(texture_size) + x * (1.0 - 1.0 / float(texture_size));
+// }
+//
+// float ClampDistance(float d) {
+//     return max(d, 0.0 * m);
+// }
+//
+// float SafeSqrt(float a) {
+//     return sqrt(max(a, 0.0 * m2));
+// }
+// float DistanceToTopAtmosphereBoundary(float r, float mu) {
+//
+//     //assert(r <= atmosphere.top_radius);
+//     //assert(mu >= -1.0 && mu <= 1.0);
+//
+//     float discriminant = r * r * (mu * mu - 1.0) + TOP_RADIUS * TOP_RADIUS;
+//     return ClampDistance(-r * mu + SafeSqrt(discriminant));
+// }
+// vec2 GetTransmittanceTextureUvFromRMu(
+//     float r,
+//     float mu)
+// {
+//     //assert(r >= atmosphere.BOTTOM_RADIUS && r <= TOP_RADIUS);
+//     //assert(mu >= -1.0 && mu <= 1.0);
+//
+//     float H = sqrt(TOP_RADIUS * TOP_RADIUS - BOTTOM_RADIUS * BOTTOM_RADIUS);
+//     float rho = SafeSqrt(r * r - BOTTOM_RADIUS * BOTTOM_RADIUS);
+//     float d = DistanceToTopAtmosphereBoundary(r, mu);
+//     float d_min = TOP_RADIUS - r;
+//     float d_max = rho + H;
+//     float x_mu = (d - d_min) / (d_max - d_min);
+//     float x_r = rho / H;
+//
+//     return vec2(
+//         GetTextureCoordFromUnitRange(x_mu, TRANSMITTANCE_TEXTURE_WIDTH),
+//         GetTextureCoordFromUnitRange(x_r, TRANSMITTANCE_TEXTURE_HEIGHT)
+//     );
+// }
+// vec3 GetTransmittanceToTopAtmosphereBoundary(in sampler2D transmittance_texture, float r, float mu)
+// {
+//     //assert(r >= BOTTOM_RADIUS && r <= TOP_RADIUS);
+//
+//     vec2 uv = GetTransmittanceTextureUvFromRMu(r, mu);
+//     return texture(transmittance_texture, uv).xyz;
+// }
+// vec3 GetTransmittanceToSun(
+//     in sampler2D transmittance_texture,
+//     float r,
+//     float mu_s)
+// {
+//     float sin_theta_h = BOTTOM_RADIUS / r;
+//     float cos_theta_h = -sqrt(max(1.0 - sin_theta_h * sin_theta_h, 0.0));
+//
+//     return GetTransmittanceToTopAtmosphereBoundary(transmittance_texture, r, mu_s) * smoothstep(
+//         -sin_theta_h * SUN_ANGULAR_RADIUS / rad, sin_theta_h * SUN_ANGULAR_RADIUS / rad,
+//         mu_s - cos_theta_h
+//     );
+// }
+// vec3 GetSunAndSkyIrradiance(
+//     in sampler2D transmittance_texture,
+//     in vec3 point,
+//     in vec3 normal,
+//     in vec3 sun_direction,
+//     out vec3 sky_irradiance)
+// {
+//     float r = length(point);
+//     float mu_s = dot(point, sun_direction) / r;
+//
+//     sky_irradiance = vec3(0.0);  // GetIrradiance(atmosphere, irradiance_texture, r, mu_s) * (1.0 + dot(normal, point) / r) * 0.5;
+//
+//     return solar_irradiance * GetTransmittanceToSun(transmittance_texture, r, mu_s) * max(dot(normal, sun_direction), 0.0);
+// }

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

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

package/lib/js/shaders/billboard.js

@@ -0,0 +1,214 @@
+import { Program } from '../webgl/Program';
+const PROJECT = `vec2 project(vec4 p) {
+                    return (0.5 * p.xyz / p.w + 0.5).xy * viewport;
+                }`;
+const ROTATE2D = `mat2 rotate2d(float angle) {
+        return mat2(cos(angle), -sin(angle),
+           sin(angle), cos(angle));
+     }`;
+export function billboardPicking() {
+    return new Program("billboardPicking", {
+        uniforms: {
+            viewport: "vec2",
+            projectionMatrix: "mat4",
+            viewMatrix: "mat4",
+            eyePositionHigh: "vec3",
+            eyePositionLow: "vec3",
+            planetRadius: "float",
+            uScaleByDistance: "vec3",
+            opacity: "float",
+            depthOffset: "float"
+        },
+        attributes: {
+            a_vertices: "vec2",
+            a_positionsHigh: "vec3",
+            a_positionsLow: "vec3",
+            a_offset: "vec3",
+            a_size: "vec2",
+            a_rotation: "float",
+            a_rgba: "vec4"
+        },
+        vertexShader: `precision highp float;
+            attribute vec2 a_vertices;
+            attribute vec3 a_positionsHigh;
+            attribute vec3 a_positionsLow;
+            attribute vec3 a_offset;
+            attribute vec2 a_size;
+            attribute float a_rotation;
+            attribute vec4 a_rgba;
+
+            varying vec3 v_rgb;
+
+            uniform mat4 viewMatrix;
+            uniform mat4 projectionMatrix;
+            uniform vec3 eyePositionHigh;
+            uniform vec3 eyePositionLow;
+            uniform vec3 uScaleByDistance;
+            uniform float opacity;
+            uniform float planetRadius;
+            uniform vec2 viewport;
+            uniform float depthOffset;
+
+            const vec3 ZERO3 = vec3(0.0);
+
+            ${PROJECT}
+
+            ${ROTATE2D}
+
+            void main() {
+
+                vec3 a_positions = a_positionsHigh + a_positionsLow;
+                vec3 cameraPos = eyePositionHigh + eyePositionLow;
+
+                vec3 look = a_positions - cameraPos;
+                float lookDist = length(look);
+                v_rgb = a_rgba.rgb;
+
+                if(opacity * step(lookDist, sqrt(dot(cameraPos,cameraPos) - planetRadius) + sqrt(dot(a_positions,a_positions) - planetRadius)) == 0.0){
+                    return;
+                }
+
+                vec3 up = vec3( viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1] );
+                vec3 right = vec3( viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0] );
+
+                float scd = (1.0 - smoothstep(uScaleByDistance[0], uScaleByDistance[1], lookDist)) * (1.0 - step(uScaleByDistance[2], lookDist));
+
+                mat4 viewMatrixRTE = viewMatrix;
+                viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+                vec3 highDiff = a_positionsHigh - eyePositionHigh;
+                vec3 lowDiff = a_positionsLow - eyePositionLow;
+                vec4 posRTE = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+                vec4 projPos = projectionMatrix * posRTE;
+                                
+                float camSlope = dot(vec3(viewMatrix[0][2], viewMatrix[1][2], viewMatrix[2][2]), normalize(cameraPos));                
+                if(camSlope > 0.5) {
+                    float dist = dot(look, normalize(cameraPos));
+                    projPos.z += dist * 0.02;
+                }else{
+                    projPos.z += -(abs(projPos.z)) * 0.002;                 
+                }
+                
+                projPos.z += depthOffset + a_offset.z;
+                                
+                vec2 screenPos = project(projPos);
+
+                vec2 v =  screenPos + rotate2d(a_rotation) * (a_vertices * a_size * scd + a_offset.xy);
+
+                gl_Position = vec4((2.0 * v / viewport - 1.0) * projPos.w, projPos.z, projPos.w);
+            }`,
+        fragmentShader: `precision highp float;
+            varying vec3 v_rgb;
+            void main () {
+                gl_FragColor = vec4(v_rgb, 1.0);
+            }`
+    });
+}
+export function billboard_screen() {
+    return new Program("billboard", {
+        uniforms: {
+            viewport: "vec2",
+            u_texture: "sampler2d",
+            projectionMatrix: "mat4",
+            viewMatrix: "mat4",
+            eyePositionHigh: "vec3",
+            eyePositionLow: "vec3",
+            planetRadius: "float",
+            uScaleByDistance: "vec3",
+            opacity: "float",
+            depthOffset: "float"
+        },
+        attributes: {
+            a_vertices: "vec2",
+            a_texCoord: "vec2",
+            a_positionsHigh: "vec3",
+            a_positionsLow: "vec3",
+            a_offset: "vec3",
+            a_size: "vec2",
+            a_rotation: "float",
+            a_rgba: "vec4",
+        },
+        vertexShader: `precision highp float;
+            attribute vec2 a_vertices;
+            attribute vec2 a_texCoord;
+            attribute vec3 a_positionsHigh;
+            attribute vec3 a_positionsLow;
+            attribute vec3 a_offset;
+            attribute vec2 a_size;
+            attribute float a_rotation;
+            attribute vec4 a_rgba;
+
+            varying vec2 v_texCoords;
+            varying vec4 v_rgba;
+
+            uniform mat4 viewMatrix;
+            uniform mat4 projectionMatrix;
+            uniform vec3 eyePositionHigh;
+            uniform vec3 eyePositionLow;
+            uniform vec3 uScaleByDistance;
+            uniform float opacity;
+            uniform float planetRadius;
+            uniform vec2 viewport;
+            uniform float depthOffset;
+
+            const vec3 ZERO3 = vec3(0.0);
+
+            ${PROJECT}
+
+            ${ROTATE2D}
+
+            void main() {
+                
+                vec3 a_positions = a_positionsHigh + a_positionsLow;
+                vec3 cameraPos = eyePositionHigh + eyePositionLow;
+
+                v_texCoords = a_texCoord;
+                vec3 look = a_positions - cameraPos;
+                float lookDist = length(look);
+                v_rgba = a_rgba;
+
+                if(opacity * step(lookDist, sqrt(dot(cameraPos,cameraPos) - planetRadius) + sqrt(dot(a_positions,a_positions) - planetRadius)) == 0.0){
+                    return;
+                }
+
+                vec3 up = vec3( viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1] );
+                vec3 right = vec3( viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0] );
+
+                float scd = (1.0 - smoothstep(uScaleByDistance[0], uScaleByDistance[1], lookDist)) * (1.0 - step(uScaleByDistance[2], lookDist));
+
+                mat4 viewMatrixRTE = viewMatrix;
+                viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+                vec3 highDiff = a_positionsHigh - eyePositionHigh;
+                vec3 lowDiff = a_positionsLow - eyePositionLow;
+                vec4 posRTE = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+                vec4 projPos = projectionMatrix * posRTE;
+                                                
+                float camSlope = dot(vec3(viewMatrix[0][2], viewMatrix[1][2], viewMatrix[2][2]), normalize(cameraPos));                
+                if(camSlope > 0.5) {
+                    float dist = dot(look, normalize(cameraPos));
+                    projPos.z += dist * 0.02;
+                }else{
+                    projPos.z += -(abs(projPos.z)) * 0.002;                 
+                }
+                
+                projPos.z += depthOffset + a_offset.z;
+                
+                vec2 screenPos = project(projPos);
+
+                vec2 v = screenPos + rotate2d(a_rotation) * (a_vertices * a_size * scd + a_offset.xy);
+
+                gl_Position = vec4((2.0 * v / viewport - 1.0) * projPos.w, projPos.z, projPos.w);
+            }`,
+        fragmentShader: `precision highp float;
+            uniform sampler2D u_texture;
+            varying vec2 v_texCoords;
+            varying vec4 v_rgba;
+            void main () {
+                vec4 color = texture2D(u_texture, v_texCoords);
+                if(color.a < 0.1)
+                    discard;
+                gl_FragColor = color * v_rgba;
+            }`
+    });
+}

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

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

package/lib/js/shaders/bloom.js

@@ -0,0 +1,32 @@
+import { Program } from '../webgl/Program';
+export function bloom() {
+    return new Program("bloom", {
+        uniforms: {
+            uTextureOriginal: "sampler2d",
+            uTexture1: "sampler2d",
+            uTexture2: "sampler2d"
+        },
+        attributes: {
+            corners: "vec3"
+        },
+        vertexShader: `attribute vec2 corners;
+            varying vec2 uv;
+            void main(void) {
+                gl_Position = vec4(corners, 0.0, 1.0);
+                uv = corners * 0.5 + 0.5;
+            }`,
+        fragmentShader: `precision highp float;
+            uniform sampler2D uTextureOriginal;
+            uniform sampler2D uTexture1;
+            uniform sampler2D uTexture2;
+
+            varying vec2 uv;
+
+            void main() {
+              vec4 vOriginal = texture2D(uTextureOriginal, uv);
+              vec4 vT1 = texture2D(uTexture1, uv);
+              vec4 vT2 = texture2D(uTexture2, uv);
+              gl_FragColor = vOriginal + vT1 + vT2;
+            }`
+    });
+}

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

@@ -0,0 +1,3 @@
+import { Program } from '../webgl/Program';
+export declare function buildKernel(sigma: number): number[];
+export declare function blur(): Program;

package/lib/js/shaders/blur.js

@@ -0,0 +1,68 @@
+import { Program } from '../webgl/Program';
+export function buildKernel(sigma) {
+    function gauss(x, sigma) {
+        return Math.exp(-(x * x) / (2.0 * sigma * sigma));
+    }
+    var i, values, sum, halfWidth, kMaxKernelSize = 25, kernelSize = 2 * Math.ceil(sigma * 3.0) + 1;
+    if (kernelSize > kMaxKernelSize)
+        kernelSize = kMaxKernelSize;
+    halfWidth = (kernelSize - 1) * 0.5;
+    values = new Array(kernelSize);
+    sum = 0.0;
+    for (i = 0; i < kernelSize; ++i) {
+        values[i] = gauss(i - halfWidth, sigma);
+        sum += values[i];
+    }
+    // normalize the kernel
+    for (i = 0; i < kernelSize; ++i)
+        values[i] /= sum;
+    return values;
+}
+export function blur() {
+    return new Program("blur", {
+        uniforms: {
+            uImageIncrement: "vec2",
+            tDiffuse: "sampler2d",
+            cKernel: "floatxx"
+        },
+        attributes: {
+            corners: "vec3"
+        },
+        vertexShader: `
+            #define KERNEL_SIZE_FLOAT 25.0
+
+            attribute vec2 corners;
+            uniform vec2 uImageIncrement;
+
+            varying vec2 vUv;
+
+            void main(void) {
+                gl_Position = vec4(corners, 0.0, 1.0);
+                vec2 uv = corners * 0.5 + 0.5;
+                vUv = uv - ( ( KERNEL_SIZE_FLOAT - 1.0 ) / 2.0 ) * uImageIncrement;
+            }`,
+        fragmentShader: `precision highp float;
+
+            #define KERNEL_SIZE_INT 25
+    
+            uniform float cKernel[ KERNEL_SIZE_INT ];
+
+            uniform sampler2D tDiffuse;
+            
+            uniform vec2 uImageIncrement;
+
+            varying vec2 vUv;
+
+            void main() {
+                vec2 imageCoord = vUv;
+                vec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );
+
+                for( int i = 0; i < KERNEL_SIZE_INT; i ++ ) {
+                    sum += texture2D( tDiffuse, imageCoord ) * cKernel[ i ];
+                    imageCoord += uImageIncrement;
+                }
+
+                gl_FragColor = sum;
+            }`
+    });
+}

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

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

package/lib/js/shaders/depth.js

@@ -0,0 +1,43 @@
+import { Program } from '../webgl/Program';
+export function depth() {
+    return new Program("depth", {
+        uniforms: {
+            depthTexture: "sampler2d"
+        },
+        attributes: {
+            corners: "vec2"
+        },
+        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;
+
+            #define MAX_FRUSTUMS 4
+
+            uniform sampler2D depthTexture;
+           
+            in vec2 tc;
+
+            layout(location = 0) out vec4 fragColor;
+
+            float LinearizeDepth(in vec2 uv)
+            {
+                float depth = texture(depthTexture, tc).x;
+                return depth;//(2.0 * zNear) / (zFar + zNear - depth * (zFar - zNear));
+            }
+            
+            void main(void) {
+                float c = LinearizeDepth(tc);
+                fragColor = vec4(c, c, c, 1.0);
+            }`
+    });
+}