@openglobus/og 0.17.2 → 0.18.1

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 {};

package/lib/js/utils/NormalMapCreator.js

@@ -0,0 +1,310 @@
+import * as quadTree from "../quadTree/quadTree";
+import { Framebuffer } from "../webgl/Framebuffer";
+import { Lock } from "../Lock";
+import { Program } from "../webgl/Program";
+import { QueueArray } from "../QueueArray";
+export class NormalMapCreator {
+    constructor(planet, options = {}) {
+        this._minTabelSize = options.minTableSize || 1;
+        this._maxTableSize = options.maxTableSize || 8;
+        this._planet = planet;
+        this._handler = null;
+        this._verticesBufferArray = [];
+        this._indexBufferArray = [];
+        this._positionBuffer = null;
+        this._framebuffer = null;
+        this._normalMapVerticesTexture = null;
+        this._width = options.width || 128;
+        this._height = options.height || 128;
+        this._queue = new QueueArray(1024);
+        this._lock = new Lock();
+    }
+    get width() {
+        return this._width;
+    }
+    get height() {
+        return this._height;
+    }
+    init() {
+        this._maxTableSize = this._planet.maxGridSize || 8;
+        this._handler = this._planet.renderer.handler;
+        let isWebkit = false; //('WebkitAppearance' in document.documentElement.style) && !/^((?!chrome).)*safari/i.test(navigator.userAgent);
+        /*==================================================================================
+         * http://www.sunsetlakesoftware.com/2013/10/21/optimizing-gaussian-blurs-mobile-gpu
+         *=================================================================================*/
+        const normalMapBlur = new Program("normalMapBlur", {
+            attributes: {
+                a_position: "vec2"
+            },
+            uniforms: {
+                s_texture: "sampler2d"
+            },
+            vertexShader: `attribute vec2 a_position;
+                       attribute vec2 a_texCoord;
+
+                      varying vec2 blurCoordinates[5];
+
+                      void main() {
+                          vec2 vt = a_position * 0.5 + 0.5; 
+                          ${isWebkit ? "vt.y = 1.0 - vt.y; " : " "}
+                          gl_Position = vec4(a_position, 0.0, 1.0);
+                          blurCoordinates[0] = vt;
+                          blurCoordinates[1] = vt + ${(1.0 / this._width) * 1.407333};
+                          blurCoordinates[2] = vt - ${(1.0 / this._height) * 1.407333};
+                          blurCoordinates[3] = vt + ${(1.0 / this._width) * 3.294215};
+                          blurCoordinates[4] = vt - ${(1.0 / this._height) * 3.294215};
+                }`,
+            fragmentShader: `precision lowp float;
+                        uniform sampler2D s_texture;                        
+                        varying vec2 blurCoordinates[5];                        
+
+                        void main() {
+                            lowp vec4 sum = vec4(0.0);
+                            //if(blurCoordinates[0].x <= 0.01 || blurCoordinates[0].x >= 0.99 ||
+                            //    blurCoordinates[0].y <= 0.01 || blurCoordinates[0].y >= 0.99){
+                            //    sum = texture2D(s_texture, blurCoordinates[0]);
+                            //} else {
+                                sum += texture2D(s_texture, blurCoordinates[0]) * 0.204164;
+                                sum += texture2D(s_texture, blurCoordinates[1]) * 0.304005;
+                                sum += texture2D(s_texture, blurCoordinates[2]) * 0.304005;
+                                sum += texture2D(s_texture, blurCoordinates[3]) * 0.093913;
+                                sum += texture2D(s_texture, blurCoordinates[4]) * 0.093913;
+                            //}
+                            gl_FragColor = sum;
+                        }`
+        });
+        const normalMap = new Program("normalMap", {
+            attributes: {
+                a_position: "vec2",
+                a_normal: "vec3"
+            },
+            uniforms: {},
+            vertexShader: `attribute vec2 a_position;
+                      attribute vec3 a_normal;
+                      
+                      varying vec3 v_color;
+                      
+                      void main() {
+                          gl_Position = vec4(a_position, 0, 1);
+                          v_color = normalize(a_normal) * 0.5 + 0.5;
+                      }`,
+            fragmentShader: `precision highp float;
+                        
+                        varying vec3 v_color;
+                        
+                        void main () {
+                            gl_FragColor = vec4(v_color, 1.0);
+                        }`
+        });
+        this._handler.addProgram(normalMapBlur);
+        this._handler.addProgram(normalMap);
+        //create hidden handler buffer
+        this._framebuffer = new Framebuffer(this._handler, {
+            width: this._width,
+            height: this._height,
+            useDepth: false
+        });
+        this._framebuffer.init();
+        this._normalMapVerticesTexture = this._handler.createEmptyTexture_l(this._width, this._height);
+        //create vertices hasharray for different grid size segments from 2^4(16) to 2^7(128)
+        for (let p = this._minTabelSize; p <= this._maxTableSize; p++) {
+            const gs = Math.pow(2, p);
+            const gs2 = gs / 2;
+            let vertices = new Float32Array((gs + 1) * (gs + 1) * 2);
+            for (let i = 0; i <= gs; i++) {
+                for (let j = 0; j <= gs; j++) {
+                    let ind = (i * (gs + 1) + j) * 2;
+                    vertices[ind] = -1 + j / gs2;
+                    vertices[ind + 1] = -1 + i / gs2;
+                }
+            }
+            this._verticesBufferArray[gs] = this._handler.createArrayBuffer(vertices, 2, vertices.length / 2);
+            this._indexBufferArray[gs] =
+                this._planet._indexesCache[Math.log2(gs)][Math.log2(gs)][Math.log2(gs)][Math.log2(gs)][Math.log2(gs)].buffer;
+        }
+        //create 2d screen square buffer
+        const positions = new Float32Array([-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0]);
+        this._positionBuffer = this._handler.createArrayBuffer(positions, 2, positions.length / 2);
+    }
+    _drawNormalMapBlur(segment) {
+        let normals = segment.normalMapNormals;
+        if (segment.node &&
+            segment.node.getState() !== quadTree.NOTRENDERING &&
+            normals &&
+            normals.length) {
+            const size = normals.length / 3;
+            const gridSize = Math.sqrt(size) - 1;
+            let indBuf = this._verticesBufferArray[gridSize];
+            if (indBuf) {
+                if (segment.planet.terrain.equalizeNormals) {
+                    segment._normalMapEdgeEqualize(quadTree.N);
+                    segment._normalMapEdgeEqualize(quadTree.S);
+                    segment._normalMapEdgeEqualize(quadTree.W);
+                    segment._normalMapEdgeEqualize(quadTree.E);
+                }
+                let outTexture = segment.normalMapTexturePtr;
+                const h = this._handler;
+                const gl = h.gl;
+                let _normalsBuffer = h.createArrayBuffer(normals, 3, size, gl.DYNAMIC_DRAW);
+                const f = this._framebuffer;
+                let p = h.programs.normalMap;
+                let sha = p._program.attributes;
+                f.bindOutputTexture(this._normalMapVerticesTexture);
+                p.activate();
+                gl.bindBuffer(gl.ARRAY_BUFFER, indBuf);
+                gl.vertexAttribPointer(sha.a_position, indBuf.itemSize, gl.FLOAT, false, 0, 0);
+                gl.bindBuffer(gl.ARRAY_BUFFER, _normalsBuffer);
+                gl.vertexAttribPointer(sha.a_normal, _normalsBuffer.itemSize, gl.FLOAT, false, 0, 0);
+                gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBufferArray[gridSize]);
+                gl.drawElements(gl.TRIANGLE_STRIP, this._indexBufferArray[gridSize].numItems, gl.UNSIGNED_INT, 0);
+                gl.deleteBuffer(_normalsBuffer);
+                //
+                // blur pass
+                //
+                f.bindOutputTexture(outTexture);
+                p = h.programs.normalMapBlur;
+                p.activate();
+                gl.bindBuffer(gl.ARRAY_BUFFER, this._positionBuffer);
+                gl.vertexAttribPointer(p._program.attributes.a_position, this._positionBuffer.itemSize, gl.FLOAT, false, 0, 0);
+                gl.activeTexture(gl.TEXTURE0);
+                gl.bindTexture(gl.TEXTURE_2D, this._normalMapVerticesTexture);
+                gl.uniform1i(p._program.uniforms.s_texture, 0);
+                gl.drawArrays(gl.TRIANGLE_STRIP, 0, this._positionBuffer.numItems);
+                return true;
+            }
+            else {
+                return true;
+            }
+        }
+        return false;
+    }
+    _drawNormalMapNoBlur(segment) {
+        let normals = segment.normalMapNormals;
+        if (segment.node &&
+            segment.node.getState() !== quadTree.NOTRENDERING &&
+            normals &&
+            normals.length) {
+            const size = normals.length / 3;
+            const gridSize = Math.sqrt(size) - 1;
+            let indBuf = this._verticesBufferArray[gridSize];
+            if (indBuf) {
+                if (segment.planet.terrain.equalizeNormals) {
+                    segment._normalMapEdgeEqualize(quadTree.N);
+                    segment._normalMapEdgeEqualize(quadTree.S);
+                    segment._normalMapEdgeEqualize(quadTree.W);
+                    segment._normalMapEdgeEqualize(quadTree.E);
+                }
+                let outTexture = segment.normalMapTexturePtr;
+                const h = this._handler;
+                const gl = h.gl;
+                let _normalsBuffer = h.createArrayBuffer(normals, 3, size, gl.DYNAMIC_DRAW);
+                const f = this._framebuffer;
+                const p = h.programs.normalMap;
+                const sha = p._program.attributes;
+                f.bindOutputTexture(outTexture);
+                p.activate();
+                gl.bindBuffer(gl.ARRAY_BUFFER, indBuf);
+                gl.vertexAttribPointer(sha.a_position, indBuf.itemSize, gl.FLOAT, false, 0, 0);
+                gl.bindBuffer(gl.ARRAY_BUFFER, _normalsBuffer);
+                gl.vertexAttribPointer(sha.a_normal, _normalsBuffer.itemSize, gl.FLOAT, false, 0, 0);
+                gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBufferArray[gridSize]);
+                gl.drawElements(gl.TRIANGLE_STRIP, this._indexBufferArray[gridSize].numItems, gl.UNSIGNED_INT, 0);
+                gl.deleteBuffer(_normalsBuffer);
+                return true;
+            }
+            else {
+                return true;
+            }
+        }
+        return false;
+    }
+    _drawNormalMap(segment) {
+        if (segment.planet.terrain.isBlur(segment)) {
+            return this._drawNormalMapBlur(segment);
+        }
+        else {
+            return this._drawNormalMapNoBlur(segment);
+        }
+    }
+    drawSingle(segment) {
+        const h = this._handler;
+        const gl = h.gl;
+        this._framebuffer.activate();
+        gl.disable(gl.CULL_FACE);
+        gl.disable(gl.DEPTH_TEST);
+        gl.disable(gl.BLEND);
+        if (segment.terrainReady && this._drawNormalMap(segment)) {
+            segment.normalMapReady = true;
+            segment.normalMapTexture = segment.normalMapTexturePtr;
+            segment.normalMapTextureBias[0] = 0;
+            segment.normalMapTextureBias[1] = 0;
+            segment.normalMapTextureBias[2] = 1;
+        }
+        segment._inTheQueue = false;
+        gl.enable(gl.DEPTH_TEST);
+        gl.enable(gl.CULL_FACE);
+        gl.enable(gl.BLEND);
+        this._framebuffer.deactivate();
+    }
+    frame() {
+        if (this._queue.length) {
+            const h = this._handler;
+            const gl = h.gl;
+            this._framebuffer.activate();
+            gl.disable(gl.CULL_FACE);
+            gl.disable(gl.DEPTH_TEST);
+            gl.disable(gl.BLEND);
+            let deltaTime = 0, startTime = window.performance.now();
+            while (this._lock.isFree() && this._queue.length && deltaTime < 0.25) {
+                const segment = this._queue.shift();
+                if (segment.terrainReady && this._drawNormalMap(segment)) {
+                    segment.normalMapReady = true;
+                    segment.normalMapTexture = segment.normalMapTexturePtr;
+                    segment.normalMapTextureBias[0] = 0;
+                    segment.normalMapTextureBias[1] = 0;
+                    segment.normalMapTextureBias[2] = 1;
+                }
+                segment._inTheQueue = false;
+                deltaTime = window.performance.now() - startTime;
+            }
+            gl.enable(gl.BLEND);
+            gl.enable(gl.DEPTH_TEST);
+            gl.enable(gl.CULL_FACE);
+            this._framebuffer.deactivate();
+        }
+    }
+    get queueSize() {
+        return this._queue.length;
+    }
+    queue(segment) {
+        segment._inTheQueue = true;
+        this._queue.push(segment);
+    }
+    unshift(segment) {
+        segment._inTheQueue = true;
+        this._queue.unshift(segment);
+    }
+    remove(segment) {
+        //...
+    }
+    clear() {
+        while (this._queue.length) {
+            let s = this._queue.pop();
+            s._inTheQueue = false;
+        }
+    }
+    /**
+     * Set activity off
+     * @public
+     */
+    lock(key) {
+        this._lock.lock(key);
+    }
+    /**
+     * Set activity on
+     * @public
+     */
+    free(key) {
+        this._lock.free(key);
+    }
+}

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

@@ -0,0 +1,24 @@
+import { BaseWorker } from "./BaseWorker";
+import { Segment } from "../segment/Segment";
+import { Geoid } from "../terrain/Geoid";
+export interface IPlainSegmentWorkerData {
+    plainVertices: Float64Array | null;
+    plainVerticesHigh: Float32Array | null;
+    plainVerticesLow: Float32Array | null;
+    plainNormals: Float32Array | null;
+    plainRadius: number;
+    normalMapNormals: Float32Array | null;
+    normalMapVertices: Float64Array | null;
+    normalMapVerticesHigh: Float32Array | null;
+    normalMapVerticesLow: Float32Array | null;
+}
+type MessageEventExt = MessageEvent & {
+    data: IPlainSegmentWorkerData;
+};
+declare class PlainSegmentWorker extends BaseWorker<Segment> {
+    constructor(numWorkers?: number);
+    protected _onMessage(e: MessageEventExt): void;
+    setGeoid(geoid: Geoid): void;
+    make(segment: Segment): void;
+}
+export { PlainSegmentWorker };