@openglobus/og 0.24.2 → 0.25.1

package/lib/js/utils/FontAtlas.js

@@ -1,220 +0,0 @@
-import { Deferred } from '../Deferred';
-import { Rectangle } from '../Rectangle';
-import { TextureAtlas, TextureAtlasNode } from './TextureAtlas';
-//@todo: get the value from shader module
-const MAX_SIZE = 11;
-class FontTextureAtlas extends TextureAtlas {
-    constructor(width, height) {
-        super(width, height);
-        this.width = 0;
-        this.height = 0;
-        this.gliphSize = 0;
-        this.distanceRange = 0;
-        this.nodes = new Map();
-        this.kernings = {};
-    }
-    get(key) {
-        return this.nodes.get(key);
-    }
-}
-class FontTextureAtlasNode extends TextureAtlasNode {
-    constructor(rect, texCoords) {
-        super(rect, texCoords);
-        this.emptySize = 1;
-        this.metrics = {
-            id: 0,
-            char: "",
-            width: 0,
-            height: 0,
-            x: 0,
-            y: 0,
-            chnl: 0,
-            index: 0,
-            page: 0,
-            xadvance: 0,
-            xoffset: 0,
-            yoffset: 0,
-            nChar: "",
-            nCode: 0,
-            nWidth: 0,
-            nHeight: 0,
-            nAdvance: 0,
-            nXOffset: 0,
-            nYOffset: 0
-        };
-    }
-}
-class FontAtlas {
-    constructor(catalogSrc) {
-        this.atlasesArr = [];
-        this.atlasIndexes = {};
-        this.atlasIndexesDeferred = {};
-        this.tokenImageSize = 64;
-        this.samplerArr = new Uint32Array(MAX_SIZE);
-        this.sdfParamsArr = new Float32Array(MAX_SIZE * 4);
-        this._handler = null;
-        this.catalogSrc = catalogSrc || "./";
-    }
-    assignHandler(handler) {
-        this._handler = handler;
-    }
-    getFontIndex(face) {
-        let fullName = this.getFullIndex(face);
-        // Try to load font from the directory
-        if (!this.atlasIndexes[fullName]) {
-            this.loadFont(face, this.catalogSrc, `${face}.json`);
-        }
-        if (!this.atlasIndexesDeferred[fullName]) {
-            this.atlasIndexesDeferred[fullName] = new Deferred();
-        }
-        return this.atlasIndexesDeferred[fullName].promise;
-    }
-    getFullIndex(face) {
-        return face.trim().toLowerCase();
-    }
-    _applyFontDataToAtlas(atlas, data, index = 0) {
-        let chars = data.chars;
-        atlas.height = data.common.scaleH;
-        atlas.width = data.common.scaleW;
-        atlas.gliphSize = data.info.size;
-        atlas.distanceRange = data.distanceField.distanceRange;
-        let w = atlas.width, h = atlas.height, s = atlas.gliphSize;
-        this.sdfParamsArr[index * 4] = w;
-        this.sdfParamsArr[index * 4 + 1] = h;
-        this.sdfParamsArr[index * 4 + 2] = s;
-        this.sdfParamsArr[index * 4 + 3] = atlas.distanceRange;
-        let idToChar = {};
-        for (let i = 0; i < chars.length; i++) {
-            let ci = chars[i];
-            let ti = ci.char;
-            idToChar[ci.id] = ti;
-            let r = new Rectangle(ci.x, ci.y, ci.x + ci.width, ci.y + ci.height);
-            let tc = new Array(12);
-            tc[0] = r.left / w;
-            tc[1] = r.top / h;
-            tc[2] = r.left / w;
-            tc[3] = r.bottom / h;
-            tc[4] = r.right / w;
-            tc[5] = r.bottom / h;
-            tc[6] = r.right / w;
-            tc[7] = r.bottom / h;
-            tc[8] = r.right / w;
-            tc[9] = r.top / h;
-            tc[10] = r.left / w;
-            tc[11] = r.top / h;
-            let taNode = new FontTextureAtlasNode(r, tc);
-            let ciNorm = ci.char.normalize('NFKC');
-            let ciCode = ciNorm.charCodeAt(0);
-            //taNode.metrics = ci;
-            let m = taNode.metrics;
-            m.id = ci.id;
-            m.char = ci.char;
-            m.width = ci.width;
-            m.height = ci.height;
-            m.x = ci.x;
-            m.y = ci.y;
-            m.chnl = ci.chnl;
-            m.index = ci.index;
-            m.page = ci.page;
-            m.xadvance = ci.xadvance;
-            m.xoffset = ci.xoffset;
-            m.yoffset = ci.yoffset;
-            m.nChar = ciNorm;
-            m.nCode = ciCode;
-            m.nWidth = taNode.metrics.width / s;
-            m.nHeight = taNode.metrics.height / s;
-            m.nAdvance = taNode.metrics.xadvance / s;
-            m.nXOffset = taNode.metrics.xoffset / s;
-            m.nYOffset = 1.0 - taNode.metrics.yoffset / s;
-            taNode.emptySize = 1;
-            atlas.nodes.set(ciNorm.charCodeAt(0), taNode);
-        }
-        atlas.kernings = {};
-        for (let i = 0; i < data.kernings.length; i++) {
-            let ki = data.kernings[i];
-            let first = ki.first, second = ki.second;
-            //let charFirst = idToChar[first],
-            //    charSecond = idToChar[second];
-            // if (!atlas.kernings[charFirst]) {
-            //     atlas.kernings[charFirst] = {};
-            // }
-            //
-            // atlas.kernings[charFirst][charSecond] = ki.amount / s;
-            if (!atlas.kernings[first]) {
-                atlas.kernings[first] = {};
-            }
-            atlas.kernings[first][second] = ki.amount / s;
-        }
-    }
-    initFont(faceName, dataJson, imageBase64) {
-        let index = this.atlasesArr.length;
-        let fullName = this.getFullIndex(faceName);
-        this.atlasIndexes[fullName] = index;
-        let def = this.atlasIndexesDeferred[fullName];
-        if (!def) {
-            def = this.atlasIndexesDeferred[fullName] = new Deferred();
-        }
-        this.samplerArr[this.atlasesArr.length] = index;
-        // TODO: FontTextureAtlas();
-        let atlas = new FontTextureAtlas();
-        atlas.height = 0;
-        atlas.width = 0;
-        atlas.gliphSize = 0;
-        atlas.distanceRange = 0;
-        atlas.kernings = {};
-        atlas.assignHandler(this._handler);
-        this.atlasesArr[index] = atlas;
-        this._applyFontDataToAtlas(atlas, dataJson, index);
-        let img = new Image();
-        img.onload = () => {
-            this._createTexture(atlas, img);
-            def.resolve(index);
-        };
-        img.src = imageBase64;
-    }
-    _createTexture(atlas, img) {
-        atlas.createTexture(img);
-    }
-    loadFont(faceName, srcDir, atlasUrl) {
-        let index = this.atlasesArr.length;
-        let fullName = this.getFullIndex(faceName);
-        this.atlasIndexes[fullName] = index;
-        let def = this.atlasIndexesDeferred[fullName];
-        if (!def) {
-            def = this.atlasIndexesDeferred[fullName] = new Deferred();
-        }
-        this.samplerArr[this.atlasesArr.length] = index;
-        // TODO: FontTextureAtlas();
-        let atlas = new FontTextureAtlas();
-        atlas.height = 0;
-        atlas.width = 0;
-        atlas.gliphSize = 0;
-        atlas.distanceRange = 0;
-        atlas.kernings = {};
-        atlas.assignHandler(this._handler);
-        this.atlasesArr[index] = atlas;
-        fetch(`${srcDir}/${atlasUrl}`)
-            .then((response) => {
-            if (!response.ok) {
-                throw Error(`Unable to load "${srcDir}/${atlasUrl}"`);
-            }
-            //return response.json(response);
-            return response.json();
-        })
-            .then((data) => {
-            this._applyFontDataToAtlas(atlas, data, index);
-            let img = new Image();
-            img.onload = () => {
-                this._createTexture(atlas, img);
-                def.resolve(index);
-            };
-            img.src = `${srcDir}/${data.pages[0]}`;
-            img.crossOrigin = "Anonymous";
-        })
-            .catch(err => {
-            def.reject();
-            return { 'status': "error", 'msg': err.toString() };
-        });
-    }
-}
-export { FontAtlas };

