@openglobus/og 0.12.1 → 0.12.3

package/types/terrain/EmptyTerrain.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Class represents terrain provider without elevation data.
+ * @class
+ */
+export class EmptyTerrain {
+    static checkNoDataValue(noDataValues: any, value: any): boolean;
+    constructor(options?: {});
+    equalizeVertices: boolean;
+    equalizeNormals: boolean;
+    isEmpty: boolean;
+    /**
+     * Provider name is "empty"
+     * @public
+     * @type {string}
+     */
+    public name: string;
+    /**
+     * Minimal z-index value for segment elevation data handling.
+     * @public
+     * @type {number}
+     */
+    public minZoom: number;
+    /**
+     * Maximal z-index value for segment elevation data handling.
+     * @public
+     * @type {number}
+     */
+    public maxZoom: number;
+    /**
+     * @public
+     * @type {Array.<number>}
+     */
+    public gridSizeByZoom: Array<number>;
+    _maxNodeZoom: number;
+    /**
+     * Elevation grid size. Currend is 2x2 is the smallest grid size.
+     * @public
+     * @type {number}
+     */
+    public plainGridSize: number;
+    /**
+     * Planet node.
+     * @protected
+     * @type {Planet}
+     */
+    protected _planet: Planet;
+    _geoid: any;
+    isBlur(): boolean;
+    set maxNodeZoom(arg: number);
+    get maxNodeZoom(): number;
+    set geoid(arg: any);
+    get geoid(): any;
+    /**
+     * Loads or creates segment elevation data.
+     * @public
+     * @virtual
+     * @param {Segment} segment - Segment to create elevation data.
+     */
+    public handleSegmentTerrain(segment: Segment): void;
+    isReady(): any;
+    /**
+     * Abstract function
+     * @public
+     * @abstract
+     */
+    public abortLoading(): void;
+    /**
+     * Abstract function
+     * @public
+     * @abstract
+     */
+    public clearCache(): void;
+}

package/types/terrain/Geoid.d.ts

@@ -0,0 +1,26 @@
+export class Geoid {
+    static loadModel(url: any): Promise<{
+        scale: number;
+        offset: number;
+        width: number;
+        height: number;
+        rlonres: number;
+        rlatres: number;
+        i: number;
+        rawfile: Uint8Array;
+    }>;
+    constructor(options?: {});
+    model: any;
+    src: any;
+    _cached_ix: any;
+    _cached_iy: number;
+    _v00: number;
+    _v01: number;
+    _v10: number;
+    _v11: number;
+    _t: any;
+    setModel(model: any): void;
+    _rawval(ix: any, iy: any): number;
+    getHeightLonLat(lonlat: any): any;
+    getHeight(lon: any, lat: any): any;
+}

