@openglobus/og 0.19.4 → 0.20.0

package/lib/@openglobus/js/entity/Ray.d.ts

@@ -0,0 +1,133 @@
+import { NumberArray3, Vec3 } from "../math/Vec3";
+import { NumberArray4, Vec4 } from "../math/Vec4";
+import { Entity } from "./Entity";
+import { RayHandler } from "./RayHandler";
+export interface IRayParams {
+    thickness?: number;
+    startPosition?: Vec3 | NumberArray3;
+    endPosition?: Vec3 | NumberArray3;
+    startColor?: string | NumberArray4;
+    endColor?: string | NumberArray4;
+    visibility?: boolean;
+}
+/**
+ * Ray class.
+ * @class
+ * @param {Object} [options] - Options:
+ * @param {Vec3|Array.<number>} [options.startPosition] - Ray start point position.
+ * @param {Vec3|Array.<number>} [options.endPosition] - Ray end point position.
+ * @param {Vec3|Array.<number>} [options.startColor] - Ray start point color.
+ * @param {Vec3|Array.<number>} [options.endColor] - Ray end point color.
+ * @param {boolean} [options.visibility] - Visibility.
+ */
+declare class Ray {
+    static __counter__: number;
+    /**
+     * Object uniq identifier.
+     * @protected
+     * @type {number}
+     */
+    protected __id: number;
+    _thickness: number;
+    protected _startPosition: Vec3;
+    _startPositionHigh: Vec3;
+    _startPositionLow: Vec3;
+    protected _endPosition: Vec3;
+    _endPositionHigh: Vec3;
+    _endPositionLow: Vec3;
+    _startColor: Vec4;
+    _endColor: Vec4;
+    /**
+     * Ray visibility.
+     * @protected
+     * @type {boolean}
+     */
+    protected _visibility: boolean;
+    /**
+     * Entity instance that holds this billboard.
+     * @public
+     * @type {Entity}
+     */
+    _entity: Entity | null;
+    /**
+     * Handler that stores and renders this billboard object.
+     * @public
+     * @type {BillboardHandler}
+     */
+    _handler: RayHandler | null;
+    /**
+     * Billboard handler array index.
+     * @public
+     * @type {number}
+     */
+    _handlerIndex: number;
+    constructor(options?: IRayParams);
+    /**
+     * Sets ray start position.
+     * @public
+     * @param {number} x - X coordinate.
+     * @param {number} y - Y coordinate.
+     * @param {number} z - Z coordinate.
+     */
+    setStartPosition(x: number, y: number, z: number): void;
+    getLength(): number;
+    /**
+     * Sets ray start position.
+     * @public
+     * @param {Vec3} position - Cartesian coordinates.
+     */
+    setStartPosition3v(position: Vec3): void;
+    /**
+     * Sets ray end position.
+     * @public
+     * @param {number} x - X coordinate.
+     * @param {number} y - Y coordinate.
+     * @param {number} z - Z coordinate.
+     */
+    setEndPosition(x: number, y: number, z: number): void;
+    /**
+     * Sets ray end position.
+     * @public
+     * @param {Vec3} position - Cartesian coordinates.
+     */
+    setEndPosition3v(position: Vec3): void;
+    setThickness(thickness: number): void;
+    setColors4v(startColor?: Vec4, endColor?: Vec4): void;
+    setColorsHTML(startColor?: string, endColor?: string): void;
+    /**
+     * Returns ray start position.
+     * @public
+     * @returns {Vec3}
+     */
+    getStartPosition(): Vec3;
+    /**
+     * Returns ray end position.
+     * @public
+     * @returns {Vec3}
+     */
+    getEndPosition(): Vec3;
+    /**
+     * Sets visibility.
+     * @public
+     * @param {boolean} visibility - Visibility flag.
+     */
+    setVisibility(visibility: boolean): void;
+    /**
+     * Returns visibility.
+     * @public
+     * @returns {boolean}
+     */
+    getVisibility(): boolean;
+    /**
+     * Remove from handler.
+     * @public
+     */
+    remove(): void;
+    /**
+     * Set picking color.
+     * @public
+     * @param {Vec3} color - Picking color.
+     */
+    setPickingColor3v(color: Vec3): void;
+}
+export { Ray };

