@openglobus/og 0.19.4 → 0.20.0

package/lib/@openglobus/js/camera/PlanetCamera.d.ts

@@ -0,0 +1,234 @@
+import { Camera, ICameraParams } from "./Camera";
+import { Key } from "../Lock";
+import { LonLat } from "../LonLat";
+import { Planet } from "../scene/Planet";
+import { Vec3 } from "../math/Vec3";
+import { Extent } from "../Extent";
+import { Segment } from "../segment/Segment";
+interface IPlanetCameraParams extends ICameraParams {
+    minAltitude?: number;
+    maxAltitude?: number;
+}
+type CameraFrame = {
+    eye: Vec3;
+    n: Vec3;
+    u: Vec3;
+    v: Vec3;
+};
+/**
+ * Planet camera.
+ * @class
+ * @extends {Camera}
+ * @param {Planet} planet - Planet render node.
+ * @param {IPlanetCameraParams} [options] - Planet camera options:
+ * @param {string} [options.name] - Camera name.
+ * @param {number} [options.viewAngle] - Camera angle of view.
+ * @param {number} [options.near] - Camera near plane distance. Default is 1.0
+ * @param {number} [options.far] - Camera far plane distance. Default is og.math.MAX
+ * @param {number} [options.minAltitude] - Minimal altitude for the camera. Default is 5
+ * @param {number} [options.maxAltitude] - Maximal altitude for the camera. Default is 20000000
+ * @param {Vec3} [options.eye] - Camera eye position. Default (0,0,0)
+ * @param {Vec3} [options.look] - Camera look position. Default (0,0,0)
+ * @param {Vec3} [options.up] - Camera eye position. Default (0,1,0)
+ */
+declare class PlanetCamera extends Camera {
+    /**
+     * Assigned camera's planet.
+     * @public
+     * @type {Planet}
+     */
+    planet: Planet;
+    /**
+     * Minimal altitude that camera can reach over the terrain.
+     * @public
+     * @type {number}
+     */
+    minAltitude: number;
+    /**
+     * Maximal altitude that camera can reach over the globe.
+     * @public
+     * @type {number}
+     */
+    maxAltitude: number;
+    /**
+     * Current geographical degree position.
+     * @public
+     * @type {LonLat}
+     */
+    _lonLat: LonLat;
+    /**
+     * Current geographical mercator position.
+     * @public
+     * @type {LonLat}
+     */
+    _lonLatMerc: LonLat;
+    /**
+     * Current altitude.
+     * @protected
+     * @type {number}
+     */
+    protected _terrainAltitude: number;
+    /**
+     * Cartesian coordinates on the terrain.
+     * @protected
+     * @type {Vec3}
+     */
+    protected _terrainPoint: Vec3;
+    /**
+     * Quad node that camera flies over.
+     * @protected
+     * @type {Segment}
+     */
+    _insideSegment: Segment | null;
+    slope: number;
+    protected _keyLock: Key;
+    protected _framesArr: CameraFrame[];
+    protected _framesCounter: number;
+    protected _numFrames: number;
+    protected _completeCallback: Function | null;
+    protected _frameCallback: Function | null;
+    protected _flying: boolean;
+    protected _checkTerrainCollision: boolean;
+    eyeNorm: Vec3;
+    constructor(planet: Planet, options?: IPlanetCameraParams);
+    setTerrainCollisionActivity(isActive: boolean): void;
+    /**
+     * Updates camera view space.
+     * @public
+     * @virtual
+     */
+    update(): void;
+    updateGeodeticPosition(): void;
+    /**
+     * Sets altitude over the terrain.
+     * @public
+     * @param {number} alt - Altitude over the terrain.
+     */
+    setAltitude(alt: number): void;
+    /**
+     * Gets altitude over the terrain.
+     * @public
+     */
+    getAltitude(): number;
+    /**
+     * Places camera to view to the geographical point.
+     * @public
+     * @param {LonLat} lonlat - New camera and camera view position.
+     * @param {LonLat} [lookLonLat] - Look up coordinates.
+     * @param {Vec3} [up] - Camera UP vector. Default (0,1,0)
+     */
+    setLonLat(lonlat: LonLat, lookLonLat?: LonLat, up?: Vec3): void;
+    /**
+     * Returns camera geographical position.
+     * @public
+     * @returns {LonLat}
+     */
+    getLonLat(): LonLat;
+    /**
+     * Returns camera height.
+     * @public
+     * @returns {number}
+     */
+    getHeight(): number;
+    /**
+     * Gets position by viewable extent.
+     * @public
+     * @param {Extent} extent - Viewable extent.
+     * @param {Number} height - Camera height
+     * @returns {Vec3}
+     */
+    getExtentPosition(extent: Extent, height?: number | null): Vec3;
+    /**
+     * View current extent.
+     * @public
+     * @param {Extent} extent - Current extent.
+     * @param {number} [height]
+     */
+    viewExtent(extent: Extent, height?: number): void;
+    /**
+     * Flies to the current extent.
+     * @public
+     * @param {Extent} extent - Current extent.
+     * @param {number} [height] - Destination height.
+     * @param {Vec3} [up] - Camera UP in the end of flying. Default - (0,1,0)
+     * @param {Number} [ampl] - Altitude amplitude factor.
+     * @param {Function} [completeCallback] - Callback that calls after flying when flying is finished.
+     * @param {Function} [startCallback] - Callback that calls before the flying begins.
+     * @param {Function} [frameCallback] - Each frame callback
+     */
+    flyExtent(extent: Extent, height?: number | null, up?: Vec3 | null, ampl?: number | null, completeCallback?: Function | null, startCallback?: Function | null, frameCallback?: Function | null): void;
+    viewDistance(cartesian: Vec3, distance?: number): void;
+    flyDistance(cartesian: Vec3, distance?: number, ampl?: number, completeCallback?: Function, startCallback?: Function, frameCallback?: Function): void;
+    /**
+     * Flies to the cartesian coordinates.
+     * @public
+     * @param {Vec3} cartesian - Finish cartesian coordinates.
+     * @param {Vec3} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
+     * @param {Vec3} [up] - Camera UP vector in the end of flying. Default - (0,1,0)
+     * @param {Number} [ampl=1.0] - Altitude amplitude factor.
+     * @param {Function} [completeCallback] - Callback that calls after flying when flying is finished.
+     * @param {Function} [startCallback] - Callback that calls before the flying begins.
+     * @param {Function} [frameCallback] - Each frame callback
+     */
+    flyCartesian(cartesian: Vec3, look?: Vec3 | LonLat | null, up?: Vec3 | null, ampl?: number, completeCallback?: Function | null, startCallback?: Function | null, frameCallback?: Function | null): void;
+    /**
+     * Flies to the geo coordinates.
+     * @public
+     * @param {LonLat} lonlat - Finish coordinates.
+     * @param {Vec3 | LonLat} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
+     * @param {Vec3} [up] - Camera UP vector in the end of flying. Default - (0,1,0)
+     * @param {number} [ampl] - Altitude amplitude factor.
+     * @param {Function} [completeCallback] - Callback that calls after flying when flying is finished.
+     * @param {Function} [startCallback] - Callback that calls befor the flying begins.
+     * @param {Function} [frameCallback] - each frame callback
+     */
+    flyLonLat(lonlat: LonLat, look?: Vec3 | LonLat, up?: Vec3, ampl?: number, completeCallback?: Function, startCallback?: Function, frameCallbak?: Function): void;
+    /**
+     * Breaks the flight.
+     * @public
+     */
+    stopFlying(): void;
+    /**
+     * Returns camera is flying.
+     * @public
+     * @returns {boolean}
+     */
+    isFlying(): boolean;
+    /**
+     * Rotates around planet to the left.
+     * @public
+     * @param {number} angle - Rotation angle.
+     * @param {boolean} [spin] - If its true rotates around globe spin.
+     */
+    rotateLeft(angle: number, spin: boolean): void;
+    /**
+     * Rotates around planet to the right.
+     * @public
+     * @param {number} angle - Rotation angle.
+     * @param {boolean} [spin] - If its true rotates around globe spin.
+     */
+    rotateRight(angle: number, spin: boolean): void;
+    /**
+     * Rotates around planet to the North Pole.
+     * @public
+     * @param {number} angle - Rotation angle.
+     */
+    rotateUp(angle: number): void;
+    /**
+     * Rotates around planet to the South Pole.
+     * @public
+     * @param {number} angle - Rotation angle.
+     */
+    rotateDown(angle: number): void;
+    rotateVertical(angle: number, center: Vec3, minSlope?: number): void;
+    /**
+     * Prepare camera to the frame. Used in render node frame function.
+     * @public
+     */
+    checkFly(): void;
+    checkTerrainCollision(): Vec3 | undefined;
+    getSurfaceVisibleDistance(d: number): number;
+    getHeading(): number;
+    isVisible(poi: Vec3): boolean;
+}
+export { PlanetCamera };

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

