@openglobus/og 0.17.2 → 0.18.1

package/lib/js/control/Atmosphere.js

@@ -0,0 +1,334 @@
+import * as atmos from "../shaders/atmos";
+import { Framebuffer } from "../webgl/Framebuffer";
+import { Program } from '../webgl/Program';
+import { Control } from "./Control";
+export class Atmosphere extends Control {
+    constructor(options = {}) {
+        super({
+            name: "Atmosphere",
+            ...options
+        });
+        this._transmittanceBuffer = null;
+        this._scatteringBuffer = null;
+        this.opacity = 1.0;
+    }
+    oninit() {
+        if (this.renderer) {
+            this.renderer.handler.addProgram(atmos.transmittance(), true);
+            this.renderer.handler.addProgram(atmos.scattering(), true);
+            this.renderer.handler.addProgram(atmosphereBackgroundShader(), true);
+            this._drawAtmosphereTextures();
+            this.activate();
+        }
+    }
+    onactivate() {
+        super.onactivate();
+        this.planet && this.planet.events.on("draw", this._drawBackground, this);
+    }
+    ondeactivate() {
+        super.ondeactivate();
+        this.planet && this.planet.events.off("draw", this._drawBackground);
+    }
+    _drawAtmosphereTextures() {
+        let width = 256, height = 128;
+        this._transmittanceBuffer = new Framebuffer(this.renderer.handler, {
+            width: width,
+            height: height,
+            useDepth: false,
+            filter: "LINEAR",
+            type: "FLOAT",
+            internalFormat: "RGBA16F"
+        });
+        this._transmittanceBuffer.init();
+        this._scatteringBuffer = new Framebuffer(this.renderer.handler, {
+            width: width,
+            height: height,
+            useDepth: false,
+            filter: "LINEAR",
+            type: "FLOAT",
+            internalFormat: "RGBA16F"
+        });
+        this._scatteringBuffer.init();
+        let positionBuffer = this.renderer.screenFramePositionBuffer;
+        let h = this.renderer.handler;
+        let gl = h.gl;
+        //
+        // Draw transmittance texture
+        //
+        this._transmittanceBuffer.activate();
+        let p = h.programs.transmittance;
+        let sha = p._program.attributes;
+        let shu = p._program.uniforms;
+        p.activate();
+        gl.clearColor(0.0, 0.0, 0.0, 1.0);
+        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+        gl.uniform2fv(shu.iResolution, [this._transmittanceBuffer.width, this._transmittanceBuffer.height]);
+        gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
+        gl.vertexAttribPointer(sha.a_position, positionBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, positionBuffer.numItems);
+        this._transmittanceBuffer.deactivate();
+        //
+        // Draw scattering texture
+        //
+        this._scatteringBuffer.activate();
+        p = h.programs.scattering;
+        sha = p._program.attributes;
+        shu = p._program.uniforms;
+        p.activate();
+        gl.clearColor(0.0, 0.0, 0.0, 1.0);
+        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+        gl.uniform2fv(shu.iResolution, [this._scatteringBuffer.width, this._scatteringBuffer.height]);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, this._transmittanceBuffer.textures[0]);
+        gl.uniform1i(shu.transmittanceTexture, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
+        gl.vertexAttribPointer(sha.a_position, positionBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, positionBuffer.numItems);
+        this._scatteringBuffer.deactivate();
+        //
+        // remove shaders
+        if (this._scatteringBuffer.isComplete()) {
+            h.removeProgram("scattering");
+        }
+        if (this._transmittanceBuffer.isComplete()) {
+            h.removeProgram("transmittance");
+        }
+    }
+    _drawBackground() {
+        let h = this.renderer.handler;
+        let sh = h.programs.atmosphereBackground, p = sh._program, shu = p.uniforms, gl = h.gl;
+        let r = this.renderer;
+        let cam = this.planet.camera;
+        gl.disable(gl.DEPTH_TEST);
+        sh.activate();
+        gl.bindBuffer(gl.ARRAY_BUFFER, r.screenFramePositionBuffer);
+        gl.vertexAttribPointer(p.attributes.corners, 2, gl.FLOAT, false, 0, 0);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, this._transmittanceBuffer.textures[0]);
+        gl.uniform1i(shu.transmittanceTexture, 0);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, this._scatteringBuffer.textures[0]);
+        gl.uniform1i(shu.scatteringTexture, 1);
+        gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
+        let sunPos = this.planet.sunPos;
+        gl.uniform3fv(shu.sunPos, [sunPos.x, sunPos.y, sunPos.z]);
+        gl.uniform3fv(shu.camPos, [cam.eye.x, cam.eye.y, cam.eye.z]);
+        gl.uniform2fv(shu.iResolution, [r.sceneFramebuffer.width, r.sceneFramebuffer.height]);
+        gl.uniform1f(shu.fov, cam.getViewAngle());
+        gl.uniform1f(shu.opacity, this.opacity);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+        gl.enable(gl.DEPTH_TEST);
+    }
+}
+function atmosphereBackgroundShader() {
+    return new Program("atmosphereBackground", {
+        uniforms: {
+            iResolution: "vec2",
+            fov: "float",
+            camPos: "vec3",
+            viewMatrix: "mat4",
+            transmittanceTexture: "sampler2D",
+            scatteringTexture: "sampler2D",
+            sunPos: "vec3",
+            opacity: "float"
+        },
+        attributes: {
+            corners: "vec3"
+        },
+        vertexShader: `            
+            attribute vec2 corners;
+            
+            void main(void) {
+                gl_Position = vec4(corners, 0.0, 1.0);
+            }`,
+        fragmentShader: `                                   
+            precision highp float;
+            
+            ${atmos.COMMON}
+            
+            uniform mat4 viewMatrix;
+            uniform vec3 sunPos;
+            uniform vec3 camPos;     
+            uniform vec2 iResolution;
+            uniform float fov;
+            uniform float opacity;
+                       
+            uniform sampler2D transmittanceTexture;
+            uniform sampler2D scatteringTexture;
+                                                           
+            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;
+            }
+            
+            vec3 multipleScatteringContributionFromTexture(float height, float angle) 
+            {
+                float u = (angle + 1.0) * 0.5;
+                float v = height / ATMOS_HEIGHT;
+                return texture2D(scatteringTexture, vec2(u, v)).xyz; 
+            }
+
+            bool intersectEllipsoidToSphere(in vec3 ro, in vec3 rd, in vec3 ellRadii, in float sphereRadius, out float t1, out float t2) 
+            {
+                float offset = 0.0,
+                      distanceToSpace = 0.0;
+                                                        
+                if(intersectEllipsoid(ro, rd, ellRadii, offset, distanceToSpace)){
+                    vec3 hitEll = ro + rd * offset;
+                    vec3 nEll = normalEllipsoid(hitEll, ellRadii);
+                    float t = 0.0;
+                    bool intersectsSphere = intersectSphere(hitEll, nEll, sphereRadius, t);
+                    vec3 hitSphere = hitEll + nEll * t;
+                    t1 = length(hitSphere - ro);
+                    
+                    hitEll = ro + rd * distanceToSpace;
+                    nEll = normalEllipsoid(hitEll, ellRadii);
+                    t = 0.0;
+                    intersectsSphere = intersectSphere(hitEll, nEll, sphereRadius, t);
+                    hitSphere = hitEll + nEll * t;
+                    t2 = length(hitSphere - ro);
+                    
+                    return true; 
+                }
+                return false; 
+            }
+            
+            mat4 transpose(in mat4 m) 
+            {
+                vec4 i0 = m[0];
+                vec4 i1 = m[1];
+                vec4 i2 = m[2];
+                vec4 i3 = m[3];
+            
+                mat4 outMatrix = mat4(
+                     vec4(i0.x, i1.x, i2.x, i3.x),
+                     vec4(i0.y, i1.y, i2.y, i3.y),
+                     vec4(i0.z, i1.z, i2.z, i3.z),
+                     vec4(i0.w, i1.w, i2.w, i3.w)
+                     );
+                                 
+                return outMatrix;
+            }
+                                                                     
+            void mainImage(out vec4 fragColor) 
+            {            
+                vec3 cameraPosition = camPos;
+                
+                vec3 lightDirection = normalize(sunPos);               
+                             
+                vec2 uv = (2.0 * gl_FragCoord.xy - iResolution.xy) / iResolution.y;
+                float fieldOfView = fov;
+                float z = 1.0 / tan(fieldOfView * 0.5 * PI / 180.0);
+                vec3 rayDirection = normalize(vec3(uv, -z));
+                vec4 rd = transpose(viewMatrix) * vec4(rayDirection, 1.0);
+                rayDirection = rd.xyz;               
+                                          
+                vec3 light = vec3(0.0);
+                vec3 transmittanceFromCameraToSpace = vec3(1.0);
+                float offset = 0.0;
+                float distanceToSpace = 0.0;
+                                                
+                rayDirection = normalize(rayDirection * SPHERE_TO_ELLIPSOID_SCALE);
+                cameraPosition *= SPHERE_TO_ELLIPSOID_SCALE;
+                lightDirection = normalize(lightDirection * SPHERE_TO_ELLIPSOID_SCALE);
+                                                
+                if (intersectSphere(cameraPosition, rayDirection, TOP_RADIUS, offset, distanceToSpace)) 
+                {    
+                    vec3 rayOrigin = cameraPosition;
+                    
+                    // above atmosphere                    
+                    if (offset > 0.0) {
+                        // intersection of camera ray with atmosphere
+                        rayOrigin = cameraPosition + rayDirection * offset;
+                    }
+                    
+                    float height = length(rayOrigin) - BOTTOM_RADIUS;
+                    float rayAngle = dot(rayOrigin, rayDirection) / length(rayOrigin);
+                    bool cameraBelow = rayAngle < 0.0;
+                    
+                    transmittanceFromCameraToSpace = transmittanceFromTexture(height, cameraBelow ? -rayAngle : rayAngle);
+                    
+                    float phaseAngle = dot(lightDirection, rayDirection);
+                    float rayleighPhase = rayleighPhase(phaseAngle);
+                    float miePhase = miePhase(phaseAngle);
+                    
+                    float distanceToGround = 0.0;
+                    
+                    bool hitGround = intersectSphere(cameraPosition, rayDirection, BOTTOM_RADIUS, distanceToGround) && distanceToGround > 0.0;
+                    
+                    if(intersectSphere(cameraPosition, rayDirection, BOTTOM_RADIUS - 15000.0, distanceToGround) && hitGround){
+                        discard;
+                    }
+                    
+                    float segmentLength = ((hitGround ? distanceToGround : distanceToSpace) - max(offset, 0.0)) / float(SAMPLE_COUNT);
+                            
+                    float t = segmentLength * 0.5;
+                    
+                    vec3 transmittanceCamera; 
+                    vec3 transmittanceLight; 
+            
+                    for (int i = 0; i < SAMPLE_COUNT; i++) 
+                    {
+                        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);
+                        // shadow is ommitted because it can create banding artifacts with low sample counts
+                        // float distanceToGround;
+                        // float shadow = intersectSphere(position, lightDirection, BOTTOM_RADIUS, distanceToGround) && distanceToGround >= 0.0 ? 0.0 : 1.0;         
+                        float shadow = 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 * rayleighPhase + mieScatteringCoefficient * opticalDensity.y * miePhase);
+                        scatteredLight += multipleScatteringContributionFromTexture(height, lightAngle) * (rayleighScatteringCoefficient * opticalDensity.x + mieScatteringCoefficient * opticalDensity.y);  
+                        light += shadow * transmittanceCamera * scatteredLight * segmentLength;
+                        t += segmentLength;
+                    }
+                    
+                    light *= SUN_INTENSITY;
+            
+                    if (hitGround) 
+                    {
+                        vec3 hitPoint = cameraPosition + rayDirection * distanceToGround;
+                        vec3 up = hitPoint / length(hitPoint);
+                        float diffuseAngle = max(dot(up, lightDirection), 0.0);
+                        float lightAngle = dot(up, lightDirection);
+                        light += transmittanceCamera * GROUND_ALBEDO * multipleScatteringContributionFromTexture(height, lightAngle) * SUN_INTENSITY;
+                        light += transmittanceCamera * transmittanceLight * GROUND_ALBEDO * diffuseAngle * SUN_INTENSITY;
+                    }
+                }
+                                     
+                // sun disk
+                // float distanceToGround;
+                // bool hitGround = intersectSphere(cameraPosition, rayDirection, BOTTOM_RADIUS, distanceToGround) && distanceToGround > 0.0;
+                // if (!hitGround) {
+                //    float angle = dot(rayDirection, lightDirection);
+                //    if (angle > cos(SUN_ANGULAR_RADIUS)) {
+                //       light = SUN_INTENSITY * transmittanceFromCameraToSpace;
+                //    }
+                // }
+                
+                float distanceToGround = 0.0;
+                bool hitGround = intersectSphere(cameraPosition, rayDirection, BOTTOM_RADIUS, distanceToGround) && distanceToGround > 0.0;
+                if(!hitGround)
+                {
+                    vec3 sunLum = sunWithBloom(rayDirection, lightDirection) * vec3(1.0,1.0,0.8);
+                    // limit the bloom effect
+                    sunLum = smoothstep(0.002, 1.0, sunLum);
+                    light += sunLum * SUN_INTENSITY * transmittanceFromCameraToSpace;
+                }
+                            
+                fragColor = vec4(pow(light * 8.0, vec3(1.0 / 2.2)), clamp(opacity, 0.0, 1.0));           
+            }
+                                    
+            void main(void) 
+            {                            
+                mainImage(gl_FragColor);            
+            }`
+    });
+}