package/lib/@openglobus/js/entity/RayHandler.d.ts

@@ -0,0 +1,70 @@
+import { TypedArray } from "../utils/shared";
+import { EntityCollection } from "./EntityCollection";
+import { Ray } from "./Ray";
+import { Renderer } from "../renderer/Renderer";
+import { Vec3 } from "../math/Vec3";
+import { Vec4 } from "../math/Vec4";
+import { WebGLBufferExt } from "../webgl/Handler";
+declare class RayHandler {
+    static __counter__: number;
+    protected __id: number;
+    /**
+     * Picking rendering option.
+     * @public
+     * @type {boolean}
+     */
+    pickingEnabled: boolean;
+    protected _entityCollection: EntityCollection;
+    protected _renderer: Renderer | null;
+    protected _rays: Ray[];
+    protected _vertexBuffer: WebGLBufferExt | null;
+    protected _startPositionHighBuffer: WebGLBufferExt | null;
+    protected _startPositionLowBuffer: WebGLBufferExt | null;
+    protected _endPositionHighBuffer: WebGLBufferExt | null;
+    protected _endPositionLowBuffer: WebGLBufferExt | null;
+    protected _thicknessBuffer: WebGLBufferExt | null;
+    protected _rgbaBuffer: WebGLBufferExt | null;
+    protected _pickingColorBuffer: WebGLBufferExt | null;
+    protected _vertexArr: TypedArray | number[];
+    protected _startPositionHighArr: TypedArray | number[];
+    protected _startPositionLowArr: TypedArray | number[];
+    protected _endPositionHighArr: TypedArray | number[];
+    protected _endPositionLowArr: TypedArray | number[];
+    protected _thicknessArr: TypedArray | number[];
+    protected _rgbaArr: TypedArray | number[];
+    protected _pickingColorArr: TypedArray | number[];
+    protected _buffersUpdateCallbacks: Function[];
+    protected _changedBuffers: boolean[];
+    constructor(entityCollection: EntityCollection);
+    static concArr(dest: number[], curr: number[]): void;
+    initProgram(): void;
+    setRenderer(renderer: Renderer): void;
+    refresh(): void;
+    protected _removeRays(): void;
+    clear(): void;
+    protected _deleteBuffers(): void;
+    update(): void;
+    add(ray: Ray): void;
+    protected _addRayToArrays(ray: Ray): void;
+    protected _displayPASS(): void;
+    protected _pickingPASS(): void;
+    draw(): void;
+    drawPicking(): void;
+    reindexRaysArray(startIndex: number): void;
+    protected _removeRay(ray: Ray): void;
+    remove(ray: Ray): void;
+    setStartPositionArr(index: number, positionHigh: Vec3, positionLow: Vec3): void;
+    setEndPositionArr(index: number, positionHigh: Vec3, positionLow: Vec3): void;
+    setPickingColorArr(index: number, color: Vec3): void;
+    setRgbaArr(index: number, startColor: Vec4, endColor: Vec4): void;
+    setThicknessArr(index: number, thickness: number): void;
+    setVisibility(index: number, visibility: boolean): void;
+    setVertexArr(index: number, vertexArr: number[]): void;
+    createStartPositionBuffer(): void;
+    createEndPositionBuffer(): void;
+    createRgbaBuffer(): void;
+    createThicknessBuffer(): void;
+    createVertexBuffer(): void;
+    createPickingColorBuffer(): void;
+}
+export { RayHandler };

package/lib/@openglobus/js/entity/Strip.d.ts