package/types/terrain/GlobusTerrain.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Class that loads segment elevation data, converts it to the array and passes it to the planet segment.
+ * @class
+ * @extends {EmptyTerrain}
+ * @param {string} [name=""] - Terrain provider name.
+ * @param {Object} [options] - Provider options:
+ * @param {number} [options.minZoom=3] - Minimal visible zoom index when terrain handler works.
+ * @param {number} [options.minZoom=14] - Maximal visible zoom index when terrain handler works.
+ * @param {string} [options.url="//openglobus.org/heights/srtm3/{z}/{y}/{x}.ddm"] - Terrain source path url template. Default is openglobus ddm elevation file.
+ * @param {Array.<number>} [options.gridSizeByZoom] - Array of segment triangulation grid sizes where array index agreed to the segment zoom index.
+ * @param {number} [options.plainGridSize=32] - Elevation grid size. Default is 32x32. Must be power of two.
+ * @param {string} [options.responseType="arraybuffer"] - Ajax responce type.
+ * @param {number} [options.MAX_LOADING_TILES] - Maximum at one time loading tiles.
+ * @param {Array.<number>} [gridSizeByZoom] - Array of values, where each value corresponds to the size of a tile(or segment) on the globe. Each value must be power of two.
+ * @fires og.terrain.GlobusTerrain#load
+ * @fires og.terrain.GlobusTerrain#loadend
+ */
+export class GlobusTerrain extends EmptyTerrain {
+    /**
+     * @param {string} [name]
+     * @param {*} [options]
+     */
+    constructor(name?: string, options?: any);
+    /**
+     * Events handler.
+     * @public
+     * @type {Events}
+     */
+    public events: Events;
+    /**
+     * Terrain source path url template.
+     * @public
+     * @type {string}
+     */
+    public url: string;
+    noDataValues: any;
+    _extent: any;
+    _dataType: string;
+    _elevationCache: {};
+    _fetchCache: {};
+    _loader: Loader;
+    /**
+     * Rewrites elevation storage url query.
+     * @private
+     * @callback og.terrain.GlobusTerrain~_urlRewriteCallback
+     * @param {Segment} segment - Segment to load.
+     * @param {string} url - Created url.
+     * @returns {string} - Url query string.
+     */
+    private _urlRewriteCallback;
+    getGeoid(): any;
+    getHeightAsync(lonLat: any, callback: any, zoom: any): boolean;
+    getTileCache(lonLat: any, z: any): any;
+    _getGroundHeightMerc(merc: any, tileData: any): number;
+    /**
+     * Sets terrain data url template.
+     * @public
+     * @param {string} url - Url template.
+     * @example <caption>Default openglobus url template:</caption>:
+     * "http://earth3.openglobus.org/{z}/{y}/{x}.ddm"
+     */
+    public setUrl(url: string): void;
+    /**
+     * Sets provider name.
+     * @public
+     * @param {string} name - Name.
+     */
+    public setName(name: string): void;
+    isReadyToLoad(segment: any): any;
+    /**
+     * Starts to load segment data.
+     * @public
+     * @virtual
+     * @param {Segment} segment - Segment that wants a terrain data.
+     * @param {boolean} forceLoading
+     */
+    public loadTerrain(segment: Segment, forceLoading: boolean): void;
+    /**
+     * Creates query url.
+     * @protected
+     * @virtual
+     * @param {Segment} segment -
+     * @returns {string} -
+     */
+    protected _createUrl(segment: Segment): string;
+    /**
+     * Returns actual url query string.
+     * @protected
+     * @param {Segment} segment - Segment that loads image data.
+     * @returns {string} - Url string.
+     */
+    protected _getHTTPRequestString(segment: Segment): string;
+    /**
+     * Sets url rewrite callback, used for custom url rewriting for every tile laoding.
+     * @public
+     * @param {GlobusTerrain~_urlRewriteCallback} ur - The callback that returns tile custom created url.
+     */
+    public setUrlRewriteCallback(ur: any): void;
+    /**
+     * Converts loaded data to segment elevation data type(columr major elevation data array in meters)
+     * @public
+     * @virtual
+     * @param {*} data - Loaded elevation data.
+     * @returns {Array.<number>} -
+     */
+    public _createHeights(data: any): Array<number>;
+    /**
+     * @protected
+     * @param {Segment} segment -
+     * @param {*} data -
+     */
+    protected _applyElevationsData(segment: Segment, elevations: any): void;
+}
+import { EmptyTerrain } from "./EmptyTerrain.js";
+import { Events } from "../Events.js";
+import { Loader } from "../utils/Loader.js";

package/types/terrain/MapboxTerrain.d.ts

@@ -0,0 +1,7 @@
+export class MapboxTerrain extends GlobusTerrain {
+    constructor(name: any, options: any);
+    _imageSize: any;
+    _ctx: CanvasRenderingContext2D;
+    _createTemporalCanvas(size: any): CanvasRenderingContext2D;
+}
+import { GlobusTerrain } from "./GlobusTerrain.js";

package/types/terrain/index.d.ts

@@ -0,0 +1,5 @@
+import { EmptyTerrain } from "./EmptyTerrain";
+import { GlobusTerrain } from "./GlobusTerrain";
+import { MapboxTerrain } from "./MapboxTerrain";
+import { BilTerrain } from "./BilTerrain";
+export { EmptyTerrain, GlobusTerrain, MapboxTerrain, BilTerrain };

package/types/utils/FontAtlas.d.ts

@@ -0,0 +1,15 @@
+export class FontAtlas {
+    atlasesArr: any[];
+    atlasIndexes: {};
+    atlasIndexesDeferred: any[];
+    tokenImageSize: number;
+    samplerArr: number[];
+    _handler: any;
+    assignHandler(handler: any): void;
+    getFontIndex(face: any): any;
+    getFullIndex(face: any): any;
+    _applyFontDataToAtlas(atlas: any, data: any): void;
+    initFont(faceName: any, dataJson: any, imageBase64: any): void;
+    _createTexture(atlas: any, img: any): void;
+    loadFont(faceName: any, srcDir: any, atlasUrl: any): void;
+}