@@ -0,0 +1,3 @@
+import { Camera } from './Camera';
+import { PlanetCamera } from './PlanetCamera';
+export { Camera, PlanetCamera };

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

@@ -0,0 +1,40 @@
+/**
+ * Console logging singleton object.
+ * @class
+ */
+export declare class Cons {
+    protected _container: HTMLElement;
+    protected _visibility: boolean;
+    constructor();
+    getVisibility(): boolean;
+    setVisibility(visibility: boolean): void;
+    /**
+     * Show console panel.
+     * @public
+     */
+    show(): void;
+    /**
+     * Hide console panel.
+     * @public
+     */
+    hide(): void;
+    /**
+     * Adds error text in the console.
+     * @public
+     * @param {string} str - Error text.
+     */
+    logErr(str: string): void;
+    /**
+     * Adds warning text in the console.
+     * @public
+     * @param {string} str - Warning text.
+     */
+    logWrn(str: string): void;
+    /**
+     * Adds log text in the console.
+     * @public
+     * @param {string} str - Log text.
+     */
+    log(str: string): void;
+}
+export declare const cons: Cons;

package/lib/@openglobus/js/control/Atmosphere.d.ts

@@ -0,0 +1,16 @@
+import { Framebuffer } from "../webgl/Framebuffer";
+import { Control, IControlParams } from "./Control";
+interface IAtmosphereParams extends IControlParams {
+}
+export declare class Atmosphere extends Control {
+    _transmittanceBuffer: Framebuffer | null;
+    _scatteringBuffer: Framebuffer | null;
+    opacity: number;
+    constructor(options?: IAtmosphereParams);
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+    protected _drawAtmosphereTextures(): void;
+    protected _drawBackground(): void;
+}
+export {};