@@ -0,0 +1,139 @@
+import { Entity } from "./Entity";
+import { RenderNode } from "../scene/RenderNode";
+import { NumberArray3, Vec3 } from "../math/Vec3";
+import { NumberArray4, Vec4 } from "../math/Vec4";
+import { StripHandler } from "./StripHandler";
+import { WebGLBufferExt } from "../webgl/Handler";
+type TPoiExt = Vec3 | NumberArray3;
+type TStripExt = [TPoiExt, TPoiExt];
+type TPoi = Vec3;
+type TStrip = [TPoi, TPoi];
+export interface IStripParams {
+    visibility?: boolean;
+    color?: string | NumberArray4 | Vec4;
+    opacity?: number;
+    path?: TStrip[];
+}
+/**
+ * Strip object.
+ * @class
+ * @param {*} [options] - Strip options:
+ * @param {boolean} [options.visibility] - Strip visibility.
+ * @example <caption>Stripe example</caption>
+ * new og.Entity({
+ *     strip: {
+ *         gridSize: 10,
+ *         path: [
+ *             [[],[]],
+ *             [[],[]]
+ *         ]
+ *     }
+ * });
+ */
+declare class Strip {
+    static __counter__: number;
+    protected __id: number;
+    /**
+     * Strip visibility.
+     * @public
+     * @type {boolean}
+     */
+    visibility: boolean;
+    color: Float32Array;
+    /**
+     * Parent collection render node.
+     * @protected
+     * @type {RenderNode}
+     */
+    protected _renderNode: RenderNode | null;
+    /**
+     * Entity instance that holds this strip.
+     * @public
+     * @type {Entity}
+     */
+    _entity: Entity | null;
+    protected _verticesHighBuffer: WebGLBufferExt | null;
+    protected _verticesLowBuffer: WebGLBufferExt | null;
+    protected _indexBuffer: WebGLBufferExt | null;
+    protected _verticesHigh: number[];
+    protected _verticesLow: number[];
+    protected _indexes: number[];
+    protected _path: TStrip[];
+    protected _pickingColor: Float32Array;
+    protected _gridSize: number;
+    /**
+     * Handler that stores and renders this object.
+     * @public
+     * @type {StripHandler | null}
+     */
+    _handler: StripHandler | null;
+    _handlerIndex: number;
+    constructor(options?: IStripParams);
+    /**
+     * Assign picking color.
+     * @public
+     * @param {Vec3} color - Picking RGB color.
+     */
+    setPickingColor3v(color: Vec3): void;
+    /**
+     * Clears object
+     * @public
+     */
+    clear(): void;
+    /**
+     * Sets RGBA color. Each channel from 0.0 to 1.0.
+     * @public
+     * @param {Vec4} color - RGBA vector.
+     */
+    setColor4v(color: Vec4): void;
+    /**
+     * Sets strip color.
+     * @public
+     * @param {string} color - HTML style color.
+     */
+    setColorHTML(color: string): void;
+    setColor(r: number, g: number, b: number, a?: number): void;
+    /**
+     * Set strip opacity.
+     * @public
+     * @param {number} opacity - opacity.
+     */
+    setOpacity(opacity: number): void;
+    /**
+     * Sets cloud visibility.
+     * @public
+     * @param {boolean} visibility - Visibility flag.
+     */
+    setVisibility(visibility: boolean): void;
+    /**
+     * @return {boolean} Strip visibility.
+     */
+    getVisibility(): boolean;
+    /**
+     * Assign rendering scene node.
+     * @public
+     * @param {RenderNode}  renderNode - Assigned render node.
+     */
+    setRenderNode(renderNode: RenderNode): void;
+    /**
+     * Removes from entity.
+     * @public
+     */
+    remove(): void;
+    draw(): void;
+    drawPicking(): void;
+    /**
+     * Delete buffers
+     * @public
+     */
+    _deleteBuffers(): void;
+    protected _createBuffers(): void;
+    addEdge3v(p2: Vec3, p3: Vec3): void;
+    setEdge3v(p2: Vec3, p3: Vec3, index: number): void;
+    removeEdge(index: number): void;
+    setGridSize(gridSize: number): void;
+    getPath(): TStrip[];
+    setPath(path: TStripExt[] | TStrip[]): void;
+    insertEdge3v(p0: Vec3, p1: Vec3, index: number): void;
+}
+export { Strip };

package/lib/@openglobus/js/entity/StripHandler.d.ts

