@openglobus/og 0.17.2 → 0.18.1

package/lib/js/segment/SegmentLonLat.d.ts

@@ -0,0 +1,48 @@
+import { Extent } from "../Extent";
+import { Layer } from "../layer/Layer";
+import { Node } from "../quadTree/Node";
+import { Planet } from "../scene/Planet";
+import { Segment } from "./Segment";
+import { LonLat } from "../LonLat";
+import { Entity } from "../entity/Entity";
+import { PlanetCamera } from "../camera/PlanetCamera";
+import { WebGLTextureExt } from "../webgl/Handler";
+export declare const POLE_PIECE_SIZE: number;
+/**
+ * Planet segment Web Mercator tile class that stored and rendered with quad tree.
+ * @class
+ * @extends {Segment}
+ */
+declare class SegmentLonLat extends Segment {
+    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent);
+    _setExtentLonLat(): void;
+    projectNative(coords: LonLat): LonLat;
+    getInsideLonLat(obj: Entity | PlanetCamera): LonLat;
+    protected _getMaxZoom(): number;
+    checkZoom(): boolean;
+    protected _assignTileIndexes(): void;
+    protected _assignTileXIndexes(extent: Extent): void;
+    protected _assignTileYIndexes(extent: Extent): void;
+    protected _createPlainVertices(): void;
+    protected _assignGlobalTextureCoordinates(): void;
+    /**
+     * @todo: replace to the strategy
+     */
+    _collectVisibleNodes(): void;
+    /**
+     * @param layer
+     * @protected
+     *
+     * @todo simplify layer._extentMerc in layer.getNativeExtent(this)
+     *
+     */
+    protected _getLayerExtentOffset(layer: Layer): [number, number, number, number];
+    layerOverlap(layer: Layer): boolean;
+    getDefaultTexture(): WebGLTextureExt | null;
+    getExtentLonLat(): Extent;
+    /**
+     * @todo: replace to the strategy
+     */
+    getNodeState(): number;
+}
+export { SegmentLonLat };

package/lib/js/segment/SegmentLonLat.js

