@openglobus/og 0.18.0 → 0.18.2

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

@@ -1,40 +1,12 @@
 // import { QueueArray } from '../QueueArray.js';
-
-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
-}
-
-class TerrainWorker extends BaseWorker<TerrainInfo> {
-    constructor(numWorkers: number = 2) {
+import { BaseWorker } from "./BaseWorker";
+class TerrainWorker extends BaseWorker {
+    constructor(numWorkers = 2) {
         super(numWorkers, TERRAIN_PROGRAM);
     }
-
-    protected override _onMessage(e: MessageEventExt) {
-        this._source.get(e.data.id)!.segment._terrainWorkerCallback(e.data);
+    _onMessage(e) {
+        this._source.get(e.data.id).segment._terrainWorkerCallback(e.data);
         this._source.delete(e.data.id);
-
         e.data.normalMapNormals = null;
         e.data.normalMapVertices = null;
         e.data.normalMapVerticesHigh = null;
@@ -43,18 +15,12 @@ class TerrainWorker extends BaseWorker<TerrainInfo> {
         e.data.terrainVerticesHigh = null;
         e.data.terrainVerticesLow = null;
     }
-
-    public override make(info: TerrainInfo) {
+    make(info) {
         if (info.segment.plainReady && info.segment.terrainIsLoading) {
-
             if (this._workerQueue.length) {
-
-                const w = this._workerQueue.pop()!;
-
+                const w = this._workerQueue.pop();
                 this._source.set(this._sourceId, info);
-
                 let segment = info.segment;
-
                 w.postMessage({
                     'elevations': info.elevations,
                     'this_plainVertices': segment.plainVertices,
@@ -62,30 +28,28 @@ class TerrainWorker extends BaseWorker<TerrainInfo> {
                     'this_normalMapVertices': segment.normalMapVertices,
                     'this_normalMapNormals': segment.normalMapNormals,
                     'heightFactor': segment.planet._heightFactor,
-                    'gridSize': segment.planet.terrain!.gridSizeByZoom[segment.tileZoom],
-                    'noDataValues': segment.planet.terrain!.noDataValues,
+                    'gridSize': segment.planet.terrain.gridSizeByZoom[segment.tileZoom],
+                    'noDataValues': segment.planet.terrain.noDataValues,
                     'id': this._sourceId
                 }, [
                     info.elevations.buffer,
-                    segment.plainVertices!.buffer,
-                    segment.plainNormals!.buffer,
-                    segment.normalMapVertices!.buffer,
-                    segment.normalMapNormals!.buffer
+                    segment.plainVertices.buffer,
+                    segment.plainNormals.buffer,
+                    segment.normalMapVertices.buffer,
+                    segment.normalMapNormals.buffer
                 ]);
-
                 this._sourceId++;
-
-            } else {
+            }
+            else {
                 this._pendingQueue.push(info);
             }
-        } else {
+        }
+        else {
             this.check();
         }
     }
 }
-
-const TERRAIN_PROGRAM =
-    `'use strict';
+const TERRAIN_PROGRAM = `'use strict';
     //
     //Terrain worker
     //
@@ -584,5 +548,4 @@ const TERRAIN_PROGRAM =
                     noDataVertices.buffer
             ]);
     }`;
-
-export {TerrainWorker};
+export { TerrainWorker };

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

@@ -0,0 +1,113 @@
+import { ImageCanvas } from "../ImageCanvas";
+import { Rectangle } from "../Rectangle";
+import { ImagesCacheManager, HTMLImageElementExt, ImagesCacheManagerCallback } from "./ImagesCacheManager";
+import { Handler, WebGLTextureExt } from "../webgl/Handler";
+/**
+ * Texture atlas stores images in one texture. Each image has its own
+ * atlas texture coordinates.
+ * @class
+ * @param {number} [width=1024] - Texture atlas width, if it hasn't 1024 default.
+ * @param {number} [height=1024] - Texture atlas height, if it hasn't 1024 default.
+ */
+declare class TextureAtlas {
+    /**
+     * Atlas nodes where input images store. It can be accessed by image.__nodeIndex.
+     * @public
+     * @type {Map<number, TextureAtlasNode>}
+     */
+    nodes: Map<number, TextureAtlasNode>;
+    /**
+     * Created gl texture.
+     * @public
+     */
+    texture: WebGLTextureExt | null;
+    /**
+     * Atlas canvas.
+     * @public
+     * @type {ImageCanvas}
+     */
+    canvas: ImageCanvas;
+    borderSize: number;
+    protected _handler: Handler | null;
+    protected _images: HTMLImageElementExt[];
+    protected _btree: TextureAtlasNode | null;
+    protected _imagesCacheManager: ImagesCacheManager;
+    constructor(width?: number, height?: number);
+    /**
+     * Returns atlas javascript image object.
+     * @public
+     * @returns {HTMLImageElement} -
+     */
+    getImage(): HTMLImageElement;
+    /**
+     * Returns canvas object.
+     * @public
+     * @returns {HTMLCanvasElement} -
+     */
+    getCanvas(): HTMLCanvasElement;
+    /**
+     * Clear atlas with black.
+     * @public
+     */
+    clearCanvas(): void;
+    /**
+     * Sets openglobus gl handler that creates gl texture.
+     * @public
+     * @param {Handler} handler - WebGL handler.
+     */
+    assignHandler(handler: Handler): void;
+    /**
+     * Returns image diagonal size.
+     * @param {HTMLImageElementExt} image - Image object.
+     * @returns {number} -
+     */
+    getDiagonal(image: HTMLImageElementExt): number;
+    /**
+     * Adds image to the atlas and returns created node with texture coordinates of the stored image.
+     * @public
+     * @param {HTMLImageElementExt} image - Input javascript image object.
+     * @param {boolean} [fastInsert] - If it's true atlas doesn't restore all images again
+     * and store image in the current atlas scheme.
+     * @returns {TextureAtlasNode | undefined} -
+     */
+    addImage(image: HTMLImageElementExt, fastInsert?: boolean): TextureAtlasNode | undefined;
+    protected _completeNode(nodes: Map<number, TextureAtlasNode>, node?: TextureAtlasNode | null): void;
+    /**
+     * Main atlas making function.
+     * @protected
+     * @param {boolean} [fastInsert] - If it's true atlas doesn't restore all images again
+     * and store image in the current atlas scheme.
+     */
+    protected _makeAtlas(fastInsert?: boolean): void;
+    get(key: number): TextureAtlasNode | undefined;
+    set(key: number, value: TextureAtlasNode): void;
+    /**
+     * Creates atlas gl texture.
+     * @public
+     */
+    createTexture(img?: HTMLImageElement | null, internalFormat?: number): void;
+    /**
+     * Asynchronous function that loads and creates image to the image cache, and call success callback when it's done.
+     * @public
+     * @param {string} src - Image object src string.
+     * @param {ImagesCacheManagerCallback} success - The callback that handles the image loads done.
+     */
+    loadImage(src: string, success: ImagesCacheManagerCallback): void;
+    getImageTexCoordinates(img: HTMLImageElementExt): number[] | undefined;
+}
+/**
+ * Atlas binary tree node.
+ * @class
+ * @param {Rectangle} rect - Node image rectangle.
+ * @param {number[]} texCoords - Node image rectangle.
+ */
+declare class TextureAtlasNode {
+    childNodes: TextureAtlasNode[] | null;
+    image: HTMLImageElementExt | null;
+    rect: Rectangle;
+    texCoords: number[];
+    atlas: TextureAtlas | null;
+    constructor(rect?: Rectangle, texCoords?: number[]);
+    insert(img: HTMLImageElementExt): TextureAtlasNode | undefined;
+}
+export { TextureAtlas, TextureAtlasNode };

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

@@ -1,8 +1,6 @@
-import {ImageCanvas} from "../ImageCanvas";
-import {Rectangle} from "../Rectangle";
-import {ImagesCacheManager, HTMLImageElementExt, ImagesCacheManagerCallback} from "./ImagesCacheManager";
-import {Handler, WebGLTextureExt} from "../webgl/Handler";
-
+import { ImageCanvas } from "../ImageCanvas";
+import { Rectangle } from "../Rectangle";
+import { ImagesCacheManager } from "./ImagesCacheManager";
 /**
  * Texture atlas stores images in one texture. Each image has its own
  * atlas texture coordinates.
@@ -11,101 +9,58 @@ import {Handler, WebGLTextureExt} from "../webgl/Handler";
  * @param {number} [height=1024] - Texture atlas height, if it hasn't 1024 default.
  */
 class TextureAtlas {
-    /**
-     * Atlas nodes where input images store. It can be accessed by image.__nodeIndex.
-     * @public
-     * @type {Map<number, TextureAtlasNode>}
-     */
-    public nodes: Map<number, TextureAtlasNode>;
-
-    /**
-     * Created gl texture.
-     * @public
-     */
-    public texture: WebGLTextureExt | null;
-
-    /**
-     * Atlas canvas.
-     * @public
-     * @type {ImageCanvas}
-     */
-    public canvas: ImageCanvas;
-
-    public borderSize: number;
-
-    protected _handler: Handler | null;
-    protected _images: HTMLImageElementExt[];
-    protected _btree: TextureAtlasNode | null;
-    protected _imagesCacheManager: ImagesCacheManager;
-
-    constructor(width: number = 1024, height: number = 1024) {
-
-        this.nodes = new Map<number, TextureAtlasNode>();
-
+    constructor(width = 1024, height = 1024) {
+        this.nodes = new Map();
         this.texture = null;
-
         this.canvas = new ImageCanvas(width, height);
-
         this.clearCanvas();
-
         this._handler = null;
-
         this._images = [];
-
         this._btree = null;
-
         this._imagesCacheManager = new ImagesCacheManager();
-
         this.borderSize = 4;
     }
-
     /**
      * Returns atlas javascript image object.
      * @public
      * @returns {HTMLImageElement} -
      */
-    public getImage() {
+    getImage() {
         return this.canvas.getImage();
     }
-
     /**
      * Returns canvas object.
      * @public
      * @returns {HTMLCanvasElement} -
      */
-    public getCanvas(): HTMLCanvasElement {
+    getCanvas() {
         return this.canvas.getCanvas();
     }
-
     /**
      * Clear atlas with black.
      * @public
      */
-    public clearCanvas() {
+    clearCanvas() {
         this.canvas.fillEmpty();
     }
-
     /**
      * Sets openglobus gl handler that creates gl texture.
      * @public
      * @param {Handler} handler - WebGL handler.
      */
-    public assignHandler(handler: Handler) {
+    assignHandler(handler) {
         this._handler = handler;
         this.createTexture();
     }
-
     /**
      * Returns image diagonal size.
      * @param {HTMLImageElementExt} image - Image object.
      * @returns {number} -
      */
-    public getDiagonal(image: HTMLImageElementExt): number {
-        let w = image.atlasWidth || image.width,
-            h = image.atlasHeight || image.height;
+    getDiagonal(image) {
+        let w = image.atlasWidth || image.width, h = image.atlasHeight || image.height;
         return Math.sqrt(w * w + h * h);
     }
-
     /**
      * Adds image to the atlas and returns created node with texture coordinates of the stored image.
      * @public
@@ -114,83 +69,60 @@ class TextureAtlas {
      * and store image in the current atlas scheme.
      * @returns {TextureAtlasNode | undefined} -
      */
-    public addImage(image: HTMLImageElementExt, fastInsert: boolean = false): TextureAtlasNode | undefined {
+    addImage(image, fastInsert = false) {
         if (!(image.width && image.height)) {
             return;
         }
-
         this._images.push(image);
-
         this._makeAtlas(fastInsert);
-
         if (image.__nodeIndex != undefined) {
             return this.get(image.__nodeIndex);
         }
     }
-
-    protected _completeNode(nodes: Map<number, TextureAtlasNode>, node?: TextureAtlasNode | null) {
+    _completeNode(nodes, node) {
         if (node) {
-
-            let w = this.canvas.getWidth(),
-                h = this.canvas.getHeight();
-
-            let im = node.image!;
+            let w = this.canvas.getWidth(), h = this.canvas.getHeight();
+            let im = node.image;
             let r = node.rect;
             let bs = Math.round(this.borderSize * 0.5);
             this.canvas.drawImage(im, r.left + bs, r.top + bs, im.atlasWidth || 0, im.atlasHeight || 0);
-
             let tc = node.texCoords;
-
             tc[0] = (r.left + bs) / w;
             tc[1] = (r.top + bs) / h;
-
             tc[2] = (r.left + bs) / w;
             tc[3] = (r.bottom - bs) / h;
-
             tc[4] = (r.right - bs) / w;
             tc[5] = (r.bottom - bs) / h;
-
             tc[6] = (r.right - bs) / w;
             tc[7] = (r.bottom - bs) / h;
-
             tc[8] = (r.right - bs) / w;
             tc[9] = (r.top + bs) / h;
-
             tc[10] = (r.left + bs) / w;
             tc[11] = (r.top + bs) / h;
-
-            nodes.set(im.__nodeIndex!, node);
+            nodes.set(im.__nodeIndex, node);
         }
     }
-
     /**
      * Main atlas making function.
      * @protected
      * @param {boolean} [fastInsert] - If it's true atlas doesn't restore all images again
      * and store image in the current atlas scheme.
      */
-    protected _makeAtlas(fastInsert: boolean = false) {
+    _makeAtlas(fastInsert = false) {
         if (fastInsert && this._btree) {
             let im = this._images[this._images.length - 1];
             this._completeNode(this.nodes, this._btree.insert(im));
-        } else {
+        }
+        else {
             let im = this._images.slice(0);
-
-            im.sort(function (b: HTMLImageElementExt, a: HTMLImageElementExt) {
-                return (
-                    (a.atlasWidth || a.width) - (b.atlasWidth || b.width) ||
-                    (a.atlasHeight || a.height) - (b.atlasHeight || b.height)
-                );
+            im.sort(function (b, a) {
+                return ((a.atlasWidth || a.width) - (b.atlasWidth || b.width) ||
+                    (a.atlasHeight || a.height) - (b.atlasHeight || b.height));
             });
-
-            this._btree = new TextureAtlasNode(
-                new Rectangle(0, 0, this.canvas.getWidth(), this.canvas.getHeight())
-            );
+            this._btree = new TextureAtlasNode(new Rectangle(0, 0, this.canvas.getWidth(), this.canvas.getHeight()));
             this._btree.atlas = this;
-
             this.clearCanvas();
-
-            let newNodes = new Map<number, TextureAtlasNode>();
+            let newNodes = new Map();
             for (let i = 0; i < im.length; i++) {
                 this._completeNode(newNodes, this._btree.insert(im[i]));
             }
@@ -199,41 +131,36 @@ class TextureAtlas {
             this.nodes = newNodes;
         }
     }
-
-    public get(key: number): TextureAtlasNode | undefined {
+    get(key) {
         return this.nodes.get(key);
     }
-
-    public set(key: number, value: TextureAtlasNode) {
+    set(key, value) {
         this.nodes.set(key, value);
     }
-
     /**
      * Creates atlas gl texture.
      * @public
      */
-    public createTexture(img?: HTMLImageElement | null, internalFormat?: number) {
+    createTexture(img, internalFormat) {
         if (this._handler) {
-            this._handler.gl!.deleteTexture(this.texture!);
+            this._handler.gl.deleteTexture(this.texture);
             if (img) {
                 this.canvas.resize(img.width, img.height);
                 this.canvas.drawImage(img, 0, 0, img.width, img.height);
             }
-            this.texture = this._handler.createTexture_l(this.canvas.getCanvas(), internalFormat)!;
+            this.texture = this._handler.createTexture_l(this.canvas.getCanvas(), internalFormat);
         }
     }
-
     /**
      * Asynchronous function that loads and creates image to the image cache, and call success callback when it's done.
      * @public
      * @param {string} src - Image object src string.
      * @param {ImagesCacheManagerCallback} success - The callback that handles the image loads done.
      */
-    public loadImage(src: string, success: ImagesCacheManagerCallback) {
+    loadImage(src, success) {
         this._imagesCacheManager.load(src, success);
     }
-
-    public getImageTexCoordinates(img: HTMLImageElementExt): number[] | undefined {
+    getImageTexCoordinates(img) {
         if (img.__nodeIndex != null) {
             let n = this.get(img.__nodeIndex);
             if (n) {
@@ -242,7 +169,6 @@ class TextureAtlas {
         }
     }
 }
-
 /**
  * Atlas binary tree node.
  * @class
@@ -250,73 +176,56 @@ class TextureAtlas {
  * @param {number[]} texCoords - Node image rectangle.
  */
 class TextureAtlasNode {
-    public childNodes: TextureAtlasNode[] | null;
-    public image: HTMLImageElementExt | null;
-    public rect: Rectangle;
-    public texCoords: number[];
-    public atlas: TextureAtlas | null;
-
-    constructor(rect?: Rectangle, texCoords?: number[]) {
+    constructor(rect, texCoords) {
         this.childNodes = null;
         this.image = null;
         this.rect = rect || new Rectangle();
         this.texCoords = texCoords || [];
         this.atlas = null;
     }
-
-    public insert(img: HTMLImageElementExt): TextureAtlasNode | undefined {
+    insert(img) {
         if (this.childNodes) {
             let newNode = this.childNodes[0].insert(img);
-
             if (newNode) {
                 return newNode;
             }
-
             return this.childNodes[1].insert(img);
-        } else {
+        }
+        else {
             if (this.image != null) {
                 return;
             }
-
             let rc = this.rect;
-            const w = (img.atlasWidth || img.width) + this.atlas!.borderSize;
-            const h = (img.atlasHeight || img.height) + this.atlas!.borderSize;
-
+            const w = (img.atlasWidth || img.width) + this.atlas.borderSize;
+            const h = (img.atlasHeight || img.height) + this.atlas.borderSize;
             if (w > rc.getWidth() || h > rc.getHeight()) {
                 return;
             }
-
             if (rc.fit(w, h)) {
                 this.image = img;
                 return this;
             }
-
             this.childNodes = new Array(2);
             this.childNodes[0] = new TextureAtlasNode();
             this.childNodes[0].atlas = this.atlas;
             this.childNodes[1] = new TextureAtlasNode();
             this.childNodes[1].atlas = this.atlas;
-
             const dw = rc.getWidth() - w;
             const dh = rc.getHeight() - h;
-
             if (dw > dh) {
                 // this.childNodes[0].rect = new Rectangle(rc.left, rc.top, rc.left + w, rc.bottom);
                 // this.childNodes[1].rect = new Rectangle(rc.left + w, rc.top, rc.right, rc.bottom);
                 this.childNodes[0].rect.set(rc.left, rc.top, rc.left + w, rc.bottom);
                 this.childNodes[1].rect.set(rc.left + w, rc.top, rc.right, rc.bottom);
-
-            } else {
+            }
+            else {
                 // this.childNodes[0].rect = new Rectangle(rc.left, rc.top, rc.right, rc.top + h);
                 // this.childNodes[1].rect = new Rectangle(rc.left, rc.top + h, rc.right, rc.bottom);
                 this.childNodes[0].rect.set(rc.left, rc.top, rc.right, rc.top + h);
                 this.childNodes[1].rect.set(rc.left, rc.top + h, rc.right, rc.bottom);
-
             }
-
             return this.childNodes[0].insert(img);
         }
     }
 }
-
-export {TextureAtlas, TextureAtlasNode};
+export { TextureAtlas, TextureAtlasNode };

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

@@ -0,0 +1,18 @@
+import { Framebuffer } from '../webgl/Framebuffer';
+import { Handler } from "../webgl/Handler";
+import { Material } from "../layer/Material";
+import { Planet } from "../scene/Planet";
+export declare class VectorTileCreator {
+    protected _width: number;
+    protected _height: number;
+    protected _planet: Planet;
+    protected _framebuffer: Framebuffer | null;
+    protected _queue: Material[];
+    protected _handler: Handler | null;
+    constructor(planet: Planet, width?: number, height?: number);
+    init(): void;
+    frame(): void;
+    add(material: Material): void;
+    remove(material: Material): void;
+    get queueSize(): number;
+}