package/lib/js/control/CompassButton.d.ts

@@ -0,0 +1,16 @@
+import { Control, IControlParams } from "./Control";
+interface ICompasButtonParams extends IControlParams {
+}
+/**
+ * Planet compass button
+ */
+export declare class CompassButton extends Control {
+    protected _heading: number;
+    protected _svg: HTMLElement | null;
+    constructor(options?: ICompasButtonParams);
+    oninit(): void;
+    protected _onClick(): void;
+    protected _draw(): void;
+    setHeading(heading: number): void;
+}
+export {};

package/lib/js/control/CompassButton.js

@@ -0,0 +1,118 @@
+import { Button } from "../ui/Button";
+import { Control } from "./Control";
+const ICON_BUTTON_SVG = `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   viewBox="0 0 110.6 110.3"
+   version="1.1"
+   id="svg21"
+   sodipodi:docname="aaa.svg"
+   inkscape:version="0.92.3 (2405546, 2018-03-11)">
+  <metadata
+     id="metadata11">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs25" />
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1920"
+     inkscape:window-height="1001"
+     id="namedview23"
+     showgrid="false"
+     inkscape:zoom="9.4900968"
+     inkscape:cx="28.376998"
+     inkscape:cy="60.17054"
+     inkscape:window-x="-9"
+     inkscape:window-y="-9"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg21" />
+  <g
+     id="Layer_2"
+     data-name="Layer 2"
+     transform="matrix(1,0,0,-1,0,110.3)">
+    <g
+       id="Слой_1"
+       data-name="Слой 1">
+      <g
+         id="_Group_"
+         data-name="&lt;Group&gt;">
+        <g
+           id="_Group_7"
+           data-name="&lt;Group&gt;">
+          <polygon
+             id="_Path_7"
+             data-name="&lt;Path&gt;"
+             points="55.2,97.6 55.3,97.4 55.3,97.6 55.3,97.2 65.3,55.1 55.3,55.1 55.2,55.1 45.3,55.1 55.2,97.2 "
+             style="fill:#ff2b45" />
+          <polygon
+             id="_Path_8"
+             data-name="&lt;Path&gt;"
+             points="55.3,12.7 55.3,12.9 55.2,12.7 55.2,13.1 45.3,55.1 55.2,55.1 55.3,55.1 65.3,55.1 55.3,13.1 "
+             style="fill:#cecece;" />
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>`;
+/**
+ * Planet compass button
+ */
+export class CompassButton extends Control {
+    constructor(options = {}) {
+        super(options);
+        this._heading = 0;
+        this._svg = null;
+    }
+    oninit() {
+        let btn = new Button({
+            classList: ["og-map-button", "og-compass-button"],
+            icon: ICON_BUTTON_SVG
+        });
+        btn.appendTo(this.renderer.div);
+        btn.events.on("click", this._onClick, this);
+        this._svg = btn.select("svg");
+        this.renderer.events.on("draw", this._draw, this);
+    }
+    _onClick() {
+        const planet = this.planet;
+        let c = planet.getCartesianFromPixelTerrain(this.renderer.handler.getCenter());
+        if (c) {
+            planet.flyCartesian(c.normal().scaleTo(c.length() + c.distance(planet.camera.eye)), null, null, 0, null, null, () => {
+                planet.camera.look(c);
+            });
+        }
+        else {
+            planet.flyCartesian(planet.camera.eye);
+        }
+    }
+    _draw() {
+        this.setHeading(this.planet.camera.getHeading());
+    }
+    setHeading(heading) {
+        if (this._heading !== heading) {
+            this._heading = heading;
+            this._svg.style.transform = `rotateZ(${-heading}deg)`;
+        }
+    }
+}

