@openglobus/og 0.19.3 → 0.20.0

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

@@ -0,0 +1,319 @@
+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 _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 };

package/lib/@openglobus/js/renderer/RendererEvents.d.ts

@@ -0,0 +1,240 @@
+import { Events, EventsHandler, EventCallback } from "../Events";
+import { KeyboardHandler } from "../input/KeyboardHandler";
+import { MouseHandler, MouseHandlerEvent, MouseEventExt } from "../input/MouseHandler";
+import { Renderer } from "./Renderer";
+import { TouchEventExt, TouchHandler } from "../input/TouchHandler";
+import { Vec2 } from "../math/Vec2";
+import { Vec3 } from "../math/Vec3";
+export type RendererEventsHandler = RendererEvents & EventsHandler<RendererEventsType>;
+export declare function createRendererEvents(renderer: Renderer): RendererEvents;
+export type RendererEventsType = [
+    "draw",
+    "drawtransparent",
+    "postdraw",
+    "resize",
+    "resizeend",
+    "mouseenter",
+    "mouseleave",
+    "mousemove",
+    "mousestop",
+    "lclick",
+    "rclick",
+    "mclick",
+    "ldblclick",
+    "rdblclick",
+    "mdblclick",
+    "lup",
+    "rup",
+    "mup",
+    "ldown",
+    "rdown",
+    "mdown",
+    "lhold",
+    "rhold",
+    "mhold",
+    "mousewheel",
+    "touchstart",
+    "touchend",
+    "touchcancel",
+    "touchmove",
+    "doubletouch",
+    "touchleave",
+    "touchenter"
+];
+export interface IBaseInputState {
+    /** Current screen mouse X position. */
+    clientX: number;
+    /** Current screen mouse Y position. */
+    clientY: number;
+    /** Current screen mouse position. */
+    pos: Vec2;
+    /** Current touch X - coordinate. */
+    x: number;
+    /** Current touch Y - coordinate. */
+    y: number;
+    /** Current touch X - coordinate from 0 to 1 */
+    nx: number;
+    /** Current touch Y - coordinate from 0 to 1 */
+    ny: number;
+    /** Previous touch X coordinate. */
+    prev_x: number;
+    /** Previous touch Y coordinate. */
+    prev_y: number;
+    /** Screen touch position world direction. */
+    direction: Vec3;
+    /** Current touched(picking) object. */
+    pickingObject: any | null;
+    /** Renderer instance. */
+    renderer: Renderer;
+    /** Touching is moving now. */
+    moving: boolean;
+}
+export interface IMouseState extends IBaseInputState {
+    /** Left mouse button has stopped pushing down right now.*/
+    leftButtonUp: boolean;
+    /** Right mouse button has stopped pushing down right now.*/
+    rightButtonUp: boolean;
+    /** Middle mouse button has stopped pushing down right now.*/
+    middleButtonUp: boolean;
+    /** Left mouse button has pushed now.*/
+    leftButtonDown: boolean;
+    /** Right mouse button has pushed now.*/
+    rightButtonDown: boolean;
+    /** Middle mouse button has pushed now.*/
+    middleButtonDown: boolean;
+    /** Left mouse button is pushing.*/
+    leftButtonHold: boolean;
+    /** Right mouse button is pushing.*/
+    rightButtonHold: boolean;
+    /** Middle mouse button is pushing.*/
+    middleButtonHold: boolean;
+    /** Left mouse button has clicked twice now.*/
+    leftButtonDoubleClick: boolean;
+    /** Right mouse button has clicked twice now.*/
+    rightButtonDoubleClick: boolean;
+    /** Middle mouse button has clicked twice now.*/
+    middleButtonDoubleClick: boolean;
+    /** Left mouse button has clicked now. */
+    leftButtonClick: boolean;
+    /** Right mouse button has clicked now. */
+    rightButtonClick: boolean;
+    /** Middle mouse button has clicked now. */
+    middleButtonClick: boolean;
+    /** Mouse has just stopped now. */
+    justStopped: boolean;
+    /** Mose double click delay response time.*/
+    doubleClickDelay: number;
+    /** Mose click delay response time.*/
+    clickDelay: number;
+    /** Mouse wheel. */
+    wheelDelta: number;
+    /** JavaScript mouse system event message. */
+    sys: MouseEvent | null;
+}
+export interface ITouchState extends IBaseInputState {
+    /** Touch has ended right now.*/
+    touchEnd: boolean;
+    /** Touch has started right now.*/
+    touchStart: boolean;
+    /** Touch canceled.*/
+    touchCancel: boolean;
+    /** Touched twice.*/
+    doubleTouch: boolean;
+    /** Double touching responce delay.*/
+    doubleTouchDelay: number;
+    /** Double touching responce radius in screen pixels.*/
+    doubleTouchRadius: number;
+    /** JavaScript mouse system event message. */
+    sys: TouchEventExt | null;
+}
+/**
+ * Renderer events handler.
+ * @class
+ * @param {Renderer} renderer - Renderer object, events that works for.
+ */
+declare class RendererEvents extends Events<RendererEventsType> implements RendererEventsHandler {
+    /**
+     * Assigned renderer.
+     * @public
+     * @type {Renderer}
+     */
+    renderer: Renderer;
+    /**
+     * Low level touch events handler.
+     * @protected
+     * @type {TouchHandler}
+     */
+    protected _touchHandler: TouchHandler;
+    /**
+     * Low level mouse events handler.
+     * @protected
+     * @type {MouseHandler}
+     */
+    protected _mouseHandler: MouseHandler;
+    /**
+     * Low level keyboard events handler.
+     * @protected
+     * @type {KeyboardHandler}
+     */
+    protected _keyboardHandler: KeyboardHandler;
+    protected _active: boolean;
+    clickRadius: number;
+    /**
+     * Current mouse state.
+     * @public
+     * @type {IMouseState}
+     */
+    mouseState: IMouseState;
+    /**
+     * Current touch state.
+     * @public
+     * @type {ITouchState}
+     */
+    touchState: ITouchState;
+    protected _dblTchCoords: Vec2;
+    protected _oneTouchStart: boolean;
+    protected _dblTchBegins: number;
+    protected _mousestopThread: any | null;
+    protected _ldblClkBegins: number;
+    protected _rdblClkBegins: number;
+    protected _mdblClkBegins: number;
+    protected _lClkBegins: number;
+    protected _rClkBegins: number;
+    protected _mClkBegins: number;
+    protected _lclickX: number;
+    protected _lclickY: number;
+    protected _rclickX: number;
+    protected _rclickY: number;
+    protected _mclickX: number;
+    protected _mclickY: number;
+    protected _isMouseInside: boolean;
+    protected _entityPickingEventsActive: boolean;
+    constructor(renderer: Renderer);
+    pointerEvent(): boolean;
+    get active(): boolean;
+    set active(isActive: boolean);
+    /**
+     * Used in render node frame.
+     * @public
+     */
+    handleEvents(): void;
+    on(name: string, p0: EventCallback | number, p1?: number | EventCallback, p2?: any, keyPriority?: number): void;
+    off(name: string, p1?: EventCallback | number | null, p2?: EventCallback): void;
+    /**
+     * Check key is pressed.
+     * @public
+     * @param {number} keyCode - Key code
+     * @return {boolean}
+     */
+    isKeyPressed(keyCode: number): boolean;
+    releaseKeys(): void;
+    /**
+     * Renderer events initialization.
+     * @public
+     */
+    initialize(): void;
+    /**
+     * @protected
+     */
+    protected onMouseWheel(event: MouseEventExt): void;
+    updateButtonsStates(buttons: number): void;
+    protected onMouseMove(sys: MouseEvent, event?: MouseHandlerEvent): void;
+    protected onMouseLeave(sys: MouseEvent): void;
+    protected onMouseEnter(sys: MouseEvent): void;
+    protected onMouseDown(sys: MouseEvent, event?: MouseHandlerEvent): void;
+    protected onMouseUp(sys: MouseEvent, event?: MouseHandlerEvent): void;
+    protected onTouchStart(event: TouchEventExt): void;
+    /**
+     * @protected
+     */
+    protected onTouchEnd(event: TouchEventExt): void;
+    protected onTouchCancel(event: TouchEventExt): void;
+    protected onTouchMove(event: TouchEventExt): void;
+    protected entityPickingEvents(): void;
+    protected handleMouseEvents(): void;
+    /**
+     * @protected
+     */
+    protected handleTouchEvents(): void;
+}
+export { RendererEvents };