package/types/utils/GeoImageCreator.d.ts

@@ -0,0 +1,30 @@
+export class GeoImageCreator {
+    constructor(planet: any, maxFrames: any);
+    _gridSize: number;
+    _planet: any;
+    _framebuffer: Framebuffer;
+    _texCoordsBuffer: any;
+    _indexBuffer: any;
+    MAX_FRAMES: any;
+    _currentFrame: number;
+    _queue: any[];
+    _animate: any[];
+    _initialize(): void;
+    /**
+     * Creates geoImage corners coordinates grid buffer.
+     * @public
+     * @param{Array.<LonLat>} c - GeoImage corners coordinates.
+     * @return{WebGLBuffer} Grid coordinates buffer.
+     */
+    public createGridBuffer(c: Array<LonLat>, toMerc: any): WebGLBuffer;
+    frame(): void;
+    add(geoImage: any): void;
+    remove(geoImage: any): void;
+    _initBuffers(): void;
+    _framebufferMercProj: Framebuffer;
+    _quadTexCoordsBuffer: any;
+    _quadVertexBuffer: any;
+    _initShaders(): void;
+}
+import { Framebuffer } from "../webgl/Framebuffer.js";
+import { LonLat } from "../LonLat.js";

package/types/utils/ImagesCacheManager.d.ts

@@ -0,0 +1,10 @@
+export class ImagesCacheManager {
+    imagesCache: {};
+    _counter: number;
+    _pendingsQueue: QueueArray;
+    _imageIndexCounter: number;
+    load(src: any, success: any): void;
+    _exec(req: any): void;
+    _dequeueRequest(): void;
+}
+import { QueueArray } from "../QueueArray.js";

package/types/utils/Loader.d.ts

@@ -0,0 +1,25 @@
+export class Loader {
+    constructor(maxRequests?: number);
+    MAX_REQUESTS: number;
+    events: Events;
+    _loading: number;
+    _queue: any[];
+    _promises: {
+        json: (r: any) => any;
+        blob: (r: any) => any;
+        arrayBuffer: (r: any) => any;
+        imageBitmap: (r: any) => any;
+        text: (r: any) => any;
+    };
+    load(params: any, callback: any): void;
+    fetch(params: any): Promise<{
+        status: string;
+        data: any;
+    } | {
+        status: string;
+        msg: any;
+    }>;
+    _exec(): Promise<void>;
+    abort(): void;
+}
+import { Events } from "../Events.js";

package/types/utils/NormalMapCreator.d.ts

@@ -0,0 +1,39 @@
+export class NormalMapCreator {
+    constructor(planet: any, options: any);
+    _minTabelSize: any;
+    _maxTableSize: any;
+    _planet: any;
+    _handler: any;
+    _verticesBufferArray: any[];
+    _indexBufferArray: any[];
+    _positionBuffer: any;
+    _framebuffer: Framebuffer;
+    _normalMapVerticesTexture: any;
+    _width: any;
+    _height: any;
+    _queue: QueueArray;
+    _lock: Lock;
+    _init(): void;
+    _drawNormalMapBlur(segment: any): boolean;
+    _drawNormalMapNoBlur(segment: any): boolean;
+    _drawNormalMap(segment: any): boolean;
+    drawSingle(segment: any): void;
+    frame(): void;
+    queue(segment: any): void;
+    unshift(segment: any): void;
+    remove(segment: any): void;
+    clear(): void;
+    /**
+     * Set activity off
+     * @public
+     */
+    public lock(key: any): void;
+    /**
+     * Set activity on
+     * @public
+     */
+    public free(key: any): void;
+}
+import { Framebuffer } from "../webgl/Framebuffer.js";
+import { QueueArray } from "../QueueArray.js";
+import { Lock } from "../Lock.js";

package/types/utils/PlainSegmentWorker.d.ts

@@ -0,0 +1,10 @@
+export class PlainSegmentWorker {
+    constructor(numWorkers?: number);
+    _id: number;
+    _segments: {};
+    _workerQueue: Worker[];
+    _pendingQueue: any[];
+    check(): void;
+    setGeoid(geoid: any): void;
+    make(segment: any): void;
+}

