@openglobus/og 0.19.4 → 0.20.0

package/lib/@openglobus/js/scene/RenderNode.d.ts

@@ -0,0 +1,150 @@
+import { BaseNode } from "./BaseNode";
+import { Renderer } from "../renderer/Renderer";
+import { LightSource } from "../light/LightSource";
+import { EntityCollection } from "../entity/EntityCollection";
+/**
+ * Render node is a logical part of a render mechanism. Represents scene rendering.
+ * For example one scene node for rendering the Earth, another one for rendering the Moon, another node for rendering stars etc.
+ * Each render node has own model view space defined with matrices(scale, rotation, translation, transformation).
+ * There are collections of light sources, entities and so on in the node.
+ * Access to the node is renderer.renderNodes["Earth"]
+ * @class
+ * @extends {BaseNode}
+ * @param {string} name - Node name.
+ */
+declare class RenderNode extends BaseNode {
+    /**
+     * Renderer that calls frame() callback.
+     * @public
+     * @type {Renderer}
+     */
+    renderer: Renderer | null;
+    drawMode: number;
+    /** Show rendering.
+     * @public
+     */
+    show: boolean;
+    protected _isActive: boolean;
+    childNodes: RenderNode[];
+    /**
+     * Lighting calculations.
+     * @public
+     * @type {boolean}
+     */
+    lightEnabled: boolean;
+    /**
+     * Point light array.
+     * @public
+     * @type {Array.<LightSource>}
+     */
+    _lights: LightSource[];
+    _lightsNames: string[];
+    _lightsPositions: number[];
+    _lightsParamsv: number[];
+    _lightsParamsf: number[];
+    /**
+     * Entity collection array.
+     * @public
+     * @type {Array.<EntityCollection>}
+     */
+    entityCollections: EntityCollection[];
+    protected _pickingId: number;
+    constructor(name?: string);
+    /**
+     * Adds node to the current hierarchy.
+     * @public
+     * @type {RenderNode}
+     */
+    addNode(node: RenderNode): void;
+    /**
+     * Assign render node with renderer.
+     * @public
+     * @param {Renderer} renderer - Render node's renderer.
+     */
+    assign(renderer: Renderer): void;
+    initialize(): void;
+    init(): void;
+    onremove(): void;
+    remove(): void;
+    /**
+     * Adds entity collection.
+     * @public
+     * @param {EntityCollection} entityCollection - Entity collection.
+     * @param {boolean} [isHidden] - If it's true that this collection has specific rendering.
+     * @returns {RenderNode} -
+     */
+    addEntityCollection(entityCollection: EntityCollection, isHidden?: boolean): RenderNode;
+    /**
+     * Removes entity collection.
+     * @public
+     * @param {EntityCollection} entityCollection - Entity collection for remove.
+     */
+    removeEntityCollection(entityCollection: EntityCollection): void;
+    /**
+     * Adds point light source.
+     * @public
+     * @param {LightSource} light - Light source.
+     * @returns {RenderNode}
+     */
+    addLight(light: LightSource): RenderNode;
+    /**
+     * Gets light object by its name.
+     * @public
+     * @param {string} name - Point light name.
+     * @returns {LightSource}
+     */
+    getLightByName(name: string): LightSource | undefined;
+    /**
+     * Removes light source.
+     * @public
+     * @param {LightSource} light - Light source object.
+     */
+    removeLight(light: LightSource): void;
+    /**
+     * Calls render frame node's callback. Used in renderer.
+     * @public
+     */
+    preDrawNode(): void;
+    /**
+     * Calls render frame node's callback. Used in renderer.
+     * @public
+     */
+    drawNode(): void;
+    /**
+     * Gets render node activity.
+     * @public
+     * @returns {Boolean} -
+     */
+    isActive(): boolean;
+    /**
+     * Rendering activation.
+     * @public
+     * @param {boolean} isActive - Activation flag.
+     */
+    setActive(isActive: boolean): void;
+    /**
+     * Sets draw mode
+     * @public
+     * @param {Number} mode - Draw mode, such as gl.TRIANGLES, gl.TRIANGLE_STRIP, gl.LINES etc.
+     */
+    setDrawMode(mode: number): void;
+    /**
+     * IMPORTANT: This function have to be called manually in each render node frame callback, before drawing scene geometry.
+     * @public
+     */
+    transformLights(): void;
+    updateBillboardsTexCoords(): void;
+    frame(): void;
+    preFrame(): void;
+    protected _preDrawNodes(): void;
+    protected _drawNodes(): void;
+    drawEntityCollections(ec: EntityCollection[]): void;
+    /**
+     * Draw entity collections picking frame.
+     * @public
+     * @param {Array<EntityCollection>} ec - Entity collection array.
+     */
+    drawPickingEntityCollections(ec: EntityCollection[]): void;
+    protected _entityCollectionPickingCallback(): void;
+}
+export { RenderNode };

