@openglobus/og 0.17.2 → 0.18.1

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

@@ -0,0 +1,52 @@
+import { Control, IControlParams } from "./Control";
+import { Key } from "../Lock";
+import { Quat } from "../math/Quat";
+import { Sphere } from "../bv/Sphere";
+import { Vec2 } from "../math/Vec2";
+import { Vec3 } from "../math/Vec3";
+import { ITouchState } from "../renderer/RendererEvents";
+interface ITouchNavigationParams extends IControlParams {
+}
+declare class TouchExt {
+    x: number;
+    y: number;
+    prev_x: number;
+    prev_y: number;
+    grabbedPoint: Vec3 | null;
+    grabbedSpheroid: Sphere;
+    protected _vec: Vec2;
+    protected _vecPrev: Vec2;
+    constructor();
+    get dY(): number;
+    get dX(): number;
+    get vec(): Vec2;
+    get vecPrev(): Vec2;
+}
+/**
+ * Touch pad planet camera dragging control.
+ */
+export declare class TouchNavigation extends Control {
+    grabbedPoint: Vec3;
+    inertia: number;
+    protected grabbedSpheroid: Sphere;
+    protected qRot: Quat;
+    protected scaleRot: number;
+    protected rot: number;
+    protected _eye0: Vec3;
+    protected pointOnEarth: Vec3 | null;
+    protected earthUp: Vec3 | null;
+    protected touches: TouchExt[];
+    protected _keyLock: Key;
+    protected _touching: boolean;
+    constructor(options?: ITouchNavigationParams);
+    oninit(): void;
+    protected onTouchStart(e: ITouchState): void;
+    protected _startTouchOne(e: ITouchState): void;
+    stopRotation(): void;
+    protected onDoubleTouch(e: ITouchState): void;
+    protected onTouchEnd(e: ITouchState): void;
+    protected onTouchCancel(e: ITouchState): void;
+    protected onTouchMove(e: ITouchState): void;
+    protected onDraw(): void;
+}
+export {};

package/lib/js/control/TouchNavigation.js