package/types/utils/TerrainWorker.d.ts

@@ -0,0 +1,9 @@
+export class TerrainWorker {
+    constructor(numWorkers?: number);
+    _id: number;
+    _segments: {};
+    _workerQueue: Worker[];
+    _pendingQueue: any[];
+    check(): void;
+    make(segment: any, elevations: any): void;
+}

package/types/utils/TextureAtlas.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Texture atlas stores images in one texture. Each image has its own
+ * atlas texture coordinates.
+ * @class
+ * @param {number} [width] - Texture atlas width, if it hasn't 1024 default.
+ * @param {number} [height] - Texture atlas height, if it hasn't 1024 default..
+ */
+export class TextureAtlas {
+    constructor(width: any, height: any);
+    /**
+     * Atlas nodes where input images store. It can be access by image.__nodeIndex.
+     * @public
+     * @type {Array.<utils.TextureAtlasNode >}
+     */
+    public nodes: Array<utils.TextureAtlasNode>;
+    /**
+     * Created gl texture.
+     * @public
+     */
+    public texture: any;
+    /**
+     * Atlas canvas.
+     * @public
+     * @type {canvas}
+     */
+    public canvas: canvas;
+    _handler: any;
+    _images: any[];
+    _btree: TextureAtlasNode;
+    _imagesCacheManager: ImagesCacheManager;
+    borderSize: number;
+    /**
+     * Returns atlas javascript image object.
+     * @public
+     * @returns {Object} -
+     */
+    public getImage(): any;
+    /**
+     * Returns canvas object.
+     * @public
+     * @returns {Object} -
+     */
+    public getCanvas(): any;
+    /**
+     * Clear atlas with black.
+     * @public
+     */
+    public clearCanvas(): void;
+    /**
+     * Sets openglobus gl handler that creates gl texture.
+     * @public
+     * @param {Handler} handler - WebGL handler.
+     */
+    public assignHandler(handler: Handler): void;
+    /**
+     * Returns image diagonal size.
+     * @param {Object} image - JavaSript image object.
+     * @returns {number} -
+     */
+    getDiagonal(image: any): number;
+    /**
+     * Adds image to the atlas and returns creted node with texture coordinates of the stored image.
+     * @public
+     * @param {Object} image - Input javascript image object.
+     * @param {boolean} [fastInsert] - If it's true atlas doesnt restore all images again
+     * and store image in the curent atlas sheme.
+     * @returns {utils.TextureAtlasNode} -
+     */
+    public addImage(image: any, fastInsert?: boolean): utils.TextureAtlasNode;
+    _completeNode(nodes: any, node: any): void;
+    /**
+     * Main atlas making function.
+     * @private
+     * @param {boolean} [fastInsert] - If it's true atlas doesnt restore all images again
+     * and store image in the curent atlas sheme.
+     */
+    private _makeAtlas;
+    /**
+     * Creates atlas gl texture.
+     * @public
+     */
+    public createTexture(img: any, internalFormat: any): void;
+    /**
+     * Image handler callback.
+     * @callback Object~successCallback
+     * @param {Image} img - Loaded image.
+     */
+    /**
+     * Asynchronous function that loads and creates image to the image cache, and call success callback when it's done.
+     * @public
+     * @param {string} src - Image object src string.
+     * @param {Object~successCallback} success - The callback that handles the image loads done.
+     */
+    public loadImage(src: string, success: any): void;
+    getImageTexCoordinates(img: any): any;
+}
+/**
+ * Atlas binary tree node.
+ * @class
+ * @param {Rectangle} rect - Node image rectangle.
+ */
+export class TextureAtlasNode {
+    constructor(rect: any, texCoords: any);
+    childNodes: any[];
+    image: any;
+    rect: any;
+    texCoords: any;
+    atlas: any;
+    insert(img: any): any;
+}
+import { ImagesCacheManager } from "./ImagesCacheManager.js";

package/types/utils/VectorTileCreator.d.ts

@@ -0,0 +1,16 @@
+export class VectorTileCreator {
+    constructor(planet: any, maxFrames: any, width: any, height: any);
+    _width: any;
+    _height: any;
+    _handler: any;
+    _planet: any;
+    _framebuffer: Framebuffer;
+    MAX_FRAMES: any;
+    _currentFrame: number;
+    _queue: any[];
+    _initialize(): void;
+    frame(): void;
+    add(material: any): void;
+    remove(material: any): void;
+}
+import { Framebuffer } from "../webgl/Framebuffer.js";

