@openglobus/og 0.17.2 → 0.18.1

package/src/og/utils/ImagesCacheManager.js

@@ -1,70 +0,0 @@
-'use strict';
-
-import { QueueArray } from '../QueueArray.js';
-
-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 {
-            var req = { "src": src, "success": success };
-            if (this._counter >= 1) {
-                this._pendingsQueue.unshift(req);
-            } else {
-                this._exec(req);
-            }
-        }
-    }
-
-    _exec(req) {
-        this._counter++;
-        var that = this;
-
-        var img = new Image();
-        img.crossOrigin = '';
-        img.onload = function () {
-            that.imagesCache[req.src] = img;
-            this.__nodeIndex = that._imageIndexCounter++;
-            req.success(this);
-            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) {
-                var 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/src/og/utils/Loader.js

@@ -1,188 +0,0 @@
-'use strict';
-
-import { Events } from '../Events.js';
-
-// if (window && !('createImageBitmap' in window)) {
-//     window.createImageBitmap = function (blob) {
-//         return new Promise((resolve, reject) => {
-//             let img = document.createElement('img');
-//             img.addEventListener('load', function () {
-//                 resolve(this);
-//             });
-//             img.src = URL.createObjectURL(blob);
-//         });
-//     };
-// }
-
-export class Loader {
-
-    constructor(maxRequests = 24) {
-
-        this.MAX_REQUESTS = maxRequests;
-
-        this.events = new Events(["loadend", "layerloadend"]);
-
-        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__: null
-                };
-            }
-            this._senderRequestCounter[params.sender._id].counter++;
-        }
-        this._queue.push({ 'params': params, 'callback': 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._terrainCompletedActivated || !sender._planet)) {
-            sender.events.dispatch(sender.events.loadend, sender);
-            this.events.dispatch(this.events.layerloadend, sender);
-            request.__requestCounterFrame__ = null;
-        } 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__ = null;
-        }
-
-        for (let i = 0, len = this._queue.length; i < len; i++) {
-            let qi = this._queue[i];
-            if (qi && sender.isEqual(qi.params.sender)) {
-                qi.callback({ 'status': "abort" });
-                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__ = null;
-                }
-                qi.callback({ 'status': "abort" });
-                this._queue[i] = null;
-            }
-        }
-        this._queue = [];
-    }
-}

package/src/og/utils/NormalMapCreator.js

@@ -1,404 +0,0 @@
-"use strict";
-
-import { Lock } from "../Lock.js";
-import * as quadTree from "../quadTree/quadTree.js";
-import { QueueArray } from "../QueueArray.js";
-import { Framebuffer } from "../webgl/Framebuffer.js";
-import { Program } from "../webgl/Program.js";
-
-export class NormalMapCreator {
-
-    constructor(planet, options) {
-        options = 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();
-    }
-
-    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
-         *=================================================================================*/
-        var 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;
-                        }`
-        });
-
-        var normalMap = new Program("normalMap", {
-            attributes: {
-                a_position: "vec2",
-                a_normal: "vec3"
-            },
-            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++) {
-            var gs = Math.pow(2, p);
-            var gs2 = gs / 2;
-            var 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
-        var 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) {
-        var normals = segment.normalMapNormals;
-        if (
-            segment.node &&
-            segment.node.getState() !== quadTree.NOTRENDERING &&
-            normals &&
-            normals.length
-        ) {
-            var size = normals.length / 3;
-            var 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);
-                }
-
-                var outTexture = segment.normalMapTexturePtr;
-
-                var h = this._handler;
-                var gl = h.gl;
-
-                var _normalsBuffer = h.createArrayBuffer(normals, 3, size, gl.DYNAMIC_DRAW);
-
-                var f = this._framebuffer;
-                var p = h.programs.normalMap;
-                var 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) {
-        var normals = segment.normalMapNormals;
-        if (
-            segment.node &&
-            segment.node.getState() !== quadTree.NOTRENDERING &&
-            normals &&
-            normals.length
-        ) {
-            var size = normals.length / 3;
-            var 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);
-                }
-
-                var outTexture = segment.normalMapTexturePtr;
-
-                var h = this._handler;
-                var gl = h.gl;
-
-                var _normalsBuffer = h.createArrayBuffer(normals, 3, size, gl.DYNAMIC_DRAW);
-
-                var f = this._framebuffer;
-                var p = h.programs.normalMap;
-                var 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) {
-        let t = segment.planet.terrain;
-
-        if (t.isBlur(segment)) {
-            return this._drawNormalMapBlur(segment);
-        } else {
-            return this._drawNormalMapNoBlur(segment);
-        }
-    }
-
-    drawSingle(segment) {
-        var h = this._handler,
-            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) {
-            var h = this._handler,
-                gl = h.gl;
-
-            this._framebuffer.activate();
-
-            gl.disable(gl.CULL_FACE);
-            gl.disable(gl.DEPTH_TEST);
-            gl.disable(gl.BLEND);
-
-            var deltaTime = 0,
-                startTime = window.performance.now();
-
-            while (this._lock.isFree() && this._queue.length && deltaTime < 0.25) {
-                var 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();
-        }
-    }
-
-    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) {
-            var 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);
-    }
-
-}