@openglobus/og 0.18.0 → 0.18.2

package/lib/js/quadTree/QuadTreeStrategy.d.ts

@@ -0,0 +1,25 @@
+import { Layer } from "../layer/Layer";
+import { Node } from "../quadTree/Node";
+import { Planet } from "../scene/Planet";
+import { Proj } from "../proj/Proj";
+export declare class QuadTreeStrategy {
+    name: string;
+    projection: Proj;
+    protected _planet: Planet;
+    /**
+     * grid tree list.
+     * @protected
+     * @type {Node[]}
+     */
+    protected _quadTreeList: Node[];
+    constructor(planet: Planet, name?: string, proj?: Proj);
+    destroyBranches(): void;
+    clearLayerMaterial(layer: Layer): void;
+    get planet(): Planet;
+    init(): void;
+    preRender(): void;
+    preLoad(): void;
+    collectRenderNodes(): void;
+    clear(): void;
+    get quadTreeList(): Node[];
+}

package/{src/quadTree/QuadTreeStrategy.ts → lib/js/quadTree/QuadTreeStrategy.js}

@@ -1,38 +1,20 @@
-import {EPSG3857} from "../proj/EPSG3857";
-import {Layer} from "../layer/Layer";
-import {Node} from "../quadTree/Node";
-import {Planet} from "../scene/Planet";
-import {Proj} from "../proj/Proj";
-
+import { EPSG3857 } from "../proj/EPSG3857";
 export class QuadTreeStrategy {
-    public name: string;
-    public projection: Proj;
-    protected _planet: Planet;
-
-    /**
-     * grid tree list.
-     * @protected
-     * @type {Node[]}
-     */
-    protected _quadTreeList: Node[];
-
-    constructor(planet: Planet, name: string = "", proj: Proj = EPSG3857) {
+    constructor(planet, name = "", proj = EPSG3857) {
         this.name = name;
         this.projection = proj;
         this._planet = planet;
         this._quadTreeList = [];
     }
-
-    public destroyBranches() {
+    destroyBranches() {
         for (let i = 0, len = this._quadTreeList.length; i < len; i++) {
             this._quadTreeList[i].destroyBranches();
         }
     }
-
-    public clearLayerMaterial(layer: Layer) {
+    clearLayerMaterial(layer) {
         let lid = layer.__id;
         for (let i = 0, len = this._quadTreeList.length; i < len; i++) {
-            this._quadTreeList[i].traverseTree(function (node: Node) {
+            this._quadTreeList[i].traverseTree(function (node) {
                 let mats = node.segment.materials;
                 if (mats[lid]) {
                     mats[lid].clear();
@@ -43,37 +25,27 @@ export class QuadTreeStrategy {
             });
         }
     }
-
-    public get planet() {
+    get planet() {
         return this._planet;
     }
-
-    public init() {
-
+    init() {
     }
-
-    public preRender() {
+    preRender() {
         for (let i = 0; i < this._quadTreeList.length; i++) {
-
             let quadTree = this._quadTreeList[i];
             quadTree.createChildrenNodes();
             quadTree.segment.createPlainSegment();
-
             for (let j = 0; j < quadTree.nodes.length; j++) {
                 quadTree.nodes[j].segment.createPlainSegment();
             }
         }
     }
-
-    public preLoad() {
-
+    preLoad() {
         for (let i = 0; i < this._quadTreeList.length; i++) {
-
             let quadTree = this._quadTreeList[i];
             quadTree.segment.passReady = true;
             quadTree.renderNode(1);
             this._planet.normalMapCreator.drawSingle(quadTree.segment);
-
             for (let j = 0; j < quadTree.nodes.length; j++) {
                 quadTree.nodes[j].segment.passReady = true;
                 quadTree.nodes[j].renderNode(1);
@@ -81,20 +53,17 @@ export class QuadTreeStrategy {
             }
         }
     }
-
-    public collectRenderNodes() {
+    collectRenderNodes() {
         for (let i = 0; i < this._quadTreeList.length; i++) {
             this._quadTreeList[i].renderTree(this._planet.camera, 0, null);
         }
     }
-
-    public clear() {
+    clear() {
         for (let i = 0; i < this._quadTreeList.length; i++) {
             this._quadTreeList[i].clearTree();
         }
     }
-
-    public get quadTreeList(): Node[] {
+    get quadTreeList() {
         return this._quadTreeList;
     }
-}
+}

package/lib/js/quadTree/Wgs84QuadTreeStrategy.d.ts

@@ -0,0 +1,6 @@
+import { Planet } from "../scene/Planet";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
+export declare class Wgs84QuadTreeStrategy extends QuadTreeStrategy {
+    constructor(planet: Planet);
+    init(): void;
+}

package/lib/js/quadTree/Wgs84QuadTreeStrategy.js

@@ -0,0 +1,15 @@
+import * as quadTree from "../quadTree/quadTree";
+import { Extent } from "../Extent";
+import { EPSG4326 } from "../proj/EPSG4326";
+import { Node } from "../quadTree/Node";
+import { SegmentLonLatWgs84 } from "../segment/SegmentLonLatWgs84";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
+export class Wgs84QuadTreeStrategy extends QuadTreeStrategy {
+    constructor(planet) {
+        super(planet, "wgs84", EPSG4326);
+    }
+    init() {
+        let wgs84QuadTree = new Node(SegmentLonLatWgs84, this.planet, quadTree.NW, null, 0, 0, Extent.createFromArray([-180, -90, 180, 90]));
+        this._quadTreeList.push(wgs84QuadTree);
+    }
+}

package/lib/js/quadTree/index.d.ts

@@ -0,0 +1,12 @@
+import { EarthQuadTreeStrategy } from "./EarthQuadTreeStrategy";
+import { MarsQuadTreeStrategy } from "./MarsQuadTreeStrategy";
+import { EPSG4326QuadTreeStrategy } from "./EPSG4326QuadTreeStrategy";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
+import { Wgs84QuadTreeStrategy } from "./Wgs84QuadTreeStrategy";
+declare const quadTreeStrategyType: {
+    epsg4326: typeof EPSG4326QuadTreeStrategy;
+    earth: typeof EarthQuadTreeStrategy;
+    mars: typeof MarsQuadTreeStrategy;
+    wgs84: typeof Wgs84QuadTreeStrategy;
+};
+export { quadTreeStrategyType, QuadTreeStrategy, Wgs84QuadTreeStrategy, MarsQuadTreeStrategy, EarthQuadTreeStrategy };

package/lib/js/quadTree/index.js

@@ -0,0 +1,12 @@
+import { EarthQuadTreeStrategy } from "./EarthQuadTreeStrategy";
+import { MarsQuadTreeStrategy } from "./MarsQuadTreeStrategy";
+import { EPSG4326QuadTreeStrategy } from "./EPSG4326QuadTreeStrategy";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
+import { Wgs84QuadTreeStrategy } from "./Wgs84QuadTreeStrategy";
+const quadTreeStrategyType = {
+    epsg4326: EPSG4326QuadTreeStrategy,
+    earth: EarthQuadTreeStrategy,
+    mars: MarsQuadTreeStrategy,
+    wgs84: Wgs84QuadTreeStrategy
+};
+export { quadTreeStrategyType, QuadTreeStrategy, Wgs84QuadTreeStrategy, MarsQuadTreeStrategy, EarthQuadTreeStrategy };

package/lib/js/quadTree/quadTree.d.ts

@@ -0,0 +1,40 @@
+export declare const VISIBLE_DISTANCE = 3570;
+export declare const MAX_RENDERED_NODES = 1000;
+export declare const NW = 0;
+export declare const NE = 1;
+export declare const SW = 2;
+export declare const SE = 3;
+export declare const N = 0;
+export declare const E = 1;
+export declare const S = 2;
+export declare const W = 3;
+export declare const NOTRENDERING = 0;
+export declare const RENDERING = 1;
+export declare const WALKTHROUGH = 2;
+/**
+ * World opposite side table.
+ */
+export declare const OPSIDE: number[];
+/**
+ * First index is {N,E,S,W} and second is {NW,NE,SW,SE}
+ */
+export declare const NEIGHBOUR: number[][];
+/**
+ * Neighbor's oposite part. For example oposite side
+ * on the east neighbor side is: [S][SE] = NE
+ */
+export declare const OPPART: number[][];
+/**
+ * Neighbos's opside array order. For example NW node
+ * by E side array index is 0, SE node by S side is 1.
+ */
+export declare const NOPSORD: number[][];
+/**
+ * First index is {NW,NE,SW,SE}, another one is {N,E,S,W}
+ */
+export declare const COMSIDE: boolean[][];
+/**
+ * Gets segment part left to right or up to downo ffset against neighbour side.
+ * Where 0 - no offset 1 - half segment size offset.
+ */
+export declare const PARTOFFSET: number[][];

package/{src/quadTree/quadTree.ts → lib/js/quadTree/quadTree.js}

@@ -1,25 +1,20 @@
 export const VISIBLE_DISTANCE = 3570.0;
 export const MAX_RENDERED_NODES = 1000;
-
 export const NW = 0;
 export const NE = 1;
 export const SW = 2;
 export const SE = 3;
-
 export const N = 0;
 export const E = 1;
 export const S = 2;
 export const W = 3;
-
 export const NOTRENDERING = 0;
 export const RENDERING = 1;
 export const WALKTHROUGH = 2;
-
 /**
  * World opposite side table.
  */
 export const OPSIDE = [S, W, N, E];
-
 /**
  * First index is {N,E,S,W} and second is {NW,NE,SW,SE}
  */
@@ -29,7 +24,6 @@ export const NEIGHBOUR = [
     [SW, SE, -1, -1],
     [-1, NW, -1, SW]
 ];
-
 /**
  * Neighbor's oposite part. For example oposite side
  * on the east neighbor side is: [S][SE] = NE
@@ -40,7 +34,6 @@ export const OPPART = [
     [SW, SE, NW, NE],
     [NE, NW, SE, SW]
 ];
-
 /**
  * Neighbos's opside array order. For example NW node
  * by E side array index is 0, SE node by S side is 1.
@@ -51,7 +44,6 @@ export const NOPSORD = [
     [0, 1, 0, 1],
     [0, 0, 1, 1]
 ];
-
 /**
  * First index is {NW,NE,SW,SE}, another one is {N,E,S,W}
  */
@@ -61,7 +53,6 @@ export const COMSIDE = [
     [false, false, true, true],
     [false, true, true, false]
 ];
-
 /**
  * Gets segment part left to right or up to downo ffset against neighbour side.
  * Where 0 - no offset 1 - half segment size offset.

package/lib/js/renderer/Renderer.d.ts

@@ -0,0 +1,320 @@
+import { Camera } from "../camera/Camera";
+import { Control } from "../control/Control";
+import { RendererEventsHandler } from "./RendererEvents";
+import { EntityCollection } from "../entity/EntityCollection";
+import { Framebuffer, Multisample } from "../webgl/index";
+import { FontAtlas } from "../utils/FontAtlas";
+import { Handler, WebGLBufferExt } from "../webgl/Handler";
+import { LabelWorker } from "../entity/LabelWorker";
+import { RenderNode } from "../scene/RenderNode";
+import { TextureAtlas } from "../utils/TextureAtlas";
+import { Vec2 } from "../math/Vec2";
+import { NumberArray3, Vec3 } from "../math/Vec3";
+import { Vec4 } from "../math/Vec4";
+interface IRendererParams {
+    controls?: Control[];
+    msaa?: number;
+    autoActivate?: boolean;
+    fontsSrc?: string;
+}
+interface IPickingObject {
+    _pickingColor?: Vec3;
+    _pickingColorU?: Float32Array;
+}
+interface IFrameCallbackHandler {
+    id: number;
+    callback: Function;
+    sender: any;
+}
+export interface HTMLDivElementExt extends HTMLDivElement {
+    attributions?: HTMLElement;
+}
+declare class Renderer {
+    /**
+     * Div element with WebGL canvas. Assigned in Globe class.
+     * @public
+     * @type {HTMLElement | null}
+     */
+    div: HTMLDivElementExt | null;
+    /**
+     * WebGL handler context.
+     * @public
+     * @type {Handler}
+     */
+    handler: Handler;
+    exposure: number;
+    gamma: number;
+    whitepoint: number;
+    brightThreshold: number;
+    /**
+     * Render nodes drawing queue.
+     * @public
+     * @type {Array.<RenderNode>}
+     */
+    _renderNodesArr: RenderNode[];
+    /**
+     * Render nodes store for the comfortable access by the node name.
+     * @public
+     * @type {Object.<RenderNode>}
+     */
+    renderNodes: Record<string, RenderNode>;
+    /**
+     * Current active camera.
+     * @public
+     * @type {Camera}
+     */
+    activeCamera: Camera | null;
+    /**
+     * Renderer events. Represents interface for setting events like mousemove, draw, keypress etc.
+     * @public
+     * @type {RendererEvents}
+     */
+    events: RendererEventsHandler;
+    /**
+     * Controls array.
+     * @public
+     * @type {Object}
+     */
+    controls: Record<string, Control>;
+    /**
+     * Provides exchange between controls.
+     * @public
+     * @type {any}
+     */
+    controlsBag: any;
+    /**
+     * Hash table for drawing objects.
+     * @public
+     * @type {Map<string, any>}
+     */
+    colorObjects: Map<string, any>;
+    /**
+     * Color picking objects rendering queue.
+     * @type {Function[]}
+     */
+    protected _pickingCallbacks: IFrameCallbackHandler[];
+    /**
+     * Picking objects(labels and billboards) framebuffer.
+     * @public
+     * @type {Framebuffer}
+     */
+    pickingFramebuffer: Framebuffer | null;
+    protected _tempPickingPix_: Uint8Array;
+    /**
+     * @public
+     * @type {Framebuffer}
+     */
+    distanceFramebuffer: Framebuffer | null;
+    /**
+     * @type {Function[]}
+     */
+    protected _distanceCallbacks: IFrameCallbackHandler[];
+    protected _tempDistancePix_: Uint8Array;
+    /**
+     * Depth objects rendering queue.
+     * @type {Function[]}
+     */
+    protected _depthCallbacks: IFrameCallbackHandler[];
+    depthFramebuffer: Framebuffer | null;
+    protected _msaa: number;
+    protected _internalFormat: string;
+    protected _format: string;
+    protected _type: string;
+    sceneFramebuffer: Framebuffer | Multisample | null;
+    protected blitFramebuffer: Framebuffer | null;
+    protected toneMappingFramebuffer: Framebuffer | null;
+    protected _initialized: boolean;
+    /**
+     * Texture atlas for the billboards images. One atlas per node.
+     * @public
+     * @type {TextureAtlas}
+     */
+    billboardsTextureAtlas: TextureAtlas;
+    /**
+     * Texture atlas for the billboards images. One atlas per node.
+     * @public
+     * @type {TextureAtlas}
+     */
+    geoObjectsTextureAtlas: TextureAtlas;
+    /**
+     * Texture font atlas for the font families and styles. One atlas per node.
+     * @public
+     * @type {FontAtlas}
+     */
+    fontAtlas: FontAtlas;
+    protected _entityCollections: EntityCollection[];
+    protected _currentOutput: string;
+    protected _fnScreenFrame: Function | null;
+    labelWorker: LabelWorker;
+    __useDistanceFramebuffer__: boolean;
+    screenDepthFramebuffer: Framebuffer | null;
+    screenFramePositionBuffer: WebGLBufferExt | null;
+    screenTexture: Record<string, WebGLTexture>;
+    outputTexture: WebGLTexture | null;
+    protected _pickingMaskCoordinatesBuffer: WebGLBufferExt | null;
+    protected _skipDistanceFrame: boolean;
+    protected _distancePixelBuffer: WebGLBuffer | null;
+    protected _skipPickingFrame: boolean;
+    protected _pickingPixelBuffer: WebGLBuffer | null;
+    protected _readDistanceBuffer: () => void;
+    protected _readPickingBuffer: () => void;
+    constructor(handler: Handler, params?: IRendererParams);
+    enableBlendOneSrcAlpha(): void;
+    enableBlendDefault(): void;
+    /**
+     * Sets renderer events activity.
+     * @param {Boolean} activity - Events activity.
+     */
+    setEventsActivity(activity: boolean): void;
+    addDepthCallback(sender: any, callback: Function): number;
+    removeDepthCallback(id: number): void;
+    addDistanceCallback(sender: any, callback: Function): number;
+    removeDistanceCallback(id: number): void;
+    /**
+     * Adds picking rendering callback function.
+     * @param {object} sender - Callback context.
+     * @param {Function} callback - Rendering callback.
+     * @returns {Number} Handler id
+     */
+    addPickingCallback(sender: any, callback: Function): number;
+    /**
+     * Removes picking rendering callback function.
+     * @param {Number} id - Handler id to remove.
+     */
+    removePickingCallback(id: number): void;
+    getPickingObject<T>(r: number, g: number, b: number): T;
+    getPickingObjectArr<T>(arr: NumberArray3 | Uint8Array): T;
+    getPickingObject3v<T>(vec: Vec3 | Vec4): T;
+    /**
+     * Assign picking color to the object.
+     * @public
+     * @param {Object} obj - Object that presume to be picked.
+     */
+    assignPickingColor<T>(obj: T & IPickingObject): void;
+    /**
+     * Removes picking color from object.
+     * @public
+     * @param {Object} obj - Object to remove picking color.
+     */
+    clearPickingColor<T>(obj: T & IPickingObject): void;
+    /**
+     * Get the client width.
+     * @public
+     * @returns {number} -
+     */
+    getWidth(): number;
+    /**
+     * Get the client height.
+     * @public
+     * @returns {number} -
+     */
+    getHeight(): number;
+    /**
+     * Get center of the canvas
+     * @public
+     * @returns {Vec2} -
+     */
+    getCenter(): Vec2;
+    /**
+     * Get center of the screen viewport
+     * @public
+     * @returns {Vec2} -
+     */
+    getClientCenter(): Vec2;
+    /**
+     * Add the given control to the renderer.
+     * @param {Control} control - Control.
+     */
+    addControl(control: Control): void;
+    /**
+     * Add the given controls array to the planet node.
+     * @param {Array.<Control>} cArr - Control array.
+     */
+    addControls(cArr: Control[]): void;
+    /**
+     * Remove control from the renderer.
+     * @param {Control} control  - Control.
+     */
+    removeControl(control: Control): void;
+    isInitialized(): boolean;
+    /**
+     * Renderer initialization.
+     * @public
+     */
+    initialize(): void;
+    _initReadPixelsBuffers(): void;
+    _initializeControls(): void;
+    resize(): void;
+    setCurrentScreen(screenName: string): void;
+    _resizeStart(): void;
+    _resizeEnd(): void;
+    removeNode(renderNode: RenderNode): void;
+    /**
+     * Adds render node to the renderer.
+     * @public
+     * @param {RenderNode} renderNode - Render node.
+     */
+    addNode(renderNode: RenderNode): void;
+    protected _initializeRenderNodes(): void;
+    /**
+     * Adds render node to the renderer before specific node.
+     * @public
+     * @param {RenderNode} renderNode - Render node.
+     * @param {RenderNode} renderNodeBefore - Insert before the renderNodeBefore node.
+     */
+    addNodeBefore(renderNode: RenderNode, renderNodeBefore: RenderNode): void;
+    /**
+     * Adds render nodes array to the renderer.
+     * @public
+     * @param {Array.<RenderNode>} nodesArr - Render nodes array.
+     */
+    addNodes(nodesArr: RenderNode[]): void;
+    getMaxMSAA(internalFormat: string): any;
+    getMSAA(): number;
+    /**
+     * TODO: replace with cache friendly linked list by BillboardHandler, LabelHandler etc.
+     */
+    enqueueEntityCollectionsToDraw(ecArr: EntityCollection[]): void;
+    /**
+     * Draws opaque items entity collections.
+     * @protected
+     */
+    protected _drawOpaqueEntityCollections(): void;
+    /**
+     * Draws transparent items entity collections.
+     * @protected
+     */
+    protected _drawTransparentEntityCollections(): void;
+    protected _clearEntityCollectionQueue(): void;
+    /**
+     * Draw nodes.
+     * @public
+     */
+    draw(): void;
+    protected _screenFrameMSAA(): void;
+    protected _screenFrameNoMSAA(): void;
+    /**
+     * Draw picking objects framebuffer.
+     * @private
+     */
+    protected _drawPickingBuffer(): void;
+    /**
+     * Draw picking objects framebuffer.
+     * @protected
+     */
+    protected _drawDistanceBuffer(): void;
+    protected _drawDepthBuffer(): void;
+    protected _readPickingBuffer_webgl1: () => void;
+    protected _readPickingBuffer_webgl2: () => void;
+    protected _readDistanceBuffer_webgl1: () => void;
+    protected _readDistanceBuffer_webgl2: () => void;
+    readPickingColor(x: number, y: number, outColor: NumberArray3 | Uint8Array): void;
+    readDistanceColor(x: number, y: number, outColor: NumberArray3 | Uint8Array): void;
+    /**
+     * Function starts renderer
+     * @public
+     */
+    start(): void;
+    destroy(): void;
+}
+export { Renderer };