package/types/utils/colorTable.d.ts

@@ -0,0 +1,143 @@
+export const colorTable: {
+    aliceblue: string;
+    antiquewhite: string;
+    aqua: string;
+    aquamarine: string;
+    azure: string;
+    beige: string;
+    bisque: string;
+    black: string;
+    blanchedalmond: string;
+    blue: string;
+    blueviolet: string;
+    brown: string;
+    burlywood: string;
+    cadetblue: string;
+    chartreuse: string;
+    chocolate: string;
+    coral: string;
+    cornflowerblue: string;
+    cornsilk: string;
+    crimson: string;
+    cyan: string;
+    darkblue: string;
+    darkcyan: string;
+    darkgoldenrod: string;
+    darkgray: string;
+    darkgreen: string;
+    darkkhaki: string;
+    darkmagenta: string;
+    darkolivegreen: string;
+    darkorange: string;
+    darkorchid: string;
+    darkred: string;
+    darksalmon: string;
+    darkseagreen: string;
+    darkslateblue: string;
+    darkslategray: string;
+    darkturquoise: string;
+    darkviolet: string;
+    deeppink: string;
+    deepskyblue: string;
+    dimgray: string;
+    dodgerblue: string;
+    firebrick: string;
+    floralwhite: string;
+    forestgreen: string;
+    fuchsia: string;
+    gainsboro: string;
+    ghostwhite: string;
+    gold: string;
+    goldenrod: string;
+    gray: string;
+    green: string;
+    greenyellow: string;
+    honeydew: string;
+    hotpink: string;
+    "indianred ": string;
+    indigo: string;
+    ivory: string;
+    khaki: string;
+    lavender: string;
+    lavenderblush: string;
+    lawngreen: string;
+    lemonchiffon: string;
+    lightblue: string;
+    lightcoral: string;
+    lightcyan: string;
+    lightgoldenrodyellow: string;
+    lightgrey: string;
+    lightgreen: string;
+    lightpink: string;
+    lightsalmon: string;
+    lightseagreen: string;
+    lightskyblue: string;
+    lightslategray: string;
+    lightsteelblue: string;
+    lightyellow: string;
+    lime: string;
+    limegreen: string;
+    linen: string;
+    magenta: string;
+    maroon: string;
+    mediumaquamarine: string;
+    mediumblue: string;
+    mediumorchid: string;
+    mediumpurple: string;
+    mediumseagreen: string;
+    mediumslateblue: string;
+    mediumspringgreen: string;
+    mediumturquoise: string;
+    mediumvioletred: string;
+    midnightblue: string;
+    mintcream: string;
+    mistyrose: string;
+    moccasin: string;
+    navajowhite: string;
+    navy: string;
+    oldlace: string;
+    olive: string;
+    olivedrab: string;
+    orange: string;
+    orangered: string;
+    orchid: string;
+    palegoldenrod: string;
+    palegreen: string;
+    paleturquoise: string;
+    palevioletred: string;
+    papayawhip: string;
+    peachpuff: string;
+    peru: string;
+    pink: string;
+    plum: string;
+    powderblue: string;
+    purple: string;
+    rebeccapurple: string;
+    red: string;
+    rosybrown: string;
+    royalblue: string;
+    saddlebrown: string;
+    salmon: string;
+    sandybrown: string;
+    seagreen: string;
+    seashell: string;
+    sienna: string;
+    silver: string;
+    skyblue: string;
+    slateblue: string;
+    slategray: string;
+    snow: string;
+    springgreen: string;
+    steelblue: string;
+    tan: string;
+    teal: string;
+    thistle: string;
+    tomato: string;
+    turquoise: string;
+    violet: string;
+    wheat: string;
+    white: string;
+    whitesmoke: string;
+    yellow: string;
+    yellowgreen: string;
+};

package/types/utils/earcut.d.ts

@@ -0,0 +1,6 @@
+export function earcut(data: any, holeIndices: any, dim: any): any[];
+export function flatten(data: any): {
+    vertices: any[];
+    holes: any[];
+    dimensions: any;
+};