@openglobus/og 0.23.0 → 0.24.0

package/lib/js/control/OldMouseNavigation.js

@@ -0,0 +1,368 @@
+import * as math from "../math";
+import { Control } from "./Control";
+import { input } from "../input/input";
+import { Key } from "../Lock";
+import { LonLat } from "../LonLat";
+import { Mat4 } from "../math/Mat4";
+import { Quat } from "../math/Quat";
+import { Ray } from "../math/Ray";
+import { Sphere } from "../bv/Sphere";
+import { Vec3 } from "../math/Vec3";
+import { Plane } from "../math/Plane";
+/**
+ * Mouse planet camera dragging control.
+ */
+export class OldMouseNavigation extends Control {
+    constructor(options = {}) {
+        super(options);
+        this._deactivate = false;
+        this._shiftBusy = false;
+        this._name = "mouseNavigation";
+        this.grabbedPoint = new Vec3();
+        this._eye0 = new Vec3();
+        this.pointOnEarth = new Vec3();
+        this.earthUp = new Vec3();
+        this.inertia = 0.007;
+        this.grabbedSpheroid = new Sphere();
+        this.qRot = new Quat();
+        this.scaleRot = 0.0;
+        this.distDiff = 0.3;
+        this.stepsCount = 8;
+        this.stepsForward = null;
+        this.stepIndex = 0;
+        this._lmbDoubleClickActive = true;
+        this.minSlope = options.minSlope || 0.1;
+        this._wheelDirection = +1;
+        this._keyLock = new Key();
+    }
+    static getMovePointsFromPixelTerrain(cam, planet, stepsCount, delta, point, forward, dir) {
+        const steps = [];
+        let eye = cam.eye.clone(), n = cam.getBackward(), u = cam.getRight(), v = cam.getUp();
+        let a = planet.getCartesianFromPixelTerrain(point);
+        if (!a) {
+            a = planet.getCartesianFromPixelTerrain(planet.renderer.handler.getCenter());
+        }
+        if (a) {
+            if (!dir) {
+                dir = Vec3.sub(a, cam.eye).normalize();
+            }
+            let d = (delta * cam.eye.distance(a)) / stepsCount;
+            if (forward) {
+                d = -1.25 * d;
+            }
+            else {
+                d *= 2;
+            }
+            const scaled_n = n.scaleTo(d);
+            const slope = dir.dot(cam.eye.normal().negate());
+            if (slope >= 0.1) {
+                const grabbedSpheroid = new Sphere();
+                grabbedSpheroid.radius = a.length();
+                let rotArr = [], eyeArr = [];
+                let breaked = false;
+                for (let i = 0; i < stepsCount; i++) {
+                    eye.addA(scaled_n);
+                    const b = new Ray(eye, dir).hitSphere(grabbedSpheroid);
+                    eyeArr[i] = eye.clone();
+                    if (b) {
+                        rotArr[i] = new Mat4().rotateBetweenVectors(a.normal(), b.normal());
+                    }
+                    else {
+                        breaked = true;
+                        break;
+                    }
+                }
+                if (!breaked) {
+                    for (let i = 0; i < stepsCount; i++) {
+                        let rot = rotArr[i];
+                        steps[i] = {
+                            eye: rot.mulVec3(eyeArr[i]),
+                            v: rot.mulVec3(v),
+                            u: rot.mulVec3(u),
+                            n: rot.mulVec3(n)
+                        };
+                    }
+                }
+                else {
+                    eye = cam.eye.clone();
+                    for (let i = 0; i < stepsCount; i++) {
+                        steps[i] = {
+                            eye: eye.addA(scaled_n).clone(),
+                            v: v,
+                            u: u,
+                            n: n,
+                        };
+                    }
+                }
+            }
+            else {
+                for (let i = 0; i < stepsCount; i++) {
+                    steps[i] = {
+                        eye: eye.addA(dir.scaleTo(-d)).clone(),
+                        v: v,
+                        u: u,
+                        n: n,
+                    };
+                }
+            }
+            return steps;
+        }
+    }
+    onactivate() {
+        if (this.renderer) {
+            this.renderer.events.on("mousewheel", this.onMouseWheel, this);
+            this.renderer.events.on("lhold", this.onMouseLeftButtonDown, this);
+            this.renderer.events.on("rhold", this.onMouseRightButtonDown, this);
+            this.renderer.events.on("ldown", this.onMouseLeftButtonClick, this);
+            this.renderer.events.on("lup", this.onMouseLeftButtonUp, this);
+            this.renderer.events.on("rdown", this.onMouseRightButtonClick, this);
+            this.renderer.events.on("draw", this.onDraw, this, -1000);
+            this.renderer.events.on("mousemove", this.onMouseMove, this);
+            this.renderer.events.on("mouseleave", this.onMouseLeave, this);
+            this.renderer.events.on("mouseenter", this.onMouseEnter, this);
+            if (this._lmbDoubleClickActive) {
+                this.renderer.events.on("ldblclick", this.onMouseLeftButtonDoubleClick, this);
+            }
+        }
+    }
+    ondeactivate() {
+        if (this.renderer) {
+            this.renderer.events.off("mousewheel", this.onMouseWheel);
+            this.renderer.events.off("lhold", this.onMouseLeftButtonDown);
+            this.renderer.events.off("rhold", this.onMouseRightButtonDown);
+            this.renderer.events.off("ldown", this.onMouseLeftButtonClick);
+            this.renderer.events.off("lup", this.onMouseLeftButtonUp);
+            this.renderer.events.off("rdown", this.onMouseRightButtonClick);
+            this.renderer.events.off("draw", this.onDraw);
+            this.renderer.events.off("ldblclick", this.onMouseLeftButtonDoubleClick);
+            this.renderer.events.off("mouseleave", this.onMouseLeave);
+            this.renderer.events.off("mouseenter", this.onMouseEnter);
+        }
+    }
+    activateDoubleClickZoom() {
+        if (!this._lmbDoubleClickActive) {
+            this._lmbDoubleClickActive = true;
+            this.renderer && this.renderer.events.on("ldblclick", this.onMouseLeftButtonDoubleClick, this);
+        }
+    }
+    deactivateDoubleClickZoom() {
+        if (this._lmbDoubleClickActive) {
+            this._lmbDoubleClickActive = false;
+            this.renderer && this.renderer.events.off("ldblclick", this.onMouseLeftButtonDoubleClick);
+        }
+    }
+    onMouseEnter(e) {
+        const renderEvents = this.renderer.events;
+        if (renderEvents.isKeyPressed(input.KEY_ALT)) {
+            renderEvents.releaseKeys();
+        }
+        renderEvents.updateButtonsStates(e.sys.buttons);
+        if (renderEvents.mouseState.leftButtonDown) {
+            this.renderer.handler.canvas.classList.add("ogGrabbingPoiner");
+        }
+        else {
+            this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
+        }
+    }
+    onMouseLeave() {
+        if (this.renderer.events.mouseState.leftButtonDown) {
+            this.scaleRot = 0;
+        }
+        this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
+    }
+    onMouseWheel(e) {
+        if (this.stepIndex) {
+            return;
+        }
+        this.planet.stopFlying();
+        this.stopRotation();
+        this._deactivate = true;
+        this.lockPlanet(true);
+        this.stepsForward = OldMouseNavigation.getMovePointsFromPixelTerrain(this.planet.camera, this.planet, this.stepsCount, this.distDiff, e.pos, e.wheelDelta > 0, e.direction) || null;
+        this._wheelDirection = e.wheelDelta;
+        if (this.stepsForward) {
+            this.stepIndex = this.stepsCount;
+        }
+    }
+    oninit() {
+        this.activate();
+        if (this.renderer) {
+            this.renderer.events.on("keyfree", input.KEY_ALT, this.onShiftFree, this);
+            this.renderer.events.on("keyfree", input.KEY_PRINTSCREEN, this.onShiftFree, this);
+        }
+    }
+    onMouseLeftButtonDoubleClick(e) {
+        this.planet.stopFlying();
+        this.stopRotation();
+        const p = this.planet.getCartesianFromPixelTerrain(e.pos);
+        if (p) {
+            const cam = this.planet.camera;
+            let maxAlt = cam.maxAltitude + this.planet.ellipsoid.polarSize;
+            let minAlt = cam.minAltitude + this.planet.ellipsoid.polarSize;
+            const camAlt = cam.eye.length();
+            const g = this.planet.ellipsoid.cartesianToLonLat(p);
+            if (camAlt > maxAlt || camAlt < minAlt) {
+                this.planet.flyLonLat(new LonLat(g.lon, g.lat));
+                return;
+            }
+            if (this.renderer.events.isKeyPressed(input.KEY_ALT)) {
+                this.planet.flyLonLat(new LonLat(g.lon, g.lat, cam.eye.distance(p) * 2.0));
+            }
+            else {
+                this.planet.flyLonLat(new LonLat(g.lon, g.lat, cam.eye.distance(p) * 0.57));
+            }
+        }
+    }
+    onMouseLeftButtonClick() {
+        if (this._active) {
+            this.renderer.handler.canvas.classList.add("ogGrabbingPoiner");
+            this.grabbedPoint = this.planet.getCartesianFromMouseTerrain();
+            if (this.grabbedPoint) {
+                this._eye0.copy(this.planet.camera.eye);
+                this.grabbedSpheroid.radius = this.grabbedPoint.length();
+                this.stopRotation();
+            }
+        }
+    }
+    stopRotation() {
+        this.qRot.clear();
+        this.freePlanet();
+    }
+    onMouseLeftButtonUp(e) {
+        this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
+        if (e.x === e.prev_x && e.y === e.prev_y) {
+            this.scaleRot = 0.0;
+        }
+    }
+    onMouseLeftButtonDown(e) {
+        if (this._active) {
+            if (!this.grabbedPoint) {
+                return;
+            }
+            this.planet.stopFlying();
+            if (e.moving) {
+                let cam = this.planet.camera;
+                if (cam.slope > 0.2) {
+                    const targetPoint = new Ray(cam.eye, e.direction).hitSphere(this.grabbedSpheroid);
+                    if (targetPoint) {
+                        this.scaleRot = 1.0;
+                        this.qRot = Quat.getRotationBetweenVectors(targetPoint.normal(), this.grabbedPoint.normal());
+                        let rot = this.qRot;
+                        cam.eye = rot.mulVec3(cam.eye);
+                        cam.rotate(rot);
+                        // cam._u = rot.mulVec3(cam._u);
+                        // cam._r = rot.mulVec3(cam._r);
+                        // cam._b = rot.mulVec3(cam._b);
+                        // cam._f.set(-cam._b.x, -cam._b.y, -cam._b.z);
+                    }
+                }
+                else {
+                    let p0 = this.grabbedPoint, p1 = Vec3.add(p0, cam.getRight()), p2 = Vec3.add(p0, p0.normal());
+                    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());
+                    }
+                }
+            }
+        }
+    }
+    onMouseRightButtonClick(e) {
+        this.stopRotation();
+        this.planet.stopFlying();
+        this.pointOnEarth = this.planet.getCartesianFromPixelTerrain(e.pos);
+        if (this.pointOnEarth) {
+            this.earthUp = this.pointOnEarth.normal();
+        }
+    }
+    onMouseRightButtonDown(e) {
+        const cam = this.planet.camera;
+        if (this.pointOnEarth && e.moving) {
+            this.renderer.controlsBag.scaleRot = 1.0;
+            let l = (0.5 / cam.eye.distance(this.pointOnEarth)) * cam._lonLat.height * 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.pointOnEarth, this.earthUp);
+            cam.rotateVertical(l * (e.y - e.prev_y), this.pointOnEarth, this.minSlope);
+        }
+    }
+    onShiftFree() {
+        this._shiftBusy = false;
+    }
+    onMouseMove(e) {
+        if (this._active && this.renderer.events.isKeyPressed(input.KEY_ALT)) {
+            if (!this._shiftBusy) {
+                this._shiftBusy = true;
+                this.onMouseRightButtonClick(e);
+            }
+            this.onMouseRightButtonDown(e);
+        }
+    }
+    onDraw() {
+        if (this._active) {
+            const r = this.renderer;
+            const cam = this.planet.camera;
+            let prevEye = cam.eye.clone();
+            if (this.stepIndex) {
+                r.controlsBag.scaleRot = 1.0;
+                const sf = this.stepsForward[this.stepsCount - this.stepIndex--];
+                cam.eye = sf.eye;
+                //@ts-ignore
+                cam._u = sf.v;
+                //@ts-ignore
+                cam._r = sf.u;
+                //@ts-ignore
+                cam._b = sf.n;
+                //@ts-ignore
+                cam._f.set(-cam._b.x, -cam._b.y, -cam._b.z);
+            }
+            else {
+                if (this._deactivate) {
+                    this._deactivate = false;
+                    this.freePlanet();
+                }
+            }
+            if (r.events.mouseState.leftButtonDown || !this.scaleRot) {
+                return;
+            }
+            this.scaleRot -= this.inertia;
+            if (this.scaleRot <= 0.0) {
+                this.scaleRot = 0.0;
+            }
+            else {
+                r.controlsBag.scaleRot = this.scaleRot;
+                let rot = this.qRot
+                    .slerp(Quat.IDENTITY, 1.0 - this.scaleRot * this.scaleRot * this.scaleRot)
+                    .normalize();
+                if (!(rot.x || rot.y || rot.z)) {
+                    this.scaleRot = 0.0;
+                }
+                cam.eye = rot.mulVec3(cam.eye);
+                cam.rotate(rot);
+                // cam._u = rot.mulVec3(cam._u);
+                // cam._r = rot.mulVec3(cam._r);
+                // cam._b = rot.mulVec3(cam._b);
+                // cam._f.set(-cam._b.x, -cam._b.y, -cam._b.z);
+            }
+            if (cam.eye.distance(prevEye) / cam.getAltitude() > 0.01) {
+                this.lockPlanet();
+            }
+            else {
+                this.freePlanet();
+            }
+        }
+    }
+    lockPlanet(skipTerrain) {
+        this.planet.layerLock.lock(this._keyLock);
+        !skipTerrain && this.planet.terrainLock.lock(this._keyLock);
+        this.planet._normalMapCreator.lock(this._keyLock);
+    }
+    freePlanet() {
+        this.planet.layerLock.free(this._keyLock);
+        this.planet.terrainLock.free(this._keyLock);
+        this.planet._normalMapCreator.free(this._keyLock);
+    }
+}