package/lib/@openglobus/js/control/CompassButton.d.ts

@@ -0,0 +1,16 @@
+import { Control, IControlParams } from "./Control";
+interface ICompasButtonParams extends IControlParams {
+}
+/**
+ * Planet compass button
+ */
+export declare class CompassButton extends Control {
+    protected _heading: number;
+    protected _svg: HTMLElement | null;
+    constructor(options?: ICompasButtonParams);
+    oninit(): void;
+    protected _onClick(): void;
+    protected _draw(): void;
+    setHeading(heading: number): void;
+}
+export {};

package/lib/@openglobus/js/control/Control.d.ts

@@ -0,0 +1,100 @@
+import { Planet, Renderer } from "../index";
+export interface IControlParams {
+    name?: string;
+    autoActivate?: boolean;
+}
+/**
+ * Base control class. All other controls extend from this class.
+ * @class Control
+ * @param {Boolean} [options.autoActivate=true] - If true - calls initialize function after the renderer assigning.
+ */
+export declare class Control {
+    static __counter__: number;
+    protected __id: number;
+    protected _name: string;
+    /**
+     * Control activity.
+     * @protected
+     * @type {boolean}
+     */
+    protected _active: boolean;
+    /**
+     * Control initialized.
+     * @protected
+     * @type {boolean}
+     */
+    protected _initialized: boolean;
+    planet: Planet | null;
+    /**
+     * Assigned renderer.
+     * @public
+     * @type {Renderer}
+     */
+    renderer: Renderer | null;
+    /**
+     * Auto activation flag.
+     * @public
+     * @type {boolean}
+     */
+    autoActivate: boolean;
+    protected _deferredActive: boolean;
+    constructor(options?: IControlParams);
+    /**
+     * Returns control name.
+     * @public
+     * @return {string} -
+     */
+    get name(): string;
+    /**
+     * Control initialization function have to be overridden.
+     * @public
+     */
+    oninit(): void;
+    /**
+     * Control renderer assigning function have to be overridden.
+     * @public
+     */
+    onadd(): void;
+    /**
+     * Control remove function have to be overridden.
+     * @public
+     */
+    onremove(): void;
+    /**
+     * Control activation function have to be overridden.
+     * @public
+     */
+    onactivate(): void;
+    /**
+     * Control deactivation function have to be overriden.
+     * @public
+     */
+    ondeactivate(): void;
+    /**
+     * Assign renderer to the control.
+     * @public
+     * @type {Renderer}
+     */
+    addTo(renderer: Renderer): void;
+    /**
+     * Removes control.
+     * @public
+     */
+    remove(): void;
+    /**
+     * Activate control.
+     * @public
+     */
+    activate(): void;
+    /**
+     * Deactivate control.
+     * @public
+     */
+    deactivate(): void;
+    /**
+     * Is control active.
+     * @public
+     */
+    isActive(): boolean;
+    isEqual(control: Control): boolean;
+}