package/lib/@openglobus/js/scene/SkyBox.d.ts

@@ -0,0 +1,13 @@
+import { RenderNode } from './RenderNode';
+import { WebGLBufferExt, WebGLTextureExt, Texture3DParams } from "../webgl/Handler";
+declare class SkyBox extends RenderNode {
+    params: Texture3DParams;
+    vertexPositionBuffer: WebGLBufferExt | null;
+    texture: WebGLTextureExt | null;
+    constructor(params: Texture3DParams);
+    static createDefault(RESOURCES_URL: string): SkyBox;
+    init(): void;
+    frame(): void;
+    protected _createBuffers(): void;
+}
+export { SkyBox };

package/lib/@openglobus/js/scene/index.d.ts

@@ -0,0 +1,5 @@
+import { Axes } from "./Axes";
+import { Planet } from "./Planet";
+import { SkyBox } from "./SkyBox";
+import { RenderNode } from "./RenderNode";
+export { Planet, Axes, SkyBox, RenderNode };

package/lib/@openglobus/js/segment/Segment.d.ts

@@ -0,0 +1,288 @@
+import { Box } from "../bv/Box";
+import { Extent } from "../Extent";
+import { Entity } from "../entity/Entity";
+import { TypedArray } from "../utils/shared";
+import { Handler, WebGLBufferExt, WebGLTextureExt } from "../webgl/Handler";
+import { ITerrainWorkerData } from "../utils/TerrainWorker";
+import { Layer } from "../layer/Layer";
+import { LonLat } from "../LonLat";
+import { Material } from "../layer/Material";
+import { Node } from "../quadTree/Node";
+import { Planet } from "../scene/Planet";
+import { PlanetCamera } from "../camera/PlanetCamera";
+import { Program } from "../webgl/Program";
+import { Proj } from "../proj/Proj";
+import { NumberArray6, Sphere } from "../bv/Sphere";
+import { Slice } from "./Slice";
+import { Vec3 } from "../math/Vec3";
+import { IPlainSegmentWorkerData } from "../utils/PlainSegmentWorker";
+export declare function getTileCellIndex(coordinate: number, tileSize: number, worldEdge: number): number;
+export declare function getTileCellExtent(x: number, y: number, z: number, worldExtent: Extent): Extent;
+export declare const TILEGROUP_COMMON = 0;
+export declare const TILEGROUP_NORTH = 20;
+export declare const TILEGROUP_SOUTH = 300;
+export declare function getTileGroupByLat(lat: number, maxLat?: number): number;
+/**
+ * Planet segment Web Mercator tile class that stored and rendered with a quad-tree.
+ * @class
+ * @param {Node} node - Segment node.
+ * @param {Planet} planet - Planet scene.
+ * @param {number} tileZoom - Zoom index.
+ * @param {Extent} extent - Segment extent.
+ */
+declare class Segment {
+    _isNorth?: boolean;
+    isPole: boolean;
+    _tileGroup: number;
+    _projection: Proj;
+    elevationData: TypedArray | null;
+    /**
+     * Quad tree node of the segment.
+     * @type {Node}
+     */
+    node: Node;
+    /**
+     * Planet pointer.
+     * @type {Planet}
+     */
+    planet: Planet;
+    /**
+     * WebGl handler pointer.
+     * @type {Handler}
+     */
+    handler: Handler;
+    /**
+     * Segment bounding sphere
+     * @type {Sphere}
+     */
+    bsphere: Sphere;
+    _plainRadius: number;
+    /**
+     * Segment bounding box.
+     * @type {Box}
+     */
+    bbox: Box;
+    _sw: Vec3;
+    _nw: Vec3;
+    _se: Vec3;
+    _ne: Vec3;
+    centerNormal: Vec3;
+    /**
+     * Geographical extent.
+     * @type {Extent}
+     */
+    _extent: Extent;
+    _extentMerc: Extent;
+    _extentLonLat: Extent;
+    /**
+     * Vertices grid size.
+     * @type {number}
+     */
+    gridSize: number;
+    fileGridSize: number;
+    /**
+     * Tile zoom index.
+     * @type {number}
+     */
+    tileZoom: number;
+    /**
+     * Equals to pow(2, tileZoom).
+     * @type {number}
+     */
+    powTileZoom: number;
+    /**
+     * Horizontal tile index.
+     * @type {number}
+     */
+    tileX: number;
+    tileXE: number;
+    tileXW: number;
+    tileYN: number;
+    tileYS: number;
+    /**
+     * Vertical tile index.
+     * @type {number}
+     */
+    tileY: number;
+    tileIndex: string;
+    /**
+     * Texture materials array.
+     * @type {Array.<Material>}
+     *
+     * @toso: Check it should be Map<number, Material> instead of array
+     *
+     */
+    materials: Material[];
+    /**
+     * Plain segment vertices was created.
+     * @type {boolean}
+     */
+    plainReady: boolean;
+    /**
+     * Segment is ready to create plain vertices.
+     * @type {boolean}
+     */
+    initialized: boolean;
+    /**
+     * Normal map is allready made.
+     * @type {boolean}
+     */
+    normalMapReady: boolean;
+    /**
+     * Terrain is allready applied flag.
+     * @type {boolean}
+     */
+    terrainReady: boolean;
+    /**
+     * Terrain is loading now flag.
+     * @type {boolean}
+     */
+    terrainIsLoading: boolean;
+    /**
+     * Terrain existing flag.
+     * @type {boolean}
+     */
+    terrainExists: boolean;
+    /**
+     * Means that tree passage reach the segment, and the segment terrain is ready.
+     * @type {boolean}
+     */
+    passReady: boolean;
+    plainVertices: Float64Array | null;
+    plainVerticesHigh: Float32Array | null;
+    plainVerticesLow: Float32Array | null;
+    plainNormals: Float32Array | null;
+    terrainVertices: Float64Array | null;
+    terrainVerticesHigh: Float32Array | null;
+    terrainVerticesLow: Float32Array | null;
+    noDataVertices: Uint8Array | null;
+    tempVertices: Float64Array | null;
+    tempVerticesHigh: Float32Array | null;
+    tempVerticesLow: Float32Array | null;
+    normalMapTexture: WebGLTextureExt | null;
+    normalMapTextureBias: Float32Array;
+    normalMapVertices: Float64Array | null;
+    normalMapVerticesHigh: Float32Array | null;
+    normalMapVerticesLow: Float32Array | null;
+    normalMapNormals: Float32Array | null;
+    vertexNormalBuffer: WebGLBufferExt | null;
+    vertexPositionBuffer: WebGLBufferExt | null;
+    vertexPositionBufferHigh: WebGLBufferExt | null;
+    vertexPositionBufferLow: WebGLBufferExt | null;
+    vertexTextureCoordBuffer: WebGLBufferExt | null;
+    _globalTextureCoordinates: Float32Array;
+    _inTheQueue: boolean;
+    _appliedNeighborsZoom: [number, number, number, number];
+    _slices: Slice[];
+    _indexBuffer: WebGLBufferExt | null;
+    readyToEngage: boolean;
+    plainProcessing: boolean;
+    normalMapTexturePtr: WebGLTextureExt | null;
+    _transitionOpacity: number;
+    _transitionTimestamp: number;
+    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent);
+    checkZoom(): boolean;
+    /**
+     * Returns entity terrain point.
+     * @public
+     * @param {Entity} entity - Entity.
+     * @param {Vec3} res - Point coordinates.
+     * @returns {Vec3} -
+     */
+    getEntityTerrainPoint(entity: Entity, res: Vec3): number;
+    getInsideLonLat(obj: Entity | PlanetCamera): LonLat;
+    isEntityInside(entity: Entity): boolean;
+    /**
+     * Returns distance from object to terrain coordinates and terrain point that calculates out in the res parameter.
+     * @public
+     * @param {Vec3} xyz - Cartesian object position.
+     * @param {LonLat} insideSegmentPosition - Geodetic object position.
+     * @param {Vec3} [res] - Result cartesian coordinates on the terrain.
+     * @returns {number} -
+     */
+    getTerrainPoint(xyz: Vec3, insideSegmentPosition: LonLat, res: Vec3): number;
+    /**
+     * Project wgs86 to segment native projection.
+     * @public
+     * @param {LonLat} lonlat - Coordinates to project.
+     * @returns {LonLat} -
+     */
+    projectNative(lonlat: LonLat): LonLat;
+    loadTerrain(forceLoading?: boolean): void;
+    /**
+     * Terrain obtained from server.
+     * @param {Float32Array} elevations - Elevation data.
+     */
+    elevationsExists(elevations: number[] | TypedArray): void;
+    /**
+     * Keep plain elevation segment for rendering
+     *
+     * 'this.tileZoom <= this.planet.terrain.maxZoom' it means, that the segment is plain
+     *
+     */
+    elevationsNotExists(): void;
+    protected _checkEqualization(neighborSide: number, neigborNode: Node): boolean;
+    equalize(): void;
+    engage(): void;
+    _terrainWorkerCallback(data: ITerrainWorkerData): void;
+    _normalMapEdgeEqualize(side: number): void;
+    applyTerrain(elevations?: number[] | TypedArray | null): void;
+    deleteBuffers(): void;
+    deleteMaterials(): void;
+    deleteElevations(): void;
+    clearSegment(): void;
+    childrenInitialized(): boolean;
+    destroySegment(): void;
+    /**
+     * @todo: looks like it could be simplified in Segment contructor
+     */
+    _setExtentLonLat(): void;
+    protected _createExtentNormals(): void;
+    createBoundsByExtent(): void;
+    createBoundsByParent(): void;
+    setBoundingSphere(x: number, y: number, z: number, v: Vec3): void;
+    setBoundingVolume(xmin: number, ymin: number, zmin: number, xmax: number, ymax: number, zmax: number): void;
+    setBoundingVolume3v(vmin: Vec3, vmax: Vec3): void;
+    setBoundingVolumeArr(bounds: NumberArray6): void;
+    createCoordsBuffers(verticesHigh: Float32Array, verticesLow: Float32Array, gridSize: number): void;
+    _addViewExtent(): void;
+    protected _assignTileIndexes(): void;
+    initialize(): void;
+    protected _assignGlobalTextureCoordinates(): void;
+    createPlainSegmentAsync(): void;
+    _plainSegmentWorkerCallback(data: IPlainSegmentWorkerData): void;
+    createPlainSegment(): void;
+    protected _projToDeg(lon: number, lat: number): LonLat;
+    protected _createPlainVertices(): void;
+    /**
+     * Gets specific layer material.
+     * @public
+     * @param {Layer} layer - Layer object.
+     * @returns {Material | undefined} - Segment material.
+     */
+    getMaterialByLayer(layer: Layer): Material | undefined;
+    /**
+     * @param layer
+     * @protected
+     *
+     * @todo siplify layer._extentMerc in this.getLayerExtent(layer)
+     *
+     */
+    protected _getLayerExtentOffset(layer: Layer): [number, number, number, number];
+    initSlice(sliceIndex: number): Slice;
+    screenRendering(sh: Program, layerSlice: Layer[], sliceIndex: number, defaultTexture?: WebGLTextureExt | null, isOverlay?: boolean, forcedOpacity?: number): void;
+    heightPickingRendering(sh: Program, layerSlice: Layer[]): void;
+    increaseTransitionOpacity(): void;
+    fadingTransitionOpacity(): void;
+    colorPickingRendering(sh: Program, layerSlice: Layer[], sliceIndex: number, defaultTexture?: WebGLTextureExt | null, isOverlay?: boolean): void;
+    depthRendering(sh: Program, layerSlice: Layer[]): void;
+    protected _getIndexBuffer(): WebGLBufferExt;
+    _collectVisibleNodes(): void;
+    layerOverlap(layer: Layer): boolean;
+    getDefaultTexture(): WebGLTextureExt | null;
+    getExtentLonLat(): Extent;
+    getExtentMerc(): Extent;
+    getExtent(): Extent;
+    getNeighborSide(b: Segment): 0 | 1 | 2 | 3 | -1;
+}
+export { Segment };

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