package/lib/js/control/ScaleControl.js

@@ -63,13 +63,13 @@ export class ScaleControl extends Control {
         let s0 = px;
         let dist = this.planet.getDistanceFromPixel(s0) || 0;
         if (dist === 0) {
-            s0 = cam.project(Vec3.ZERO);
+            s0 = cam.project3v(Vec3.ZERO);
             dist = this.planet.getDistanceFromPixel(s0) || 0;
         }
         let p0 = cam.getForward().scaleTo(dist).addA(cam.eye);
         let tempSize = dist * Math.tan(cam.viewAngle * RADIANS);
         let p1 = p0.add(cam.getRight().scaleTo(tempSize));
-        let s1 = cam.project(p1);
+        let s1 = cam.project3v(p1);
         this._mPx = tempSize / s1.distance(s0);
         let metersInMinSize = this._mPx * this._minWidth;
         let index = binarySearch(scale, metersInMinSize, (a, b) => a - b);

package/lib/js/control/SimpleNavigation.js

@@ -3,6 +3,7 @@ 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.
  */
@@ -45,7 +46,7 @@ export class SimpleNavigation extends Control {
                         p2 = Vec3.add(p0, Vec3.UP);
                     }
                     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) {
                         cam.eye = this._eye0.addA(px.subA(p0).negate());
                     }
                 }