package/lib/js/utils/GeoImageCreator.d.ts

@@ -1,34 +0,0 @@
-import { BaseGeoImage } from "../layer/BaseGeoImage";
-import { Framebuffer } from '../webgl/Framebuffer';
-import { LonLat } from '../LonLat';
-import { Planet } from "../scene/Planet";
-import type { WebGLBufferExt, WebGLTextureExt } from "../webgl/Handler";
-export declare class GeoImageCreator {
-    MAX_FRAMES: number;
-    protected _gridSize: number;
-    protected _planet: Planet;
-    _framebuffer: Framebuffer | null;
-    protected _framebufferMercProj: Framebuffer | null;
-    _texCoordsBuffer: WebGLBufferExt | null;
-    _indexBuffer: WebGLBufferExt | null;
-    protected _currentFrame: number;
-    protected _queue: BaseGeoImage[];
-    protected _animate: BaseGeoImage[];
-    protected _quadTexCoordsBuffer: WebGLBufferExt | null;
-    protected _quadVertexBuffer: WebGLTextureExt | null;
-    constructor(planet: Planet, maxFrames?: number);
-    init(): void;
-    /**
-     * Creates geoImage corners coordinates grid buffer.
-     * @public
-     * @param{Array.<LonLat>} c - GeoImage corners coordinates.
-     * @param{boolean} [toMerc=false] - Transform to web mercator.
-     * @return{WebGLBuffer} Grid coordinates buffer.
-     */
-    createGridBuffer(c: LonLat[], toMerc?: boolean): [WebGLBufferExt, WebGLBufferExt];
-    frame(): void;
-    add(geoImage: BaseGeoImage): void;
-    remove(geoImage: BaseGeoImage): void;
-    protected _initBuffers(): void;
-    protected _initShaders(): void;
-}

