@openglobus/og 0.17.2 → 0.18.0

package/src/{og/control/drawing/PolygonDrawingScene.js → control/drawing/PolygonDrawingScene.ts}

@@ -1,16 +1,26 @@
-'use strict';
-
-import * as math from "../../math.js";
-import { Entity } from '../../entity/Entity.js';
-import { Events } from '../../Events.js';
-import { Vector } from '../../layer/Vector.js';
-import { Vec2 } from '../../math/Vec2.js';
-import { Object3d } from '../../Object3d.js';
-import { RenderNode } from '../../scene/RenderNode.js';
-import { Vec3 } from '../../math/Vec3.js';
-import { Line3 } from '../../math/Line3.js';
-import { LonLat } from '../../LonLat.js';
-import { Geometry, GeometryType } from "../../entity/Geometry.js";
+import * as math from "../../math";
+import {createEvents, EventsHandler} from '../../Events';
+import {CoordinatesType} from "../../entity/Geometry";
+import {Entity} from '../../entity/Entity';
+import {IMouseState} from "../../renderer/RendererEvents";
+import {MouseNavigation} from "../MouseNavigation";
+import {LonLat} from '../../LonLat';
+import {Line3} from '../../math/Line3';
+import {Object3d} from '../../Object3d';
+import {Planet} from '../../scene/Planet';
+import {RenderNode} from '../../scene/RenderNode';
+import {Vec2} from '../../math/Vec2';
+import {Vec3} from '../../math/Vec3';
+import {Vector} from '../../layer/Vector';
+
+type PolygonDrawingSceneEventsList = ["change", "startpoint"];
+
+const POLYGONDRAWINGSCENE_EVENTS: PolygonDrawingSceneEventsList = ["change", "startpoint"];
+
+export interface IPolygonDrawingSceneParams {
+    coordinates?: CoordinatesType[];
+    name: string;
+}
 
 const POINTER_OBJ3D = Object3d.createCylinder(1, 1, 2.0, 20, 1, true, false, 0, -0.5, 0);
 
@@ -43,10 +53,28 @@ export const OUTLINE_OPTIONS = {
 }
 
 class PolygonDrawingScene extends RenderNode {
-    constructor(options = {}) {
+    public events: EventsHandler<PolygonDrawingSceneEventsList>;
+    public _planet: Planet | null;
+    protected _initCoordinates: CoordinatesType[];
+    protected _pickedCorner: Entity | null;
+    protected _pickedCenter: Entity | null;
+    protected _startPos: Vec2 | null;
+    protected _startClick: Vec2;
+    protected _geometryLayer: Vector;
+    protected _cornerLayer: Vector;
+    protected _centerLayer: Vector;
+    protected _outlineLayer: Vector;
+    protected _ghostCorner: Entity;
+    protected _ghostOutlineLayer: Vector;
+    protected _showGhostPointer: boolean;
+    protected _isStartPoint: boolean;
+    protected _insertCornerIndex: number;
+    protected _cornerDblClick = false;
+
+    constructor(options: IPolygonDrawingSceneParams) {
         super(options.name);
 
-        this.events = new Events(EVENT_NAMES);
+        this.events = createEvents(POLYGONDRAWINGSCENE_EVENTS);
 
         this._planet = null;
 
@@ -85,9 +113,6 @@ class PolygonDrawingScene extends RenderNode {
                     path3v: [],
                     isClosed: false,
                     ...OUTLINE_OPTIONS
-                },
-                properties: {
-                    index: 0
                 }
             })],
             pickingEnabled: false,
@@ -95,13 +120,13 @@ class PolygonDrawingScene extends RenderNode {
             relativeToGround: true
         });
 