@@ -97,32 +98,32 @@ export class SimpleNavigation extends Control {
         };
         this.onCameraLookUp = () => {
             let cam = this.renderer.activeCamera;
-            cam.pitch(0.5);
+            cam.setPitch(0.5);
             cam.update();
         };
         this.onCameraLookDown = () => {
             let cam = this.renderer.activeCamera;
-            cam.pitch(-0.5);
+            cam.setPitch(-0.5);
             cam.update();
         };
         this.onCameraTurnLeft = () => {
             let cam = this.renderer.activeCamera;
-            cam.yaw(0.5);
+            cam.setYaw(0.5);
             cam.update();
         };
         this.onCameraTurnRight = () => {
             let cam = this.renderer.activeCamera;
-            cam.yaw(-0.5);
+            cam.setYaw(-0.5);
             cam.update();
         };
         this.onCameraRollLeft = () => {
             let cam = this.renderer.activeCamera;
-            cam.roll(-0.5);
+            cam.setRoll(-0.5);
             cam.update();
         };
         this.onCameraRollRight = () => {
             let cam = this.renderer.activeCamera;
-            cam.roll(0.5);
+            cam.setRoll(0.5);
             cam.update();
         };
         this.speed = options.speed || 1.0; // m/s

package/lib/js/control/Sun.js