package/lib/js/utils/GeoImageCreator.js

@@ -1,163 +0,0 @@
-import * as utils from '../utils/shared';
-import { Framebuffer } from '../webgl/Framebuffer';
-import { LonLat } from '../LonLat';
-import { Program } from '../webgl/Program';
-import { doubleToTwoFloats2 } from "../math/coder";
-export class GeoImageCreator {
-    constructor(planet, maxFrames = 5) {
-        this.MAX_FRAMES = maxFrames;
-        this._gridSize = 64;
-        this._planet = planet;
-        this._framebuffer = null;
-        this._framebufferMercProj = null;
-        this._texCoordsBuffer = null;
-        this._indexBuffer = null;
-        this._currentFrame = 0;
-        this._queue = [];
-        this._animate = [];
-        this._quadTexCoordsBuffer = null;
-        this._quadVertexBuffer = null;
-    }
-    init() {
-        this._initShaders();
-        this._initBuffers();
-    }
-    /**
-     * Creates geoImage corners coordinates grid buffer.
-     * @public
-     * @param{Array.<LonLat>} c - GeoImage corners coordinates.
-     * @param{boolean} [toMerc=false] - Transform to web mercator.
-     * @return{WebGLBuffer} Grid coordinates buffer.
-     */
-    createGridBuffer(c, toMerc = false) {
-        let gs = this._gridSize;
-        let v03 = new LonLat((c[3].lon - c[0].lon) / gs, (c[3].lat - c[0].lat) / gs), v12 = new LonLat((c[2].lon - c[1].lon) / gs, (c[2].lat - c[1].lat) / gs), v01 = new LonLat((c[1].lon - c[0].lon) / gs, (c[1].lat - c[0].lat) / gs), v32 = new LonLat((c[2].lon - c[3].lon) / gs, (c[2].lat - c[3].lat) / gs);
-        const size = (gs + 1) * (gs + 1) * 2, halfSize = size / 2;
-        let gridHigh = new Float32Array(size), gridLow = new Float32Array(size);
-        let lonLatArr = new Array(halfSize);
-        let kh = 0, kl = 0, k = 0;
-        let tempArr = new Float32Array(2);
-        for (let i = 0; i <= gs; i++) {
-            let P03i = new LonLat(c[0].lon + i * v03.lon, c[0].lat + i * v03.lat), P12i = new LonLat(c[1].lon + i * v12.lon, c[1].lat + i * v12.lat);
-            for (let j = 0; j <= gs; j++) {
-                let P01j = new LonLat(c[0].lon + j * v01.lon, c[0].lat + j * v01.lat), P32j = new LonLat(c[3].lon + j * v32.lon, c[3].lat + j * v32.lat);
-                let xx = utils.getLinesIntersectionLonLat(P03i, P12i, P01j, P32j);
-                doubleToTwoFloats2(xx.lon, tempArr);
-                gridHigh[kh++] = tempArr[0];
-                gridLow[kl++] = tempArr[1];
-                doubleToTwoFloats2(xx.lat, tempArr);
-                gridHigh[kh++] = tempArr[0];
-                gridLow[kl++] = tempArr[1];
-                lonLatArr[k++] = xx;
-            }
-        }
-        if (toMerc) {
-            for (let i = 0; i < halfSize; i++) {
-                let c = lonLatArr[i].forwardMercator();
-                doubleToTwoFloats2(c.lon, tempArr);
-                gridHigh[i * 2] = tempArr[0];
-                gridLow[i * 2] = tempArr[1];
-                doubleToTwoFloats2(c.lat, tempArr);
-                gridHigh[i * 2 + 1] = tempArr[0];
-                gridLow[i * 2 + 1] = tempArr[1];
-            }
-        }
-        return [
-            this._planet.renderer.handler.createArrayBuffer(gridHigh, 2, halfSize),
-            this._planet.renderer.handler.createArrayBuffer(gridLow, 2, halfSize)
-        ];
-    }
-    frame() {
-        let i = this.MAX_FRAMES;
-        while (i-- && this._queue.length) {
-            const q = this._queue.shift();
-            q._isRendering = false;
-            q.rendering();
-            q.events.dispatch(q.events.loadend);
-        }
-        i = this._animate.length;
-        while (i--) {
-            this._animate[i].rendering();
-        }
-    }
-    add(geoImage) {
-        if (!geoImage._isRendering) {
-            geoImage._isRendering = true;
-            if (geoImage._animate) {
-                this._animate.push(geoImage);
-            }
-            else {
-                this._queue.push(geoImage);
-            }
-        }
-    }
-    remove(geoImage) {
-        if (geoImage._isRendering) {
-            geoImage._creationProceeding = false;
-            geoImage._isRendering = false;
-            let arr;
-            if (geoImage._animate) {
-                arr = this._animate;
-            }
-            else {
-                arr = this._queue;
-            }
-            for (let i = 0; i < arr.length; i++) {
-                if (arr[i].isEqual(geoImage)) {
-                    arr.splice(i, 1);
-                    return;
-                }
-            }
-        }
-    }
-    _initBuffers() {
-        let h = this._planet.renderer.handler;
-        this._framebuffer = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
-        this._framebuffer.init();
-        this._framebufferMercProj = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
-        this._framebufferMercProj.init();
-        let gs = Math.log2(this._gridSize);
-        this._texCoordsBuffer = this._planet._textureCoordsBufferCache[gs];
-        this._indexBuffer = this._planet._indexesCache[gs][gs][gs][gs][gs].buffer;
-        this._quadTexCoordsBuffer = h.createArrayBuffer(new Float32Array([0, 1, 1, 1, 0, 0, 1, 0]), 2, 4);
-        this._quadVertexBuffer = h.createArrayBuffer(new Float32Array([-1, 1, 1, 1, -1, -1, 1, -1]), 2, 4);
-    }
-    _initShaders() {
-        this._planet.renderer.handler.addProgram(new Program("geoImageTransform", {
-            uniforms: {
-                sourceTexture: "sampler2d",
-                extentParamsHigh: "vec4",
-                extentParamsLow: "vec4",
-                isFullExtent: "bool"
-            },
-            attributes: {
-                cornersHigh: "vec2",
-                cornersLow: "vec2",
-                texCoords: "vec2"
-            },
-            vertexShader: `attribute vec2 cornersHigh; 
-                     attribute vec2 cornersLow;
-                      attribute vec2 texCoords; 
-                      uniform vec4 extentParamsHigh; 
-                      uniform vec4 extentParamsLow; 
-                      varying vec2 v_texCoords;
-                      void main() {                                                             
-                          v_texCoords = texCoords; 
-                          vec2 highDiff = cornersHigh - extentParamsHigh.xy;
-                          vec2 lowDiff = cornersLow - extentParamsLow.xy;                                        
-                          gl_Position = vec4((-1.0 + (highDiff * step(1.0, length(highDiff)) + lowDiff) * extentParamsHigh.zw) * vec2(1.0, -1.0), 0.0, 1.0); 
-                      }`,
-            fragmentShader: `precision highp float;
-                        uniform sampler2D sourceTexture;
-                        uniform bool isFullExtent;
-                        varying vec2 v_texCoords;
-                        void main () {
-                            if(!isFullExtent && (v_texCoords.x <= 0.001 || v_texCoords.x >= 0.999 ||
-                                v_texCoords.y <= 0.001 || v_texCoords.y >= 0.999)) {
-                                discard;
-                            }
-                            gl_FragColor = texture2D(sourceTexture, v_texCoords);
-                        }`
-        }));
-    }
-}

