@openglobus/og 0.24.1 → 0.25.0

package/lib/js/utils/Loader.js

@@ -1,156 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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 { Handler } from "../webgl/Handler";
-import type { WebGLBufferExt, WebGLTextureExt } 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

@@ -1,310 +0,0 @@
-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 = (1 << p); //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

@@ -1,24 +0,0 @@
-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 };