@openglobus/og 0.18.0 → 0.18.1

package/{src/utils/ImagesCacheManager.ts → lib/js/utils/ImagesCacheManager.js}

@@ -1,49 +1,29 @@
-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;
-}
-
+import { QueueArray } from '../QueueArray';
 class ImagesCacheManager {
-
-    public imagesCache: Record<string, HTMLImageElementExt>;
-
-    protected _counter: number;
-    protected _pendingsQueue: QueueArray<IImagesCacheRequest>;
-    protected _imageIndexCounter: number;
-
     constructor() {
         this.imagesCache = {};
-
         this._counter = 0;
-        this._pendingsQueue = new QueueArray<IImagesCacheRequest>();
+        this._pendingsQueue = new QueueArray();
         this._imageIndexCounter = 0;
     }
-
-    public load(src: string, success: ImagesCacheManagerCallback) {
+    load(src, success) {
         if (this.imagesCache[src]) {
             success(this.imagesCache[src]);
-        } else {
-            let req = {"src": src, "success": success};
+        }
+        else {
+            let req = { "src": src, "success": success };
             if (this._counter >= 1) {
                 this._pendingsQueue.unshift(req);
-            } else {
+            }
+            else {
                 this._exec(req);
             }
         }
     }
-
-    protected _exec(req: IImagesCacheRequest) {
+    _exec(req) {
         this._counter++;
         const that = this;
-
-        let img: HTMLImageElementExt = new Image();
+        let img = new Image();
         img.crossOrigin = '';
         img.onload = function () {
             that.imagesCache[req.src] = img;
@@ -51,15 +31,12 @@ class ImagesCacheManager {
             req.success(img);
             that._dequeueRequest();
         };
-
         img.onerror = function () {
             that._dequeueRequest();
         };
-
         img.src = req.src;
     }
-
-    protected _dequeueRequest() {
+    _dequeueRequest() {
         this._counter--;
         if (this._pendingsQueue.length && this._counter < 1) {
             while (this._pendingsQueue.length) {
@@ -68,11 +45,13 @@ class ImagesCacheManager {
                     if (this.imagesCache[req.src]) {
                         if (this._counter <= 0) {
                             this._counter = 0;
-                        } else {
+                        }
+                        else {
                             this._counter--;
                         }
                         req.success(this.imagesCache[req.src]);
-                    } else {
+                    }
+                    else {
                         this._exec(req);
                         break;
                     }
@@ -81,5 +60,4 @@ class ImagesCacheManager {
         }
     }
 }
-
-export {ImagesCacheManager};
+export { ImagesCacheManager };

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

@@ -0,0 +1,63 @@
+import { 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 {};

package/lib/js/utils/Loader.js

@@ -0,0 +1,156 @@
+import { createEvents } from '../Events';
+const LOADER_EVENTS = ["loadend", "layerloadend"];
+export class Loader {
+    constructor(maxRequests = 24) {
+        this.MAX_REQUESTS = maxRequests;
+        this.events = createEvents(LOADER_EVENTS);
+        this._loading = 0;
+        this._queue = []; //new QueueArray();
+        this._senderRequestCounter = [];
+        this._promises = {
+            'json': r => r.json(),
+            'blob': r => r.blob(),
+            'arrayBuffer': r => r.arrayBuffer(),
+            'imageBitmap': r => r.blob().then((r) => createImageBitmap(r, {
+                premultiplyAlpha: "premultiply"
+            })),
+            'text': r => r.text()
+        };
+    }
+    load(params, callback) {
+        if (params.sender) {
+            if (!this._senderRequestCounter[params.sender.__id]) {
+                this._senderRequestCounter[params.sender.__id] = {
+                    sender: params.sender, counter: 0, __requestCounterFrame__: 0
+                };
+            }
+            this._senderRequestCounter[params.sender.__id].counter++;
+        }
+        this._queue.push({ params, callback });
+        this._exec();
+    }
+    fetch(params) {
+        return fetch(params.src, params.options || {})
+            .then((response) => {
+            if (!response.ok) {
+                throw Error(`Unable to load '${params.src}'`);
+            }
+            return this._promises[params.type || "blob"](response);
+        })
+            .then((data) => {
+            return { status: "ready", data: data };
+        })
+            .catch((err) => {
+            return { status: "error", msg: err.toString() };
+        });
+    }
+    getRequestCounter(sender) {
+        if (sender) {
+            let r = this._senderRequestCounter[sender.__id];
+            if (r) {
+                return r.counter;
+            }
+        }
+        return 0;
+    }
+    isIdle(sender) {
+        return sender.isIdle;
+    }
+    _checkLoadend(request, sender) {
+        if (request.counter === 0 && (!sender._planet || sender._planet._terrainCompletedActivated)) {
+            sender.events.dispatch(sender.events.loadend, sender);
+            this.events.dispatch(this.events.layerloadend, sender);
+            request.__requestCounterFrame__ = 0;
+        }
+        else {
+            request.__requestCounterFrame__ = requestAnimationFrame(() => {
+                this._checkLoadend(request, sender);
+            });
+        }
+    }
+    _handleResponse(q, response) {
+        q.callback(response);
+        let sender = q.params.sender;
+        if (sender && (sender.events.loadend.handlers.length || this.events.layerloadend.handlers.length)) {
+            let request = this._senderRequestCounter[sender.__id];
+            if (request && request.counter > 0) {
+                request.counter--;
+                cancelAnimationFrame(request.__requestCounterFrame__);
+                request.__requestCounterFrame__ = requestAnimationFrame(() => {
+                    this._checkLoadend(request, sender);
+                });
+            }
+        }
+        this._exec();
+    }
+    _exec() {
+        if (this._queue.length > 0 && this._loading < this.MAX_REQUESTS) {
+            let q = this._queue.pop();
+            if (!q)
+                return;
+            let p = q.params;
+            if (!p.filter || p.filter(p)) {
+                this._loading++;
+                return fetch(p.src, p.options || {})
+                    .then((response) => {
+                    if (!response.ok) {
+                        throw Error(`Unable to load '${p.src}'`);
+                    }
+                    return this._promises[p.type || "blob"](response);
+                })
+                    .then((data) => {
+                    this._loading--;
+                    this._handleResponse(q, { status: "ready", data: data });
+                })
+                    .catch((err) => {
+                    this._loading--;
+                    this._handleResponse(q, { status: "error", msg: err.toString() });
+                });
+            }
+            else {
+                this._handleResponse(q, { status: "abort" });
+            }
+        }
+        else if (this._loading === 0) {
+            this.events.dispatch(this.events.loadend);
+        }
+    }
+    abort(sender) {
+        if (this._senderRequestCounter[sender.__id]) {
+            this._senderRequestCounter[sender.__id].counter = 0;
+            cancelAnimationFrame(this._senderRequestCounter[sender.__id].__requestCounterFrame__);
+            this._senderRequestCounter[sender.__id].__requestCounterFrame__ = 0;
+        }
+        for (let i = 0, len = this._queue.length; i < len; i++) {
+            let qi = this._queue[i];
+            if (qi && qi.params.sender && sender.isEqual(qi.params.sender)) {
+                qi.callback({ 'status': "abort" });
+                //@ts-ignore
+                this._queue[i] = null;
+            }
+        }
+    }
+    abortAll() {
+        for (let i = 0, len = this._queue.length; i < len; i++) {
+            let qi = this._queue[i];
+            if (qi) {
+                let sender = qi.params.sender;
+                if (sender && this._senderRequestCounter[sender.__id]) {
+                    this._senderRequestCounter[sender.__id].counter = 0;
+                    cancelAnimationFrame(this._senderRequestCounter[sender.__id].__requestCounterFrame__);
+                    this._senderRequestCounter[sender.__id].__requestCounterFrame__ = 0;
+                }
+                qi.callback({ 'status': "abort" });
+                //@ts-ignore
+                this._queue[i] = null;
+            }
+        }
+        this._queue = [];
+    }
+    get loading() {
+        return this._loading;
+    }
+    get queue() {
+        return this._queue;
+    }
+}

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

@@ -0,0 +1,52 @@
+import { Framebuffer } from "../webgl/Framebuffer";
+import { Lock, Key } from "../Lock";
+import { Planet } from "../scene/Planet";
+import { QueueArray } from "../QueueArray";
+import { Segment } from "../segment/Segment";
+import { WebGLBufferExt, WebGLTextureExt, Handler } from "../webgl/Handler";
+interface INormalMapCreatorParams {
+    minTableSize?: number;
+    maxTableSize?: number;
+    width?: number;
+    height?: number;
+}
+export declare class NormalMapCreator {
+    protected _minTabelSize: number;
+    protected _maxTableSize: number;
+    protected _planet: Planet;
+    protected _handler: Handler | null;
+    protected _verticesBufferArray: WebGLBufferExt[];
+    protected _indexBufferArray: WebGLBufferExt[];
+    protected _positionBuffer: WebGLBufferExt | null;
+    protected _framebuffer: Framebuffer | null;
+    protected _normalMapVerticesTexture: WebGLTextureExt | null;
+    protected _width: number;
+    protected _height: number;
+    protected _queue: QueueArray<Segment>;
+    protected _lock: Lock;
+    constructor(planet: Planet, options?: INormalMapCreatorParams);
+    get width(): number;
+    get height(): number;
+    init(): void;
+    protected _drawNormalMapBlur(segment: Segment): boolean;
+    protected _drawNormalMapNoBlur(segment: Segment): boolean;
+    protected _drawNormalMap(segment: Segment): boolean;
+    drawSingle(segment: Segment): void;
+    frame(): void;
+    get queueSize(): number;
+    queue(segment: Segment): void;
+    unshift(segment: Segment): void;
+    remove(segment: Segment): void;
+    clear(): void;
+    /**
+     * Set activity off
+     * @public
+     */
+    lock(key: Key): void;
+    /**
+     * Set activity on
+     * @public
+     */
+    free(key: Key): void;
+}
+export {};