@@ -0,0 +1,214 @@
+import * as mercator from "../mercator";
+import * as quadTree from "../quadTree/quadTree";
+import { EPSG4326 } from "../proj/EPSG4326";
+import { Extent } from "../Extent";
+import { Layer } from "../layer/Layer";
+import { Segment, TILEGROUP_NORTH, TILEGROUP_SOUTH } from "./Segment";
+import { LonLat } from "../LonLat";
+import { Vec3 } from "../math/Vec3";
+const MAX_POLE_ZOOM = 7;
+export const POLE_PIECE_SIZE = (90.0 - mercator.MAX_LAT) / Math.pow(2, MAX_POLE_ZOOM);
+let _tempHigh = new Vec3(), _tempLow = new Vec3();
+/**
+ * Planet segment Web Mercator tile class that stored and rendered with quad tree.
+ * @class
+ * @extends {Segment}
+ */
+class SegmentLonLat extends Segment {
+    constructor(node, planet, tileZoom, extent) {
+        super(node, planet, tileZoom, extent);
+        this._projection = EPSG4326;
+        this._extentLonLat = this._extent;
+        this._extentMerc = new Extent(extent.southWest.forwardMercatorEPS01(), extent.northEast.forwardMercatorEPS01());
+        this._isNorth = this._extent.northEast.lat > 0;
+        this.isPole = true;
+    }
+    _setExtentLonLat() {
+        this._extentLonLat = this._extent;
+    }
+    projectNative(coords) {
+        return coords;
+    }
+    getInsideLonLat(obj) {
+        return obj._lonLat;
+    }
+    _getMaxZoom() {
+        let maxPoleZoom = 0;
+        if (this._isNorth) {
+            //north pole limits
+            let Yz = Math.floor((90.0 - this._extent.northEast.lat) / POLE_PIECE_SIZE);
+            maxPoleZoom = Math.floor(Yz / 16) + 7;
+        }
+        else {
+            //south pole limits
+            let Yz = Math.floor((mercator.MIN_LAT - this._extent.northEast.lat) / POLE_PIECE_SIZE);
+            maxPoleZoom = 12 - Math.floor(Yz / 16);
+        }
+        return maxPoleZoom;
+    }
+    checkZoom() {
+        return super.checkZoom() && this.tileZoom <= this._getMaxZoom();
+    }
+    _assignTileIndexes() {
+        this._assignTileXIndexes(this._extent);
+        this._assignTileYIndexes(this._extent);
+        this.tileIndex = Layer.getTileIndex(this.tileX, this.tileY, this.tileZoom);
+    }
+    _assignTileXIndexes(extent) {
+        this.tileX = Math.round(Math.abs(-180.0 - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon));
+        let p2 = 1 << this.tileZoom;
+        this.tileXE = (this.tileX + 1) % p2;
+        this.tileXW = (p2 + this.tileX - 1) % p2;
+    }
+    _assignTileYIndexes(extent) {
+        const lat = extent.northEast.lat;
+        if (lat > 0) {
+            this._tileGroup = TILEGROUP_NORTH;
+            this.tileY = Math.round((90.0 - lat) / (extent.northEast.lat - extent.southWest.lat));
+        }
+        else {
+            this._tileGroup = TILEGROUP_SOUTH;
+            this.tileY = Math.round((mercator.MIN_LAT - lat) / (extent.northEast.lat - extent.southWest.lat));
+        }
+        this.tileYN = this.tileY - 1;
+        this.tileYS = this.tileY + 1;
+    }
+    _createPlainVertices() {
+        const gridSize = this.planet.terrain.gridSizeByZoom[this.tileZoom];
+        const e = this._extent;
+        const fgs = this.planet.terrain.plainGridSize;
+        const lonSize = e.getWidth();
+        const latSize = e.getHeight();
+        const llStep = lonSize / Math.max(fgs, gridSize);
+        const ltStep = latSize / gridSize;
+        const esw_lon = e.southWest.lon;
+        const ene_lat = e.northEast.lat;
+        const dg = Math.max(fgs / gridSize, 1);
+        const gs = Math.max(fgs, gridSize) + 1;
+        const r2 = this.planet.ellipsoid._invRadii2;
+        let ind = 0, nmInd = 0;
+        const gsgs = gs * gs;
+        const gridSize3 = (gridSize + 1) * (gridSize + 1) * 3;
+        this.plainNormals = new Float32Array(gridSize3);
+        this.plainVertices = new Float64Array(gridSize3);
+        this.plainVerticesHigh = new Float32Array(gridSize3);
+        this.plainVerticesLow = new Float32Array(gridSize3);
+        this.normalMapNormals = new Float32Array(gsgs * 3);
+        this.normalMapVertices = new Float64Array(gsgs * 3);
+        this.normalMapVerticesHigh = new Float32Array(gsgs * 3);
+        this.normalMapVerticesLow = new Float32Array(gsgs * 3);
+        let xmin = 549755748352.0, xmax = -549755748352.0, ymin = 549755748352.0, ymax = -549755748352.0, zmin = 549755748352.0, zmax = -549755748352.0;
+        let verts = this.plainVertices, vertsHigh = this.plainVerticesHigh, vertsLow = this.plainVerticesLow, norms = this.plainNormals, nmVerts = this.normalMapVertices, nmVertsHigh = this.normalMapVerticesHigh, nmVertsLow = this.normalMapVerticesLow, nmNorms = this.normalMapNormals;
+        for (let k = 0; k < gsgs; k++) {
+            let j = k % gs, i = ~~(k / gs);
+            const v = this.planet.ellipsoid.lonLatToCartesian(new LonLat(esw_lon + j * llStep, ene_lat - i * ltStep));
+            let nx = v.x * r2.x, ny = v.y * r2.y, nz = v.z * r2.z;
+            let l = 1.0 / Math.sqrt(nx * nx + ny * ny + nz * nz);
+            let nxl = nx * l, nyl = ny * l, nzl = nz * l;
+            Vec3.doubleToTwoFloats(v, _tempHigh, _tempLow);
+            nmVerts[nmInd] = v.x;
+            nmVertsHigh[nmInd] = _tempHigh.x;
+            nmVertsLow[nmInd] = _tempLow.x;
+            nmNorms[nmInd++] = nxl;
+            nmVerts[nmInd] = v.y;
+            nmVertsHigh[nmInd] = _tempHigh.y;
+            nmVertsLow[nmInd] = _tempLow.y;
+            nmNorms[nmInd++] = nyl;
+            nmVerts[nmInd] = v.z;
+            nmVertsHigh[nmInd] = _tempHigh.z;
+            nmVertsLow[nmInd] = _tempLow.z;
+            nmNorms[nmInd++] = nzl;
+            if (i % dg === 0 && j % dg === 0) {
+                verts[ind] = v.x;
+                vertsHigh[ind] = _tempHigh.x;
+                vertsLow[ind] = _tempLow.x;
+                norms[ind++] = nxl;
+                verts[ind] = v.y;
+                vertsHigh[ind] = _tempHigh.y;
+                vertsLow[ind] = _tempLow.y;
+                norms[ind++] = nyl;
+                verts[ind] = v.z;
+                vertsHigh[ind] = _tempHigh.z;
+                vertsLow[ind] = _tempLow.z;
+                norms[ind++] = nzl;
+                if (v.x < xmin)
+                    xmin = v.x;
+                if (v.x > xmax)
+                    xmax = v.x;
+                if (v.y < ymin)
+                    ymin = v.y;
+                if (v.y > ymax)
+                    ymax = v.y;
+                if (v.z < zmin)
+                    zmin = v.z;
+                if (v.z > zmax)
+                    zmax = v.z;
+            }
+        }
+        this.terrainVertices = verts;
+        this.terrainVerticesHigh = vertsHigh;
+        this.terrainVerticesLow = vertsLow;
+        let x = (xmax - xmin) * 0.5, y = (ymax - ymin) * 0.5, z = (zmax - zmin) * 0.5;
+        this._plainRadius = Math.sqrt(x * x + y * y + z * z);
+        this.plainReady = true;
+    }
+    _assignGlobalTextureCoordinates() {
+        const e = this._extent;
+        this._globalTextureCoordinates[0] = (e.southWest.lon + 180.0) / 360.0;
+        this._globalTextureCoordinates[1] = (90 - e.northEast.lat) / 180.0;
+        this._globalTextureCoordinates[2] = (e.northEast.lon + 180.0) / 360.0;
+        this._globalTextureCoordinates[3] = (90 - e.southWest.lat) / 180.0;
+    }
+    /**
+     * @todo: replace to the strategy
+     */
+    _collectVisibleNodes() {
+        if (this._isNorth) {
+            this.planet._visibleNodesNorth[this.node.nodeId] = this.node;
+        }
+        else {
+            this.planet._visibleNodesSouth[this.node.nodeId] = this.node;
+        }
+    }
+    /**
+     * @param layer
+     * @protected
+     *
+     * @todo simplify layer._extentMerc in layer.getNativeExtent(this)
+     *
+     */
+    _getLayerExtentOffset(layer) {
+        const v0s = layer._extent;
+        const v0t = this._extent;
+        const sSize_x = v0s.northEast.lon - v0s.southWest.lon;
+        const sSize_y = v0s.northEast.lat - v0s.southWest.lat;
+        const dV0s_x = (v0t.southWest.lon - v0s.southWest.lon) / sSize_x;
+        const dV0s_y = (v0s.northEast.lat - v0t.northEast.lat) / sSize_y;
+        const dSize_x = (v0t.northEast.lon - v0t.southWest.lon) / sSize_x;
+        const dSize_y = (v0t.northEast.lat - v0t.southWest.lat) / sSize_y;
+        return [dV0s_x, dV0s_y, dSize_x, dSize_y];
+    }
+    layerOverlap(layer) {
+        return this._extent.overlaps(layer._extent);
+    }
+    getDefaultTexture() {
+        return this._isNorth ? this.planet.solidTextureOne : this.planet.solidTextureTwo;
+    }
+    getExtentLonLat() {
+        return this._extent;
+    }
+    /**
+     * @todo: replace to the strategy
+     */
+    getNodeState() {
+        let vn;
+        if (this._isNorth) {
+            vn = this.planet._visibleNodesNorth[this.node.nodeId];
+        }
+        else {
+            vn = this.planet._visibleNodesSouth[this.node.nodeId];
+        }
+        return (vn && vn.state) || quadTree.NOTRENDERING;
+    }
+}
+export { SegmentLonLat };