@@ -0,0 +1,44 @@
+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 _projToDeg(lon: number, lat: number): LonLat;
+    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;
+}
+export { SegmentLonLat };

package/lib/@openglobus/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/@openglobus/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/@openglobus/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/@openglobus/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;

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

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

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

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

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

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

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

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

package/lib/@openglobus/js/shaders/drawnode.d.ts

@@ -0,0 +1,8 @@
+import { Program } from "../webgl/Program";
+export declare function drawnode_screen_nl(): Program;
+export declare function drawnode_screen_wl_webgl1NoAtmos(): Program;
+export declare function drawnode_screen_wl_webgl2NoAtmos(): Program;
+export declare function drawnode_screen_wl_webgl2Atmos(): Program;
+export declare function drawnode_colorPicking(): Program;
+export declare function drawnode_heightPicking(): Program;
+export declare function drawnode_depth(): Program;

package/lib/@openglobus/js/shaders/geoObject.d.ts

@@ -0,0 +1,3 @@
+import { Program } from "../webgl/Program";
+export declare const geo_object: () => Program;
+export declare const geo_object_picking: () => Program;

package/lib/@openglobus/js/shaders/label.d.ts

@@ -0,0 +1,4 @@
+import { Program } from '../webgl/Program';
+export declare function label_webgl2(): Program;
+export declare function label_screen(): Program;
+export declare function labelPicking(): Program;