@@ -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)));

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

@@ -4,6 +4,7 @@ import { Checkbox } from "../../ui/Checkbox";
 import { Button } from "../../ui/Button";
 import { Vec3 } from "../../math/Vec3";
 import { ToggleButton } from "../../ui/ToggleButton";
+import { DEGREES, RADIANS } from "../../math";
 const ICON_LOCK_BUTTON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="filter-center-focus">
   <path d="M5 15H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zM12 9c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"/>
 </svg>`;
@@ -41,39 +42,24 @@ export class GeoObjectPropertiesDialog extends Dialog {
         };
         this._onPosition = (pos, entity) => {
             this._refresh(entity);
-            // let ll = entity.getLonLat();
-            // this._lonView.stopPropagation();
-            // this._latView.stopPropagation();
-            // this._heightView.stopPropagation();
-            // this._lonView.value = ll.lon;
-            // this._latView.value = ll.lat;
-            // this._heightView.value = ll.height;
-            //
-            // let cart = entity.getCartesian();
-            // this._xView.stopPropagation();
-            // this._yView.stopPropagation();
-            // this._zView.stopPropagation();
-            // this._xView.value = cart.x;
-            // this._yView.value = cart.y;
-            // this._zView.value = cart.z;
         };
         this._onPitch = (a, entity) => {
             this._pitchView.stopPropagation();
-            this._pitchView.value = entity.getPitch();
+            this._pitchView.value = entity.getPitch() * DEGREES;
             this._absolutePitchView.stopPropagation();
-            this._absolutePitchView.value = entity.getAbsolutePitch();
+            this._absolutePitchView.value = entity.getAbsolutePitch() * DEGREES;
         };
         this._onYaw = (a, entity) => {
             this._yawView.stopPropagation();
-            this._yawView.value = entity.getYaw();
+            this._yawView.value = entity.getYaw() * DEGREES;
             this._absoluteYawView.stopPropagation();
-            this._absoluteYawView.value = entity.getAbsoluteYaw();
+            this._absoluteYawView.value = entity.getAbsoluteYaw() * DEGREES;
         };
         this._onRoll = (a, entity) => {
             this._rollView.stopPropagation();
-            this._rollView.value = entity.getRoll();
+            this._rollView.value = entity.getRoll() * DEGREES;
             this._absoluteRollView.stopPropagation();
-            this._absoluteRollView.value = entity.getAbsoluteRoll();
+            this._absoluteRollView.value = entity.getAbsoluteRoll() * DEGREES;
         };
         this._onChangeLon = (val) => {
             let entity = this.model.getSelectedEntity();
@@ -150,42 +136,42 @@ export class GeoObjectPropertiesDialog extends Dialog {
         this._onChangePitch = (val) => {
             let entity = this.model.getSelectedEntity();
             if (entity) {
-                entity.setPitch(parseFloat(val));
+                entity.setPitch(parseFloat(val) * RADIANS);
                 this._refresh(entity);
             }
         };
         this._onChangeYaw = (val) => {
             let entity = this.model.getSelectedEntity();
             if (entity) {
-                entity.setYaw(parseFloat(val));
+                entity.setYaw(parseFloat(val) * RADIANS);
                 this._refresh(entity);
             }
         };
         this._onChangeRoll = (val) => {
             let entity = this.model.getSelectedEntity();
             if (entity) {
-                entity.setRoll(parseFloat(val));
+                entity.setRoll(parseFloat(val) * RADIANS);
                 this._refresh(entity);
             }
         };
         this._onChangeAbsolutePitch = (val) => {
             let entity = this.model.getSelectedEntity();
             if (entity) {
-                entity.setAbsolutePitch(parseFloat(val));
+                entity.setAbsolutePitch(parseFloat(val) * RADIANS);
                 this._refresh(entity);
             }
         };
         this._onChangeAbsoluteYaw = (val) => {
             let entity = this.model.getSelectedEntity();
             if (entity) {
-                entity.setAbsoluteYaw(parseFloat(val));
+                entity.setAbsoluteYaw(parseFloat(val) * RADIANS);
                 this._refresh(entity);
             }
         };
         this._onChangeAbsoluteRoll = (val) => {
             let entity = this.model.getSelectedEntity();
             if (entity) {
-                entity.setAbsoluteRoll(parseFloat(val));
+                entity.setAbsoluteRoll(parseFloat(val) * RADIANS);
                 this._refresh(entity);
             }
         };
@@ -470,15 +456,15 @@ export class GeoObjectPropertiesDialog extends Dialog {
         this._pitchView.stopPropagation();
         this._yawView.stopPropagation();
         this._rollView.stopPropagation();
-        this._pitchView.value = entity.getPitch();
-        this._yawView.value = entity.getYaw();
-        this._rollView.value = entity.getRoll();
+        this._pitchView.value = entity.getPitch() * DEGREES;
+        this._yawView.value = entity.getYaw() * DEGREES;
+        this._rollView.value = entity.getRoll() * DEGREES;
         this._absolutePitchView.stopPropagation();
         this._absoluteYawView.stopPropagation();
         this._absoluteRollView.stopPropagation();
-        this._absolutePitchView.value = entity.getAbsolutePitch();
-        this._absoluteYawView.value = entity.getAbsoluteYaw();
-        this._absoluteRollView.value = entity.getAbsoluteRoll();
+        this._absolutePitchView.value = entity.getAbsolutePitch() * DEGREES;
+        this._absoluteYawView.value = entity.getAbsoluteYaw() * DEGREES;
+        this._absoluteRollView.value = entity.getAbsoluteRoll() * DEGREES;
         this._scaleView.stopPropagation();
         let scl = entity.getScale();
         if ((scl.x === scl.y) && (scl.y === scl.z)) {