package/lib/js/segment/SegmentLonLatWgs84.d.ts

@@ -0,0 +1,10 @@
+import { Extent } from "../Extent";
+import { Node } from "../quadTree/Node";
+import { Planet } from "../scene/Planet";
+import { SegmentLonLat } from "./SegmentLonLat";
+export declare class SegmentLonLatWgs84 extends SegmentLonLat {
+    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent);
+    protected _getMaxZoom(): number;
+    protected _assignTileYIndexes(extent: Extent): void;
+    protected _assignTileXIndexes(extent: Extent): void;
+}

package/lib/js/segment/SegmentLonLatWgs84.js

@@ -0,0 +1,23 @@
+import { SegmentLonLat } from "./SegmentLonLat";
+import { TILEGROUP_COMMON } from "./Segment";
+export class SegmentLonLatWgs84 extends SegmentLonLat {
+    constructor(node, planet, tileZoom, extent) {
+        super(node, planet, tileZoom, extent);
+        this.isPole = false;
+        this._tileGroup = TILEGROUP_COMMON;
+    }
+    _getMaxZoom() {
+        return 150;
+    }
+    _assignTileYIndexes(extent) {
+        this.tileY = Math.round((90.0 - extent.northEast.lat) / (extent.northEast.lat - extent.southWest.lat));
+        this.tileYN = this.tileY - 1;
+        this.tileYS = this.tileY + 1;
+    }
+    _assignTileXIndexes(extent) {
+        this.tileX = Math.round(Math.abs(-180.0 - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon));
+        let p2 = (1 << this.tileZoom) * 2;
+        this.tileXE = (this.tileX + 1) % p2;
+        this.tileXW = (p2 + this.tileX - 1) % p2;
+    }
+}

