@openglobus/og 0.18.0 → 0.18.2

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

@@ -1,44 +1,12 @@
 import * as quadTree from "../quadTree/quadTree";
-import {Framebuffer} from "../webgl/Framebuffer";
-import {Lock, Key} from "../Lock";
-import {Planet} from "../scene/Planet";
-import {Program} from "../webgl/Program";
-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;
-}
-
+import { Framebuffer } from "../webgl/Framebuffer";
+import { Lock } from "../Lock";
+import { Program } from "../webgl/Program";
+import { QueueArray } from "../QueueArray";
 export 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 = {}) {
-
+    constructor(planet, options = {}) {
         this._minTabelSize = options.minTableSize || 1;
         this._maxTableSize = options.maxTableSize || 8;
-
         this._planet = planet;
         this._handler = null;
         this._verticesBufferArray = [];
@@ -46,31 +14,21 @@ export class NormalMapCreator {
         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();
     }
-
-    public get width(): number {
+    get width() {
         return this._width;
     }
-
-    public get height(): number {
+    get height() {
         return this._height;
     }
-
-    public init() {
-
+    init() {
         this._maxTableSize = this._planet.maxGridSize || 8;
-
-        this._handler = this._planet.renderer!.handler;
-
+        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
          *=================================================================================*/
@@ -81,8 +39,7 @@ export class NormalMapCreator {
             uniforms: {
                 s_texture: "sampler2d"
             },
-            vertexShader:
-                `attribute vec2 a_position;
+            vertexShader: `attribute vec2 a_position;
                        attribute vec2 a_texCoord;
 
                       varying vec2 blurCoordinates[5];
@@ -116,7 +73,6 @@ export class NormalMapCreator {
                             gl_FragColor = sum;
                         }`
         });
-
         const normalMap = new Program("normalMap", {
             attributes: {
                 a_position: "vec2",
@@ -140,29 +96,21 @@ export class NormalMapCreator {
                             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;
@@ -170,182 +118,121 @@ export class NormalMapCreator {
                     vertices[ind + 1] = -1 + i / gs2;
                 }
             }
-
-            this._verticesBufferArray[gs] = this._handler.createArrayBuffer(
-                vertices,
-                2,
-                vertices.length / 2
-            );
-
+            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!;
+                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);
     }
-
-    protected _drawNormalMapBlur(segment: Segment): boolean {
+    _drawNormalMapBlur(segment) {
         let normals = segment.normalMapNormals;
-        if (
-            segment.node &&
+        if (segment.node &&
             segment.node.getState() !== quadTree.NOTRENDERING &&
             normals &&
-            normals.length
-        ) {
+            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) {
+                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!;
-
+                const h = this._handler;
+                const gl = h.gl;
                 let _normalsBuffer = h.createArrayBuffer(normals, 3, size, gl.DYNAMIC_DRAW);
-
-                const f = this._framebuffer!;
+                const f = this._framebuffer;
                 let p = h.programs.normalMap;
                 let sha = p._program.attributes;
-
-                f.bindOutputTexture(this._normalMapVerticesTexture!);
-
+                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.drawElements(gl.TRIANGLE_STRIP, this._indexBufferArray[gridSize].numItems, gl.UNSIGNED_INT, 0);
                 gl.deleteBuffer(_normalsBuffer);
-
                 //
                 // blur pass
                 //
-                f.bindOutputTexture(outTexture!);
-
+                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.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.bindTexture(gl.TEXTURE_2D, this._normalMapVerticesTexture);
                 gl.uniform1i(p._program.uniforms.s_texture, 0);
-                gl.drawArrays(gl.TRIANGLE_STRIP, 0, this._positionBuffer!.numItems);
+                gl.drawArrays(gl.TRIANGLE_STRIP, 0, this._positionBuffer.numItems);
                 return true;
-            } else {
+            }
+            else {
                 return true;
             }
         }
         return false;
     }
-
-    protected _drawNormalMapNoBlur(segment: Segment): boolean {
+    _drawNormalMapNoBlur(segment) {
         let normals = segment.normalMapNormals;
-        if (
-            segment.node &&
+        if (segment.node &&
             segment.node.getState() !== quadTree.NOTRENDERING &&
             normals &&
-            normals.length
-        ) {
+            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) {
+                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!;
-
+                const h = this._handler;
+                const gl = h.gl;
                 let _normalsBuffer = h.createArrayBuffer(normals, 3, size, gl.DYNAMIC_DRAW);
-
-                const f = this._framebuffer!;
+                const f = this._framebuffer;
                 const p = h.programs.normalMap;
                 const sha = p._program.attributes;
-
-                f.bindOutputTexture(outTexture!);
-
+                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.drawElements(gl.TRIANGLE_STRIP, this._indexBufferArray[gridSize].numItems, gl.UNSIGNED_INT, 0);
                 gl.deleteBuffer(_normalsBuffer);
-
                 return true;
-            } else {
+            }
+            else {
                 return true;
             }
         }
         return false;
     }
-
-    protected _drawNormalMap(segment: Segment) {
-        if (segment.planet.terrain!.isBlur(segment)) {
+    _drawNormalMap(segment) {
+        if (segment.planet.terrain.isBlur(segment)) {
             return this._drawNormalMapBlur(segment);
-        } else {
+        }
+        else {
             return this._drawNormalMapNoBlur(segment);
         }
     }
-
-    public drawSingle(segment: Segment) {
-        const h = this._handler!;
-        const gl = h.gl!;
-
-        this._framebuffer!.activate();
-
+    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;
@@ -354,30 +241,22 @@ export class NormalMapCreator {
             segment.normalMapTextureBias[2] = 1;
         }
         segment._inTheQueue = false;
-
         gl.enable(gl.DEPTH_TEST);
         gl.enable(gl.CULL_FACE);
         gl.enable(gl.BLEND);
-
-        this._framebuffer!.deactivate();
+        this._framebuffer.deactivate();
     }
-
-    public frame() {
+    frame() {
         if (this._queue.length) {
-            const h = this._handler!;
-            const gl = h.gl!;
-
-            this._framebuffer!.activate();
-
+            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();
-
+            let deltaTime = 0, startTime = window.performance.now();
             while (this._lock.isFree() && this._queue.length && deltaTime < 0.25) {
-                const segment = this._queue.shift()!;
+                const segment = this._queue.shift();
                 if (segment.terrainReady && this._drawNormalMap(segment)) {
                     segment.normalMapReady = true;
                     segment.normalMapTexture = segment.normalMapTexturePtr;
@@ -388,54 +267,44 @@ export class NormalMapCreator {
                 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();
+            this._framebuffer.deactivate();
         }
     }
-
-    public get queueSize(): number {
+    get queueSize() {
         return this._queue.length;
     }
-
-    public queue(segment: Segment) {
+    queue(segment) {
         segment._inTheQueue = true;
         this._queue.push(segment);
     }
-
-    public unshift(segment: Segment) {
+    unshift(segment) {
         segment._inTheQueue = true;
         this._queue.unshift(segment);
     }
-
-    public remove(segment: Segment) {
+    remove(segment) {
         //...
     }
-
-    public clear() {
+    clear() {
         while (this._queue.length) {
-            let s = this._queue.pop()!;
+            let s = this._queue.pop();
             s._inTheQueue = false;
         }
     }
-
     /**
      * Set activity off
      * @public
      */
-    public lock(key: Key) {
+    lock(key) {
         this._lock.lock(key);
     }
-
     /**
      * Set activity on
      * @public
      */
-    public free(key: Key) {
+    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 };

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

@@ -1,34 +1,12 @@
 // import { QueueArray } from '../QueueArray.js';
-import {EPSG4326} from "../proj/EPSG4326";
-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
-}
-
-class PlainSegmentWorker extends BaseWorker<Segment> {
-    constructor(numWorkers: number = 2) {
+import { EPSG4326 } from "../proj/EPSG4326";
+import { BaseWorker } from "./BaseWorker";
+class PlainSegmentWorker extends BaseWorker {
+    constructor(numWorkers = 2) {
         super(numWorkers, PLAIN_SEGMENT_PROGRAM);
     }
-
-    protected override _onMessage(e: MessageEventExt) {
-        this._source.get(e.data.id)!._plainSegmentWorkerCallback(e.data);
-
+    _onMessage(e) {
+        this._source.get(e.data.id)._plainSegmentWorkerCallback(e.data);
         e.data.plainVertices = null;
         e.data.plainVerticesHigh = null;
         e.data.plainVerticesLow = null;
@@ -37,12 +15,9 @@ class PlainSegmentWorker extends BaseWorker<Segment> {
         e.data.normalMapVertices = null;
         e.data.normalMapVerticesHigh = null;
         e.data.normalMapVerticesLow = null;
-
-        this._source.delete(e.data.id)
+        this._source.delete(e.data.id);
     }
-
-    public setGeoid(geoid: Geoid) {
-
+    setGeoid(geoid) {
         if (geoid.model) {
             let m = geoid.model;
             let model = {
@@ -54,20 +29,18 @@ class PlainSegmentWorker extends BaseWorker<Segment> {
                 rlatres: m.rlatres,
                 i: m.i
             };
-
             this._workerQueue.forEach((w) => {
                 let rawfile = new Uint8Array(m.rawfile.length);
                 rawfile.set(m.rawfile);
-
                 w.postMessage({
-                        model: model,
-                        rawfile: rawfile
-                    }, [
-                        rawfile.buffer
-                    ]
-                );
+                    model: model,
+                    rawfile: rawfile
+                }, [
+                    rawfile.buffer
+                ]);
             });
-        } else {
+        }
+        else {
             this._workerQueue.forEach((w) => {
                 w.postMessage({
                     model: null
@@ -75,19 +48,16 @@ class PlainSegmentWorker extends BaseWorker<Segment> {
             });
         }
     }
-
-    public override make(segment: Segment) {
+    make(segment) {
         if (segment.initialized) {
             if (this._workerQueue.length) {
-                let w = this._workerQueue.pop()!;
-
+                let w = this._workerQueue.pop();
                 this._source.set(this._sourceId, segment);
-
                 let params = new Float64Array([
                     this._sourceId,
                     segment._projection.id === EPSG4326.id ? 1.0 : 0.0,
-                    segment.planet.terrain!.gridSizeByZoom[segment.tileZoom],
-                    segment.planet.terrain!.plainGridSize,
+                    segment.planet.terrain.gridSizeByZoom[segment.tileZoom],
+                    segment.planet.terrain.plainGridSize,
                     segment._extent.southWest.lon,
                     segment._extent.southWest.lat,
                     segment._extent.northEast.lon,
@@ -100,23 +70,22 @@ class PlainSegmentWorker extends BaseWorker<Segment> {
                     segment.planet.ellipsoid._invRadii2.z,
                     segment.planet._heightFactor
                 ]);
-
                 this._sourceId++;
-
                 w.postMessage({
                     params: params
                 }, [
                     params.buffer
                 ]);
-            } else {
+            }
+            else {
                 this._pendingQueue.push(segment);
             }
-        } else {
+        }
+        else {
             this.check();
         }
     }
 }
-
 const PLAIN_SEGMENT_PROGRAM = `
     'use strict';
     
@@ -411,5 +380,4 @@ const PLAIN_SEGMENT_PROGRAM = `
             ]);
         }
     }`;
-
-export {PlainSegmentWorker};
+export { PlainSegmentWorker };

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

@@ -0,0 +1,28 @@
+import { BaseWorker } from "./BaseWorker";
+import { Segment } from "../segment/Segment";
+import { NumberArray6 } from "../bv/Sphere";
+interface TerrainInfo {
+    segment: Segment;
+    elevations: Float32Array;
+}
+export interface ITerrainWorkerData {
+    id: number;
+    normalMapNormals: Float32Array | null;
+    normalMapVertices: Float64Array | null;
+    normalMapVerticesHigh: Float32Array | null;
+    normalMapVerticesLow: Float32Array | null;
+    terrainVertices: Float64Array | null;
+    terrainVerticesHigh: Float32Array | null;
+    terrainVerticesLow: Float32Array | null;
+    noDataVertices: Uint8Array | null;
+    bounds: NumberArray6;
+}
+type MessageEventExt = MessageEvent & {
+    data: ITerrainWorkerData;
+};
+declare class TerrainWorker extends BaseWorker<TerrainInfo> {
+    constructor(numWorkers?: number);
+    protected _onMessage(e: MessageEventExt): void;
+    make(info: TerrainInfo): void;
+}
+export { TerrainWorker };