@openglobus/og 0.17.2 → 0.18.0

package/src/control/TouchNavigation.ts

@@ -0,0 +1,368 @@
+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;
+}
+
+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;
+        this.prev_x = 0;
+        this.prev_y = 0;
+        this.grabbedPoint = null;
+        this.grabbedSpheroid = new Sphere();
+        this._vec = new Vec2();
+        this._vecPrev = new Vec2();
+    }
+
+    public get dY(): number {
+        return this.y - this.prev_y;
+    }
+
+    public get dX(): number {
+        return this.x - this.prev_x;
+    }
+
+    public get vec(): Vec2 {
+        return this._vec.set(this.x, this.y);
+    }
+
+    public get vecPrev(): Vec2 {
+        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 = {}) {
+        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;
+    }
+
+    override 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);
+        }
+    }
+
+    protected onTouchStart(e: ITouchState) {
+        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);
+        }
+    }
+
+    protected _startTouchOne(e: ITouchState) {
+        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();
+        }
+    }
+
+    public stopRotation() {
+        this.qRot.clear();
+        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();
+        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)
+            );
+        }
+    }
+
+    protected onTouchEnd(e: ITouchState) {
+        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;
+        }
+    }
+
+    protected onTouchCancel(e: ITouchState) {
+    }
+
+    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];
+
+            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;
+                    }
+                }
+            }
+        }
+    }
+
+    protected 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/src/control/ZoomControl.ts

@@ -0,0 +1,111 @@
+import {Key} from "../Lock";
+import {Button} from "../ui/Button";
+import {Control, IControlParams} from "./Control";
+import {Renderer} from "../renderer/Renderer";
+import {Vec2} from "../math/Vec2";
+
+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 = {}) {
+        super(options);
+        this._keyLock = new Key();
+        this._move = 0;
+        this._targetPoint = null;
+    }
+
+    public override 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
+     */
+    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;
+    }
+
+    public stopZoom() {
+        this._move = 0;
+
+        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;
+
+        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/src/control/drawing/DrawingControl.ts

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

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

@@ -1,30 +1,30 @@
+import {Entity} from "../../entity/Entity";
+import {Vec2} from "../../math/Vec2";
+import {Vec3} from "../../math/Vec3";
 import {
-    OUTLINE_ALT,
+    CENTER_OPTIONS,
     CORNER_OPTIONS,
     NUM_SEGMENTS,
+    OUTLINE_ALT,
     OUTLINE_OPTIONS,
-    CENTER_OPTIONS,
-    PolygonDrawingScene
-} from "./PolygonDrawingScene.js";
-import { Entity } from "../../entity/Entity.js";
-import { Line3, Vec2, Vec3 } from "../../math/index.js";
-import * as math from "../../math.js";
-import { GeometryType } from "../../entity/Geometry.js";
+    PolygonDrawingScene,
+    IPolygonDrawingSceneParams
+} from "./PolygonDrawingScene";
 
 class LineStringDrawingScene extends PolygonDrawingScene {
-    constructor(props) {
+    constructor(props: IPolygonDrawingSceneParams) {
         super(props);
     }
 
-    get geometryType() {
+    public override get geometryType(): string {
         return "LineString";
     }
 
-    _addNew(cart) {
+    protected override _addNew(cart: Vec3) {
         this._appendCart(cart);
     }
 
-    _appendCart(cart) {
+    protected override _appendCart(cart: Vec3) {
         let corners = this._cornerLayer.getEntities();
 
         let segNum = corners.length - 1;
@@ -59,13 +59,10 @@ class LineStringDrawingScene extends PolygonDrawingScene {
                 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 prevCenterCart = vecPrev.scaleTo(distPrev * 0.5).addA(prevCart);
@@ -80,18 +77,18 @@ class LineStringDrawingScene extends PolygonDrawingScene {
         }
     }
 
-    _clearGhostPointer() {
-        this._ghostOutlineLayer.getEntities()[0].polyline.clear();
+    protected override _clearGhostPointer() {
+        this._ghostOutlineLayer.getEntities()[0].polyline!.clear();
     }
 
-    _moveCorner(indexCurrent, indexPrev, indexCenter) {
+    protected _moveCorner(indexCurrent: number, indexPrev: number, indexCenter: number) {
         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 vecCurr = this._pickedCorner!.getCartesian().sub(cartCurr);
         let distCurr = vecCurr.length();
         vecCurr.normalize();
 
@@ -105,7 +102,7 @@ class LineStringDrawingScene extends PolygonDrawingScene {
 
         let prevPolyline = entities[indexPrev].polyline;
 
-        prevPolyline.setPath3v([path]);
+        prevPolyline?.setPath3v([path]);
 
         //
         // Move center points
@@ -119,21 +116,20 @@ class LineStringDrawingScene extends PolygonDrawingScene {
         }
     }
 
-    _moveCornerPoint(e) {
+    protected override _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 size = corners.length;
+                let ind = this._pickedCorner!.layerIndex;
 
                 if (ind === 0) {
                     this._moveCorner(ind + 1, ind + 1, ind);
@@ -147,7 +143,7 @@ class LineStringDrawingScene extends PolygonDrawingScene {
         }
     }
 
-    _updateGhostOutlinePointer(groundPos) {
+    public override _updateGhostOutlinePointer(groundPos: Vec3) {
 
         let corners = this._cornerLayer.getEntities();
         let size = corners.length;
@@ -175,29 +171,26 @@ class LineStringDrawingScene extends PolygonDrawingScene {
 
             let entities = this._ghostOutlineLayer.getEntities();
 
-            let prevPolyline = entities[0].polyline;
+            let prevPolyline = entities[0].polyline!;
 
             prevPolyline.setPath3v([pathPrev]);
         }
     }
 
-    _initGhostLayerPointer() {
+    protected override _initGhostLayerPointer() {
         this._ghostOutlineLayer.setEntities([
             new Entity({
                 polyline: {
                     path3v: [],
                     isClosed: false,
                     ...OUTLINE_OPTIONS
-                },
-                properties: {
-                    index: 0
                 }
             }),
             this._ghostCorner
         ]);
 
-        this._ghostOutlineLayer.getEntities()[0].polyline.altitude = OUTLINE_ALT;
+        this._ghostOutlineLayer.getEntities()[0].polyline!.altitude = OUTLINE_ALT;
     }
 }
 
-export { LineStringDrawingScene };
+export {LineStringDrawingScene};