@openglobus/og 0.24.2 → 0.25.0

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

@@ -1,53 +0,0 @@
-import { Control } from "./Control";
-import type { 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 type { 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

@@ -1,266 +0,0 @@
-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";
-import { Plane } from "../math/Plane";
-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.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.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).hitPlaneRes(Plane.fromPoints(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.rotate(rot);
-            // 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

@@ -1,28 +0,0 @@
-import { Key } from "../Lock";
-import { Control } from "./Control";
-import type { 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

@@ -1,86 +0,0 @@
-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

@@ -1,12 +0,0 @@
-import { Control, type 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

@@ -1,35 +0,0 @@
-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

@@ -1,15 +0,0 @@
-import { Vec2 } from "../../math/Vec2";
-import { Vec3 } from "../../math/Vec3";
-import { PolygonDrawingScene, type 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

@@ -1,139 +0,0 @@
-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 };