package/lib/js/segment/Slice.d.ts

@@ -0,0 +1,13 @@
+import { Layer } from "../layer/Layer";
+import { Segment } from "./Segment";
+import { Material } from "../layer/Material";
+declare class Slice {
+    segment: Segment;
+    layers: Layer[];
+    tileOffsetArr: Float32Array;
+    layerOpacityArr: Float32Array;
+    constructor(segment: Segment);
+    clear(): void;
+    append(layer: Layer, material: Material): void;
+}
+export { Slice };

package/lib/js/segment/Slice.js

@@ -0,0 +1,33 @@
+class Slice {
+    constructor(segment) {
+        this.segment = segment;
+        this.layers = [];
+        this.tileOffsetArr = new Float32Array(segment.planet.SLICE_SIZE_4);
+        this.layerOpacityArr = new Float32Array(segment.planet.SLICE_SIZE);
+    }
+    clear() {
+        // @ts-ignore
+        this.layers = null;
+        // @ts-ignore
+        this.tileOffsetArr = null;
+        // @ts-ignore
+        this.layerOpacityArr = null;
+    }
+    append(layer, material) {
+        let n = this.layers.length;
+        this.layers.push(layer);
+        this.layerOpacityArr[n] = layer.screenOpacity;
+        let n4 = n * 4;
+        let arr = layer.applyMaterial(material);
+        this.tileOffsetArr[n4] = arr[0];
+        this.tileOffsetArr[n4 + 1] = arr[1];
+        this.tileOffsetArr[n4 + 2] = arr[2];
+        this.tileOffsetArr[n4 + 3] = arr[3];
+        //arr = this.segment._getLayerExtentOffset(layer);
+        //slice.visibleExtentOffsetArr[n4] = arr[0];
+        //slice.visibleExtentOffsetArr[n4 + 1] = arr[1];
+        //slice.visibleExtentOffsetArr[n4 + 2] = arr[2];
+        //slice.visibleExtentOffsetArr[n4 + 3] = arr[3];
+    }
+}
+export { Slice };