package/lib/@openglobus/js/control/DebugInfo.d.ts

@@ -0,0 +1,25 @@
+import { Control, IControlParams } from "./Control";
+import { Dialog } from "../ui/Dialog";
+import { ToggleButton } from "../ui/ToggleButton";
+import { CanvasTiles } from "../layer/CanvasTiles";
+export interface IDebugInfoWatch {
+    label: string;
+    valEl?: HTMLElement;
+    frame?: () => string | number;
+}
+interface IDebugInfoParams extends IControlParams {
+    watch?: IDebugInfoWatch[];
+}
+export declare class DebugInfo extends Control {
+    el: HTMLElement | null;
+    protected _watch: IDebugInfoWatch[];
+    protected _toggleBtn: ToggleButton;
+    protected _dialog: Dialog<null>;
+    protected _canvasTiles: CanvasTiles;
+    constructor(options?: IDebugInfoParams);
+    addWatches(watches: IDebugInfoWatch[]): void;
+    addWatch(watch: IDebugInfoWatch): void;
+    oninit(): void;
+    protected _frame(): void;
+}
+export {};

package/lib/@openglobus/js/control/DrawingSwitcher.d.ts

@@ -0,0 +1,13 @@
+import { Control } from "./Control";
+import { DrawingControl } from "./drawing/DrawingControl";
+/**
+ * Activate drawing control
+ */
+export declare class DrawingSwitcher extends Control {
+    drawingControl: DrawingControl;
+    constructor(options?: {});
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+    protected _createMenu(): void;
+}

package/lib/@openglobus/js/control/EarthCoordinates.d.ts