@@ -0,0 +1,42 @@
+import { EntityCollection } from "./EntityCollection";
+import { Renderer } from "../renderer/Renderer";
+import { RenderNode } from "../scene/RenderNode";
+import { Strip } from "./Strip";
+declare class StripHandler {
+    static __counter__: number;
+    protected __id: number;
+    /**
+     * Picking rendering option.
+     * @public
+     * @type {boolean}
+     */
+    pickingEnabled: boolean;
+    /**
+     * Parent collection
+     * @protected
+     * @type {EntityCollection}
+     */
+    protected _entityCollection: EntityCollection;
+    /**
+     * Renderer
+     * @protected
+     * @type {Renderer | null}
+     */
+    protected _renderer: Renderer | null;
+    /**
+     * Strip objects array
+     * @protected
+     * @type {Array.<Strip>}
+     */
+    protected _strips: Strip[];
+    constructor(entityCollection: EntityCollection);
+    protected _initProgram(): void;
+    setRenderNode(renderNode: RenderNode): void;
+    add(strip: Strip): void;
+    remove(strip: Strip): void;
+    reindexStripArray(startIndex: number): void;
+    draw(): void;
+    drawPicking(): void;
+    clear(): void;
+}
+export { StripHandler };

package/lib/@openglobus/js/entity/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./Billboard";
+export * from "./Entity";
+export * from "./EntityCollection";
+export * from "./Geometry";
+export * from "./GeoObject";
+export * from "./Label";
+export * from "./PointCloud";
+export * from "./Polyline";
+export * from "./Ray";
+export * from "./Strip";

package/lib/@openglobus/js/index.d.ts

@@ -0,0 +1,33 @@
+import * as jd from './astro/jd';
+import * as math from './math';
+import * as mercator from './mercator';
+import * as utils from './utils/shared';
+import * as bv from './bv/index';
+import * as control from './control/index';
+import * as scene from './scene/index';
+import * as terrain from './terrain/index';
+import * as layer from './layer/index';
+import * as webgl from './webgl/index';
+export * from './Globe';
+import { Geoid } from './terrain/Geoid';
+import { input } from './input/input';
+import { Ellipsoid, wgs84 } from './ellipsoid/index';
+import { Camera, PlanetCamera } from './camera/index';
+import { Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4 } from './math/index';
+import { Renderer } from './renderer/Renderer';
+import { LightSource } from './light/LightSource';
+import { Clock } from './Clock';
+import { Events } from './Events';
+import { Extent } from './Extent';
+import { LonLat } from './LonLat';
+import { RenderNode } from './scene/RenderNode';
+import { Planet } from './scene/Planet';
+import { Popup } from './Popup';
+import { EarthQuadTreeStrategy, MarsQuadTreeStrategy, QuadTreeStrategy, quadTreeStrategyType, Wgs84QuadTreeStrategy } from './quadTree/index';
+import { Object3d } from './Object3d';
+import { Handler, Program, Framebuffer, Multisample } from './webgl/index';
+import { Control } from './control/Control';
+export * from './entity/index';
+export * from './layer/index';
+import { EmptyTerrain, GlobusTerrain, RgbTerrain, BilTerrain, GlobusRgbTerrain } from './terrain/index';
+export { bv, jd, math, mercator, utils, input, control, scene, quadTreeStrategyType, wgs84, terrain, layer, webgl, Framebuffer, EmptyTerrain, GlobusTerrain, RgbTerrain, GlobusRgbTerrain, BilTerrain, Control, Camera, Ellipsoid, Planet, PlanetCamera, LightSource, Program, Handler, Multisample, Renderer, Clock, Events, Extent, LonLat, RenderNode, Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4, Geoid, Popup, QuadTreeStrategy, MarsQuadTreeStrategy, EarthQuadTreeStrategy, Wgs84QuadTreeStrategy, Object3d };

package/lib/@openglobus/js/input/KeyboardHandler.d.ts

