@openglobus/og 0.17.2 → 0.18.1

package/lib/js/quadTree/QuadTreeStrategy.js

@@ -0,0 +1,69 @@
+import { EPSG3857 } from "../proj/EPSG3857";
+export class QuadTreeStrategy {
+    constructor(planet, name = "", proj = EPSG3857) {
+        this.name = name;
+        this.projection = proj;
+        this._planet = planet;
+        this._quadTreeList = [];
+    }
+    destroyBranches() {
+        for (let i = 0, len = this._quadTreeList.length; i < len; i++) {
+            this._quadTreeList[i].destroyBranches();
+        }
+    }
+    clearLayerMaterial(layer) {
+        let lid = layer.__id;
+        for (let i = 0, len = this._quadTreeList.length; i < len; i++) {
+            this._quadTreeList[i].traverseTree(function (node) {
+                let mats = node.segment.materials;
+                if (mats[lid]) {
+                    mats[lid].clear();
+                    //@ts-ignore
+                    mats[lid] = null;
+                    //delete mats[lid];
+                }
+            });
+        }
+    }
+    get planet() {
+        return this._planet;
+    }
+    init() {
+    }
+    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();
+            }
+        }
+    }
+    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);
+                this._planet._normalMapCreator.drawSingle(quadTree.nodes[j].segment);
+            }
+        }
+    }
+    collectRenderNodes() {
+        for (let i = 0; i < this._quadTreeList.length; i++) {
+            this._quadTreeList[i].renderTree(this._planet.camera, 0, null);
+        }
+    }
+    clear() {
+        for (let i = 0; i < this._quadTreeList.length; i++) {
+            this._quadTreeList[i].clearTree();
+        }
+    }
+    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/lib/js/quadTree/quadTree.js

@@ -0,0 +1,66 @@
+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}
+ */
+export const NEIGHBOUR = [
+    [-1, -1, NW, NE],
+    [NE, -1, SE, -1],
+    [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
+ */
+export const OPPART = [
+    [SW, SE, NW, NE],
+    [NE, NW, SE, SW],
+    [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.
+ */
+export const NOPSORD = [
+    [0, 1, 0, 1],
+    [0, 0, 1, 1],
+    [0, 1, 0, 1],
+    [0, 0, 1, 1]
+];
+/**
+ * First index is {NW,NE,SW,SE}, another one is {N,E,S,W}
+ */
+export const COMSIDE = [
+    [true, false, false, true],
+    [true, true, false, false],
+    [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.
+ */
+export const PARTOFFSET = [
+    /*     N  E  S  W */
+    /*NW*/ [0, 1, 0, 0],
+    /*NE*/ [1, 0, 0, 0],
+    /*SW*/ [0, 1, 0, 1],
+    /*SE*/ [1, 1, 1, 1]
+];

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

@@ -0,0 +1,311 @@
+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;
+    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;
+    _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.
+     * @private
+     */
+    protected _drawDistanceBuffer(): void;
+    protected _drawDepthBuffer(): void;
+    protected _readPickingBuffer(): void;
+    protected _readDistanceBuffer(): 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 };