@openglobus/og 0.22.1 → 0.23.0

package/lib/js/control/CameraLock.js

@@ -0,0 +1,216 @@
+import { Control } from "./Control";
+import { Quat } from "../math/Quat";
+import { Vec3 } from "../math/Vec3";
+import { createEvents } from "../Events";
+import { input } from "../input/input";
+import { RADIANS } from "../math";
+const MIN_LOCK_DISTANCE = 0.001;
+const MIN_VIEW_DISTANCE = 120.0;
+let qOrientationRot = new Quat();
+const t = 0.08;
+const CameraLockEvents = ["lockview", "unlockview"];
+export class CameraLock extends Control {
+    constructor(options = {}) {
+        super(options);
+        this._onLockViewDraw = () => {
+            if (this.renderer && this._lockEntity) {
+                if (this._isFromTheBack) {
+                    // let cam = this.planet.camera;
+                    // let vehPos = this._lockEntity.getCartesian(),
+                    //     vehDir = this._lockEntity.direction;
+                    // let currPos = vehPos.sub(this._viewDir.scaleTo(this._lockDistance));
+                    // let dh = new Vec3();
+                    // let currPosProj = new Plane(vehPos, vehPos.normal()).getProjectionPoint(currPos, dh);
+                    // let projViewDir = vehPos.sub(currPosProj);
+                    // Quat.getRotationBetweenVectorsRes(projViewDir.normal(), vehDir, qOrientationRot);
+                    // let rot = qOrientationRot.slerp(Quat.IDENTITY, 1.0 - t).normalize();
+                    // let projViewDir_t = rot.mulVec3(projViewDir.normal());
+                    // projViewDir = projViewDir_t.scale(projViewDir.length());
+                    // let newPos = vehPos.add(dh).sub(projViewDir);
+                    // this._viewDir = vehPos.sub(newPos).normalize();
+                    // cam.set(newPos, vehPos, vehPos.normal());
+                    // cam.update();
+                }
+                else {
+                    this.renderer.activeCamera.viewDistance(this._lockEntity.getAbsoluteCartesian(), this._lockDistance);
+                }
+            }
+        };
+        this._onMouseWheel = (e) => {
+            if (this.renderer && this._lockEntity) {
+                if (this._isFromTheBack) {
+                    //...
+                }
+                else {
+                    let d = this.renderer.activeCamera.eye.distance(this._lockEntity.getAbsoluteCartesian());
+                    this._lockDistance -= 0.33 * d * Math.sign(e.wheelDelta);
+                    if (this._lockDistance < MIN_LOCK_DISTANCE) {
+                        this._lockDistance = MIN_LOCK_DISTANCE;
+                    }
+                    this.renderer.activeCamera.viewDistance(this._lockEntity.getAbsoluteCartesian(), this._lockDistance);
+                }
+            }
+        };
+        this._onMouseMove = (ms) => {
+            if (this._lockEntity && this.renderer) {
+                if (ms.rightButtonDown || this.renderer.events.isKeyPressed(input.KEY_ALT)) {
+                    let p = this._lockEntity.getAbsoluteCartesian(), cam = this.renderer.activeCamera, l = 0.5 / RADIANS;
+                    if (l > 0.007)
+                        l = 0.007;
+                    if (this.planet) {
+                        cam.rotateHorizontal(l * (ms.x - ms.prev_x), false, p, p.isZero() ? Vec3.UP : p.normal());
+                    }
+                    else {
+                        cam.rotateHorizontal(l * (ms.x - ms.prev_x), false, p, Vec3.UP);
+                    }
+                    cam.rotateVertical(l * (ms.y - ms.prev_y), p);
+                    this._viewDir = p.sub(cam.eye).normalize();
+                }
+            }
+        };
+        this.events = createEvents(CameraLockEvents);
+        this._name = "CameraLock";
+        this.planet = options.planet || null;
+        this._lockDistance = 0;
+        this._isFromTheBack = false;
+        this._lockEntity = null;
+        this._viewDir = new Vec3(0, 0, 0);
+    }
+    onactivate() {
+        if (this.renderer) {
+        }
+    }
+    ondeactivate() {
+        if (this.renderer) {
+            this.unlockView();
+        }
+    }
+    oninit() {
+        this.activate();
+        if (this.renderer) {
+        }
+    }
+    flyCartesian(cartesian, dist = MIN_VIEW_DISTANCE) {
+        if (cartesian.isZero() || !this.renderer) {
+            return;
+        }
+        this.unlockView();
+        if (this.planet) {
+            let cam = this.planet.camera;
+            if (this.isVisibleDistance(cartesian)) {
+                cam.flyDistance(cartesian, dist);
+            }
+            if (cam.eye.distance(cartesian) < 1000000.0) {
+                cam.flyDistance(cartesian, dist);
+            }
+            else {
+                cam.viewDistance(cartesian, dist);
+            }
+        }
+        else {
+            this.renderer.activeCamera.viewDistance(cartesian, dist);
+        }
+    }
+    lockView(entity, fromTheBack = false) {
+        if (!this.renderer)
+            return;
+        this._lockDistance = this._getDistance(entity, this._lockEntity);
+        this._isFromTheBack = fromTheBack;
+        this._deactivateLockViewEvents();
+        this._lockEntity = entity;
+        let cam = this.renderer.activeCamera;
+        if (this.planet) {
+            this.planet.camera.stopFlying();
+        }
+        cam.viewDistance(entity.getAbsoluteCartesian(), this._lockDistance);
+        this._deactivateNav();
+        this._activateLockViewEvents();
+        this._viewDir = entity.getAbsoluteCartesian().sub(cam.eye).normalize();
+        this.events.dispatch(this.events.lockview, this._lockEntity, fromTheBack);
+    }
+    _activateNav() {
+        if (this.renderer && this.renderer.controls.mouseNavigation) {
+            this.renderer.controls.mouseNavigation.activate();
+        }
+        if (this.renderer && this.renderer.controls.simpleNavigation) {
+            this.renderer.controls.simpleNavigation.activate();
+        }
+    }
+    _deactivateNav() {
+        if (this.renderer && this.renderer.controls.mouseNavigation) {
+            this.renderer.controls.mouseNavigation.deactivate();
+            this.renderer.controls.mouseNavigation.stopRotation();
+        }
+        if (this.renderer && this.renderer.controls.simpleNavigation) {
+            this.renderer.controls.simpleNavigation.deactivate();
+        }
+    }
+    unlockView() {
+        if (this._lockEntity) {
+            this._deactivateLockViewEvents();
+            this._activateNav();
+            this.events.dispatch(this.events.unlockview, this._lockEntity);
+            this._lockEntity = null;
+        }
+    }
+    _getCenterDist() {
+        if (this.renderer) {
+            return this.renderer.getDistanceFromPixel(this.renderer.handler.getCenter()) || 0;
+        }
+        return 0;
+    }
+    _getDistance(entity, prevEntity) {
+        if (this.renderer) {
+            let cartesian = entity.getAbsoluteCartesian();
+            let cam = this.renderer.activeCamera;
+            let dist = cam.eye.distance(cartesian);
+            if (prevEntity) {
+                dist = cam.eye.distance(prevEntity.getAbsoluteCartesian());
+            }
+            if (this.isVisibleDistance(cartesian)) {
+                return dist;
+            }
+            if (cam.eye.distance(cartesian) < 1000000.0) {
+                return this._getCenterDist();
+            }
+            else {
+                return MIN_VIEW_DISTANCE;
+            }
+        }
+        return 0;
+    }
+    isVisibleDistance(cart, C = 0.0) {
+        if (this.planet) {
+            let R = this.planet.ellipsoid.equatorialSize;
+            let eye = this.planet.camera.eye;
+            let camDist = eye.distance(cart);
+            return camDist < Math.sqrt(eye.length2() - R * R) + C;
+        }
+        return true;
+    }
+    get lockEntity() {
+        return this._lockEntity;
+    }
+    flyLonLat(lonLat, dist = MIN_VIEW_DISTANCE) {
+        if (this.planet) {
+            let cartesian = this.planet.ellipsoid.lonLatToCartesian(lonLat);
+            this.flyCartesian(cartesian, dist);
+        }
+    }
+    _activateLockViewEvents() {
+        if (this.renderer) {
+            this.renderer.events.on("mousewheel", this._onMouseWheel);
+            this.renderer.events.on("mousemove", this._onMouseMove);
+            this.renderer.events.on("draw", this._onLockViewDraw);
+        }
+    }
+    _deactivateLockViewEvents() {
+        if (this.renderer) {
+            this.renderer.events.off("mousewheel", this._onMouseWheel);
+            this.renderer.events.off("mousemove", this._onMouseMove);
+            if (this._lockEntity) {
+                this.renderer.events.off("draw", this._onLockViewDraw);
+            }
+        }
+    }
+}

