@openglobus/og 0.22.2 → 0.24.0

package/css/og.css

@@ -8,6 +8,7 @@
     --grey6: #bfbfbf; /*map button icon color*/
     --grey7: #707070; /*slider progress color*/
     --grey8: #e2e2e2; /*text color*/
+    --grey9: #9f9f9f;
     --blue0: #1700a9ee;
 }
 
@@ -744,7 +745,7 @@ input {
     height: 20px;
 }
 
-.og-atmosphere.og-options-container  .og-slider input{
+.og-atmosphere.og-options-container .og-slider input {
     width: 87px;
 }
 
@@ -870,6 +871,7 @@ TIMELINE
     flex-direction: row;
     width: 200px;
     /*height: 20px;*/
+    gap: 5px;
 }
 
 .og-slider .og-slider-label {
@@ -890,6 +892,7 @@ TIMELINE
     height: 20px;
     background-color: var(--grey1);
     z-index: 1;
+    border-radius: 5px;
 }
 
 .og-slider .og-slider-panel .og-slider-progress {
@@ -897,6 +900,8 @@ TIMELINE
     height: 100%;
     background-color: var(--grey7);
     pointer-events: none;
+    border-top-left-radius: 5px;
+    border-bottom-left-radius: 5px;
 }
 
 .og-slider .og-slider-panel .og-slider-pointer {
@@ -919,6 +924,7 @@ TIMELINE
     color: var(--grey3);
     padding-left: 5px;
     width: 60px;
+    border-radius: 5px;
 }
 
 .og-slider input:focus-visible {
@@ -937,6 +943,116 @@ TIMELINE
     -moz-appearance: textfield;
 }
 