@@ -0,0 +1,263 @@
+import { Control } from "./Control";
+import { Key } from "../Lock";
+import { LonLat } from "../LonLat";
+import { math } from "../index";
+import { Quat } from "../math/Quat";
+import { Ray } from "../math/Ray";
+import { Sphere } from "../bv/Sphere";
+import { Vec2 } from "../math/Vec2";
+import { Vec3 } from "../math/Vec3";
+class TouchExt {
+    constructor() {
+        this.x = 0;
+        this.y = 0;
+        this.prev_x = 0;
+        this.prev_y = 0;
+        this.grabbedPoint = null;
+        this.grabbedSpheroid = new Sphere();
+        this._vec = new Vec2();
+        this._vecPrev = new Vec2();
+    }
+    get dY() {
+        return this.y - this.prev_y;
+    }
+    get dX() {
+        return this.x - this.prev_x;
+    }
+    get vec() {
+        return this._vec.set(this.x, this.y);
+    }
+    get vecPrev() {
+        return this._vecPrev.set(this.prev_x, this.prev_y);
+    }
+}
+/**
+ * Touch pad planet camera dragging control.
+ */
+export class TouchNavigation extends Control {
+    constructor(options = {}) {
+        super(options);
+        this._name = "touchNavigation";
+        this.grabbedPoint = new Vec3();
+        this.inertia = 0.007;
+        this.grabbedSpheroid = new Sphere();
+        this.planet = null;
+        this.qRot = new Quat();
+        this.scaleRot = 0;
+        this.rot = 1;
+        this._eye0 = new Vec3();
+        this.pointOnEarth = null;
+        this.earthUp = null;
+        this.touches = [new TouchExt(), new TouchExt()];
+        this._keyLock = new Key();
+        this._touching = false;
+    }
+    oninit() {
+        if (this.renderer) {
+            this.renderer.events.on("touchstart", this.onTouchStart, this);
+            this.renderer.events.on("touchend", this.onTouchEnd, this);
+            this.renderer.events.on("doubletouch", this.onDoubleTouch, this);
+            this.renderer.events.on("touchcancel", this.onTouchCancel, this);
+            this.renderer.events.on("touchmove", this.onTouchMove, this);
+            this.renderer.events.on("draw", this.onDraw, this);
+        }
+    }
+    onTouchStart(e) {
+        const handler = this.renderer.handler;
+        this._touching = true;
+        if (e.sys.touches.length === 2) {
+            const t0 = this.touches[0];
+            const t1 = this.touches[1];
+            t0.x = (e.sys.touches.item(0).clientX - e.sys.offsetLeft) * handler.pixelRatio;
+            t0.y = (e.sys.touches.item(0).clientY - e.sys.offsetTop) * handler.pixelRatio;
+            t0.prev_x = t0.x;
+            t0.prev_y = t0.y;
+            t0.grabbedPoint = this.planet.getCartesianFromPixelTerrain(new Vec2(t0.x, t0.y)) || null;
+            t1.x = (e.sys.touches.item(1).clientX - e.sys.offsetLeft) * handler.pixelRatio;
+            t1.y = (e.sys.touches.item(1).clientY - e.sys.offsetTop) * handler.pixelRatio;
+            t1.prev_x = t1.x;
+            t1.prev_y = t1.y;
+            t1.grabbedPoint = this.planet.getCartesianFromPixelTerrain(new Vec2(t1.x, t1.y)) || null;
+            this.pointOnEarth = this.planet.getCartesianFromPixelTerrain(this.renderer.handler.getCenter()) || null;
+            if (this.pointOnEarth) {
+                this.earthUp = this.pointOnEarth.normal();
+            }
+            if (t0.grabbedPoint && t1.grabbedPoint) {
+                t0.grabbedSpheroid.radius = t0.grabbedPoint.length();
+                t1.grabbedSpheroid.radius = t1.grabbedPoint.length();
+                this.stopRotation();
+            }
+        }
+        else if (e.sys.touches.length === 1) {
+            this._startTouchOne(e);
+        }
+    }
+    _startTouchOne(e) {
+        const t = this.touches[0];
+        const handler = this.renderer.handler;
+        t.x = (e.sys.touches.item(0).clientX - e.sys.offsetLeft) * handler.pixelRatio;
+        t.y = (e.sys.touches.item(0).clientY - e.sys.offsetTop) * handler.pixelRatio;
+        t.prev_x = t.x;
+        t.prev_y = t.y;
+        // t.grabbedPoint = this.planet!.getCartesianFromPixelTerrain(e, true);
+        t.grabbedPoint = this.planet.getCartesianFromPixelTerrain(e) || null;
+        this._eye0.copy(this.planet.camera.eye);
+        if (t.grabbedPoint) {
+            t.grabbedSpheroid.radius = t.grabbedPoint.length();
+            this.stopRotation();
+        }
+    }
+    stopRotation() {
+        this.qRot.clear();
+        this.planet.layerLock.free(this._keyLock);
+        this.planet.terrainLock.free(this._keyLock);
+        this.planet._normalMapCreator.free(this._keyLock);
+    }
+    onDoubleTouch(e) {
+        this.planet.stopFlying();
+        this.stopRotation();
+        const p = this.planet.getCartesianFromPixelTerrain(e);
+        if (p) {
+            const g = this.planet.ellipsoid.cartesianToLonLat(p);
+            this.planet.flyLonLat(new LonLat(g.lon, g.lat, this.planet.camera.eye.distance(p) * 0.57));
+        }
+    }
+    onTouchEnd(e) {
+        if (e.sys.touches.length === 0) {
+            this._touching = false;
+        }
+        if (e.sys.touches.length === 1) {
+            this._startTouchOne(e);
+        }
+        if (Math.abs(this.touches[0].x - this.touches[0].prev_x) < 3 &&
+            Math.abs(this.touches[0].y - this.touches[0].prev_y) < 3) {
+            this.scaleRot = 0;
+        }
+    }
+    onTouchCancel(e) {
+    }
+    onTouchMove(e) {
+        let cam = this.planet.camera;
+        const handler = this.renderer.handler;
+        if (e.sys.touches.length === 2) {
+            this.renderer.controlsBag.scaleRot = 1;
+            let t0 = this.touches[0], t1 = this.touches[1];
+            if (!t0.grabbedPoint || !t1.grabbedPoint) {
+                return;
+            }
+            this.planet.stopFlying();
+            t0.prev_x = t0.x;
+            t0.prev_y = t0.y;
+            t0.x = (e.sys.touches.item(0).clientX - e.sys.offsetLeft) * handler.pixelRatio;
+            t0.y = (e.sys.touches.item(0).clientY - e.sys.offsetTop) * handler.pixelRatio;
+            t1.prev_x = t1.x;
+            t1.prev_y = t1.y;
+            t1.x = (e.sys.touches.item(1).clientX - e.sys.offsetLeft) * handler.pixelRatio;
+            t1.y = (e.sys.touches.item(1).clientY - e.sys.offsetTop) * handler.pixelRatio;
+            const middle = t0.vec.add(t1.vec).scale(0.5);
+            const earthMiddlePoint = this.planet.getCartesianFromPixelTerrain(middle);
+            if (earthMiddlePoint) {
+                this.pointOnEarth = earthMiddlePoint;
+                const prevAngle = Math.atan2(t0.prev_y - t1.prev_y, t0.prev_x - t1.prev_x);
+                const curAngle = Math.atan2(t0.y - t1.y, t0.x - t1.x);
+                const deltaAngle = curAngle - prevAngle;
+                const distanceToPointOnEarth = cam.eye.distance(this.pointOnEarth);
+                const zoomCur = t0.vec.sub(t1.vec);
+                const zoomPrev = t0.vecPrev.sub(t1.vecPrev);
+                const scale = zoomCur.length() / zoomPrev.length();
+                let d = distanceToPointOnEarth * -(1 - scale);
+                cam.eye.addA(cam.getForward().scale(d));
+                cam.rotateAround(-deltaAngle, false, this.pointOnEarth, this.earthUp);
+                const panCur = t0.vec.add(t1.vec).scale(0.5);
+                const panPrev = t0.vecPrev.add(t1.vecPrev).scale(0.5);
+                const panOffset = panCur.sub(panPrev).scale(-1);
+                var l = 0.5 / distanceToPointOnEarth * cam._lonLat.height * math.RADIANS;
+                if (l > 0.003)
+                    l = 0.003;
+                cam.rotateHorizontal(l * -panOffset.x, false, this.pointOnEarth, this.earthUp);
+                cam.rotateVertical(l * -panOffset.y, this.pointOnEarth);
+                cam.checkTerrainCollision();
+                cam.update();
+            }
+            this.scaleRot = 0;
+        }
+        else if (e.sys.touches.length === 1) {
+            let t = this.touches[0];
+            t.prev_x = t.x;
+            t.prev_y = t.y;
+            t.x = (e.sys.touches.item(0).clientX - e.sys.offsetLeft) * handler.pixelRatio;
+            t.y = (e.sys.touches.item(0).clientY - e.sys.offsetTop) * handler.pixelRatio;
+            if (!t.grabbedPoint) {
+                return;
+            }
+            this.planet.stopFlying();
+            let direction = e.direction;
+            let targetPoint = new Ray(cam.eye, direction).hitSphere(t.grabbedSpheroid);
+            if (targetPoint) {
+                if (cam.slope > 0.2) {
+                    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.checkTerrainCollision();
+                    cam.update();
+                    this.scaleRot = 1;
+                }
+                else {
+                    let p0 = t.grabbedPoint, p1 = Vec3.add(p0, cam._u), p2 = Vec3.add(p0, p0.normal());
+                    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) {
+                        cam.eye = this._eye0.addA(px.subA(p0).negate());
+                        cam.checkTerrainCollision();
+                        cam.update();
+                        this.scaleRot = 0;
+                    }
+                }
+            }
+        }
+    }
+    onDraw() {
+        const r = this.renderer;
+        r.controlsBag.scaleRot = this.scaleRot;
+        if (this._touching) {
+            return;
+        }
+        let cam = this.planet.camera;
+        let prevEye = cam.eye.clone();
+        if (r.events.mouseState.leftButtonDown || !this.scaleRot) {
+            return;
+        }
+        this.scaleRot -= this.inertia;
+        if (this.scaleRot <= 0) {
+            this.scaleRot = 0;
+        }
+        else {
+            r.controlsBag.scaleRot = this.scaleRot;
+            let rot = this.qRot
+                .slerp(Quat.IDENTITY, 1 - this.scaleRot * this.scaleRot * this.scaleRot)
+                .normalize();
+            if (!(rot.x || rot.y || rot.z)) {
+                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.checkTerrainCollision();
+            cam.update();
+        }
+        if (cam.eye.distance(prevEye) / cam.getAltitude() > 0.01) {
+            this.planet.layerLock.lock(this._keyLock);
+            this.planet.terrainLock.lock(this._keyLock);
+            this.planet._normalMapCreator.lock(this._keyLock);
+        }
+        else {
+            this.planet.layerLock.free(this._keyLock);
+            this.planet.terrainLock.free(this._keyLock);
+            this.planet._normalMapCreator.free(this._keyLock);
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Key } from "../Lock";
+import { Control, IControlParams } from "./Control";
+import { Renderer } from "../renderer/Renderer";
+import { Vec2 } from "../math/Vec2";
+/**
+ * Planet zoom buttons control.
+ */
+declare class ZoomControl extends Control {
+    protected _keyLock: Key;
+    protected _move: number;
+    protected _targetPoint: Vec2 | null;
+    constructor(options?: IControlParams);
+    oninit(): void;
+    /**
+     * Planet zoom in.
+     * @public
+     */
+    zoomIn(): void;
+    /**
+     * Planet zoom out.
+     * @public
+     */
+    zoomOut(): void;
+    stopZoom(): void;
+    protected _draw(e: Renderer): void;
+}
+export { ZoomControl };

package/lib/js/control/ZoomControl.js

@@ -0,0 +1,86 @@
+import { Key } from "../Lock";
+import { Button } from "../ui/Button";
+import { Control } from "./Control";
+const ICON_PLUS_SVG = '<?xml version="1.0"?>' +
+    '<svg width=24 height=24 xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">' +
+    '    <path d="M 11 5 L 11 11 L 5 11 L 5 13 L 11 13 L 11 19 L 13 19 L 13 13 L 19 13 L 19 11 L 13 11 L 13 5 L 11 5 z"/>' +
+    '</svg>';
+const ICON_MINUS_SVG = '<?xml version="1.0"?>' +
+    '<svg width=24 height=24 xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">' +
+    '    <path d="M 5 11 L 5 13 L 19 13 L 19 11 L 5 11 z"/>' +
+    '</svg>';
+/**
+ * Planet zoom buttons control.
+ */
+class ZoomControl extends Control {
+    constructor(options = {}) {
+        super(options);
+        this._keyLock = new Key();
+        this._move = 0;
+        this._targetPoint = null;
+    }
+    oninit() {
+        let zoomInBtn = new Button({
+            classList: ["og-map-button", "og-zoomin-button"],
+            icon: ICON_PLUS_SVG
+        });
+        zoomInBtn.appendTo(this.renderer.div);
+        let zoomOutBtn = new Button({
+            classList: ["og-map-button", "og-zoomout-button"],
+            icon: ICON_MINUS_SVG
+        });
+        zoomOutBtn.appendTo(this.renderer.div);
+        zoomInBtn.events.on("mousedown", () => this.zoomIn());
+        zoomInBtn.events.on("mouseup", () => this.stopZoom());
+        zoomOutBtn.events.on("mousedown", () => this.zoomOut());
+        zoomOutBtn.events.on("mouseup", () => this.stopZoom());
+        zoomInBtn.events.on("touchstart", () => this.zoomIn());
+        zoomInBtn.events.on("touchend", () => this.stopZoom());
+        zoomInBtn.events.on("touchcancel", () => this.stopZoom());
+        zoomOutBtn.events.on("touchstart", () => this.zoomOut());
+        zoomOutBtn.events.on("touchend", () => this.stopZoom());
+        zoomOutBtn.events.on("touchcancel", () => this.stopZoom());
+        this.renderer.events.on("draw", this._draw, this);
+    }
+    /**
+     * Planet zoom in.
+     * @public
+     */
+    zoomIn() {
+        this.planet.layerLock.lock(this._keyLock);
+        this.planet.terrainLock.lock(this._keyLock);
+        this.planet._normalMapCreator.lock(this._keyLock);
+        this._targetPoint = this.renderer.getCenter();
+        this._move = 1;
+    }
+    /**
+     * Planet zoom out.
+     * @public
+     */
+    zoomOut() {
+        this.planet.layerLock.lock(this._keyLock);
+        this.planet.terrainLock.lock(this._keyLock);
+        this.planet._normalMapCreator.lock(this._keyLock);
+        this._targetPoint = this.renderer.getCenter();
+        this._move = -1;
+    }
+    stopZoom() {
+        this._move = 0;
+        this.planet.layerLock.free(this._keyLock);
+        this.planet.terrainLock.free(this._keyLock);
+        this.planet._normalMapCreator.free(this._keyLock);
+    }
+    _draw(e) {
+        const cam = this.planet.camera;
+        if (this._move !== 0) {
+            const pos = this.planet.getCartesianFromPixelTerrain(e.getCenter());
+            if (pos) {
+                let d = cam.eye.distance(pos) * 0.035;
+                cam.eye.addA(cam.getForward().scale(this._move * d));
+                cam.checkTerrainCollision();
+                cam.update();
+            }
+        }
+    }
+}
+export { ZoomControl };

package/lib/js/control/drawing/DrawingControl.d.ts

@@ -0,0 +1,12 @@
+import { Control, IControlParams } from "../Control";
+import { PolygonDrawingScene } from "./PolygonDrawingScene";
+declare class DrawingControl extends Control {
+    protected _drawingScene: PolygonDrawingScene;
+    constructor(options?: IControlParams);
+    activatePolygonDrawing(): void;
+    activateLineStringDrawing(): void;
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+}
+export { DrawingControl };

package/lib/js/control/drawing/DrawingControl.js

@@ -0,0 +1,35 @@
+import { Control } from "../Control";
+import { LineStringDrawingScene } from "./LineStringDrawingScene";
+import { PolygonDrawingScene } from "./PolygonDrawingScene";
+class DrawingControl extends Control {
+    constructor(options = {}) {
+        super(options);
+        this._drawingScene = new LineStringDrawingScene({
+            name: `drawingScene:${this.__id}`
+        });
+    }
+    activatePolygonDrawing() {
+        this.deactivate();
+        this._drawingScene = new PolygonDrawingScene({
+            name: `polygonDrawingScene:${this.__id}`
+        });
+        this.activate();
+    }
+    activateLineStringDrawing() {
+        this.deactivate();
+        this._drawingScene = new LineStringDrawingScene({
+            name: `linestringDrawingScene:${this.__id}`
+        });
+        this.activate();
+    }
+    oninit() {
+    }
+    onactivate() {
+        this.planet && this._drawingScene.bindPlanet(this.planet);
+        this.renderer && this.renderer.addNode(this._drawingScene);
+    }
+    ondeactivate() {
+        this.renderer && this.renderer.removeNode(this._drawingScene);
+    }
+}
+export { DrawingControl };

package/lib/js/control/drawing/LineStringDrawingScene.d.ts

@@ -0,0 +1,15 @@
+import { Vec2 } from "../../math/Vec2";
+import { Vec3 } from "../../math/Vec3";
+import { PolygonDrawingScene, IPolygonDrawingSceneParams } from "./PolygonDrawingScene";
+declare class LineStringDrawingScene extends PolygonDrawingScene {
+    constructor(props: IPolygonDrawingSceneParams);
+    get geometryType(): string;
+    protected _addNew(cart: Vec3): void;
+    protected _appendCart(cart: Vec3): void;
+    protected _clearGhostPointer(): void;
+    protected _moveCorner(indexCurrent: number, indexPrev: number, indexCenter: number): void;
+    protected _moveCornerPoint(e: Vec2): void;
+    _updateGhostOutlinePointer(groundPos: Vec3): void;
+    protected _initGhostLayerPointer(): void;
+}
+export { LineStringDrawingScene };

package/lib/js/control/drawing/LineStringDrawingScene.js

@@ -0,0 +1,139 @@
+import { Entity } from "../../entity/Entity";
+import { Vec2 } from "../../math/Vec2";
+import { CENTER_OPTIONS, CORNER_OPTIONS, NUM_SEGMENTS, OUTLINE_ALT, OUTLINE_OPTIONS, PolygonDrawingScene } from "./PolygonDrawingScene";
+class LineStringDrawingScene extends PolygonDrawingScene {
+    constructor(props) {
+        super(props);
+    }
+    get geometryType() {
+        return "LineString";
+    }
+    _addNew(cart) {
+        this._appendCart(cart);
+    }
+    _appendCart(cart) {
+        let corners = this._cornerLayer.getEntities();
+        let segNum = corners.length - 1;
+        let prevCorn = corners[segNum];
+        let corner = new Entity({
+            geoObject: CORNER_OPTIONS,
+        });
+        corner.setCartesian3v(cart);
+        corner.addTo(this._cornerLayer);
+        this._checkTerrainCollision(corner);
+        if (prevCorn) {
+            let prevCart = prevCorn.getCartesian();
+            let vecPrev = corner.getCartesian().sub(prevCart);
+            let distPrev = vecPrev.length();
+            vecPrev.normalize();
+            let prevPath = [];
+            for (let i = 0; i <= NUM_SEGMENTS; i++) {
+                let p = vecPrev.scaleTo(i * distPrev / NUM_SEGMENTS).addA(prevCart);
+                prevPath.push(p);
+            }
+            let entity = new Entity({
+                polyline: {
+                    path3v: [prevPath],
+                    isClosed: false,
+                    ...OUTLINE_OPTIONS
+                }
+            });
+            entity.polyline.altitude = OUTLINE_ALT;
+            this._outlineLayer.add(entity);
+            let prevCenterCart = vecPrev.scaleTo(distPrev * 0.5).addA(prevCart);
+            let center = new Entity({
+                geoObject: CENTER_OPTIONS,
+            });
+            center.setCartesian3v(prevCenterCart);
+            center.addTo(this._centerLayer);
+            this._checkTerrainCollision(center);
+        }
+    }
+    _clearGhostPointer() {
+        this._ghostOutlineLayer.getEntities()[0].polyline.clear();
+    }
+    _moveCorner(indexCurrent, indexPrev, indexCenter) {
+        let corners = this._cornerLayer.getEntities();
+        if (corners.length == 0)
+            return;
+        if (corners.length == 1) {
+            indexCurrent = indexPrev = indexCenter = 0;
+        }
+        let cartCurr = corners[indexCurrent].getCartesian();
+        let vecCurr = this._pickedCorner.getCartesian().sub(cartCurr);
+        let distCurr = vecCurr.length();
+        vecCurr.normalize();
+        let path = [];
+        for (let i = 0; i <= NUM_SEGMENTS; i++) {
+            let p = vecCurr.scaleTo(i * distCurr / NUM_SEGMENTS).addA(cartCurr);
+            path.push(p);
+        }
+        let entities = this._outlineLayer.getEntities();
+        let prevPolyline = entities[indexPrev].polyline;
+        prevPolyline?.setPath3v([path]);
+        //
+        // Move center points
+        let centers = this._centerLayer.getEntities();
+        let center = centers[indexCenter];
+        if (center) {
+            let centerCart = vecCurr.scaleTo(distCurr * 0.5).addA(cartCurr);
+            center.setCartesian3v(centerCart);
+            this._checkTerrainCollision(center);
+        }
+    }
+    _moveCornerPoint(e) {
+        let d = new Vec2(e.x, e.y).sub(this._startClick), p = this._startPos.add(d);
+        let groundCoords = this._planet.getCartesianFromPixelTerrain(p);
+        if (groundCoords) {
+            this._pickedCorner.setCartesian3v(groundCoords);
+            let corners = this._cornerLayer.getEntities();
+            if (corners.length) {
+                let ind = this._pickedCorner.layerIndex;
+                if (ind === 0) {
+                    this._moveCorner(ind + 1, ind + 1, ind);
+                }
+                else if (ind === corners.length - 1) {
+                    this._moveCorner(ind - 1, ind, ind - 1);
+                }
+                else {
+                    this._moveCorner(ind + 1, ind + 1, ind);
+                    this._moveCorner(ind - 1, ind, ind - 1);
+                }
+            }
+        }
+    }
+    _updateGhostOutlinePointer(groundPos) {
+        let corners = this._cornerLayer.getEntities();
+        let size = corners.length;
+        if (size > 0) {
+            let ind = size - 1;
+            this._insertCornerIndex = ind;
+            let cartPrev = corners[ind].getCartesian();
+            let vecPrev = this._ghostCorner.getCartesian().sub(cartPrev);
+            let distPrev = vecPrev.length();
+            vecPrev.normalize();
+            let pathPrev = [];
+            for (let i = 0; i <= NUM_SEGMENTS; i++) {
+                let p = vecPrev.scaleTo(i * distPrev / NUM_SEGMENTS).addA(cartPrev);
+                pathPrev.push(p);
+            }
+            let entities = this._ghostOutlineLayer.getEntities();
+            let prevPolyline = entities[0].polyline;
+            prevPolyline.setPath3v([pathPrev]);
+        }
+    }
+    _initGhostLayerPointer() {
+        this._ghostOutlineLayer.setEntities([
+            new Entity({
+                polyline: {
+                    path3v: [],
+                    isClosed: false,
+                    ...OUTLINE_OPTIONS
+                }
+            }),
+            this._ghostCorner
+        ]);
+        this._ghostOutlineLayer.getEntities()[0].polyline.altitude = OUTLINE_ALT;
+    }
+}
+export { LineStringDrawingScene };