@openglobus/og 0.18.0 → 0.18.2

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

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

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

@@ -1,60 +1,36 @@
-import {Entity} from "../../entity/Entity";
-import {Vec2} from "../../math/Vec2";
-import {Vec3} from "../../math/Vec3";
-import {
-    CENTER_OPTIONS,
-    CORNER_OPTIONS,
-    NUM_SEGMENTS,
-    OUTLINE_ALT,
-    OUTLINE_OPTIONS,
-    PolygonDrawingScene,
-    IPolygonDrawingSceneParams
-} from "./PolygonDrawingScene";
-
+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: IPolygonDrawingSceneParams) {
+    constructor(props) {
         super(props);
     }
-
-    public override get geometryType(): string {
+    get geometryType() {
         return "LineString";
     }
-
-    protected override _addNew(cart: Vec3) {
+    _addNew(cart) {
         this._appendCart(cart);
     }
-
-    protected override _appendCart(cart: Vec3) {
+    _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],
@@ -62,122 +38,91 @@ class LineStringDrawingScene extends PolygonDrawingScene {
                     ...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);
-
             let center = new Entity({
                 geoObject: CENTER_OPTIONS,
             });
             center.setCartesian3v(prevCenterCart);
             center.addTo(this._centerLayer);
             this._checkTerrainCollision(center);
-
         }
     }
-
-    protected override _clearGhostPointer() {
-        this._ghostOutlineLayer.getEntities()[0].polyline!.clear();
+    _clearGhostPointer() {
+        this._ghostOutlineLayer.getEntities()[0].polyline.clear();
     }
-
-    protected _moveCorner(indexCurrent: number, indexPrev: number, indexCenter: number) {
+    _moveCorner(indexCurrent, indexPrev, indexCenter) {
         let corners = this._cornerLayer.getEntities();
-        if (corners.length == 0) return;
+        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();
-
         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);
         }
     }
-
-    protected override _moveCornerPoint(e: Vec2) {
-        let d = new Vec2(e.x, e.y).sub(this._startClick),
-            p = this._startPos!.add(d);
-
-        let groundCoords = this._planet!.getCartesianFromPixelTerrain(p);
-
+    _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);
-
+            this._pickedCorner.setCartesian3v(groundCoords);
             let corners = this._cornerLayer.getEntities();
-
             if (corners.length) {
-                let ind = this._pickedCorner!.layerIndex;
-
+                let ind = this._pickedCorner.layerIndex;
                 if (ind === 0) {
                     this._moveCorner(ind + 1, ind + 1, ind);
-                } else if (ind === corners.length - 1) {
+                }
+                else if (ind === corners.length - 1) {
                     this._moveCorner(ind - 1, ind, ind - 1);
-                } else {
+                }
+                else {
                     this._moveCorner(ind + 1, ind + 1, ind);
                     this._moveCorner(ind - 1, ind, ind - 1);
                 }
             }
         }
     }
-
-    public override _updateGhostOutlinePointer(groundPos: Vec3) {
-
+    _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!;
-
+            let prevPolyline = entities[0].polyline;
             prevPolyline.setPath3v([pathPrev]);
         }
     }
-
-    protected override _initGhostLayerPointer() {
+    _initGhostLayerPointer() {
         this._ghostOutlineLayer.setEntities([
             new Entity({
                 polyline: {
@@ -188,9 +133,7 @@ class LineStringDrawingScene extends PolygonDrawingScene {
             }),
             this._ghostCorner
         ]);
-
-        this._ghostOutlineLayer.getEntities()[0].polyline!.altitude = OUTLINE_ALT;
+        this._ghostOutlineLayer.getEntities()[0].polyline.altitude = OUTLINE_ALT;
     }
 }
-
-export {LineStringDrawingScene};
+export { LineStringDrawingScene };

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

@@ -0,0 +1,98 @@
+import { EventsHandler } from '../../Events';
+import { CoordinatesType } from "../../entity/Geometry";
+import { Entity } from '../../entity/Entity';
+import { IMouseState } from "../../renderer/RendererEvents";
+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"];
+export interface IPolygonDrawingSceneParams {
+    coordinates?: CoordinatesType[];
+    name: string;
+}
+export declare const NUM_SEGMENTS = 200;
+export declare const OUTLINE_ALT = 0.3;
+export declare const COORDINATES_COLOR = "rgb(350, 350, 0)";
+export declare const CENTER_COLOR = "rgb(0, 350, 50)";
+export declare const OUTLINE_COLOR = "rgb(0, 350, 50)";
+export declare const OUTLINE_THICKNESS = 3.5;
+export declare const CORNER_OPTIONS: {
+    scale: number;
+    instanced: boolean;
+    tag: string;
+    color: string;
+    object3d: Object3d;
+};
+export declare const CENTER_OPTIONS: {
+    scale: number;
+    instanced: boolean;
+    tag: string;
+    color: string;
+    object3d: Object3d;
+};
+export declare const OUTLINE_OPTIONS: {
+    thickness: number;
+    color: string;
+};
+declare class PolygonDrawingScene extends RenderNode {
+    events: EventsHandler<PolygonDrawingSceneEventsList>;
+    _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: boolean;
+    constructor(options: IPolygonDrawingSceneParams);
+    get geometryType(): string;
+    getCoordinates(): CoordinatesType[];
+    bindPlanet(planet: Planet): void;
+    init(): void;
+    protected _onChange: (e: PolygonDrawingScene) => void;
+    onremove(): void;
+    clear(): void;
+    setCoordinates(coords: CoordinatesType[]): void;
+    stopNewPoint(): void;
+    startNewPoint(): void;
+    showGhostPointer(): void;
+    hideGhostPointer(): void;
+    setGhostPointerPosition(groundPos: Vec3): void;
+    protected _onCornerMouseEnter: (e: IMouseState) => void;
+    _onCornerMouseLeave: (e: IMouseState) => void;
+    _onCenterMouseEnter: (e: IMouseState) => void;
+    _onCenterMouseLeave: (e: IMouseState) => void;
+    protected _onLup: (e: IMouseState) => void;
+    protected _getLdown(e: IMouseState): Entity | null;
+    protected _onCornerLdown: (e: IMouseState) => void;
+    protected _onCenterLdown: (e: IMouseState) => void;
+    protected _onMouseMove: (e: IMouseState) => void;
+    protected _onCornerLdblclick: (e: IMouseState) => void;
+    protected _onMouseDblClick: (e: IMouseState) => void;
+    protected _initEvents(): void;
+    protected _clearEvents(): void;
+    protected _drawCorners(): void;
+    protected _drawCenters(): void;
+    protected _drawGhostCorner(): void;
+    frame(): void;
+    protected _checkTerrainCollision(entity: Entity): void;
+    protected _moveCenterPoint(): void;
+    protected _addNew(cart: Vec3): void;
+    protected _appendCart(cart: Vec3): void;
+    protected _clearGhostPointer(): void;
+    protected _moveCornerPoint(e: Vec2): void;
+    protected _updateGhostOutlinePointer(groundPos: Vec3): void;
+    protected _initGhostLayerPointer(): void;
+}
+export { PolygonDrawingScene };