+
+/*
+    INPUT
+*/
+
+.og-checkbox,
+.og-input {
+    display: flex;
+    flex-direction: row;
+    margin: 5px;
+}
+
+.og-checkbox .og-input-label,
+.og-input .og-input-label {
+    width: 100%;
+    height: 100%;
+    color: var(--grey6);
+    font-family: "Segoe UI", Frutiger, "Frutiger Linotype", "Dejavu Sans", "Helvetica Neue", Arial, sans-serif;
+    font-size: 14px;
+    align-items: center;
+    text-align: left;
+    margin-right: 5px;
+}
+
+.og-checkbox input,
+.og-input input {
+    position: relative;
+    height: 100%;
+    width: 100%;
+    background: var(--grey5);
+    border: 1px solid var(--grey1);
+    z-index: 0;
+    color: var(--grey3);
+    padding-left: 5px;
+    border-radius: 5px;
+}
+
+.og-checkbox input:focus-visible,
+.og-input input:focus-visible {
+    outline: none;
+}
+
+.og-checkbox input[type="checkbox"] {
+    width: 14px;
+    height: 14px;
+    appearance: none;
+    -webkit-appearance: none;
+    display: flex;
+    align-content: center;
+    justify-content: center;
+    border: 1px solid var(--grey1);
+    border-radius: 3px;
+    background: var(--grey8);
+    cursor: pointer;
+    position: relative;
+    padding: 0;
+}
+
+.og-checkbox input[type="checkbox"]::before {
+    content: "";
+    position: absolute;
+    width: 3px;
+    height: 6px;
+    border: solid black;
+    border-width: 0 2px 2px 0;
+    transform: rotate(45deg);
+    top: 2px;
+    left: 3.5px;
+    opacity: 0;
+    transition: opacity 0.2s ease-in-out;
+}
+
+.og-checkbox input[type="checkbox"]:checked::before {
+    opacity: 1;
+}
+
+.og-checkbox input[type="checkbox"]:hover {
+    border-color: var(--grey2);
+}
+
+.og-checkbox .og-input-label {
+    margin-right: 0;
+}
+
+.og-checkbox-input {
+    width: 100%;
+}
+
+.og-input-disabled {
+    pointer-events: none;
+    opacity: 0.7;
+}
+
+.og-input-disabled input[type="checkbox"] {
+    background: var(--grey9);
+}
+
+/* Chrome, Safari, Edge, Opera */
+/*.og-input input::-webkit-outer-spin-button,*/
+/*.og-input input::-webkit-inner-spin-button {*/
+/*    -webkit-appearance: none;*/
+/*    margin: 0;*/
+/*}*/
+
+/* Firefox */
+.og-input input[type=number] {
+    -moz-appearance: textfield;
+}
+
+
 .og-selection_button {
     top: 117px;
     right: 12px;
@@ -1203,4 +1319,24 @@ TIMELINE
 
 .ldio-p0v5a1f6oz div {
     box-sizing: content-box;
+}
+
+.og-editor-ground_button {
+    width: fit-content;
+    background: var(--grey1);
+    padding: 4px 6px 8px;
+    margin-left: 5px;
+    margin-top: 15px;
+}
+
+.og-editor_toolbar {
+    padding-bottom: 8px;
+    display: flex;
+}
+
+.og-editor_toolbar-button {
+    width: 25px;
+    height: 25px;
+    float: left;
+    margin: 3px;
 }

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

@@ -33,7 +33,6 @@ export interface IGlobeParams {
     transitionOpacityEnabled?: boolean;
     terrain?: EmptyTerrain;
     controls?: Control[];
-    useEarthNavigation?: boolean;
     minSlope?: number;
     sun?: {
         active?: boolean;

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

@@ -8,32 +8,39 @@ interface IObject3dParams {
     indices?: number[];
     normals?: number[];
     center?: boolean;
-    src?: string;
     color?: number[] | TypedArray | string;
     scale?: number | Vec3;
+    ambient?: string | NumberArray3;
+    diffuse?: string | NumberArray3;
+    specular?: string | NumberArray3;
+    shininess?: number;
+    colorTexture?: string;
+    normalTexture?: string;
+    metallicRoughnessTexture?: string;
 }
 declare class Object3d {
     protected _name: string;
     protected _vertices: number[];
     protected _numVertices: number;
     protected _texCoords: number[];
-    /**
-     * Image src.
-     * @protected
-     * @type {string}
-     */
-    protected _src: string | null;
-    protected color: Float32Array;
     protected _indices: number[];
     protected _normals: number[];
+    color: Float32Array;
+    ambient: Float32Array;
+    diffuse: Float32Array;
+    specular: Float32Array;
+    shininess: number;
+    colorTexture: string;
+    normalTexture: string;
+    metallicRoughnessTexture: string;
+    center: Vec3;
     constructor(data?: IObject3dParams);
+    static getCenter(verts: number[]): Vec3;
     static centering(verts: number[]): void;
     centering(): this;
     applyMat4(m: Mat4): this;
     scale(s: Vec3): this;
     translate(v: Vec3): this;
-    get src(): string | null;
-    set src(src: string | null);
     get name(): string;
     get vertices(): number[];
     get normals(): number[];
@@ -63,8 +70,11 @@ declare class Object3d {
     static createFrustum(length?: number, width?: number, height?: number, xOffset?: number, yOffset?: number, zOffset?: number): Object3d;
     static createCylinder(radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number, heightSegments?: number, isTop?: boolean, isBottom?: boolean, offsetX?: number, offsetY?: number, offsetZ?: number): Object3d;
     static createCube(length?: number, height?: number, depth?: number, xOffset?: number, yOffset?: number, zOffset?: number): Object3d;
+    static createPlane(width?: number, height?: number, xOffset?: number, yOffset?: number, zOffset?: number): Object3d;
     static createArrow(back?: number, height?: number, front?: number): Object3d;
+    static readFileObj(objFile: File, mtlFile?: File): Promise<Object3d[]>;
     static loadObj(src: string): Promise<Object3d[]>;
     merge(other: Object3d): Object3d;
+    static merge(objects: Object3d[], maxSize?: number): Object3d;
 }
 export { Object3d };

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

@@ -6,6 +6,7 @@ import { Renderer } from "../renderer/Renderer";
 import { Vec2, NumberArray2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
 import { Sphere } from "../bv/Sphere";
+import { Quat } from "../math/Quat";
 type CameraEvents = ["viewchange", "moveend"];
 export interface ICameraParams {
     eye?: Vec3;
@@ -80,6 +81,7 @@ declare class Camera {
      * @type {Mat4}
      */
     protected _viewMatrix: Mat4;
+    protected _viewMatrixRTE: Mat4;
     /**
      * Camera normal matrix.
      * @protected
@@ -88,22 +90,28 @@ declare class Camera {
     protected _normalMatrix: Mat3;
     /**
      * Camera right vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _r: Vec3;
     /**
      * Camera up vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _u: Vec3;
     /**
      * Camera backward vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _b: Vec3;
+    /**
+     * Camera forward vector.
+     * @protected
+     * @type {Vec3}
+     */
+    _f: Vec3;
     protected _pr: Vec3;
     protected _pu: Vec3;
     protected _pb: Vec3;
@@ -116,6 +124,7 @@ declare class Camera {
     frustumColors: number[];
     FARTHEST_FRUSTUM_INDEX: number;
     currentFrustumIndex: number;
+    frustumColorIndex: number;
     isFirstPass: boolean;
     constructor(renderer: Renderer | null, options?: ICameraParams);
     checkMoveEnd(): void;
@@ -206,23 +215,40 @@ declare class Camera {
      */
     slide(du: number, dv: number, dn: number): void;
     /**
-     * Roll the camera to the angle in degrees
+     * Roll the camera to the angle in radians
+     * @public
+     * @param {number} angle - Delta roll angle in radians
+     */
+    setRoll(angle: number): void;
+    /**
+     * Pitch the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta roll angle in degrees
+     * @param {number} angle - Delta pitch angle in radians
      */
-    roll(angle: number): void;
+    setPitch(angle: number): void;
     /**
-     * Pitch the camera to the angle in degrees
+     * Yaw the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta pitch angle in degrees
+     * @param {number} angle - Delta yaw angle in radians
      */
-    pitch(angle: number): void;
+    setYaw(angle: number): void;
+    setPitchYawRoll(pitch: number, yaw: number, roll: number): void;
+    getPitch(): number;
+    getYaw(): number;
+    getRoll(): number;
     /**
-     * Yaw the camera to the angle in degrees
+     * Returns camera quaternion
+     */
+    getRotation(): Quat;
+    setRotation(rot: Quat, up?: Vec3, right?: Vec3, back?: Vec3): void;
+    rotate(rot: Quat): void;
+    /**
+     * Returns normal vector direction to the unprojected screen point from camera eye
      * @public
-     * @param {number} angle - Delta yaw angle in degrees
+     * @param {Vec2} pos - Screen X coordinate
+     * @returns {Vec3} - Direction vector
      */
-    yaw(angle: number): void;
+    unproject2v(pos: Vec2): Vec3;
     /**
      * Returns normal vector direction to the unprojected screen point from camera eye
      * @public
@@ -237,7 +263,16 @@ declare class Camera {
      * @param {Vec3} v - Cartesian 3d coordinates
      * @returns {Vec2} - Screen point coordinates
      */
-    project(v: Vec3): Vec2;
+    project3v(v: Vec3): Vec2;
+    /**
+     * Gets projected 3d point to the 2d screen coordinates
+     * @public
+     * @param {number} x - X coordinate
+     * @param {number} y - Y coordinate
+     * @param {number} z - Z coordinate
+     * @returns {Vec2} - Screen point coordinates
+     */
+    project(x: number, y: number, z: number): Vec2;
     /**
      * Rotates camera around center point
      * @public
@@ -247,7 +282,7 @@ declare class Camera {
      * @param {Vec3} [center] - Point that the camera rotates around
      * @param {Vec3} [up] - Camera up vector
      */
-    rotateAround(angle: number, isArc?: boolean, center?: Vec3 | null, up?: Vec3 | null): void;
+    rotateAround(angle: number, isArc?: boolean, center?: Vec3, up?: Vec3): void;
     /**
      * Rotates camera around center point by horizontal.
      * @public
@@ -257,7 +292,7 @@ declare class Camera {
      * @param {Vec3} [center] - Point that the camera rotates around.
      * @param {Vec3} [up] - Camera up vector.
      */
-    rotateHorizontal(angle: number, isArc?: boolean, center?: Vec3 | null, up?: Vec3 | null): void;
+    rotateHorizontal(angle: number, isArc?: boolean, center?: Vec3, up?: Vec3): void;
     /**
      * Rotates camera around center point by vertical.
      * @param {number} angle - Rotation angle in radians.
@@ -300,6 +335,12 @@ declare class Camera {
      * @return {Mat4} - Projection-view matrix.
      */
     getProjectionViewMatrix(): NumberArray16;
+    /**
+     * Returns projection and model RTE matrix product.
+     * @public
+     * @return {Mat4} - Projection-view matrix.
+     */
+    getProjectionViewRTEMatrix(): NumberArray16;
     /**
      * Returns inverse projection and model matrix product.
      * @public
@@ -312,5 +353,6 @@ declare class Camera {
      * @returns {Mat4} - Inverse projection-view matrix.
      */
     getInverseProjectionMatrix(): NumberArray16;
+    viewDistance(cartesian: Vec3, distance?: number): void;
 }
 export { Camera };

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

@@ -35,6 +35,7 @@ declare class Frustum {
      * @type {Mat4}
      */
     projectionViewMatrix: Mat4;
+    projectionViewRTEMatrix: Mat4;
     /**
      * Inverse projectionView Matrix.
      * @protected
@@ -81,6 +82,7 @@ declare class Frustum {
     getBackwardPlane(): NumberArray4;
     getForwardPlane(): NumberArray4;
     getProjectionViewMatrix(): NumberArray16;
+    getProjectionViewRTEMatrix(): NumberArray16;
     getProjectionMatrix(): NumberArray16;
     getInverseProjectionMatrix(): NumberArray16;
     /**
@@ -92,6 +94,7 @@ declare class Frustum {
      * @param {number} far - Far camera distance.
      */
     setProjectionMatrix(angle: number, aspect: number, near: number, far: number): void;
+    setProjectionViewRTEMatrix(viewRTEMatrix: Mat4): void;
     /**
      * Camera's projection matrix values.
      * @public

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

@@ -228,7 +228,20 @@ declare class PlanetCamera extends Camera {
     checkFly(): void;
     checkTerrainCollision(): Vec3 | undefined;
     getSurfaceVisibleDistance(d: number): number;
+    /**
+     * should be yje same as getYaw
+     */
     getHeading(): number;
     isVisible(poi: Vec3): boolean;
+    getPitch(): number;
+    /**
+     * should be the same as getHeading
+     */
+    getYaw(): number;
+    getRoll(): number;
+    setPitch(a: number): void;
+    setYaw(a: number): void;
+    setRoll(a: number): void;
+    setPitchYawRoll(pitch: number, yaw: number, roll: number): void;
 }
 export { PlanetCamera };

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

@@ -0,0 +1,38 @@
+import { Control, IControlParams } from "./Control";
+import { LonLat } from "../LonLat";
+import { Vec3 } from "../math/Vec3";
+import { EventsHandler } from "../Events";
+import { Entity } from "../entity/Entity";
+import { IMouseState } from "../renderer/RendererEvents";
+import { Planet } from "../scene/Planet";
+type CameraLockEventsList = ["lockview", "unlockview"];
+interface ICameraLockParams extends IControlParams {
+    planet?: Planet | null;
+}
+export declare class CameraLock extends Control {
+    events: EventsHandler<CameraLockEventsList>;
+    protected _lockDistance: number;
+    protected _isFromTheBack: boolean;
+    protected _lockEntity: Entity | null;
+    protected _viewDir: Vec3;
+    constructor(options?: ICameraLockParams);
+    onactivate(): void;
+    ondeactivate(): void;
+    oninit(): void;
+    flyCartesian(cartesian: Vec3, dist?: number): void;
+    lockView(entity: Entity, fromTheBack?: boolean): void;
+    protected _activateNav(): void;
+    protected _deactivateNav(): void;
+    unlockView(): void;
+    private _getCenterDist;
+    protected _getDistance(entity: Entity, prevEntity?: Entity | null): number;
+    isVisibleDistance(cart: Vec3, C?: number): boolean;
+    get lockEntity(): Entity | null;
+    flyLonLat(lonLat: LonLat, dist?: number): void;
+    protected _activateLockViewEvents(): void;
+    protected _deactivateLockViewEvents(): void;
+    private _onLockViewDraw;
+    protected _onMouseWheel: (e: IMouseState) => void;
+    protected _onMouseMove: (ms: IMouseState) => void;
+}
+export {};

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

@@ -1,64 +1,75 @@
 import { Control, IControlParams } from "./Control";
-import { Key } from "../Lock";
+import { IMouseState } from "../renderer/RendererEvents";
 import { Quat } from "../math/Quat";
 import { Sphere } from "../bv/Sphere";
-import { Vec3 } from "../math/Vec3";
 import { Vec2 } from "../math/Vec2";
-import { Planet } from "../scene/Planet";
-import { PlanetCamera } from "../camera/PlanetCamera";
-import { IMouseState } from "../renderer/RendererEvents";
-export interface IStepForward {
-    eye: Vec3;
-    v: Vec3;
-    u: Vec3;
-    n: Vec3;
-}
-interface IMouseNavigationParams extends IControlParams {
-    minSlope?: number;
+import { Vec3 } from "../math/Vec3";
+interface IEarthNavigationParams extends IControlParams {
+    speed?: number;
+    fixedUp?: boolean;
 }
-/**
- * Mouse planet camera dragging control.
- */
 export declare class MouseNavigation extends Control {
-    protected grabbedPoint: Vec3;
-    protected _eye0: Vec3;
-    protected pointOnEarth: Vec3;
-    protected earthUp: Vec3;
-    inertia: number;
-    protected grabbedSpheroid: Sphere;
-    protected qRot: Quat;
-    protected scaleRot: number;
-    protected distDiff: number;
-    protected stepsCount: number;
-    protected stepsForward: IStepForward[] | null;
-    protected stepIndex: number;
-    protected _lmbDoubleClickActive: boolean;
-    minSlope: number;
+    speed: number;
+    force: Vec3;
+    force_h: number;
+    force_v: number;
+    vel: Vec3;
+    vel_h: number;
+    vel_v: number;
+    mass: number;
+    vel_roll: number;
+    force_roll: number;
+    protected _lookPos: Vec3 | undefined;
+    protected _grabbedPoint: Vec3 | null;
+    protected _targetZoomPoint: Vec3 | null;
+    protected _targetDragPoint: Vec3 | null;
+    protected _targetRotationPoint: Vec3 | null;
+    protected _grabbedSphere: Sphere;
     protected _wheelDirection: number;
-    protected _keyLock: Key;
-    protected _deactivate: boolean;
+    protected _currScreenPos: Vec2;
+    protected _tUp: Vec3;
+    protected _tRad: number;
     protected _shiftBusy: boolean;
-    constructor(options?: IMouseNavigationParams);
-    static getMovePointsFromPixelTerrain(cam: PlanetCamera, planet: Planet, stepsCount: number, delta: number, point: Vec2, forward: boolean, dir?: Vec3 | null): IStepForward[] | undefined;
+    protected fixedUp: boolean;
+    protected _curPitch: number;
+    protected _curYaw: number;
+    protected _curRoll: number;
+    protected _rot: Quat;
+    protected _eye0: Vec3;
+    protected _grabbedCameraHeight: number;
+    protected _newEye: Vec3;
+    protected _isTouchPad: boolean;
+    protected _velInertia: number;
+    protected _hold: boolean;
+    protected _prevVel: Vec3;
+    protected _screenPosIsChanged: boolean;
+    protected _rotHDir: number;
+    protected _rotVDir: number;
+    constructor(options?: IEarthNavigationParams);
+    oninit(): void;
     onactivate(): void;
     ondeactivate(): void;
-    activateDoubleClickZoom(): void;
-    deactivateDoubleClickZoom(): void;
-    protected onMouseEnter(e: IMouseState): void;
-    protected onMouseLeave(): void;
-    protected onMouseWheel(e: IMouseState): void;
-    oninit(): void;
-    protected onMouseLeftButtonDoubleClick(e: IMouseState): void;
-    protected onMouseLeftButtonClick(): void;
-    stopRotation(): void;
-    protected onMouseLeftButtonUp(e: IMouseState): void;
-    protected onMouseLeftButtonDown(e: IMouseState): void;
-    protected onMouseRightButtonClick(e: IMouseState): void;
-    protected onMouseRightButtonDown(e: IMouseState): void;
-    onShiftFree(): void;
-    protected onMouseMove(e: IMouseState): void;
     protected onDraw(): void;
-    lockPlanet(skipTerrain?: boolean): void;
-    freePlanet(): void;
+    _onShiftFree: () => void;
+    protected _onMouseMove: (e: IMouseState) => void;
+    protected _onMouseEnter: (e: IMouseState) => void;
+    protected _onMouseLeave: () => void;
+    protected _onRHold: (e: IMouseState) => void;
+    protected _handleRotation(): void;
+    protected _onRDown: (e: IMouseState) => void;
+    protected _getTargetPoint(p: Vec2): Vec3 | null;
+    protected _onMouseWheel: (e: IMouseState) => void;
+    protected _onLDown: (e: IMouseState) => void;
+    protected _onLHold: (e: IMouseState) => void;
+    protected _onLUp: (e: IMouseState) => void;
+    protected _handleDrag(): void;
+    protected _corrRoll(): void;
+    protected _handleZoom(): void;
+    protected _updateVel(): void;
+    protected _updateVel_h(): void;
+    protected _updateVel_v(): void;
+    protected _updateVel_roll(): void;
+    protected get dt(): number;
+    stop(): void;
 }
 export {};

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

@@ -0,0 +1,64 @@
+import { Control, IControlParams } from "./Control";
+import { Key } from "../Lock";
+import { Quat } from "../math/Quat";
+import { Sphere } from "../bv/Sphere";
+import { Vec3 } from "../math/Vec3";
+import { Vec2 } from "../math/Vec2";
+import { Planet } from "../scene/Planet";
+import { PlanetCamera } from "../camera/PlanetCamera";
+import { IMouseState } from "../renderer/RendererEvents";
+export interface IStepForward {
+    eye: Vec3;
+    v: Vec3;
+    u: Vec3;
+    n: Vec3;
+}
+interface IMouseNavigationParams extends IControlParams {
+    minSlope?: number;
+}
+/**
+ * Mouse planet camera dragging control.
+ */
+export declare class OldMouseNavigation extends Control {
+    protected grabbedPoint: Vec3;
+    protected _eye0: Vec3;
+    protected pointOnEarth: Vec3;
+    protected earthUp: Vec3;
+    inertia: number;
+    protected grabbedSpheroid: Sphere;
+    protected qRot: Quat;
+    protected scaleRot: number;
+    protected distDiff: number;
+    protected stepsCount: number;
+    protected stepsForward: IStepForward[] | null;
+    protected stepIndex: number;
+    protected _lmbDoubleClickActive: boolean;
+    minSlope: number;
+    protected _wheelDirection: number;
+    protected _keyLock: Key;
+    protected _deactivate: boolean;
+    protected _shiftBusy: boolean;
+    constructor(options?: IMouseNavigationParams);
+    static getMovePointsFromPixelTerrain(cam: PlanetCamera, planet: Planet, stepsCount: number, delta: number, point: Vec2, forward: boolean, dir?: Vec3 | null): IStepForward[] | undefined;
+    onactivate(): void;
+    ondeactivate(): void;
+    activateDoubleClickZoom(): void;
+    deactivateDoubleClickZoom(): void;
+    protected onMouseEnter(e: IMouseState): void;
+    protected onMouseLeave(): void;
+    protected onMouseWheel(e: IMouseState): void;
+    oninit(): void;
+    protected onMouseLeftButtonDoubleClick(e: IMouseState): void;
+    protected onMouseLeftButtonClick(): void;
+    stopRotation(): void;
+    protected onMouseLeftButtonUp(e: IMouseState): void;
+    protected onMouseLeftButtonDown(e: IMouseState): void;
+    protected onMouseRightButtonClick(e: IMouseState): void;
+    protected onMouseRightButtonDown(e: IMouseState): void;
+    onShiftFree(): void;
+    protected onMouseMove(e: IMouseState): void;
+    protected onDraw(): void;
+    lockPlanet(skipTerrain?: boolean): void;
+    freePlanet(): void;
+}
+export {};