@@ -0,0 +1,41 @@
+import { Control, IControlParams } from './Control';
+import { LonLat } from '../LonLat';
+import { IMouseState } from "../renderer/RendererEvents";
+interface IEarthCoordinatesParams extends IControlParams {
+    heightMode?: string;
+    centerMode?: boolean;
+    altitudeUnit?: string;
+    type?: number;
+}
+/**
+ * Control displays mouse or screen center Earth coordinates.
+ * @param {Boolean} [options.center] - Earth coordinates by screen center otherwise mouse pointer. False is default.
+ * @param {Boolean} [options.type] - Coordinates shown: 0 - is decimal degrees, 1 - degrees, 2 - mercator geodetic coordinates.
+ */
+export declare class EarthCoordinates extends Control {
+    protected _type: number;
+    protected _TYPE_FUNC: ((ll?: LonLat | null) => void)[];
+    protected _showFn: ((ll?: LonLat | null) => void) | null;
+    protected _lonLat: LonLat | null;
+    protected _latSideEl: HTMLElement | null;
+    protected _lonSideEl: HTMLElement | null;
+    protected _latValEl: HTMLElement | null;
+    protected _lonValEl: HTMLElement | null;
+    protected _heightEl: HTMLElement | null;
+    protected _altUnitVal: string;
+    protected _heightModeVal: string;
+    protected _altUnit: number;
+    protected _heightMode: number;
+    protected _centerMode: boolean;
+    protected _el: HTMLElement | null;
+    constructor(options?: IEarthCoordinatesParams);
+    protected _SHOW_DECIMAL(ll?: LonLat | null): void;
+    protected _SHOW_DEGREE(ll?: LonLat | null): void;
+    protected _createCenterEl(): HTMLElement;
+    protected _updateUnits(): void;
+    protected _refreshCoordinates(): void;
+    oninit(): void;
+    protected _grabCoordinates(e: IMouseState): void;
+    protected _showHeight(): Promise<void>;
+}
+export {};

package/lib/@openglobus/js/control/EarthNavigation.d.ts

@@ -0,0 +1,50 @@
+import { Control, IControlParams } from "./Control";
+import { ITouchState } from "../renderer/RendererEvents";
+import { IMouseState } from "../renderer/RendererEvents";
+import { Quat } from "../math/Quat";
+import { Sphere } from "../bv/Sphere";
+import { Vec3 } from "../math/Vec3";
+interface IEarthNavigationParams extends IControlParams {
+}
+declare class TouchExt {
+    x: number;
+    y: number;
+    prev_x: number;
+    prev_y: number;
+    grabbedPoint: Vec3 | null;
+    grabbedSpheroid: Sphere;
+    constructor();
+    dX(): number;
+    dY(): number;
+}
+export declare class EarthNavigation extends Control {
+    protected grabbedPoint: Vec3 | null;
+    protected grabbedDir: Vec3;
+    inertia: number;
+    protected grabbedSpheroid: Sphere;
+    protected _vRot: Quat;
+    protected _hRot: Quat;
+    protected _a: number;
+    protected scaleRot: number;
+    protected currState: number;
+    protected positionState: {
+        h: number;
+        max: number;
+        min: number;
+    }[];
+    protected touches: TouchExt[];
+    constructor(options?: IEarthNavigationParams);
+    switchZoomState(wheelDelta: number): void;
+    protected onMouseWheel(event: IMouseState): void;
+    oninit(): void;
+    onactivate(): void;
+    protected onTouchStart(e: ITouchState): void;
+    protected onTouchEnd(e: ITouchState): void;
+    protected onTouchMove(e: ITouchState): void;
+    protected onMouseLeftButtonClick(e: IMouseState): void;
+    stopRotation(): void;
+    protected onMouseLeftButtonUp(e: IMouseState): void;
+    protected onMouseLeftButtonDown(e: IMouseState): void;
+    protected onDraw(): void;
+}
+export {};

package/lib/@openglobus/js/control/GeoImageDragControl.d.ts

@@ -0,0 +1,22 @@
+import { Control, IControlParams } from './Control';
+import { Layer } from "../layer/Layer";
+import { ToggleButton } from "../ui/ToggleButton";
+import { IMouseState } from "../renderer/RendererEvents";
+interface IGeoImageDragControlParams extends IControlParams {
+}
+export declare class GeoImageDragControl extends Control {
+    protected _cornerIndex: number;
+    protected _catchCorner: boolean;
+    protected _toggleBtn: ToggleButton;
+    constructor(options?: IGeoImageDragControlParams);
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+    _bindLayer(layer: Layer): void;
+    protected _unbindLayer(layer: Layer): void;
+    protected _onLUp(ms: IMouseState): void;
+    protected _onLDown(ms: IMouseState): void;
+    protected _onMouseLeave(): void;
+    protected _onMouseMove(ms: IMouseState): void;
+}
+export {};

package/lib/@openglobus/js/control/KeyboardNavigation.d.ts

