@openglobus/og 0.24.2 → 0.25.1

package/lib/js/shaders/atmos.js

@@ -1,326 +0,0 @@
-import { Program } from '../webgl/Program';
-import { UTILS } from './utils';
-const DEFAULT_PARAMS = {
-    ATMOS_HEIGHT: 100000.0,
-    RAYLEIGH_SCALE: 0.08,
-    MIE_SCALE: 0.012,
-    GROUND_ALBEDO: 0.05,
-    BOTTOM_RADIUS: 6356752.3142451793,
-    rayleighScatteringCoefficient: [5.802, 13.558, 33.100],
-    mieScatteringCoefficient: 3.996,
-    mieExtinctionCoefficient: 4.440,
-    ozoneAbsorptionCoefficient: [0.650, 1.881, 0.085],
-    SUN_ANGULAR_RADIUS: 0.004685,
-    SUN_INTENSITY: 1.0,
-    ozoneDensityHeight: 25e3,
-    ozoneDensityWide: 15e3,
-};
-export const COMMON = (atmosParams = DEFAULT_PARAMS) => `    
-    ${UTILS}
-    
-    #define PI 3.1415926538
-    #define ATMOS_HEIGHT ${atmosParams.ATMOS_HEIGHT.toFixed(2)}
-    #define RAYLEIGH_SCALE ${atmosParams.RAYLEIGH_SCALE.toFixed(5)}
-    #define MIE_SCALE ${atmosParams.MIE_SCALE.toFixed(5)}
-    
-    #define SAMPLE_COUNT 16
-    #define SQRT_SAMPLE_COUNT 4
-            
-    const float GROUND_ALBEDO = ${atmosParams.GROUND_ALBEDO.toFixed(2)} / PI;
-
-    // Sphere
-    const float BOTTOM_RADIUS = ${atmosParams.BOTTOM_RADIUS.toFixed(10)};
-    const float TOP_RADIUS = BOTTOM_RADIUS + ATMOS_HEIGHT;   
-    const float EQUATORIAL_RADIUS = 6378137.0;
-    
-    // Ellipsoid
-    const vec3 bottomRadii = vec3(EQUATORIAL_RADIUS, EQUATORIAL_RADIUS, BOTTOM_RADIUS);           
-    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(${atmosParams.rayleighScatteringCoefficient[0].toFixed(5)}, ${atmosParams.rayleighScatteringCoefficient[1].toFixed(5)}, ${atmosParams.rayleighScatteringCoefficient[2].toFixed(5)}) * 1e-6;
-    
-    const float mieScatteringCoefficient = ${atmosParams.mieScatteringCoefficient.toFixed(3)} * 1e-6;
-    const float mieExtinctionCoefficient = ${atmosParams.mieExtinctionCoefficient.toFixed(3)} * 1e-6;
-    const vec3 ozoneAbsorptionCoefficient = vec3(${atmosParams.ozoneAbsorptionCoefficient[0].toFixed(5)}, ${atmosParams.ozoneAbsorptionCoefficient[1].toFixed(5)}, ${atmosParams.ozoneAbsorptionCoefficient[2].toFixed(5)}) * 1e-6;
-    
-    const float SUN_ANGULAR_RADIUS = ${atmosParams.SUN_ANGULAR_RADIUS.toFixed(10)};
-    const float SUN_INTENSITY = ${atmosParams.SUN_INTENSITY.toFixed(2)};        
-    
-    const float ozoneDensityHeight = ${atmosParams.ozoneDensityHeight.toFixed(1)};//25e3;
-    const float ozoneDensityWide = ${atmosParams.ozoneDensityWide.toFixed(1)};//15e3;
-    
-    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;
-            opticalDepth.z += (1.0 - min(abs(height - ozoneDensityHeight) / ozoneDensityWide, 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(atmosParams) {
-    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(atmosParams)}
-                       
-            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(atmosParams) {
-    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(atmosParams)}
-            
-            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); 
-                            light += transmittanceCamera * transmittanceLight * GROUND_ALBEDO * 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

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

package/lib/js/shaders/billboard.js

@@ -1,214 +0,0 @@
-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

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

package/lib/js/shaders/bloom.js

@@ -1,32 +0,0 @@
-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

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

package/lib/js/shaders/blur.js

@@ -1,68 +0,0 @@
-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

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