package/lib/js/control/Control.js

@@ -62,7 +62,7 @@ export class Control {
             this.renderer = renderer;
             renderer.controls[this.name] = this;
             this.onadd && this.onadd();
-            if (renderer.isInitialized()) {
+            if (renderer.isInitialized() && !this._initialized) {
                 this._initialized = true;
                 this.oninit && this.oninit();
                 if (this.autoActivate) {

package/lib/js/control/DebugInfo.js

@@ -186,10 +186,20 @@ export class DebugInfo extends Control {
                     frame: () => p.getViewExtent().toString()
                 },
                 {
-                    label: "height/alt (km)",
-                    frame: () => `<div style="width:190px">${(p.camera._lonLat.height / 1000.0).toFixed(2) +
+                    label: "Mouse distance, m",
+                    frame: () => {
+                        let cart = p.getCartesianFromMouseTerrain();
+                        if (cart) {
+                            return p.camera.eye.distance(cart).toFixed(3);
+                        }
+                        return "";
+                    }
+                },
+                {
+                    label: "height/alt, m",
+                    frame: () => `<div style="width:190px">${(p.camera._lonLat.height).toFixed(2) +
                         " / " +
-                        (p.camera.getAltitude() / 1000.0).toFixed(2)}</div>`
+                        (p.camera.getAltitude()).toFixed(2)}</div>`
                 },
                 {
                     label: "cam.slope",

package/lib/js/control/KeyboardNavigation.js

@@ -9,7 +9,7 @@ export class KeyboardNavigation extends Control {
     constructor(options = {}) {
         options = options || {};
         super({ name: "KeyboardNavigation", ...options });
-        this.step = options.step || 250;
+        this.step = options.step || 25000;
     }
     onactivate() {
         let r = this.renderer;

package/lib/js/control/ScaleControl.js

@@ -3,7 +3,7 @@ import { Control } from "./Control";
 import { RADIANS } from "../math";
 import { Vec3 } from "../math/Vec3";
 const scale = [
-    1, 2, 3, 5, 10, 20, 30, 50, 100, 200, 300, 500, 1e3, 2e3, 3e3, 5e3, 10e3, 20e3, 30e3, 50e3,
+    0.001, 0.005, 0.01, 0.05, 0.1, 0.2, 0.5, 1, 2, 3, 5, 10, 20, 30, 50, 100, 200, 300, 500, 1e3, 2e3, 3e3, 5e3, 10e3, 20e3, 30e3, 50e3,
     100e3, 200e3, 300e3, 500e3, 1000e3, 2000e3, 3000e3, 5000e3, 10000e3
 ];
 const TEMPLATE = `<div class="og-scale-container">
@@ -79,12 +79,18 @@ export class ScaleControl extends Control {
         let minMeters = scale[index], maxMeters = scale[index + 1];
         let t = (minMeters - metersInMinSize) / (maxMeters - minMeters);
         this.currWidth = this._minWidth + t * (this._maxWidth - this._minWidth);
-        if (minMeters > 1000) {
+        if (minMeters >= 1000) {
             this._scaleLabelEl.innerText = `${minMeters / 1000} km`;
         }
-        else {
+        else if (minMeters >= 1) {
             this._scaleLabelEl.innerText = `${minMeters} m`;
         }
+        else if (minMeters >= 0.01) {
+            this._scaleLabelEl.innerText = `${minMeters * 100} cm`;
+        }
+        else {
+            this._scaleLabelEl.innerText = `${minMeters * 1000} mm`;
+        }
         this._metersInMinSize = metersInMinSize;
         this.el.style.width = this.currWidth + "px";
     }

package/lib/js/control/SimpleNavigation.d.ts

@@ -1,4 +1,6 @@
 import { Control, IControlParams } from "./Control";
+import { IMouseState } from "../renderer/RendererEvents";
+import { Vec3 } from "../math/Vec3";
 interface ISimpleNavigationParams extends IControlParams {
     speed?: number;
 }
@@ -7,19 +9,34 @@ interface ISimpleNavigationParams extends IControlParams {
  */
 export declare class SimpleNavigation extends Control {
     speed: number;
+    force: Vec3;
+    vel: Vec3;
+    mass: number;
+    protected _lookPos: Vec3 | undefined;
+    protected _up: Vec3 | null;
+    protected _grabbedPoint: Vec3 | undefined;
+    protected _eye0: Vec3;
     constructor(options?: ISimpleNavigationParams);
     oninit(): void;
     onactivate(): void;
     ondeactivate(): void;
-    protected onCameraMoveForward(): void;
-    protected onCameraMoveBackward(): void;
-    protected onCameraStrifeLeft(): void;
-    protected onCameraStrifeRight(): void;
-    protected onCameraLookUp(): void;
-    protected onCameraLookDown(): void;
-    protected onCameraTurnLeft(): void;
-    protected onCameraTurnRight(): void;
-    protected onCameraRollLeft(): void;
-    protected onCameraRollRight(): void;
+    protected _onMouseLeftButtonClick: (e: IMouseState) => void;
+    protected _onMouseLeftButtonUp: (e: IMouseState) => void;
+    protected _onMouseLeftButtonDown: (e: IMouseState) => void;
+    protected _onRHold: (e: IMouseState) => void;
+    protected _onRDown: (e: IMouseState) => void;
+    protected _onMouseWheel: (e: IMouseState) => void;
+    protected onCameraMoveForward: () => void;
+    protected onCameraMoveBackward: () => void;
+    protected onCameraStrifeLeft: () => void;
+    protected onCameraStrifeRight: () => void;
+    protected onCameraLookUp: () => void;
+    protected onCameraLookDown: () => void;
+    protected onCameraTurnLeft: () => void;
+    protected onCameraTurnRight: () => void;
+    protected onCameraRollLeft: () => void;
+    protected onCameraRollRight: () => void;
+    protected get dt(): number;
+    protected onDraw(): void;
 }
 export {};

package/lib/js/control/SimpleNavigation.js

@@ -1,5 +1,8 @@
 import { Control } from "./Control";
 import { input } from "../input/input";
+import { Vec3 } from "../math/Vec3";
+import * as math from "../math";
+import { Ray } from "../math/Ray";
 /**
  * Simple keyboard camera navigation with W,S,A,D and shift keys to fly around the scene.
  */
@@ -9,13 +12,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).hitPlane(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.pitch(0.5);
+            cam.update();
+        };
+        this.onCameraLookDown = () => {
+            let cam = this.renderer.activeCamera;
+            cam.pitch(-0.5);
+            cam.update();
+        };
+        this.onCameraTurnLeft = () => {
+            let cam = this.renderer.activeCamera;
+            cam.yaw(0.5);
+            cam.update();
+        };
+        this.onCameraTurnRight = () => {
+            let cam = this.renderer.activeCamera;
+            cam.yaw(-0.5);
+            cam.update();
+        };
+        this.onCameraRollLeft = () => {
+            let cam = this.renderer.activeCamera;
+            cam.roll(-0.5);
+            cam.update();
+        };
+        this.onCameraRollRight = () => {
+            let cam = this.renderer.activeCamera;
+            cam.roll(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 +150,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 +171,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),

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

@@ -379,7 +379,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 +419,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 +444,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 +468,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;
+}