@@ -0,0 +1,33 @@
+import { EventCallback, EventCallbackStamp } from "../Events";
+interface ICallbackHandler {
+    callback: EventCallbackStamp;
+    sender: any;
+    priority: number;
+}
+declare class KeyboardHandler {
+    protected _currentlyPressedKeys: Record<number, boolean>;
+    protected _pressedKeysCallbacks: Record<number, ICallbackHandler[]>;
+    protected _unpressedKeysCallbacks: Record<number, ICallbackHandler[]>;
+    protected _charkeysCallbacks: Record<number, ICallbackHandler[]>;
+    protected _anykeyCallback: any;
+    protected _event: KeyboardEvent | null;
+    protected _active: boolean;
+    protected _stampCache: Record<string, number>;
+    constructor();
+    getcurrentlyPressedKeys(): Record<number, boolean>;
+    getPressedKeysCallbacks(): Record<number, ICallbackHandler[]>;
+    getUnpressedKeysCallbacks(): Record<number, ICallbackHandler[]>;
+    getCharkeysCallbacks(): Record<number, ICallbackHandler[]>;
+    removeEvent(event: string, keyCode: number, callback: EventCallback): void;
+    protected _removeCallback(handlers: ICallbackHandler[], callback: EventCallbackStamp): void;
+    protected _getStamp(name: string, keyCode: number, ogid: number): string;
+    protected _stamp(name: string, keyCode: number, obj: any): boolean;
+    setActivity(activity: boolean): void;
+    releaseKeys(): void;
+    addEvent(event: string, keyCode: number, callback: EventCallback, sender?: any, priority?: number): void;
+    isKeyPressed(keyCode: number): boolean;
+    handleKeyDown(): void;
+    handleKeyUp(): void;
+    handleEvents(): void;
+}
+export { KeyboardHandler };

package/lib/@openglobus/js/input/MouseHandler.d.ts

@@ -0,0 +1,16 @@
+export type MouseEventExt = MouseEvent & {
+    wheelDelta?: number;
+    deltaY?: number;
+};
+export interface MouseHandlerEvent {
+    button?: number;
+    clientX: number;
+    clientY: number;
+}
+type MouseHandlerEventCallback = (sys: MouseEvent, event?: MouseHandlerEvent) => void;
+declare class MouseHandler {
+    protected _htmlObject: HTMLElement;
+    constructor(htmlObject: HTMLElement);
+    setEvent(event: string, sender: any, callback: MouseHandlerEventCallback): void;
+}
+export { MouseHandler };

package/lib/@openglobus/js/input/TouchHandler.d.ts

@@ -0,0 +1,11 @@
+export type TouchEventExt = TouchEvent & {
+    offsetLeft: number;
+    offsetTop: number;
+};
+type TouchHandlerEventCallback = (sys: TouchEventExt) => void;
+declare class TouchHandler {
+    protected _htmlObject: HTMLElement;
+    constructor(htmlObject: HTMLElement);
+    setEvent(event: string, sender: any, callback: TouchHandlerEventCallback): void;
+}
+export { TouchHandler };

package/lib/@openglobus/js/input/input.d.ts

@@ -0,0 +1,3 @@
+export declare const input: {
+    [id: string]: number;
+};

package/lib/@openglobus/js/layer/BaseGeoImage.d.ts