@@ -0,0 +1,28 @@
+import { Control, IControlParams } from "./Control";
+interface IKeyboardNavigationParams extends IControlParams {
+    step?: number;
+}
+/**
+ * Planet camera keyboard navigation. Use W,S,A,D and left shift key for fly around a planet.
+ */
+export declare class KeyboardNavigation extends Control {
+    step: number;
+    constructor(options?: IKeyboardNavigationParams);
+    onactivate(): void;
+    ondeactivate(): void;
+    oninit(): void;
+    protected onCameraMoveForward(): void;
+    protected onCameraMoveBackward(): void;
+    protected onCameraStrifeLeft(): void;
+    protected onCameraStrifeRight(): void;
+    protected onCameraLookUp(): void;
+    protected onCameraLookDown(): void;
+    protected onCameraLookLeft(): void;
+    protected onCameraLookRight(): void;
+    protected onCameraTurnLeft(): void;
+    protected onCameraTurnRight(): void;
+    protected onCameraRollNorth(): void;
+    protected onCameraRollLeft(): void;
+    protected onCameraRollRight(): void;
+}
+export {};

package/lib/@openglobus/js/control/LayerAnimation.d.ts

@@ -0,0 +1,71 @@
+import { EventsHandler } from '../Events';
+import { Layer } from '../layer/Layer';
+import { Control, IControlParams } from "./Control";
+type LayerAnimationEventsList = ["change", "idle", "play", "pause", "stop"];
+interface ILayerAnimationParams extends IControlParams {
+    layers?: Layer;
+    playInterval?: number;
+    frameSize?: number;
+    repeat?: boolean;
+    skipTimeout?: number;
+}
+export declare class LayerAnimation extends Control {
+    events: EventsHandler<LayerAnimationEventsList>;
+    protected _layersArr: Layer[];
+    protected _currentIndex: number;
+    protected _playInterval: number;
+    protected _playIntervalHandler: any;
+    protected _playIndex: number;
+    protected _frameSize: number;
+    repeat: boolean;
+    skipTimeout: number;
+    protected _timeoutStart: number;
+    protected _currVisibleIndex: number;
+    constructor(options?: ILayerAnimationParams);
+    protected _onViewchange: () => void;
+    protected _getFramesNum(): number;
+    protected _setFrame(frameIndex: number): void;
+    protected _getFrameIndex(layerIndex: number): number;
+    protected _appendFrameToPlanet(frameIndex: number): void;
+    protected _removeFrameFromPlanet(frameIndex: number): void;
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+    protected _onVisibilityChange: (isVisible: boolean) => void;
+    clear(): void;
+    protected _initLayers(): void;
+    setLayers(layers: Layer[]): void;
+    appendLayer(layer: Layer): void;
+    /**
+     * warning: Use XYZ.isIdle in requestAnimationFrame(after setVisibility)
+     * @returns Returns true if current layer is idle
+     */
+    get isIdle(): boolean;
+    get playInterval(): number;
+    set playInterval(val: number);
+    get isPlaying(): boolean;
+    get layers(): Layer[];
+    protected _checkEnd(): void;
+    play(): void;
+    stop(): void;
+    pause(): void;
+    protected _clearInterval(): void;
+    /**
+     * Waiting for the current index layer loadend and make it non-transparent,
+     * and make prev layer transparent, also check previous frame index to clean up.
+     */
+    private _onLayerLoadend;
+    /**
+     * Function sets layer index visible.
+     * @param {number} index
+     * @param {boolean} [stopPropagation=false]
+     */
+    setCurrentIndex(index: number, stopPropagation?: boolean): void;
+    /**
+     * Function sets layer index visible. If the layer is idle (all visible tiles loaded), sets opacity to one,
+     * otherwise to ZERO it means that when all visible tiles will be loaded the opacity becomes ONE. So, previous
+     * layer remains not transparent (opacity = 1) till current layer is loading.
+     */
+    protected _setCurrentIndexAsync(index: number, forceVisibility?: boolean, stopPropagation?: boolean): void;
+}
+export {};