package/lib/@openglobus/js/scene/Axes.d.ts

@@ -0,0 +1,12 @@
+import { RenderNode } from './RenderNode';
+import { WebGLBufferExt } from "../webgl/Handler";
+declare class Axes extends RenderNode {
+    size: number;
+    axesBuffer: WebGLBufferExt | null;
+    axesColorBuffer: WebGLBufferExt | null;
+    constructor(size?: number);
+    init(): void;
+    frame(): void;
+    createAxesBuffer(gridSize: number): void;
+}
+export { Axes };

package/lib/@openglobus/js/scene/BaseNode.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Scene node base class.
+ * @class
+ * @param {string} name - Node name.
+ */
+declare class BaseNode {
+    static __counter__: number;
+    protected __id: number;
+    /**
+     * Node name.
+     * @public
+     * @type {string}
+     */
+    protected _name: string;
+    /**
+     * Top scene tree node pointer.
+     * @public
+     * @type {BaseNode}
+     */
+    topNode: BaseNode;
+    protected _dictionary: Record<string, BaseNode>;
+    /**
+     * Children nodes.
+     * @public
+     * @type {Array.<BaseNode>}
+     */
+    childNodes: BaseNode[];
+    /**
+     * Parent node pointer.
+     * @public
+     * @type {BaseNode}
+     */
+    parentNode: BaseNode | null;
+    constructor(name?: string);
+    get name(): string;
+    /**
+     * Adds node to the current hierarchy.
+     * @public
+     * @type {BaseNode}
+     */
+    addNode(node: BaseNode): void;
+    /**
+     * Destroy node.
+     * @public
+     */
+    destroy(): void;
+    /**
+     * Gets node by name in the current.
+     * @public
+     * @param {string} name - Node name.
+     * @return {RenderNode} Node object in the current node.
+     */
+    getNodeByName(name: string): BaseNode;
+    /**
+     * Clear current node.
+     * @protected
+     */
+    protected _clear(): void;
+    isEqual(node: BaseNode): boolean;
+}
+export { BaseNode };