package/lib/@openglobus/js/shaders/lumFilter.d.ts

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

package/lib/@openglobus/js/shaders/pointCloud.d.ts

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

package/lib/@openglobus/js/shaders/polyline.d.ts

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

package/lib/@openglobus/js/shaders/ray.d.ts

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

package/lib/@openglobus/js/shaders/screenFrame.d.ts

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

package/lib/@openglobus/js/shaders/skybox.d.ts

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

package/lib/@openglobus/js/shaders/toneMapping.d.ts

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

package/lib/@openglobus/js/shaders/utils.d.ts

@@ -0,0 +1 @@
+export declare const UTILS = "\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";

package/lib/@openglobus/js/terrain/BilTerrain.d.ts

@@ -0,0 +1,18 @@
+import { GlobusTerrain, IGlobusTerrainParams } from "./GlobusTerrain";
+import { Segment } from "../segment/Segment";
+import { Extent } from "../Extent";
+import { TypedArray } from "../utils/shared";
+interface IBilTerrainParams extends IGlobusTerrainParams {
+    layers?: string;
+    imageSize?: number;
+}
+declare class BilTerrain extends GlobusTerrain {
+    protected _format: string;
+    protected _layers: string;
+    protected _imageSize: number;
+    constructor(options?: IBilTerrainParams);
+    isBlur(segment: Segment): boolean;
+    protected _createUrl(segment: Segment): string;
+    protected _createHeights(data: number[], segment: Segment | null, tileGroup: number, tileX: number, tileY: number, tileZoom: number, extent: Extent, preventChildren: boolean): TypedArray | number[];
+}
+export { BilTerrain };