@openglobus/og 0.22.2 → 0.24.0

package/lib/js/control/SimpleNavigation.js

@@ -1,5 +1,9 @@
 import { Control } from "./Control";
 import { input } from "../input/input";
+import { Vec3 } from "../math/Vec3";
+import * as math from "../math";
+import { Ray } from "../math/Ray";
+import { Plane } from "../math/Plane";
 /**
  * Simple keyboard camera navigation with W,S,A,D and shift keys to fly around the scene.
  */
@@ -9,13 +13,134 @@ export class SimpleNavigation extends Control {
             name: "SimpleNavigation",
             autoActivate: true, ...options
         });
-        this.speed = options.speed || 1.0;
+        this._onMouseLeftButtonClick = (e) => {
+            if (this._active && this.renderer) {
+                this.renderer.handler.canvas.classList.add("ogGrabbingPoiner");
+                this._grabbedPoint = this.renderer.getCartesianFromPixel(e);
+                if (this._grabbedPoint) {
+                    this._eye0.copy(this.renderer.activeCamera.eye);
+                }
+            }
+        };
+        this._onMouseLeftButtonUp = (e) => {
+            this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
+            if (e.x === e.prev_x && e.y === e.prev_y) {
+                //this.force.set(0, 0, 0);
+            }
+        };
+        this._onMouseLeftButtonDown = (e) => {
+            if (this._active && this.renderer) {
+                if (!this._grabbedPoint) {
+                    return;
+                }
+                if (e.moving) {
+                    let cam = this.renderer.activeCamera;
+                    let camSlope = Math.abs(cam.getForward().dot(Vec3.UP));
+                    let p0 = this._grabbedPoint, p1, p2;
+                    if (camSlope > 0.7) {
+                        p1 = Vec3.add(p0, Vec3.LEFT);
+                        p2 = Vec3.add(p0, cam.getRight());
+                    }
+                    else {
+                        p1 = Vec3.add(p0, cam.getRight());
+                        p2 = Vec3.add(p0, Vec3.UP);
+                    }
+                    let px = new Vec3();
+                    if (new Ray(cam.eye, e.direction).hitPlaneRes(Plane.fromPoints(p0, p1, p2), px) === Ray.INSIDE) {
+                        cam.eye = this._eye0.addA(px.subA(p0).negate());
+                    }
+                }
+            }
+        };
+        this._onRHold = (e) => {
+            if (this._lookPos && e.moving && this.renderer) {
+                const cam = this.renderer.activeCamera;
+                this.renderer.controlsBag.scaleRot = 1.0;
+                let l = (0.5 / cam.eye.distance(this._lookPos)) * math.RADIANS;
+                if (l > 0.007) {
+                    l = 0.007;
+                }
+                else if (l < 0.003) {
+                    l = 0.003;
+                }
+                cam.rotateHorizontal(l * (e.x - e.prev_x), false, this._lookPos, this._up);
+                cam.rotateVertical(l * (e.y - e.prev_y), this._lookPos);
+            }
+        };
+        this._onRDown = (e) => {
+            if (this.renderer) {
+                this._lookPos = this.renderer.getCartesianFromPixel(e.pos);
+                if (this._lookPos) {
+                    this._up = Vec3.UP; //this.renderer.activeCamera.getUp();
+                }
+            }
+        };
+        this._onMouseWheel = (e) => {
+            if (this.renderer) {
+                let pos = this.renderer.getCartesianFromPixel(e), dist = 10;
+                if (pos) {
+                    dist = this.renderer.activeCamera.eye.distance(pos);
+                }
+                this.force.addA(e.direction.scale(e.wheelDelta)).normalize().scale(dist);
+            }
+        };
+        this.onCameraMoveForward = () => {
+            this.force.addA(this.renderer.activeCamera.getForward()).normalize();
+        };
+        this.onCameraMoveBackward = () => {
+            this.force.addA(this.renderer.activeCamera.getBackward()).normalize();
+        };
+        this.onCameraStrifeLeft = () => {
+            this.force.addA(this.renderer.activeCamera.getLeft()).normalize();
+        };
+        this.onCameraStrifeRight = () => {
+            this.force.addA(this.renderer.activeCamera.getRight()).normalize();
+        };
+        this.onCameraLookUp = () => {
+            let cam = this.renderer.activeCamera;
+            cam.setPitch(0.5);
+            cam.update();
+        };
+        this.onCameraLookDown = () => {
+            let cam = this.renderer.activeCamera;
+            cam.setPitch(-0.5);
+            cam.update();
+        };
+        this.onCameraTurnLeft = () => {
+            let cam = this.renderer.activeCamera;
+            cam.setYaw(0.5);
+            cam.update();
+        };
+        this.onCameraTurnRight = () => {
+            let cam = this.renderer.activeCamera;
+            cam.setYaw(-0.5);
+            cam.update();
+        };
+        this.onCameraRollLeft = () => {
+            let cam = this.renderer.activeCamera;
+            cam.setRoll(-0.5);
+            cam.update();
+        };
+        this.onCameraRollRight = () => {
+            let cam = this.renderer.activeCamera;
+            cam.setRoll(0.5);
+            cam.update();
+        };
+        this.speed = options.speed || 1.0; // m/s
+        this.force = new Vec3();
+        this.vel = new Vec3();
+        this.mass = 1;
+        this._lookPos = undefined;
+        this._grabbedPoint = undefined;
+        this._up = null;
+        this._eye0 = new Vec3();
     }
     oninit() {
     }
     onactivate() {
         super.onactivate();
         let r = this.renderer;
+        r.events.on("mousewheel", this._onMouseWheel);
         r.events.on("keypress", input.KEY_W, this.onCameraMoveForward, this);
         r.events.on("keypress", input.KEY_S, this.onCameraMoveBackward, this);
         r.events.on("keypress", input.KEY_A, this.onCameraStrifeLeft, this);
@@ -26,10 +151,17 @@ export class SimpleNavigation extends Control {
         r.events.on("keypress", input.KEY_RIGHT, this.onCameraTurnRight, this);
         r.events.on("keypress", input.KEY_Q, this.onCameraRollLeft, this);
         r.events.on("keypress", input.KEY_E, this.onCameraRollRight, this);
+        r.events.on("rhold", this._onRHold, this);
+        r.events.on("rdown", this._onRDown, this);
+        r.events.on("lhold", this._onMouseLeftButtonDown);
+        r.events.on("ldown", this._onMouseLeftButtonClick);
+        r.events.on("lup", this._onMouseLeftButtonUp);
+        r.events.on("draw", this.onDraw, this, -1000);
     }
     ondeactivate() {
         super.ondeactivate();
         let r = this.renderer;
+        r.events.off("mousewheel", this._onMouseWheel);
         r.events.off("keypress", input.KEY_W, this.onCameraMoveForward);
         r.events.off("keypress", input.KEY_S, this.onCameraMoveBackward);
         r.events.off("keypress", input.KEY_A, this.onCameraStrifeLeft);
@@ -40,57 +172,25 @@ export class SimpleNavigation extends Control {
         r.events.off("keypress", input.KEY_RIGHT, this.onCameraTurnRight);
         r.events.off("keypress", input.KEY_Q, this.onCameraRollLeft);
         r.events.off("keypress", input.KEY_E, this.onCameraRollRight);
+        r.events.off("rhold", this._onRHold);
+        r.events.off("rdown", this._onRDown);
+        r.events.off("lhold", this._onMouseLeftButtonDown);
+        r.events.off("ldown", this._onMouseLeftButtonClick);
+        r.events.off("lup", this._onMouseLeftButtonUp);
+        r.events.off("draw", this.onDraw);
+    }
+    get dt() {
+        return 0.001 * this.renderer.handler.deltaTime;
     }
-    onCameraMoveForward() {
-        if (this._active) {
+    onDraw() {
+        if (this.renderer) {
+            let acc = this.force.scale(1.0 / this.mass);
+            this.vel.addA(acc);
+            this.vel.scale(0.96);
+            this.force.set(0, 0, 0);
             let cam = this.renderer.activeCamera;
-            cam.slide(0, 0, -this.speed);
+            cam.eye = cam.eye.add(this.vel.scaleTo(this.dt));
             cam.update();
         }
     }
-    onCameraMoveBackward() {
-        let cam = this.renderer.activeCamera;
-        cam.slide(0, 0, this.speed);
-        cam.update();
-    }
-    onCameraStrifeLeft() {
-        let cam = this.renderer.activeCamera;
-        cam.slide(-this.speed, 0, 0);
-        cam.update();
-    }
-    onCameraStrifeRight() {
-        let cam = this.renderer.activeCamera;
-        cam.slide(this.speed, 0, 0);
-        cam.update();
-    }
-    onCameraLookUp() {
-        let cam = this.renderer.activeCamera;
-        cam.pitch(0.5);
-        cam.update();
-    }
-    onCameraLookDown() {
-        let cam = this.renderer.activeCamera;
-        cam.pitch(-0.5);
-        cam.update();
-    }
-    onCameraTurnLeft() {
-        let cam = this.renderer.activeCamera;
-        cam.yaw(0.5);
-        cam.update();
-    }
-    onCameraTurnRight() {
-        let cam = this.renderer.activeCamera;
-        cam.yaw(-0.5);
-        cam.update();
-    }
-    onCameraRollLeft() {
-        let cam = this.renderer.activeCamera;
-        cam.roll(-0.5);
-        cam.update();
-    }
-    onCameraRollRight() {
-        let cam = this.renderer.activeCamera;
-        cam.roll(0.5);
-        cam.update();
-    }
 }

package/lib/js/control/Sun.js

@@ -13,7 +13,7 @@ export class Sun extends Control {
         this.activationHeight = options.activationHeight || 12079000.0;
         this.offsetVertical = options.offsetVertical || -5000000;
         this.offsetHorizontal = options.offsetHorizontal || 5000000;
-        this.sunlight = new LightSource("Sun", {
+        this.sunlight = new LightSource({
             ambient: new Vec3(0.15, 0.15, 0.25),
             diffuse: new Vec3(0.9, 0.9, 0.8),
             specular: new Vec3(0.1, 0.1, 0.06),
@@ -71,18 +71,18 @@ export class Sun extends Control {
                 this._lightOn = true;
                 this._f = 1;
                 let n = cam.eye.normal(), u = cam.getForward();
-                u.scale(Math.sign(cam._u.dot(n))); // up
+                u.scale(Math.sign(cam.getUp().dot(n))); // up
                 if (cam.slope > 0.99) {
-                    u = cam._u;
+                    u = cam.getUp();
                 }
                 let tu = Vec3.proj_b_to_plane(u, n, u).normalize().scale(this.offsetVertical);
-                let tr = Vec3.proj_b_to_plane(cam._r, n, cam._r)
+                let tr = Vec3.proj_b_to_plane(cam.getRight(), n, cam.getRight())
                     .normalize()
                     .scale(this.offsetHorizontal); // right
                 let d = tu.add(tr);
                 let pos = cam.eye.add(d);
                 if (this._k > 0) {
-                    this._k -= 0.01;
+                    this._k -= 0.001;
                     let rot = Quat.getRotationBetweenVectors(this.sunlight._position.normal(), pos.normal());
                     let r = rot.slerp(Quat.IDENTITY, this._k).normalize();
                     this.sunlight.setPosition3v(r.mulVec3(this.sunlight._position));
@@ -94,7 +94,7 @@ export class Sun extends Control {
             else {
                 this._k = 1;
                 if (this._f > 0) {
-                    this._f -= 0.01;
+                    this._f -= 0.001;
                     let rot = Quat.getRotationBetweenVectors(this.sunlight._position.normal(), getSunPosition(this._currDate).normal());
                     let r = rot.slerp(Quat.IDENTITY, this._f).normalize();
                     this.sunlight.setPosition3v(r.mulVec3(this.sunlight._position));

package/lib/js/control/TouchNavigation.js

@@ -7,6 +7,7 @@ import { Ray } from "../math/Ray";
 import { Sphere } from "../bv/Sphere";
 import { Vec2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
+import { Plane } from "../math/Plane";
 class TouchExt {
     constructor() {
         this.x = 0;
@@ -198,18 +199,19 @@ export class TouchNavigation extends Control {
                     this.qRot = Quat.getRotationBetweenVectors(targetPoint.normal(), t.grabbedPoint.normal());
                     let rot = this.qRot;
                     cam.eye = rot.mulVec3(cam.eye);
-                    cam._r = rot.mulVec3(cam._r);
-                    cam._u = rot.mulVec3(cam._u);
-                    cam._b = rot.mulVec3(cam._b);
+                    cam.rotate(rot);
+                    // cam._r = rot.mulVec3(cam._r);
+                    // cam._u = rot.mulVec3(cam._u);
+                    // cam._b = rot.mulVec3(cam._b);
                     cam.checkTerrainCollision();
                     cam.update();
                     this.scaleRot = 1;
                 }
                 else {
-                    let p0 = t.grabbedPoint, p1 = Vec3.add(p0, cam._u), p2 = Vec3.add(p0, p0.normal());
+                    let p0 = t.grabbedPoint, p1 = Vec3.add(p0, cam.getUp()), p2 = Vec3.add(p0, p0.getNormal());
                     let dir = cam.unproject(t.x, t.y);
                     let px = new Vec3();
-                    if (new Ray(cam.eye, dir).hitPlane(p0, p1, p2, px) === Ray.INSIDE) {
+                    if (new Ray(cam.eye, dir).hitPlaneRes(Plane.fromPoints(p0, p1, p2), px) === Ray.INSIDE) {
                         cam.eye = this._eye0.addA(px.subA(p0).negate());
                         cam.checkTerrainCollision();
                         cam.update();
@@ -243,9 +245,10 @@ export class TouchNavigation extends Control {
                 this.scaleRot = 0;
             }
             cam.eye = rot.mulVec3(cam.eye);
-            cam._r = rot.mulVec3(cam._r);
-            cam._u = rot.mulVec3(cam._u);
-            cam._b = rot.mulVec3(cam._b);
+            cam.rotate(rot);
+            // cam._r = rot.mulVec3(cam._r);
+            // cam._u = rot.mulVec3(cam._u);
+            // cam._b = rot.mulVec3(cam._b);
             cam.checkTerrainCollision();
             cam.update();
         }

package/lib/js/control/elevationProfile/ElevationProfileScene.js

@@ -8,6 +8,7 @@ import { Vector } from '../../layer/Vector';
 import { Vec2 } from '../../math/Vec2';
 import { Vec3 } from '../../math/Vec3';
 import { Ray } from "../../math/Ray";
+import { Plane } from "../../math/Plane";
 let groundObj3d = Object3d.createCylinder(0.33, 0, 1.0, 20, 1, true, false, 0, 0, 0);
 let headObj3d = Object3d.createCylinder(0.33, 0.33, 1.1, 20, 1, true, true, 0, -0.55, 0);
 const POINTER_RAY_OPTIONS = {
@@ -79,7 +80,7 @@ class ElevationProfileScene extends RenderNode {
                 let p1 = p0.add(groundNormal);
                 let p2 = p0.add(cam.getRight());
                 let px = new Vec3();
-                if (new Ray(cam.eye, e.direction).hitPlane(p0, p1, p2, px) === Ray.INSIDE) {
+                if (new Ray(cam.eye, e.direction).hitPlaneRes(Plane.fromPoints(p0, p1, p2), px) === Ray.INSIDE) {
                     let h = Vec3.proj_b_to_a(px, p0);
                     let s = h.sub(p0).dot(p0);
                     let headPos = p0.add(groundNormal.scale(Math.sign(s) * h.distance(p0)));
@@ -379,7 +380,7 @@ class ElevationProfileScene extends RenderNode {
                 groundEntity.setCartesian3v(groundPos);
                 heightLabelEntity.setCartesian3v(headPos);
                 heightLabelEntity.label.setText(`${hEll.toFixed(1)} m`);
-                heightLabelEntity.childrenNodes[0].label.setText(`${altitude.toFixed(1)} m`);
+                heightLabelEntity.childEntities[0].label.setText(`${altitude.toFixed(1)} m`);
                 headEntity.properties.altitude = altitude;
                 headEntity.setCartesian3v(headPos);
                 headEntity.properties.columnEntity.ray.setStartPosition3v(groundPos);
@@ -419,7 +420,7 @@ class ElevationProfileScene extends RenderNode {
                 let headPos = groundPos.add(groundNormal.scale(altitude));
                 heightLabelEntity.setCartesian3v(headPos);
                 heightLabelEntity.label.setText(`${hEll.toFixed(1)} m`);
-                heightLabelEntity.childrenNodes[0].label.setText(`${altitude.toFixed(1)} m`);
+                heightLabelEntity.childEntities[0].label.setText(`${altitude.toFixed(1)} m`);
                 headEntity.setCartesian3v(headPos);
                 headEntity.properties.columnEntity.ray.setEndPosition3v(headPos);
                 this._trackEntity.polyline?.setPoint3v(headPos, headEntity.properties.index);
@@ -444,7 +445,7 @@ class ElevationProfileScene extends RenderNode {
             headEntity.setCartesian3v(headPos);
             headEntity.properties.columnEntity.ray.setEndPosition3v(headPos);
             headEntity.properties.heightLabelEntity.setCartesian3v(headPos);
-            headEntity.properties.heightLabelEntity.childrenNodes[0].label.setText(`${altitude.toFixed(1)} m`);
+            headEntity.properties.heightLabelEntity.childEntities[0].label.setText(`${altitude.toFixed(1)} m`);
             this._trackEntity.polyline.setPoint3v(headPos, entityIndex);
             this.events.dispatch(this.events.change, this._pickedHeadEntity);
         }
@@ -468,7 +469,7 @@ class ElevationProfileScene extends RenderNode {
             this._trackEntity.polyline?.setPoint3v(headPos, headEntity.properties.index);
             heightLabelEntity.setCartesian3v(headPos);
             heightLabelEntity.label.setText(`${lonLat.height.toFixed(1)} m`);
-            heightLabelEntity.childrenNodes[0].label.setText(`${altitude.toFixed(1)} m`);
+            heightLabelEntity.childEntities[0].label.setText(`${altitude.toFixed(1)} m`);
             this.events.dispatch(this.events.change, groundEntity.properties.headEntity);
         }
     }

package/lib/js/control/geoObjectEditor/ArrowEntity.d.ts

@@ -0,0 +1,15 @@
+import { Entity, IEntityParams } from "../../entity/Entity";
+export interface IArrowEntityParams extends IEntityParams {
+    yaw?: number;
+    pitch?: number;
+    roll?: number;
+    size?: number;
+    color?: string;
+    properties?: any;
+}
+export declare class ArrowEntity extends Entity {
+    protected _size: number;
+    constructor(params?: IArrowEntityParams);
+    setSize(size: number): void;
+    setColorHTML(color: string): void;
+}

package/lib/js/control/geoObjectEditor/ArrowEntity.js

@@ -0,0 +1,59 @@
+import { Entity } from "../../entity/Entity";
+import { X_COLOR } from "./colors";
+import { Object3d } from "../../Object3d";
+import { Vec3 } from "../../math/Vec3";
+const SCALE = 0.1;
+const SCALE_VEC = new Vec3(SCALE, SCALE, SCALE);
+const TIP_LENGTH = 0.17;
+const TIP_RADIUS = 0.04;
+const SPIN_RADIUS = 0.0095;
+const lineObj = Object3d.createCylinder(SPIN_RADIUS, SPIN_RADIUS, 1.0 - TIP_LENGTH).scale(SCALE_VEC);
+const tipObj = Object3d.createCylinder(0, TIP_RADIUS, TIP_LENGTH, 16, 16, false, true, 0, -TIP_LENGTH).scale(SCALE_VEC);
+export class ArrowEntity extends Entity {
+    constructor(params = {}) {
+        const scale = 1.0;
+        super({
+            independentPicking: true,
+            yaw: params.yaw || 0,
+            pitch: params.pitch || 0,
+            roll: params.roll || 0,
+            forceGlobalPosition: true,
+            geoObject: {
+                color: params.color || X_COLOR,
+                scale,
+                tag: "line",
+                object3d: lineObj,
+            },
+            properties: params.properties
+        });
+        this._size = params.size != undefined ? params.size : 1.0;
+        this.appendChild(new Entity({
+            yaw: params.yaw || 0,
+            pitch: params.pitch || 0,
+            roll: params.roll || 0,
+            forceGlobalPosition: true,
+            geoObject: {
+                color: params.color || X_COLOR,
+                scale,
+                tag: "tip",
+                object3d: tipObj,
+            },
+            properties: params.properties
+        }));
+    }
+    setSize(size) {
+        this._size = size;
+        const scale = new Vec3(1, (this._size - TIP_LENGTH) / (1.0 - TIP_LENGTH), 1);
+        const trans = new Vec3(0, this._size * SCALE, 0);
+        let line = this;
+        let tip = line.childEntities[0];
+        line.setScale3v(scale);
+        tip.geoObject.setTranslate3v(trans);
+    }
+    setColorHTML(color) {
+        let line = this;
+        let tip = line.childEntities[0];
+        line.geoObject.setColorHTML(color);
+        tip.geoObject.setColorHTML(color);
+    }
+}

package/lib/js/control/geoObjectEditor/AxisTrackEntity.d.ts

@@ -0,0 +1,9 @@
+import { Entity, IEntityParams } from "../../entity/Entity";
+import { Vec3 } from "../../math/Vec3";
+export interface IAxisTrackEntityParams extends IEntityParams {
+}
+export declare class AxisTrackEntity extends Entity {
+    constructor(params?: IAxisTrackEntityParams);
+    private _init;
+    setCartesian3v(cart: Vec3): void;
+}

package/lib/js/control/geoObjectEditor/AxisTrackEntity.js

@@ -0,0 +1,93 @@
+import { Entity } from "../../entity/Entity";
+import { Vec3 } from "../../math/Vec3";
+import { SEL_X_COLOR, SEL_Y_COLOR, SEL_Z_COLOR } from "./colors";
+import { LonLat } from "../../LonLat";
+import { htmlColorToFloat32Array } from "../../utils/shared";
+const SEG_SIZE = 20;
+export class AxisTrackEntity extends Entity {
+    constructor(params = {}) {
+        super({ ...params, forceGlobalPosition: true });
+        this._init();
+    }
+    _init() {
+        const length = SEG_SIZE;
+        let lonColors = [], latCoords = [], yColors = [];
+        let lonCol = htmlColorToFloat32Array(SEL_X_COLOR), yCol = htmlColorToFloat32Array(SEL_Y_COLOR), latCol = htmlColorToFloat32Array(SEL_Z_COLOR);
+        for (let i = 0; i < length; i++) {
+            let op = 1;
+            if (i < 5) {
+                let t = i / 5;
+                op = 0.5 * (1 - Math.cos(Math.PI * t));
+            }
+            else if (i > 15) {
+                let t = (i - 15) / 5;
+                op = 1 - 0.5 * (1 - Math.cos(Math.PI * t));
+            }
+            latCoords.push([latCol[0], latCol[1], latCol[2], op]);
+            lonColors.push([lonCol[0], lonCol[1], lonCol[2], op]);
+            yColors.push([yCol[0], yCol[1], yCol[2], op]);
+        }
+        let axisX = new Entity({
+            polyline: {
+                path3v: [Array.from({ length }, (_, i) => new Vec3())],
+                thickness: 2.5,
+                pathColors: [lonColors],
+                isClosed: false
+            }
+        });
+        let axisY = new Entity({
+            polyline: {
+                path3v: [Array.from({ length }, (_, i) => new Vec3())],
+                thickness: 2.5,
+                pathColors: [yColors],
+                isClosed: false
+            }
+        });
+        let axisZ = new Entity({
+            polyline: {
+                path3v: [Array.from({ length }, (_, i) => new Vec3())],
+                thickness: 2.5,
+                pathColors: [latCoords],
+                isClosed: false
+            }
+        });
+        this.appendChild(axisX);
+        this.appendChild(axisY);
+        this.appendChild(axisZ);
+    }
+    setCartesian3v(cart) {
+        super.setCartesian3v(cart);
+        if (this._entityCollection && this._entityCollection.renderNode) {
+            let rn = this._entityCollection.renderNode;
+            let cam = rn.renderer.activeCamera;
+            let r = cam.eye.distance(cart) * 0.05;
+            if (rn.planet) {
+                let yCoords = [], lonCoords = [], latCoords = [];
+                let n = rn.planet.ellipsoid.getSurfaceNormal3v(cart);
+                let ll = this._lonLat;
+                let size = SEG_SIZE / 2;
+                for (let i = -size; i < size; i++) {
+                    latCoords.push(new LonLat(ll.lon, ll.lat + i, ll.height));
+                    lonCoords.push(new LonLat(ll.lon + i, ll.lat, ll.height));
+                    yCoords.push(cart.add(n.scaleTo(i * r)));
+                }
+                this.childEntities[0].polyline.setPathLonLatFast([lonCoords]);
+                this.childEntities[1].polyline.setPath3vFast([yCoords]);
+                this.childEntities[2].polyline.setPathLonLatFast([latCoords]);
+            }
+            else {
+                let zCoords = [], xCoords = [], yCoords = [];
+                let y = Vec3.UNIT_Y, x = Vec3.UNIT_X, z = Vec3.UNIT_Z;
+                let size = SEG_SIZE / 2;
+                for (let i = -size; i < size; i++) {
+                    xCoords.push(cart.add(x.scaleTo(i * r)));
+                    yCoords.push(cart.add(y.scaleTo(i * r)));
+                    zCoords.push(cart.add(z.scaleTo(i * r)));
+                }
+                this.childEntities[0].polyline.setPath3vFast([xCoords]);
+                this.childEntities[1].polyline.setPath3vFast([yCoords]);
+                this.childEntities[2].polyline.setPath3vFast([zCoords]);
+            }
+        }
+    }
+}

package/lib/js/control/geoObjectEditor/GeoObjectEditor.d.ts

@@ -0,0 +1,13 @@
+import { Control, IControlParams } from "../Control";
+import { GeoObjectEditorScene } from "./GeoObjectEditorScene";
+import { GeoObjectPropertiesDialog } from "./GeoObjectEditorDialog";
+export interface IGeoObjectEditorParams extends IControlParams {
+}
+export declare class GeoObjectEditor extends Control {
+    protected _geoObjectEditopScene: GeoObjectEditorScene;
+    protected _dialog: GeoObjectPropertiesDialog;
+    constructor(options?: IGeoObjectEditorParams);
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+}

package/lib/js/control/geoObjectEditor/GeoObjectEditor.js

@@ -0,0 +1,30 @@
+import { Control } from "../Control";
+import { GeoObjectEditorScene } from "./GeoObjectEditorScene";
+import { GeoObjectPropertiesDialog } from "./GeoObjectEditorDialog";
+import { CameraLock } from "../CameraLock";
+export class GeoObjectEditor extends Control {
+    constructor(options = {}) {
+        super(options);
+        this._geoObjectEditopScene = new GeoObjectEditorScene({
+            name: `geoObjectEditorScene:${this.__id}`
+        });
+        this._dialog = new GeoObjectPropertiesDialog({
+            model: this._geoObjectEditopScene
+        });
+    }
+    oninit() {
+        if (this.renderer) {
+            this.renderer.addControl(new CameraLock({ planet: this.planet }));
+            this._geoObjectEditopScene.bindPlanet(this.planet);
+            this._dialog.appendTo(this.renderer.div || document.body);
+            this.activate();
+        }
+    }
+    onactivate() {
+        this.renderer && this.renderer.addNode(this._geoObjectEditopScene);
+    }
+    ondeactivate() {
+        this.renderer && this.renderer.removeNode(this._geoObjectEditopScene);
+        this._dialog.hide();
+    }
+}

package/lib/js/control/geoObjectEditor/GeoObjectEditorDialog.d.ts

@@ -0,0 +1,69 @@
+import { Dialog, IDialogParams } from "../../ui/Dialog";
+import { GeoObjectEditorScene } from "./GeoObjectEditorScene";
+import { Entity } from "../../entity/Entity";
+import { Input } from "../../ui/Input";
+import { Checkbox } from "../../ui/Checkbox";
+import { Button } from "../../ui/Button";
+import { Vec3 } from "../../math/Vec3";
+interface IGeoObjectPropertiesDialog extends IDialogParams {
+    model: GeoObjectEditorScene;
+}
+export declare class GeoObjectPropertiesDialog extends Dialog<GeoObjectEditorScene> {
+    protected _relativePositionView: Checkbox;
+    protected _lonView: Input;
+    protected _latView: Input;
+    protected _heightView: Input;
+    protected _xView: Input;
+    protected _yView: Input;
+    protected _zView: Input;
+    protected _absXView: Input;
+    protected _absYView: Input;
+    protected _absZView: Input;
+    protected _pitchView: Input;
+    protected _yawView: Input;
+    protected _rollView: Input;
+    protected _absolutePitchView: Input;
+    protected _absoluteYawView: Input;
+    protected _absoluteRollView: Input;
+    protected _scaleView: Input;
+    protected _scaleXView: Input;
+    protected _scaleYView: Input;
+    protected _scaleZView: Input;
+    protected _groundBtn: Button;
+    constructor(params: IGeoObjectPropertiesDialog);
+    render(params: any): this;
+    protected _onVisibility: (vis: boolean) => void;
+    remove(): void;
+    protected _initSceneEvents(): void;
+    protected _clearSceneEvents(): void;
+    protected _onSelect: (entity: Entity) => void;
+    protected _refresh(entity: Entity): void;
+    hide(): void;
+    protected _onUnselect: (entity: Entity) => void;
+    protected _onChangeRelativePosition: (checked: boolean) => void;
+    protected _onPosition: (pos: Vec3, entity: Entity) => void;
+    protected _onPitch: (a: number, entity: Entity) => void;
+    protected _onYaw: (a: number, entity: Entity) => void;
+    protected _onRoll: (a: number, entity: Entity) => void;
+    protected _onChangeLon: (val: string) => void;
+    protected _onChangeLat: (val: string) => void;
+    protected _onChangeHeight: (val: string) => void;
+    protected _onChangeX: (val: string) => void;
+    protected _onChangeY: (val: string) => void;
+    protected _onChangeZ: (val: string) => void;
+    protected _onChangeAbsoluteX: (val: string) => void;
+    protected _onChangeAbsoluteY: (val: string) => void;
+    protected _onChangeAbsoluteZ: (val: string) => void;
+    protected _onChangePitch: (val: string) => void;
+    protected _onChangeYaw: (val: string) => void;
+    protected _onChangeRoll: (val: string) => void;
+    protected _onChangeAbsolutePitch: (val: string) => void;
+    protected _onChangeAbsoluteYaw: (val: string) => void;
+    protected _onChangeAbsoluteRoll: (val: string) => void;
+    protected _onChangeScale: (val: string) => void;
+    protected _onChangeScaleX: (val: string) => void;
+    protected _onChangeScaleY: (val: string) => void;
+    protected _onChangeScaleZ: (val: string) => void;
+    protected _onGround: () => void;
+}
+export {};