@@ -0,0 +1,145 @@
+import { Extent } from "../Extent";
+import { EventCallback, EventsHandler } from "../Events";
+import { Layer, LayerEventsList, ILayerParams } from "./Layer";
+import { LonLat } from "../LonLat";
+import { Material } from "./Material";
+import { NumberArray2 } from "../math/Vec2";
+import { NumberArray4 } from "../math/Vec4";
+import { Planet } from "../scene/Planet";
+import { WebGLBufferExt, WebGLTextureExt } from "../webgl/Handler";
+export interface IBaseGeoImageParams extends ILayerParams {
+    fullExtent?: boolean;
+    corners?: NumberArray2[];
+}
+type BaseGeoImageEventsList = [
+    "loadend"
+];
+export type BaseGeoImageEventsType = EventsHandler<BaseGeoImageEventsList> & EventsHandler<LayerEventsList>;
+/**
+ * BaseGeoImage layer represents square imagery layer that
+ * could be a static image, or animated video or webgl buffer
+ * object displayed on the globe.
+ * @class
+ * @extends {Layer}
+ */
+declare class BaseGeoImage extends Layer {
+    events: BaseGeoImageEventsType;
+    protected _projType: number;
+    protected _frameWidth: number;
+    protected _frameHeight: number;
+    protected _sourceReady: boolean;
+    protected _sourceTexture: WebGLTextureExt | null;
+    protected _materialTexture: WebGLTextureExt | null;
+    protected _gridBufferLow: WebGLBufferExt | null;
+    protected _gridBufferHigh: WebGLBufferExt | null;
+    protected _extentWgs84ParamsHigh: Float32Array;
+    protected _extentWgs84ParamsLow: Float32Array;
+    protected _extentMercParamsHigh: Float32Array;
+    protected _extentMercParamsLow: Float32Array;
+    protected _refreshFrame: boolean;
+    protected _frameCreated: boolean;
+    protected _sourceCreated: boolean;
+    _animate: boolean;
+    protected _ready: boolean;
+    _creationProceeding: boolean;
+    _isRendering: boolean;
+    protected _extentWgs84: Extent;
+    protected _cornersWgs84: LonLat[];
+    protected _cornersMerc: LonLat[];
+    protected _isFullExtent: number;
+    /**
+     * rendering function pointer
+     * @type {Function}
+     */
+    rendering: Function;
+    protected _onLoadend_: EventCallback | null;
+    constructor(name: string | null, options?: IBaseGeoImageParams);
+    get isIdle(): boolean;
+    addTo(planet: Planet): void;
+    protected _onLoadend(): void;
+    remove(): this;
+    get instanceName(): string;
+    /**
+     * Gets corners coordinates.
+     * @public
+     * @return {Array.<LonLat>} - (exactly 4 entries)
+     */
+    getCornersLonLat(): LonLat[];
+    /**
+     * Gets corners coordinates.
+     * @public
+     * @return {Array.<Array<number>>} - (exactly 3 entries)
+     */
+    getCorners(): NumberArray2[];
+    /**
+     * Sets geoImage geographical corners coordinates.
+     * @public
+     * @param {Array.<Array.<number>>} corners - GeoImage corners coordinates. Where first coordinate (exactly 3 entries)
+     * coincedents to the left top image corner, secont to the right top image corner, third to the right bottom
+     * and fourth - left bottom image corner.
+     */
+    setCorners(corners: NumberArray2[]): void;
+    /**
+     * Sets geoImage geographical corners coordinates.
+     * @public
+     * @param {Array.<LonLat>} corners - GeoImage corners coordinates. Where first coordinate
+     * coincedents to the left top image corner, secont to the right top image corner, third to the right bottom
+     * and fourth - left bottom image corner. (exactly 4 entries)
+     */
+    setCornersLonLat(corners: LonLat[]): void;
+    /**
+     * Creates geoImage frame.
+     * @protected
+     */
+    protected _createFrame(): void;
+    /**
+     * @public
+     * @override
+     * @param {Material} material - GeoImage material.
+     */
+    abortMaterialLoading(material: Material): void;
+    /**
+     * Clear layer material.
+     * @public
+     * @override
+     */
+    clear(): void;
+    /**
+     * Sets layer visibility.
+     * @public
+     * @override
+     * @param {boolean} visibility - GeoImage visibility.
+     */
+    setVisibility(visibility: boolean): void;
+    /**
+     * @public
+     * @param {Material} material - GeoImage material.
+     */
+    clearMaterial(material: Material): void;
+    /**
+     * @public
+     * @override
+     * @returns {Array<number>} -
+     */
+    applyMaterial(material: Material): NumberArray4;
+    /**
+     * Gets frame width size in pixels.
+     * @public
+     * @returns {Number} Frame width.
+     */
+    get getFrameWidth(): number;
+    /**
+     * Gets frame height size in pixels.
+     * @public
+     * @returns {Number} Frame height.
+     */
+    get getFrameHeight(): number;
+    /**
+     * Method depends on GeoImage instance
+     * @protected
+     */
+    protected _createSourceTexture(): void;
+    _renderingProjType1(): void;
+    protected _renderingProjType0(): void;
+}
+export { BaseGeoImage };

package/lib/@openglobus/js/layer/Bing.d.ts

@@ -0,0 +1,4 @@
+import { XYZ, IXYZParams } from "./XYZ";
+export declare class Bing extends XYZ {
+    constructor(name: string | null, options?: IXYZParams);
+}