package/lib/js/utils/ImagesCacheManager.d.ts

@@ -1,22 +0,0 @@
-import { QueueArray } from '../QueueArray';
-export type HTMLImageElementExt = HTMLImageElement & {
-    __nodeIndex?: number;
-    atlasWidth?: number;
-    atlasHeight?: number;
-};
-export type ImagesCacheManagerCallback = (image: HTMLImageElementExt) => void;
-interface IImagesCacheRequest {
-    "src": string;
-    "success": ImagesCacheManagerCallback;
-}
-declare class ImagesCacheManager {
-    imagesCache: Record<string, HTMLImageElementExt>;
-    protected _counter: number;
-    protected _pendingsQueue: QueueArray<IImagesCacheRequest>;
-    protected _imageIndexCounter: number;
-    constructor();
-    load(src: string, success: ImagesCacheManagerCallback): void;
-    protected _exec(req: IImagesCacheRequest): void;
-    protected _dequeueRequest(): void;
-}
-export { ImagesCacheManager };

package/lib/js/utils/ImagesCacheManager.js

@@ -1,63 +0,0 @@
-import { QueueArray } from '../QueueArray';
-class ImagesCacheManager {
-    constructor() {
-        this.imagesCache = {};
-        this._counter = 0;
-        this._pendingsQueue = new QueueArray();
-        this._imageIndexCounter = 0;
-    }
-    load(src, success) {
-        if (this.imagesCache[src]) {
-            success(this.imagesCache[src]);
-        }
-        else {
-            let req = { "src": src, "success": success };
-            if (this._counter >= 1) {
-                this._pendingsQueue.unshift(req);
-            }
-            else {
-                this._exec(req);
-            }
-        }
-    }
-    _exec(req) {
-        this._counter++;
-        const that = this;
-        let img = new Image();
-        img.crossOrigin = '';
-        img.onload = function () {
-            that.imagesCache[req.src] = img;
-            img.__nodeIndex = that._imageIndexCounter++;
-            req.success(img);
-            that._dequeueRequest();
-        };
-        img.onerror = function () {
-            that._dequeueRequest();
-        };
-        img.src = req.src;
-    }
-    _dequeueRequest() {
-        this._counter--;
-        if (this._pendingsQueue.length && this._counter < 1) {
-            while (this._pendingsQueue.length) {
-                let req = this._pendingsQueue.pop();
-                if (req) {
-                    if (this.imagesCache[req.src]) {
-                        if (this._counter <= 0) {
-                            this._counter = 0;
-                        }
-                        else {
-                            this._counter--;
-                        }
-                        req.success(this.imagesCache[req.src]);
-                    }
-                    else {
-                        this._exec(req);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-}
-export { ImagesCacheManager };

package/lib/js/utils/Loader.d.ts

@@ -1,63 +0,0 @@
-import type { EventsHandler } from '../Events';
-import { Planet } from "../scene/Planet";
-import { Segment } from "../segment/Segment";
-type LoaderEventsList = ["loadend", "layerloadend"];
-export interface IResponse {
-    status: string;
-    data?: any;
-    msg?: string;
-}
-type IResponseCallback = (response: IResponse) => void;
-interface Obj<T> {
-    __id: number;
-    isIdle: boolean;
-    isEqual: (obj: T) => boolean;
-    events: EventsHandler<any>;
-    _planet: Planet | null;
-}
-type QueryParams<T> = {
-    sender?: T;
-    src: string;
-    type: string;
-    filter?: (val: QueryParams<T>) => boolean;
-    options?: any;
-    segment?: Segment;
-};
-type QueueData<T> = {
-    params: QueryParams<T>;
-    callback: IResponseCallback;
-};
-type RequestCounter<T> = {
-    sender: T;
-    counter: number;
-    __requestCounterFrame__: number;
-};
-export declare class Loader<T extends Obj<T>> {
-    MAX_REQUESTS: number;
-    events: EventsHandler<LoaderEventsList>;
-    protected _loading: number;
-    protected _queue: QueueData<T>[];
-    protected _senderRequestCounter: RequestCounter<T>[];
-    protected _promises: {
-        [key: string]: (r: Response) => Promise<any>;
-    };
-    constructor(maxRequests?: number);
-    load(params: QueryParams<T>, callback: IResponseCallback): void;
-    fetch(params: QueryParams<T>): Promise<{
-        status: string;
-        data: any;
-    } | {
-        status: string;
-        msg: string;
-    }>;
-    getRequestCounter(sender: T): number;
-    isIdle(sender: T): boolean;
-    protected _checkLoadend(request: RequestCounter<T>, sender: T): void;
-    protected _handleResponse(q: QueueData<T>, response: IResponse): void;
-    protected _exec(): Promise<void> | undefined;
-    abort(sender: T): void;
-    abortAll(): void;
-    get loading(): number;
-    get queue(): QueueData<T>[];
-}
-export {};