@openglobus/og 0.18.0 → 0.18.2

package/{src/control/TouchNavigation.ts → lib/js/control/TouchNavigation.js}

@@ -1,35 +1,13 @@
-import {Control, IControlParams} 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 {ITouchState} from "../renderer/RendererEvents";
-
-interface ITouchNavigationParams extends IControlParams {
-
-}
-
-interface Touch {
-    clientX: number;
-    clientY: number;
-}
-
+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 {
-    public x: number;
-    public y: number;
-    public prev_x: number;
-    public prev_y: number;
-    public grabbedPoint: Vec3 | null;
-    public grabbedSpheroid: Sphere;
-
-    protected _vec: Vec2;
-    protected _vecPrev: Vec2;
-
-
     constructor() {
         this.x = 0;
         this.y = 0;
@@ -40,49 +18,26 @@ class TouchExt {
         this._vec = new Vec2();
         this._vecPrev = new Vec2();
     }
-
-    public get dY(): number {
+    get dY() {
         return this.y - this.prev_y;
     }
-
-    public get dX(): number {
+    get dX() {
         return this.x - this.prev_x;
     }
-
-    public get vec(): Vec2 {
+    get vec() {
         return this._vec.set(this.x, this.y);
     }
-
-    public get vecPrev(): Vec2 {
+    get vecPrev() {
         return this._vecPrev.set(this.prev_x, this.prev_y);
     }
 }
-
 /**
  * Touch pad planet camera dragging control.
  */
 export class TouchNavigation extends Control {
-
-    public grabbedPoint: Vec3;
-    public 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 = {}) {
+    constructor(options = {}) {
         super(options);
-
         this._name = "touchNavigation";
-
         this.grabbedPoint = new Vec3();
         this.inertia = 0.007;
         this.grabbedSpheroid = new Sphere();
@@ -91,18 +46,13 @@ export class TouchNavigation extends Control {
         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;
     }
-
-    override oninit() {
+    oninit() {
         if (this.renderer) {
             this.renderer.events.on("touchstart", this.onTouchStart, this);
             this.renderer.events.on("touchend", this.onTouchEnd, this);
@@ -112,188 +62,140 @@ export class TouchNavigation extends Control {
             this.renderer.events.on("draw", this.onDraw, this);
         }
     }
-
-    protected onTouchStart(e: ITouchState) {
-        const handler = this.renderer!.handler;
+    onTouchStart(e) {
+        const handler = this.renderer.handler;
         this._touching = true;
-
-        if (e.sys!.touches.length === 2) {
+        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.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;
+            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;
-
+            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) {
+        }
+        else if (e.sys.touches.length === 1) {
             this._startTouchOne(e);
         }
     }
-
-    protected _startTouchOne(e: ITouchState) {
+    _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;
+        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);
-
+        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();
         }
     }
-
-    public stopRotation() {
+    stopRotation() {
         this.qRot.clear();
-        this.planet!.layerLock.free(this._keyLock);
-        this.planet!.terrainLock.free(this._keyLock);
-        this.planet!._normalMapCreator.free(this._keyLock);
+        this.planet.layerLock.free(this._keyLock);
+        this.planet.terrainLock.free(this._keyLock);
+        this.planet._normalMapCreator.free(this._keyLock);
     }
-
-    protected onDoubleTouch(e: ITouchState) {
-
-        this.planet!.stopFlying();
+    onDoubleTouch(e) {
+        this.planet.stopFlying();
         this.stopRotation();
-
-        const p = this.planet!.getCartesianFromPixelTerrain(e);
+        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)
-            );
+            const g = this.planet.ellipsoid.cartesianToLonLat(p);
+            this.planet.flyLonLat(new LonLat(g.lon, g.lat, this.planet.camera.eye.distance(p) * 0.57));
         }
     }
-
-    protected onTouchEnd(e: ITouchState) {
-        if (e.sys!.touches.length === 0) {
+    onTouchEnd(e) {
+        if (e.sys.touches.length === 0) {
             this._touching = false;
         }
-
-        if (e.sys!.touches.length === 1) {
+        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
-        ) {
+        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;
         }
     }
-
-    protected onTouchCancel(e: ITouchState) {
+    onTouchCancel(e) {
     }
-
-    protected onTouchMove(e: ITouchState) {
-        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];
-
+    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();
-
+            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;
-
+            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;
-
+            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
-            );
+            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)
-
+                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;
+                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) {
+        }
+        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;
-
+            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
+            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()
-                    );
+                    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);
@@ -302,10 +204,9 @@ export class TouchNavigation extends Control {
                     cam.checkTerrainCollision();
                     cam.update();
                     this.scaleRot = 1;
-                } else {
-                    let p0 = t.grabbedPoint,
-                        p1 = Vec3.add(p0, cam._u),
-                        p2 = Vec3.add(p0, p0.normal());
+                }
+                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) {
@@ -318,28 +219,22 @@ export class TouchNavigation extends Control {
             }
         }
     }
-
-    protected onDraw() {
-
-        const r = this.renderer!;
-
+    onDraw() {
+        const r = this.renderer;
         r.controlsBag.scaleRot = this.scaleRot;
-
         if (this._touching) {
             return;
         }
-
-        let cam = this.planet!.camera;
+        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 {
+        }
+        else {
             r.controlsBag.scaleRot = this.scaleRot;
             let rot = this.qRot
                 .slerp(Quat.IDENTITY, 1 - this.scaleRot * this.scaleRot * this.scaleRot)
@@ -354,15 +249,15 @@ export class TouchNavigation extends Control {
             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);
+            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/{src/control/ZoomControl.ts → lib/js/control/ZoomControl.js}

@@ -1,49 +1,35 @@
-import {Key} from "../Lock";
-import {Button} from "../ui/Button";
-import {Control, IControlParams} from "./Control";
-import {Renderer} from "../renderer/Renderer";
-import {Vec2} from "../math/Vec2";
-
+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 {
-    protected _keyLock: Key;
-    protected _move: number;
-    protected _targetPoint: Vec2 | null;
-
-    constructor(options: IControlParams = {}) {
+    constructor(options = {}) {
         super(options);
         this._keyLock = new Key();
         this._move = 0;
         this._targetPoint = null;
     }
-
-    public override oninit() {
-
+    oninit() {
         let zoomInBtn = new Button({
             classList: ["og-map-button", "og-zoomin-button"],
             icon: ICON_PLUS_SVG
         });
-        zoomInBtn.appendTo(this.renderer!.div!);
-
-
+        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!);
-
+        zoomOutBtn.appendTo(this.renderer.div);
         zoomInBtn.events.on("mousedown", () => this.zoomIn());
         zoomInBtn.events.on("mouseup", () => this.stopZoom());
         zoomOutBtn.events.on("mousedown", () => this.zoomOut());
@@ -54,50 +40,40 @@ class ZoomControl extends Control {
         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);
+        this.renderer.events.on("draw", this._draw, this);
     }
-
     /**
      * Planet zoom in.
      * @public
      */
-    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();
-
+    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.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;
     }
-
-    public stopZoom() {
+    stopZoom() {
         this._move = 0;
-
-        this.planet!.layerLock.free(this._keyLock);
-        this.planet!.terrainLock.free(this._keyLock);
-        this.planet!._normalMapCreator.free(this._keyLock);
+        this.planet.layerLock.free(this._keyLock);
+        this.planet.terrainLock.free(this._keyLock);
+        this.planet._normalMapCreator.free(this._keyLock);
     }
-
-    protected _draw(e: Renderer) {
-        const cam = this.planet!.camera;
-
+    _draw(e) {
+        const cam = this.planet.camera;
         if (this._move !== 0) {
-            const pos = this.planet!.getCartesianFromPixelTerrain(e.getCenter());
+            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));
@@ -107,5 +83,4 @@ class ZoomControl extends Control {
         }
     }
 }
-
-export {ZoomControl};
+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/{src/control/drawing/DrawingControl.ts → lib/js/control/drawing/DrawingControl.js}

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