package/lib/js/control/Control.d.ts

@@ -0,0 +1,100 @@
+import { Planet, Renderer } from "../index";
+export interface IControlParams {
+    name?: string;
+    autoActivate?: boolean;
+}
+/**
+ * Base control class. All other controls extend from this class.
+ * @class Control
+ * @param {Boolean} [options.autoActivate=true] - If true - calls initialize function after the renderer assigning.
+ */
+export declare class Control {
+    static __counter__: number;
+    protected __id: number;
+    protected _name: string;
+    /**
+     * Control activity.
+     * @protected
+     * @type {boolean}
+     */
+    protected _active: boolean;
+    /**
+     * Control initialized.
+     * @protected
+     * @type {boolean}
+     */
+    protected _initialized: boolean;
+    planet: Planet | null;
+    /**
+     * Assigned renderer.
+     * @public
+     * @type {Renderer}
+     */
+    renderer: Renderer | null;
+    /**
+     * Auto activation flag.
+     * @public
+     * @type {boolean}
+     */
+    autoActivate: boolean;
+    protected _deferredActive: boolean;
+    constructor(options?: IControlParams);
+    /**
+     * Returns control name.
+     * @public
+     * @return {string} -
+     */
+    get name(): string;
+    /**
+     * Control initialization function have to be overridden.
+     * @public
+     */
+    oninit(): void;
+    /**
+     * Control renderer assigning function have to be overridden.
+     * @public
+     */
+    onadd(): void;
+    /**
+     * Control remove function have to be overridden.
+     * @public
+     */
+    onremove(): void;
+    /**
+     * Control activation function have to be overridden.
+     * @public
+     */
+    onactivate(): void;
+    /**
+     * Control deactivation function have to be overriden.
+     * @public
+     */
+    ondeactivate(): void;
+    /**
+     * Assign renderer to the control.
+     * @public
+     * @type {Renderer}
+     */
+    addTo(renderer: Renderer): void;
+    /**
+     * Removes control.
+     * @public
+     */
+    remove(): void;
+    /**
+     * Activate control.
+     * @public
+     */
+    activate(): void;
+    /**
+     * Deactivate control.
+     * @public
+     */
+    deactivate(): void;
+    /**
+     * Is control active.
+     * @public
+     */
+    isActive(): boolean;
+    isEqual(control: Control): boolean;
+}