@openglobus/og 0.20.1 → 0.20.3

package/lib/js/Globe.d.ts

@@ -9,6 +9,7 @@ import { Sun } from "./control/Sun";
 import { HTMLDivElementExt, Renderer } from "./renderer/Renderer";
 import { RenderNode } from "./scene/RenderNode";
 import { Extent } from "./Extent";
+import { IAtmosphereParams } from "./control/Atmosphere";
 export interface IGlobeParams {
     attributionContainer?: HTMLElement;
     target?: string | HTMLElement;
@@ -43,6 +44,7 @@ export interface IGlobeParams {
     autoActivate?: boolean;
     fontsSrc?: string;
     resourcesSrc?: string;
+    atmosphereParameters?: IAtmosphereParams;
 }
 /**
  * Creates a WebGL context with globe.
@@ -94,6 +96,7 @@ export interface IGlobeParams {
  * @param {number} [options.dpi] - Device pixel ratio. Default is current screen DPI.
  * @param {boolean} [options.atmosphereEnabled] - Enables atmosphere effect.
  * @param {boolean} [options.transtitionOpacityEnabled] - Enables terrain smooth opacity transition effect.
+ * @param {IAtmosphereParams} [options.atmosphereParameters] - Atmosphere model parameters.
  */
 declare class Globe {
     static __counter__: number;

package/lib/js/Globe.js

@@ -67,6 +67,7 @@ const PLANET_NAME_PREFIX = "globus_planet_";
  * @param {number} [options.dpi] - Device pixel ratio. Default is current screen DPI.
  * @param {boolean} [options.atmosphereEnabled] - Enables atmosphere effect.
  * @param {boolean} [options.transtitionOpacityEnabled] - Enables terrain smooth opacity transition effect.
+ * @param {IAtmosphereParams} [options.atmosphereParameters] - Atmosphere model parameters.
  */
 class Globe {
     constructor(options) {
@@ -148,7 +149,8 @@ class Globe {
             quadTreeStrategyPrototype: options.quadTreeStrategyPrototype,
             maxLoadingRequests: options.maxLoadingRequests,
             atmosphereEnabled: options.atmosphereEnabled,
-            transitionOpacityEnabled: options.transitionOpacityEnabled
+            transitionOpacityEnabled: options.transitionOpacityEnabled,
+            atmosphereParameters: options.atmosphereParameters
         });
         // Attach terrain provider (can be one object or array)
         if (options.terrain) {
@@ -260,7 +262,10 @@ class Globe {
     }
     destroy() {
         this.detach();
+        this.planet.layers.forEach(l => l.remove());
+        this.planet.destroy();
         this.renderer.destroy();
+        window[this._instanceID] = null;
     }
 }
 Globe.__counter__ = 0;

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

@@ -1,16 +1,40 @@
+import { AtmosphereParameters } from "../shaders/atmos";
 import { Framebuffer } from "../webgl/Framebuffer";
 import { Control, IControlParams } from "./Control";
-interface IAtmosphereParams extends IControlParams {
+import { NumberArray3 } from '../math/Vec3';
+export interface IAtmosphereParams extends IControlParams {
+    height?: number;
+    rayleighScale?: number;
+    mieScale?: number;
+    groundAlbedo?: number;
+    bottomRadius?: number;
+    rayleighScatteringCoefficient?: NumberArray3;
+    mieScatteringCoefficient?: number;
+    mieExtinctionCoefficient?: number;
+    ozoneAbsorptionCoefficient?: NumberArray3;
+    sunAngularRadius?: number;
+    sunIntensity?: number;
+    ozoneDensityHeight?: number;
+    ozoneDensityWide?: number;
 }
 export declare class Atmosphere extends Control {
     _transmittanceBuffer: Framebuffer | null;
     _scatteringBuffer: Framebuffer | null;
     opacity: number;
+    protected _parameters: AtmosphereParameters;
     constructor(options?: IAtmosphereParams);
+    setParameters(parameters: AtmosphereParameters): void;
+    get parameters(): AtmosphereParameters;
+    initPlanetAtmosphereShader(): void;
     oninit(): void;
+    initLookupTexturesShaders(): void;
+    initBackgroundShader(): void;
+    removeBackgroundShader(): void;
+    removeLookupTexturesShaders(): void;
     onactivate(): void;
     ondeactivate(): void;
-    protected _drawAtmosphereTextures(): void;
+    protected _initLookupTextures(): void;
+    protected _renderLookupTextures(): void;
+    drawLookupTextures(): void;
     protected _drawBackground(): void;
 }
-export {};

package/lib/js/control/Atmosphere.js

@@ -1,4 +1,4 @@
-import * as atmos from "../shaders/atmos";
+import { COMMON, transmittance, scattering } from "../shaders/atmos";
 import { Framebuffer } from "../webgl/Framebuffer";
 import { Program } from '../webgl/Program';
 import { Control } from "./Control";
@@ -11,16 +11,75 @@ export class Atmosphere extends Control {
         this._transmittanceBuffer = null;
         this._scatteringBuffer = null;
         this.opacity = 1.0;
+        this._parameters = {
+            ATMOS_HEIGHT: options.height || 100000.0,
+            RAYLEIGH_SCALE: options.rayleighScale || 0.08,
+            MIE_SCALE: options.mieScale || 0.012,
+            GROUND_ALBEDO: options.groundAlbedo || 0.05,
+            BOTTOM_RADIUS: options.bottomRadius || 6356752.3142451793,
+            rayleighScatteringCoefficient: options.rayleighScatteringCoefficient || [5.802, 13.558, 33.100],
+            mieScatteringCoefficient: options.mieScatteringCoefficient || 3.996,
+            mieExtinctionCoefficient: options.mieExtinctionCoefficient || 4.440,
+            ozoneAbsorptionCoefficient: options.ozoneAbsorptionCoefficient || [0.650, 1.881, 0.085],
+            SUN_ANGULAR_RADIUS: options.sunAngularRadius || 0.004685,
+            SUN_INTENSITY: options.sunIntensity || 1.0,
+            ozoneDensityHeight: options.ozoneDensityHeight || 25e3,
+            ozoneDensityWide: options.ozoneDensityWide || 15e3,
+        };
+    }
+    setParameters(parameters) {
+        this._parameters = JSON.parse(JSON.stringify(parameters));
+        this.initLookupTexturesShaders();
+        this.drawLookupTextures();
+        this.removeLookupTexturesShaders();
+        this.initPlanetAtmosphereShader();
+    }
+    get parameters() {
+        return JSON.parse(JSON.stringify(this._parameters));
+    }
+    initPlanetAtmosphereShader() {
+        this.planet?.initAtmosphereShader(this._parameters);
     }
     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();
+            //
+            // Draw atmosphere lookup textures
+            //
+            this._initLookupTextures();
+            this.initLookupTexturesShaders();
+            this.drawLookupTextures();
+            this.removeLookupTexturesShaders();
+            this.initBackgroundShader();
             this.activate();
         }
     }
+    initLookupTexturesShaders() {
+        if (this.renderer) {
+            this.renderer.handler.addProgram(transmittance(this._parameters), true);
+            this.renderer.handler.addProgram(scattering(this._parameters), true);
+        }
+    }
+    initBackgroundShader() {
+        if (this.renderer) {
+            this.renderer.handler.addProgram(atmosphereBackgroundShader(this._parameters), true);
+        }
+    }
+    removeBackgroundShader() {
+        if (this.renderer) {
+            this.renderer.handler.removeProgram("atmosphereBackground");
+        }
+    }
+    removeLookupTexturesShaders() {
+        if (this.renderer) {
+            let h = this.renderer.handler;
+            if (this._scatteringBuffer?.isComplete()) {
+                h.removeProgram("scattering");
+            }
+            if (this._transmittanceBuffer?.isComplete()) {
+                h.removeProgram("transmittance");
+            }
+        }
+    }
     onactivate() {
         super.onactivate();
         this.planet && this.planet.events.on("draw", this._drawBackground, this);
@@ -29,7 +88,7 @@ export class Atmosphere extends Control {
         super.ondeactivate();
         this.planet && this.planet.events.off("draw", this._drawBackground);
     }
-    _drawAtmosphereTextures() {
+    _initLookupTextures() {
         let width = 1024, height = 1024;
         this._transmittanceBuffer = new Framebuffer(this.renderer.handler, {
             width: width,
@@ -49,51 +108,54 @@ export class Atmosphere extends Control {
             internalFormat: "RGBA16F"
         });
         this._scatteringBuffer.init();
+    }
+    _renderLookupTextures() {
+        if (!this.renderer)
+            return;
         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();
+        if (this._transmittanceBuffer) {
+            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");
+        if (this._scatteringBuffer && this._transmittanceBuffer) {
+            this._scatteringBuffer.activate();
+            let p = h.programs.scattering;
+            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._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();
         }
     }
+    drawLookupTextures() {
+        this._renderLookupTextures();
+    }
     _drawBackground() {
         let h = this.renderer.handler;
         let sh = h.programs.atmosphereBackground, p = sh._program, shu = p.uniforms, gl = h.gl;
@@ -120,7 +182,7 @@ export class Atmosphere extends Control {
         gl.enable(gl.DEPTH_TEST);
     }
 }
-function atmosphereBackgroundShader() {
+function atmosphereBackgroundShader(atmosParams) {
     return new Program("atmosphereBackground", {
         uniforms: {
             iResolution: "vec2",
@@ -144,7 +206,7 @@ function atmosphereBackgroundShader() {
         fragmentShader: `                                   
             precision lowp float;
             
-            ${atmos.COMMON}
+            ${COMMON(atmosParams)}
             
             uniform mat4 viewMatrix;
             uniform vec3 sunPos;
@@ -233,6 +295,10 @@ function atmosphereBackgroundShader() {
                 rayDirection = normalize(rayDirection * SPHERE_TO_ELLIPSOID_SCALE);
                 cameraPosition *= SPHERE_TO_ELLIPSOID_SCALE;
                 lightDirection = normalize(lightDirection * SPHERE_TO_ELLIPSOID_SCALE);
+                
+                if(length(cameraPosition) < BOTTOM_RADIUS + 100.0){
+                    cameraPosition = normalize(cameraPosition) * (BOTTOM_RADIUS + 100.0); 
+                }
                                                 
                 if (intersectSphere(cameraPosition, rayDirection, TOP_RADIUS, offset, distanceToSpace)) 
                 {    
@@ -258,7 +324,7 @@ function atmosphereBackgroundShader() {
                     
                     bool hitGround = intersectSphere(cameraPosition, rayDirection, BOTTOM_RADIUS, distanceToGround) && distanceToGround > 0.0;
                     
-                    if(intersectSphere(cameraPosition, rayDirection, BOTTOM_RADIUS - 15000.0, distanceToGround) && hitGround)
+                    if(intersectSphere(cameraPosition, rayDirection, BOTTOM_RADIUS - 100000.0, distanceToGround) && hitGround)
                     {
                         discard;
                     }

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

@@ -0,0 +1,59 @@
+import { Control, IControlParams } from "./Control";
+import { Dialog } from '../ui/Dialog';
+import { Slider } from "../ui/Slider";
+import { ToggleButton } from "../ui/ToggleButton";
+import { View } from '../ui/View';
+import { AtmosphereParameters } from "../shaders/atmos";
+interface IAtmosphereConfigParams extends IControlParams {
+}
+/**
+ * Helps to set up atmosphere parameters.
+ */
+export declare class AtmosphereConfig extends Control {
+    protected _toggleBtn: ToggleButton;
+    protected _dialog: Dialog<null>;
+    protected _panel: View<null>;
+    $maxOpacity: HTMLElement | null;
+    $minOpacity: HTMLElement | null;
+    $rayleight: HTMLElement | null;
+    $mie: HTMLElement | null;
+    $height: HTMLElement | null;
+    $bottomRadius: HTMLElement | null;
+    $mieScatteringCoefficient: HTMLElement | null;
+    $mieExtinctionCoefficient: HTMLElement | null;
+    $rayleighScatteringCoefficientA: HTMLElement | null;
+    $rayleighScatteringCoefficientB: HTMLElement | null;
+    $rayleighScatteringCoefficientC: HTMLElement | null;
+    $ozoneAbsorptionCoefficientA: HTMLElement | null;
+    $ozoneAbsorptionCoefficientB: HTMLElement | null;
+    $ozoneAbsorptionCoefficientC: HTMLElement | null;
+    $sunAngularRadius: HTMLElement | null;
+    $sunIntensity: HTMLElement | null;
+    $groundAlbedo: HTMLElement | null;
+    $ozoneDensityHeight: HTMLElement | null;
+    $ozoneDensityWide: HTMLElement | null;
+    protected _maxOpacity: Slider;
+    protected _minOpacity: Slider;
+    protected _rayleight: Slider;
+    protected _mie: Slider;
+    protected _height: Slider;
+    protected _bottomRadius: Slider;
+    protected _mieScatteringCoefficient: Slider;
+    protected _mieExtinctionCoefficient: Slider;
+    protected _rayleighScatteringCoefficientA: Slider;
+    protected _rayleighScatteringCoefficientB: Slider;
+    protected _rayleighScatteringCoefficientC: Slider;
+    protected _ozoneAbsorptionCoefficientA: Slider;
+    protected _ozoneAbsorptionCoefficientB: Slider;
+    protected _ozoneAbsorptionCoefficientC: Slider;
+    protected _sunAngularRadius: Slider;
+    protected _sunIntensity: Slider;
+    protected _groundAlbedo: Slider;
+    protected _ozoneDensityHeight: Slider;
+    protected _ozoneDensityWide: Slider;
+    protected _parameters: AtmosphereParameters;
+    constructor(options?: IAtmosphereConfigParams);
+    oninit(): void;
+    protected _update(): void;
+}
+export {};