package/lib/js/segment/segmentHelper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module og/segment/SegmentHelper
+ */
+type IndexTypeArray = Uint32Array;
+type IndexesTable = [IndexTypeArray[][], IndexTypeArray[][], IndexTypeArray[][], IndexTypeArray[][]];
+declare class SegmentHelper {
+    protected _maxGridSize: number;
+    centerIndexesTable: IndexTypeArray[];
+    skirtsIndexesTable: IndexesTable;
+    constructor(maxGridSize?: number);
+    get maxGridSize(): number;
+    init(): void;
+    setMaxGridSize(gridSize: number): void;
+    createSegmentIndexes(size: number, sidesSizes: [number, number, number, number]): Uint32Array;
+    initTextureCoordsTable(pow: number): Uint16Array[];
+}
+export declare function getInstance(): SegmentHelper;
+export {};

package/lib/js/segment/segmentHelper.js

@@ -0,0 +1,180 @@
+/**
+ * @module og/segment/SegmentHelper
+ */
+import { N, W, S, E } from '../quadTree/quadTree';
+function NewIndexesTypedArray(arr) {
+    return new Uint32Array(arr);
+}
+function NewIndexesTypedArrayEmpty(size) {
+    return new Uint32Array(size);
+}
+function createCenterBodyIndexes(size) {
+    let indexes = [];
+    let i0 = 1, j0 = 1;
+    let i1 = 1, j1 = 1;
+    let ind1 = 0, ind2 = 0, nr = 0;
+    for (let i = i0; i < size - 1 - i1; i++) {
+        for (let j = j0; j < size - j1; j++) {
+            ind1 = i * size + j;
+            nr = (i + 1) * size;
+            ind2 = nr + j;
+            indexes.push(ind1, ind2);
+        }
+        indexes.push(ind2, nr + j0);
+    }
+    indexes.push(indexes[indexes.length - 1], size * size - size);
+    return NewIndexesTypedArray(indexes);
+}
+function createWestNeighborSkirt(size, deltaGr) {
+    let indexes = [];
+    const grCount = (size - 1) / deltaGr;
+    const b = size * size - size;
+    let k = 0;
+    for (let i = 0; i < size - 2; i++) {
+        if (i % grCount === 0) {
+            k = i;
+        }
+        let rind = b - size * i - size + 1, lind = b - size * k;
+        indexes.push(lind, rind);
+    }
+    if (deltaGr === (size - 1)) {
+        indexes.push(size);
+        indexes.push(0);
+    }
+    return NewIndexesTypedArray(indexes);
+}
+function createNorthNeighborSkirt(size, deltaGr) {
+    let indexes = [];
+    const grCount = (size - 1) / deltaGr;
+    let k = 0;
+    for (let i = 0; i < size - 2; i++) {
+        if (i % grCount === 0) {
+            k = i;
+        }
+        let rind = size + i + 1, lind = k;
+        indexes.push(lind, rind);
+    }
+    if (deltaGr === (size - 1)) {
+        indexes.push(size - 2);
+        indexes.push(size - 1);
+    }
+    return NewIndexesTypedArray(indexes);
+}
+function createEastNeighborSkirt(size, deltaGr) {
+    let indexes = [];
+    const grCount = (size - 1) / deltaGr;
+    let k = 0;
+    for (let i = 0; i < size - 2; i++) {
+        if (i % grCount === 0) {
+            k = i;
+        }
+        let rind = size * (i + 1) + size - 2, lind = size + size * k - 1;
+        indexes.push(lind, rind);
+    }
+    if (deltaGr === (size - 1)) {
+        indexes.push(size * (size - 1) - 1);
+        indexes.push(size * size - 1);
+    }
+    return NewIndexesTypedArray(indexes);
+}
+function createSouthNeighborSkirt(size, deltaGr) {
+    let indexes = [];
+    const grCount = (size - 1) / deltaGr;
+    let k = 0;
+    const rb = size * (size - 1) - 2;
+    const lb = size * size - 1;
+    for (let i = 0; i < size - 2; i++) {
+        if (i % grCount === 0) {
+            k = i;
+        }
+        let rind = rb - i, lind = lb - k;
+        indexes.push(lind, rind);
+    }
+    if (deltaGr === (size - 1)) {
+        indexes.push(size * size - size + 1);
+    }
+    indexes.push(size * size - size);
+    return NewIndexesTypedArray(indexes);
+}
+function initIndexesBodySkirts(pow) {
+    let table = [[], [], [], []];
+    for (let i = 0; i <= pow; i++) {
+        let d = Math.pow(2, i), d1 = d + 1;
+        table[N][i] = [];
+        table[W][i] = [];
+        table[S][i] = [];
+        table[E][i] = [];
+        for (let j = 0; j <= pow; j++) {
+            let dd = Math.pow(2, j);
+            table[W][i][j] = createWestNeighborSkirt(d1, dd);
+            table[N][i][j] = createNorthNeighborSkirt(d1, dd);
+            table[E][i][j] = createEastNeighborSkirt(d1, dd);
+            table[S][i][j] = createSouthNeighborSkirt(d1, dd);
+        }
+    }
+    return table;
+}
+function initIndexBodiesTable(pow) {
+    let table = [];
+    for (let i = 0; i <= pow; i++) {
+        const d = Math.pow(2, i);
+        table[i] = createCenterBodyIndexes(d + 1);
+    }
+    return table;
+}
+function createTextureCoords(size) {
+    let texCoords = new Uint16Array((size + 1) * (size + 1) * 2);
+    let k = 0;
+    for (let i = 0; i <= size; i++) {
+        for (let j = 0; j <= size; j++) {
+            texCoords[k++] = j / size * 0xFFFF;
+            texCoords[k++] = i / size * 0xFFFF;
+        }
+    }
+    return texCoords;
+}
+class SegmentHelper {
+    constructor(maxGridSize = 0) {
+        this._maxGridSize = maxGridSize;
+        this.centerIndexesTable = initIndexBodiesTable(this._maxGridSize);
+        this.skirtsIndexesTable = initIndexesBodySkirts(this._maxGridSize);
+    }
+    get maxGridSize() {
+        return this._maxGridSize;
+    }
+    init() {
+        this.centerIndexesTable = initIndexBodiesTable(this._maxGridSize);
+        this.skirtsIndexesTable = initIndexesBodySkirts(this._maxGridSize);
+    }
+    setMaxGridSize(gridSize) {
+        this._maxGridSize = gridSize;
+        this.init();
+    }
+    createSegmentIndexes(size, sidesSizes) {
+        if (size) {
+            let c = this.centerIndexesTable[size], w = this.skirtsIndexesTable[W][size][sidesSizes[W]], n = this.skirtsIndexesTable[N][size][sidesSizes[N]], e = this.skirtsIndexesTable[E][size][sidesSizes[E]], s = this.skirtsIndexesTable[S][size][sidesSizes[S]];
+            let indexes = NewIndexesTypedArrayEmpty(c.length + w.length + n.length + e.length + s.length);
+            indexes.set(c, 0);
+            indexes.set(w, c.length);
+            indexes.set(n, c.length + w.length);
+            indexes.set(e, c.length + w.length + n.length);
+            indexes.set(s, c.length + w.length + n.length + e.length);
+            return indexes;
+        }
+        else {
+            return NewIndexesTypedArray([0, 2, 1, 3]);
+        }
+    }
+    initTextureCoordsTable(pow) {
+        let table = [];
+        for (let i = 0; i <= pow; i++) {
+            const d = Math.pow(2, i);
+            table[i] = createTextureCoords(d);
+        }
+        return table;
+    }
+}
+let instance = new SegmentHelper();
+export function getInstance() {
+    return instance;
+}

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