-        this._outlineLayer.getEntities()[0].polyline.altitude = OUTLINE_ALT;
+        this._outlineLayer.getEntities()[0].polyline!.altitude = OUTLINE_ALT;
 
         //
         // Ghost cursor pointer
         //
         this._ghostCorner = new Entity({
-            geoObject: CORNER_OPTIONS,
+            geoObject: CORNER_OPTIONS
         });
 
         this._ghostOutlineLayer = new Vector("ghost-pointer", {
@@ -119,14 +144,14 @@ class PolygonDrawingScene extends RenderNode {
         this._insertCornerIndex = -1;
     }
 
-    get geometryType() {
+    public get geometryType(): string {
         return "Polygon";
     }
 
-    getCoordinates() {
+    public getCoordinates(): CoordinatesType[] {
         let corners = this._cornerLayer.getEntities();
         if (corners.length > 0) {
-            return corners.map((c) => {
+            return corners.map((c: Entity) => {
                 let ll = c.getLonLat();
                 return [ll.lon, ll.lat, ll.height];
             });
@@ -135,11 +160,11 @@ class PolygonDrawingScene extends RenderNode {
         }
     }
 
-    bindPlanet(planet) {
+    public bindPlanet(planet: Planet) {
         this._planet = planet;
     }
 
-    init() {
+    public override init() {
 
         this._initEvents();
 
@@ -149,22 +174,21 @@ class PolygonDrawingScene extends RenderNode {
             this.setCoordinates(this._initCoordinates);
         }
 
-        this._planet.addLayer(this._outlineLayer);
-        this._planet.addLayer(this._cornerLayer);
-        this._planet.addLayer(this._centerLayer);
+        this._planet!.addLayer(this._outlineLayer);
+        this._planet!.addLayer(this._cornerLayer);
+        this._planet!.addLayer(this._centerLayer);
 
         this.showGhostPointer();
         this.startNewPoint();
 
-        this._planet.renderer.controls.mouseNavigation.deactivateDoubleClickZoom();
+        (this._planet!.renderer!.controls.mouseNavigation as MouseNavigation).deactivateDoubleClickZoom();
 
-        this._geometryLayer.addTo(this._planet);
+        this._geometryLayer.addTo(this._planet!);
 
-        this._onChange_ = this._onChange.bind(this);
-        this.events.on("change", this._onChange_, this);
+        this.events.on("change", this._onChange, this);
     }
 
-    _onChange(e) {
+    protected _onChange = (e: PolygonDrawingScene) => {
         if (e.geometryType === "Polygon") {
             let coords = this.getCoordinates();
             let entity = new Entity({
@@ -181,7 +205,7 @@ class PolygonDrawingScene extends RenderNode {
         }
     }
 
-    onremove() {
+    override onremove() {
         this._clearEvents();
         this.hideGhostPointer();
         this.stopNewPoint();
@@ -189,7 +213,7 @@ class PolygonDrawingScene extends RenderNode {
         this._geometryLayer.remove();
     }
 
-    clear() {
+    public clear() {
 
         this._geometryLayer.clear();
 
@@ -209,7 +233,7 @@ class PolygonDrawingScene extends RenderNode {
         let entities = this._outlineLayer.getEntities();
         i = entities.length;
         while (i--) {
-            entities[i].polyline.clear();
+            entities[i].polyline!.clear();
             if (i > 0) {
                 entities[i].remove();
             }
@@ -218,114 +242,112 @@ class PolygonDrawingScene extends RenderNode {
         this._clearGhostPointer();
     }
 
-    setCoordinates(coords) {
+    public setCoordinates(coords: CoordinatesType[]) {
         this.clear();
         for (let i = 0; i < coords.length; i++) {
             let ci = coords[i];
-            let cart = this._planet.ellipsoid.lonLatToCartesian(new LonLat(ci[0], ci[1], ci[2]));
+            let cart = this._planet!.ellipsoid.lonLatToCartesian(new LonLat(ci[0], ci[1], ci[2]));
             this._appendCart(cart);
         }
         this.events.dispatch(this.events.change, this);
     }
 
-    stopNewPoint() {
+    public stopNewPoint() {
         if (this.renderer) {
-            this.renderer.events.off("ldblclick", this._onMouseDblClick_);
-            this._onMouseDblClick_ = null;
+            this.renderer.events.off("ldblclick", this._onMouseDblClick);
         }
     }
 
-    startNewPoint() {
-        this._onMouseDblClick_ = this._onMouseDblClick.bind(this);
-        this.renderer.events.on("ldblclick", this._onMouseDblClick_, this);
+    public startNewPoint() {
+        this.renderer!.events.on("ldblclick", this._onMouseDblClick, this);
     }
 
-    showGhostPointer() {
+    public showGhostPointer() {
         this._showGhostPointer = true;
-        this._planet.addLayer(this._ghostOutlineLayer);
+        this._planet!.addLayer(this._ghostOutlineLayer);
         this._insertCornerIndex = this._cornerLayer.getEntities().length;
     }
 
-    hideGhostPointer() {
+    public hideGhostPointer() {
         this._showGhostPointer = false;
         this._ghostOutlineLayer.remove();
         this._insertCornerIndex = -1;
     }
 
-    setGhostPointerPosition(groundPos) {
+    public setGhostPointerPosition(groundPos: Vec3) {
         if (groundPos) {
             this._ghostCorner.setCartesian3v(groundPos);
             this._updateGhostOutlinePointer(groundPos);
         }
     }
 
-    _onCornerMouseEnter(e) {
-        e.renderer.handler.canvas.style.cursor = "pointer";
+    protected _onCornerMouseEnter = (e: IMouseState) => {
+        e.renderer.handler.canvas!.style.cursor = "pointer";
         this.hideGhostPointer();
     }
 
-    _onCornerMouseLeave(e) {
-        e.renderer.handler.canvas.style.cursor = "default";
+    _onCornerMouseLeave = (e: IMouseState) => {
+        e.renderer.handler.canvas!.style.cursor = "default";
         this.showGhostPointer();
     }
 
-    _onCenterMouseEnter(e) {
-        e.renderer.handler.canvas.style.cursor = "pointer";
+    _onCenterMouseEnter = (e: IMouseState) => {
+        e.renderer.handler.canvas!.style.cursor = "pointer";
         this.hideGhostPointer();
     }
 
-    _onCenterMouseLeave(e) {
-        e.renderer.handler.canvas.style.cursor = "default";
+    _onCenterMouseLeave = (e: IMouseState) => {
+        e.renderer.handler.canvas!.style.cursor = "default";
         if (!(this._pickedCenter || this._pickedCorner)) {
             this.showGhostPointer();
         }
     }
 
-    _onLup(e) {
-        this._planet.renderer.controls.mouseNavigation.activate();
+    protected _onLup = (e: IMouseState) => {
+        (this._planet!.renderer!.controls.mouseNavigation as MouseNavigation).activate();
         if (this._pickedCorner || this._pickedCenter) {
             this.events.dispatch(this.events.change, this);
-            this.setGhostPointerPosition(this._planet.getCartesianFromPixelTerrain(e));
+            this.setGhostPointerPosition(this._planet!.getCartesianFromPixelTerrain(e)!);
             this.showGhostPointer();
             this._pickedCorner = null;
             this._pickedCenter = null;
         }
     }
 
-    _getLdown(e) {
-        this._planet.renderer.controls.mouseNavigation.deactivate();
+    protected _getLdown(e: IMouseState): Entity | null {
+        (this._planet!.renderer!.controls.mouseNavigation as MouseNavigation).deactivate();
         this._startClick.set(e.x, e.y);
         let coords = e.pickingObject.getCartesian();
-        this._startPos = this._planet.getPixelFromCartesian(coords);
+        this._startPos = this._planet!.getPixelFromCartesian(coords);
         return e.pickingObject;
     }
 
-    _onCornerLdown(e) {
+    protected _onCornerLdown = (e: IMouseState) => {
         this._pickedCorner = this._getLdown(e);
     }
 
-    _onCenterLdown(e) {
+    protected _onCenterLdown = (e: IMouseState) => {
         this._pickedCenter = this._getLdown(e);
     }
 
-    _onMouseMove(e) {
+    protected _onMouseMove = (e: IMouseState) => {
         if (this._pickedCenter) {
             this._moveCenterPoint();
         } else if (this._pickedCorner) {
-            this._moveCornerPoint(e);
+            this._moveCornerPoint(e.pos!);
         } else {
-            this.setGhostPointerPosition(this._planet.getCartesianFromPixelTerrain(e));
+            this.setGhostPointerPosition(this._planet!.getCartesianFromPixelTerrain(e.pos)!);
         }
     }
 
-    _onCornerLdblclick(e) {
+    protected _onCornerLdblclick = (e: IMouseState) => {
         this._cornerDblClick = true;
         let coords = this.getCoordinates();
         coords.splice(e.pickingObject.layerIndex, 1);
         this.setCoordinates(coords);
     }
 
-    _onMouseDblClick(e) {
+    protected _onMouseDblClick = (e: IMouseState) => {
 
         if (this._cornerDblClick) {
             this._cornerDblClick = false;
@@ -336,7 +358,7 @@ class PolygonDrawingScene extends RenderNode {
             return;
         }
 
-        let cart = this._planet.getCartesianFromPixelTerrain(e);
+        let cart = this._planet!.getCartesianFromPixelTerrain(e);
         if (cart) {
             this._addNew(cart);
             if (!this._isStartPoint && this._cornerLayer.getEntities().length > 2) {
@@ -347,66 +369,36 @@ class PolygonDrawingScene extends RenderNode {
         }
     }
 
-    _initEvents() {
-
-        this._onCornerLdblclick_ = this._onCornerLdblclick.bind(this);
-        this._cornerLayer.events.on("ldblclick", this._onCornerLdblclick_, this);
-
-        this._onCornerLdown_ = this._onCornerLdown.bind(this);
-        this._cornerLayer.events.on("ldown", this._onCornerLdown_, this);
-
-        this._onCenterLdown_ = this._onCenterLdown.bind(this);
-        this._centerLayer.events.on("ldown", this._onCenterLdown_, this);
-
-        this._onLup_ = this._onLup.bind(this);
-        this.renderer.events.on("lup", this._onLup_, this);
-
-        this._onMouseMove_ = this._onMouseMove.bind(this);
-        this.renderer.events.on("mousemove", this._onMouseMove_, this);
-
-        this._onCornerMouseEnter_ = this._onCornerMouseEnter.bind(this);
-        this._cornerLayer.events.on("mouseenter", this._onCornerMouseEnter_, this);
+    protected _initEvents() {
 
-        this._onCornerMouseLeave_ = this._onCornerMouseLeave.bind(this);
-        this._cornerLayer.events.on("mouseleave", this._onCornerMouseLeave_, this);
+        this._cornerLayer.events.on("ldblclick", this._onCornerLdblclick, this);
+        this._cornerLayer.events.on("ldown", this._onCornerLdown, this);
+        this._centerLayer.events.on("ldown", this._onCenterLdown, this);
 
-        this._onCenterMouseEnter_ = this._onCenterMouseEnter.bind(this);
-        this._centerLayer.events.on("mouseenter", this._onCenterMouseEnter_, this);
+        this.renderer!.events.on("lup", this._onLup, this);
+        this.renderer!.events.on("mousemove", this._onMouseMove, this);
 
-        this._onCenterMouseLeave_ = this._onCenterMouseLeave.bind(this);
-        this._centerLayer.events.on("mouseleave", this._onCenterMouseLeave_, this);
+        this._cornerLayer.events.on("mouseenter", this._onCornerMouseEnter, this);
+        this._cornerLayer.events.on("mouseleave", this._onCornerMouseLeave, this);
+        this._centerLayer.events.on("mouseenter", this._onCenterMouseEnter, this);
+        this._centerLayer.events.on("mouseleave", this._onCenterMouseLeave, this);
     }
 
-    _clearEvents() {
-        this._cornerLayer.events.off("ldblclick", this._onCornerLdblclick_);
-        this._onCornerLdblclick_ = null;
+    protected _clearEvents() {
+        this._cornerLayer.events.off("ldblclick", this._onCornerLdblclick);
+        this._cornerLayer.events.off("ldown", this._onCornerLdown);
+        this._centerLayer.events.off("ldown", this._onCenterLdown);
 
-        this._cornerLayer.events.off("ldown", this._onCornerLdown_);
-        this._onCornerLdown_ = null;
+        this.renderer!.events.off("lup", this._onLup);
+        this.renderer!.events.off("mousemove", this._onMouseMove);
 
-        this._centerLayer.events.off("ldown", this._onCenterLdown_);
-        this._onCenterLdown_ = null;
-
-        this.renderer.events.off("lup", this._onLup_);
-        this._onLup_ = null;
-
-        this.renderer.events.off("mousemove", this._onMouseMove_);
-        this._onMouseMove_ = null;
-
-        this._cornerLayer.events.off("mouseenter", this._onCornerMouseEnter_);
-        this._onCornerMouseEnter_ = null;
-
-        this._cornerLayer.events.off("mouseleave", this._onCornerMouseLeave_);
-        this._onCornerMouseLeave_ = null;
-
-        this._centerLayer.events.off("mouseenter", this._onCenterMouseEnter_);
-        this._onCenterMouseEnter_ = null;
-
-        this._centerLayer.events.off("mouseleave", this._onCenterMouseLeave_);
-        this._onCenterMouseLeave_ = null;
+        this._cornerLayer.events.off("mouseenter", this._onCornerMouseEnter);
+        this._cornerLayer.events.off("mouseleave", this._onCornerMouseLeave);
+        this._centerLayer.events.off("mouseenter", this._onCenterMouseEnter);
+        this._centerLayer.events.off("mouseleave", this._onCenterMouseLeave);
     }
 
-    _drawCorners() {
+    protected _drawCorners() {
         let corners = this._cornerLayer.getEntities();
         for (let i = 0; i < corners.length; i++) {
             let ai = corners[i];
@@ -414,7 +406,7 @@ class PolygonDrawingScene extends RenderNode {
         }
     }
 
-    _drawCenters() {
+    protected _drawCenters() {
         let centers = this._centerLayer.getEntities();
         for (let i = 0; i < centers.length; i++) {
             let ai = centers[i];
@@ -422,21 +414,21 @@ class PolygonDrawingScene extends RenderNode {
         }
     }
 
-    _drawGhostCorner() {
+    protected _drawGhostCorner() {
         if (this._showGhostPointer) {
             this._checkTerrainCollision(this._ghostCorner);
         }
     }
 
-    frame() {
+    public override frame() {
         this._drawCorners();
         this._drawCenters();
         this._drawGhostCorner();
     }
 
-    _checkTerrainCollision(entity) {
+    protected _checkTerrainCollision(entity: Entity) {
         let _tempTerrPoint = new Vec3();
-        let nodes = this._planet._renderedNodes;
+        let nodes = this._planet!._renderedNodes;
         for (let j = 0; j < nodes.length; j++) {
             let seg = nodes[j].segment;
             if (seg && seg._extentLonLat.isInside(entity.getLonLat())) {
@@ -447,11 +439,11 @@ class PolygonDrawingScene extends RenderNode {
         }
     }
 
-    _moveCenterPoint() {
+    protected _moveCenterPoint() {
         let coords = this.getCoordinates(),
-            index = this._pickedCenter.layerIndex + 1,
-            ll = this._pickedCenter.getLonLat();
-        let newCorner = [ll.lon, ll.lat, ll.height];
+            index = this._pickedCenter!.layerIndex + 1,
+            ll = this._pickedCenter!.getLonLat();
+        let newCorner: CoordinatesType = [ll.lon, ll.lat, ll.height];
 
         coords.splice(index, 0, newCorner);
 
@@ -462,25 +454,21 @@ class PolygonDrawingScene extends RenderNode {
         this._pickedCorner = this._cornerLayer.getEntities()[index];
     }
 
-    //
-    // virtual
-    //
-
-    _addNew(cart) {
+    protected _addNew(cart: Vec3) {
         if (this._insertCornerIndex === -1 || this._cornerLayer.getEntities().length < 2) {
             this._appendCart(cart);
         } else {
             let area = this.getCoordinates(),
                 index = this._insertCornerIndex;
-            let ll = this._planet.ellipsoid.cartesianToLonLat(cart);
-            let newCorner = [ll.lon, ll.lat, ll.height];
+            let ll = this._planet!.ellipsoid.cartesianToLonLat(cart);
+            let newCorner: CoordinatesType = [ll.lon, ll.lat, ll.height];
             area.splice(index, 0, newCorner);
             this.clear();
             this.setCoordinates(area);
         }
     }
 
-    _appendCart(cart) {
+    protected _appendCart(cart: Vec3) {
         let corners = this._cornerLayer.getEntities();
 
         let segNum = corners.length - 1;
@@ -519,19 +507,16 @@ class PolygonDrawingScene extends RenderNode {
                 firstPath.push(f);
             }
 
-            this._outlineLayer.getEntities()[0].polyline.setPath3v([firstPath]);
+            this._outlineLayer.getEntities()[0].polyline!.setPath3v([firstPath]);
 
             let entity = new Entity({
                 polyline: {
                     path3v: [prevPath],
                     isClosed: false,
-                    properties: {
-                        index: segNum + 1
-                    },
                     ...OUTLINE_OPTIONS
                 }
             });
-            entity.polyline.altitude = OUTLINE_ALT;
+            entity.polyline!.altitude = OUTLINE_ALT;
             this._outlineLayer.add(entity);
 
             let centers = this._centerLayer.getEntities();
@@ -561,32 +546,33 @@ class PolygonDrawingScene extends RenderNode {
         }
     }
 
-    _clearGhostPointer() {
-        this._ghostOutlineLayer.getEntities()[0].polyline.clear();
-        this._ghostOutlineLayer.getEntities()[1].polyline.clear();
+    protected _clearGhostPointer() {
+        const g = this._ghostOutlineLayer;
+        g.getEntities()[0].polyline!.clear();
+        g.getEntities()[1].polyline!.clear();
     }
 
-    _moveCornerPoint(e) {
+    protected _moveCornerPoint(e: Vec2) {
         let d = new Vec2(e.x, e.y).sub(this._startClick),
-            p = this._startPos.add(d);
+            p = this._startPos!.add(d);
 
-        let groundCoords = this._planet.getCartesianFromPixelTerrain(p);
+        let groundCoords = this._planet!.getCartesianFromPixelTerrain(p);
 
         if (groundCoords) {
 
-            this._pickedCorner.setCartesian3v(groundCoords);
+            this._pickedCorner!.setCartesian3v(groundCoords);
 
             let corners = this._cornerLayer.getEntities();
 
             if (corners.length) {
-                let ind = this._pickedCorner.layerIndex;
+                let ind = this._pickedCorner!.layerIndex;
                 let size = corners.length;
 
                 let cartPrev = corners[ind === 0 ? (size - 1) : (ind - 1)].getCartesian(),
                     cartNext = corners[(ind + 1) % size].getCartesian();
 
-                let vecPrev = this._pickedCorner.getCartesian().sub(cartPrev),
-                    vecNext = this._pickedCorner.getCartesian().sub(cartNext);
+                let vecPrev = this._pickedCorner!.getCartesian().sub(cartPrev),
+                    vecNext = this._pickedCorner!.getCartesian().sub(cartNext);
 
                 let distPrev = vecPrev.length(),
                     distNext = vecNext.length();
@@ -610,8 +596,8 @@ class PolygonDrawingScene extends RenderNode {
                 let prevPolyline = entities[ind].polyline,
                     nextPolyline = entities[(ind + 1) % size].polyline;
 
-                prevPolyline.setPath3v([pathPrev]);
-                nextPolyline.setPath3v([pathNext]);
+                prevPolyline?.setPath3v([pathPrev]);
+                nextPolyline?.setPath3v([pathNext]);
 
                 //
                 // Move center points
@@ -631,7 +617,7 @@ class PolygonDrawingScene extends RenderNode {
         }
     }
 
-    _updateGhostOutlinePointer(groundPos) {
+    protected _updateGhostOutlinePointer(groundPos: Vec3) {
 
         let corners = this._cornerLayer.getEntities();
         let size = corners.length;
@@ -715,71 +701,32 @@ class PolygonDrawingScene extends RenderNode {
             let prevPolyline = entities[0].polyline,
                 nextPolyline = entities[1].polyline;
 
-            prevPolyline.setPath3v([pathPrev]);
-            nextPolyline.setPath3v([pathNext]);
+            prevPolyline?.setPath3v([pathPrev]);
+            nextPolyline?.setPath3v([pathNext]);
         }
     }
 
-    _initGhostLayerPointer() {
+    protected _initGhostLayerPointer() {
         this._ghostOutlineLayer.setEntities([
             new Entity({
                 polyline: {
                     path3v: [],
                     isClosed: false,
                     ...OUTLINE_OPTIONS
-                },
-                properties: {
-                    index: 0
                 }
             }), new Entity({
                 polyline: {
                     path3v: [],
                     isClosed: false,
                     ...OUTLINE_OPTIONS
-                },
-                properties: {
-                    index: 0
                 }
             }),
             this._ghostCorner
         ]);
 
-        this._ghostOutlineLayer.getEntities()[0].polyline.altitude =
-            this._ghostOutlineLayer.getEntities()[1].polyline.altitude = OUTLINE_ALT;
+        const g = this._ghostOutlineLayer;
+        g.getEntities()[0].polyline!.altitude = g.getEntities()[1].polyline!.altitude = OUTLINE_ALT;
     }
 }
 
-const EVENT_NAMES = [
-    "startpoint",
-    "change",
-    "add",
-    "remove",
-    "mousemove",
-    "mouseenter",
-    "mouseleave",
-    "lclick",
-    "rclick",
-    "mclick",
-    "ldblclick",
-    "rdblclick",
-    "mdblclick",
-    "lup",
-    "rup",
-    "mup",
-    "ldown",
-    "rdown",
-    "mdown",
-    "lhold",
-    "rhold",
-    "mhold",
-    "mousewheel",
-    "touchmove",
-    "touchstart",
-    "touchend",
-    "doubletouch",
-    "touchleave",
-    "touchenter"
-];
-
-
-export { PolygonDrawingScene };
+export {PolygonDrawingScene};