@@ -0,0 +1,4 @@
+import { Program } from '../webgl/Program';
+export declare const COMMON = "\n    \n    \n    float getLerpValue(in float min, in float max, in float between)\n    {\n        return (clamp(between, min, max) - min) / (max - min);\n    }\n    \n    vec3 aces(vec3 color) \n    {\n        float a = 2.51;\n        float b = 0.03;\n        float c = 2.43;\n        float d = 0.59;\n        float e = 0.14;\n        return clamp((color * (a * color + b)) / (color * (c * color + d ) + e), 0.0, 1.0);\n    }\n     \n    bool intersectSphere(vec3 rayOrigin, vec3 rayDirection, float radius, inout float t1, inout float t2) \n    {\n        float b = dot(rayDirection, rayOrigin);\n        float c = dot(rayOrigin, rayOrigin) - radius * radius;\n        float d = b * b - c;\n        if (d < 0.0) {\n            return false;\n        }\n        t1 = -b - sqrt(d);\n        t2 = -b + sqrt(d);\n        return true;\n    }\n    \n    bool intersectSphere(vec3 rayOrigin, vec3 rayDirection, float radius, inout float t) \n    {\n        float b = dot(rayDirection, rayOrigin);\n        float c = dot(rayOrigin, rayOrigin) - radius * radius;\n        float d = b * b - c;\n        if (d < 0.0) {\n            return false;\n        }\n        t = -b - sqrt(d);\n        return true;\n    }\n    \n    bool intersectEllipsoid( in vec3 ro, in vec3 rd, in vec3 ra, inout float t )\n    {\n        vec3 ocn = ro/ra;\n        vec3 rdn = rd/ra;\n        float a = dot( rdn, rdn );\n        float b = dot( ocn, rdn );\n        float c = dot( ocn, ocn );\n        float h = b*b - a*(c-1.0);\n                       \n        if (h < 0.0) \n        { \n            return false; \n        }\n        \n        t = (-b-sqrt(h))/a;\n        \n        return true;\n    }\n    \n    bool intersectEllipsoid( in vec3 ro, in vec3 rd, in vec3 ra, inout float t1, inout float t2)\n    {\n        vec3 ocn = ro/ra;\n        vec3 rdn = rd/ra;\n        float a = dot( rdn, rdn );\n        float b = dot( ocn, rdn );\n        float c = dot( ocn, ocn );\n        float h = b*b - a*(c-1.0);\n                \n        if (h < 0.0) \n        { \n            return false; \n        }\n        \n        h = sqrt(h);\n        t1 = (-b-h)/a;\n        t2 = (-b+h)/a;\n        \n        return true;\n    }\n    \n    vec3 normalEllipsoid( in vec3 pos, in vec3 ra )\n    {\n        return normalize( pos/(ra*ra) );\n    }\n\n    \n    #define PI 3.1415926538\n    #define ATMOS_HEIGHT 100000.0\n    #define RAYLEIGH_SCALE 0.08\n    #define MIE_SCALE 0.012\n    \n    #define SAMPLE_COUNT 16\n    #define SQRT_SAMPLE_COUNT 4\n            \n    const float GROUND_ALBEDO = 0.05 / PI;\n\n    // Sphere\n    const float BOTTOM_RADIUS = 6356752.3142451793;\n    const float TOP_RADIUS = 6356752.3142451793 + ATMOS_HEIGHT;\n        \n    // Ellipsoid\n    const vec3 bottomRadii = vec3(6378137.0, 6378137.0, 6356752.3142451793);           \n    const vec3 topRadii = bottomRadii + ATMOS_HEIGHT;\n    \n    const vec3 SPHERE_TO_ELLIPSOID_SCALE = vec3(BOTTOM_RADIUS) / bottomRadii;           \n    \n    const vec2 rayleighMieHeights = vec2(RAYLEIGH_SCALE, MIE_SCALE) * ATMOS_HEIGHT;\n     \n    const vec3 rayleighScatteringCoefficient = vec3(5.802, 13.558, 33.100) * 1e-6;\n    \n    const float mieScatteringCoefficient = 3.996e-06;\n    const float mieExtinctionCoefficient = 4.440e-06;\n    const vec3 ozoneAbsorptionCoefficient = vec3(0.650, 1.881, 0.085) * 1e-6;\n    \n    const float SUN_ANGULAR_RADIUS = 0.004685;\n    const float SUN_INTENSITY = 1.0;        \n    \n    vec3 sunWithBloom(vec3 rayDir, vec3 sunDir) \n    {\n        float minSunCosTheta = cos(SUN_ANGULAR_RADIUS);            \n        float cosTheta = dot(rayDir, sunDir);\n        if (cosTheta >= minSunCosTheta) return vec3(1.0);                \n        float offset = minSunCosTheta - cosTheta;\n        float gaussianBloom = exp(-offset*15000.0)*0.7;\n        float invBloom = 1.0/(0.09 + offset*200.0)*0.01;\n        return vec3(gaussianBloom + invBloom);\n    }\n    \n    float rayleighPhase(float angle) \n    {\n        return 3.0 / (16.0 * PI) * (1.0 + (angle * angle));\n    }\n    \n    float miePhase(float angle) \n    {\n        float g = 0.8;\n        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));\n    }\n        \n    vec3 opticalDepth(float height, float angle) \n    {\n        vec3 rayOrigin = vec3(0.0, BOTTOM_RADIUS + height, 0.0);\n        vec3 rayDirection = vec3(sqrt(1.0 - angle * angle), angle, 0.0);\n        float t1, t2;\n        intersectSphere(rayOrigin, rayDirection, TOP_RADIUS, t1, t2);\n        float segmentLength = t2 / float(SAMPLE_COUNT);\n        \n        float t = segmentLength * 0.5;\n        vec3 opticalDepth = vec3(0.0);\n        \n        for (int i = 0; i < SAMPLE_COUNT; i++) \n        {\n            vec3 position = rayOrigin + t * rayDirection;\n            float height = length(position) - BOTTOM_RADIUS;\n            opticalDepth.xy += exp(-height / rayleighMieHeights) * segmentLength;\n            \n            // density of the ozone layer is modeled as a triangular \n            // function that is 30 km wide and centered at 25 km altitude\n            opticalDepth.z += (1.0 - min(abs(height - 25e3) / 15e3, 1.0)) * segmentLength;  \n            t += segmentLength;\n        }\n        \n        return opticalDepth;\n    }\n    \n    vec3 transmittance(float height, float angle) \n    {\n        vec3 opticalDepth = opticalDepth(height, angle);\n        return exp(-(rayleighScatteringCoefficient * opticalDepth.x + mieExtinctionCoefficient * opticalDepth.y + ozoneAbsorptionCoefficient * opticalDepth.z));\n    }";
+export declare function transmittance(): Program;
+export declare function scattering(): Program;