@openglobus/og 0.22.2 → 0.23.0

package/lib/js/control/geoObjectEditor/ArrowEntity.js

@@ -0,0 +1,59 @@
+import { Entity } from "../../entity/Entity";
+import { X_COLOR } from "./colors";
+import { Object3d } from "../../Object3d";
+import { Vec3 } from "../../math/Vec3";
+const SCALE = 0.1;
+const SCALE_VEC = new Vec3(SCALE, SCALE, SCALE);
+const TIP_LENGTH = 0.17;
+const TIP_RADIUS = 0.04;
+const SPIN_RADIUS = 0.0095;
+const lineObj = Object3d.createCylinder(SPIN_RADIUS, SPIN_RADIUS, 1.0 - TIP_LENGTH).scale(SCALE_VEC);
+const tipObj = Object3d.createCylinder(0, TIP_RADIUS, TIP_LENGTH, 16, 16, false, true, 0, -TIP_LENGTH).scale(SCALE_VEC);
+export class ArrowEntity extends Entity {
+    constructor(params = {}) {
+        const scale = 1.0;
+        super({
+            independentPicking: true,
+            yaw: params.yaw || 0,
+            pitch: params.pitch || 0,
+            roll: params.roll || 0,
+            forceGlobalPosition: true,
+            geoObject: {
+                color: params.color || X_COLOR,
+                scale,
+                tag: "line",
+                object3d: lineObj,
+            },
+            properties: params.properties
+        });
+        this._size = params.size != undefined ? params.size : 1.0;
+        this.appendChild(new Entity({
+            yaw: params.yaw || 0,
+            pitch: params.pitch || 0,
+            roll: params.roll || 0,
+            forceGlobalPosition: true,
+            geoObject: {
+                color: params.color || X_COLOR,
+                scale,
+                tag: "tip",
+                object3d: tipObj,
+            },
+            properties: params.properties
+        }));
+    }
+    setSize(size) {
+        this._size = size;
+        const scale = new Vec3(1, (this._size - TIP_LENGTH) / (1.0 - TIP_LENGTH), 1);
+        const trans = new Vec3(0, this._size * SCALE, 0);
+        let line = this;
+        let tip = line.childEntities[0];
+        line.setScale3v(scale);
+        tip.geoObject.setTranslate3v(trans);
+    }
+    setColorHTML(color) {
+        let line = this;
+        let tip = line.childEntities[0];
+        line.geoObject.setColorHTML(color);
+        tip.geoObject.setColorHTML(color);
+    }
+}

package/lib/js/control/geoObjectEditor/AxisTrackEntity.d.ts

@@ -0,0 +1,9 @@
+import { Entity, IEntityParams } from "../../entity/Entity";
+import { Vec3 } from "../../math/Vec3";
+export interface IAxisTrackEntityParams extends IEntityParams {
+}
+export declare class AxisTrackEntity extends Entity {
+    constructor(params?: IAxisTrackEntityParams);
+    private _init;
+    setCartesian3v(cart: Vec3): void;
+}

package/lib/js/control/geoObjectEditor/AxisTrackEntity.js

@@ -0,0 +1,93 @@
+import { Entity } from "../../entity/Entity";
+import { Vec3 } from "../../math/Vec3";
+import { SEL_X_COLOR, SEL_Y_COLOR, SEL_Z_COLOR } from "./colors";
+import { LonLat } from "../../LonLat";
+import { htmlColorToFloat32Array } from "../../utils/shared";
+const SEG_SIZE = 20;
+export class AxisTrackEntity extends Entity {
+    constructor(params = {}) {
+        super({ ...params, forceGlobalPosition: true });
+        this._init();
+    }
+    _init() {
+        const length = SEG_SIZE;
+        let lonColors = [], latCoords = [], yColors = [];
+        let lonCol = htmlColorToFloat32Array(SEL_X_COLOR), yCol = htmlColorToFloat32Array(SEL_Y_COLOR), latCol = htmlColorToFloat32Array(SEL_Z_COLOR);
+        for (let i = 0; i < length; i++) {
+            let op = 1;
+            if (i < 5) {
+                let t = i / 5;
+                op = 0.5 * (1 - Math.cos(Math.PI * t));
+            }
+            else if (i > 15) {
+                let t = (i - 15) / 5;
+                op = 1 - 0.5 * (1 - Math.cos(Math.PI * t));
+            }
+            latCoords.push([latCol[0], latCol[1], latCol[2], op]);
+            lonColors.push([lonCol[0], lonCol[1], lonCol[2], op]);
+            yColors.push([yCol[0], yCol[1], yCol[2], op]);
+        }
+        let axisX = new Entity({
+            polyline: {
+                path3v: [Array.from({ length }, (_, i) => new Vec3())],
+                thickness: 2.5,
+                pathColors: [lonColors],
+                isClosed: false
+            }
+        });
+        let axisY = new Entity({
+            polyline: {
+                path3v: [Array.from({ length }, (_, i) => new Vec3())],
+                thickness: 2.5,
+                pathColors: [yColors],
+                isClosed: false
+            }
+        });
+        let axisZ = new Entity({
+            polyline: {
+                path3v: [Array.from({ length }, (_, i) => new Vec3())],
+                thickness: 2.5,
+                pathColors: [latCoords],
+                isClosed: false
+            }
+        });
+        this.appendChild(axisX);
+        this.appendChild(axisY);
+        this.appendChild(axisZ);
+    }
+    setCartesian3v(cart) {
+        super.setCartesian3v(cart);
+        if (this._entityCollection && this._entityCollection.renderNode) {
+            let rn = this._entityCollection.renderNode;
+            let cam = rn.renderer.activeCamera;
+            let r = cam.eye.distance(cart) * 0.05;
+            if (rn.planet) {
+                let yCoords = [], lonCoords = [], latCoords = [];
+                let n = rn.planet.ellipsoid.getSurfaceNormal3v(cart);
+                let ll = this._lonLat;
+                let size = SEG_SIZE / 2;
+                for (let i = -size; i < size; i++) {
+                    latCoords.push(new LonLat(ll.lon, ll.lat + i, ll.height));
+                    lonCoords.push(new LonLat(ll.lon + i, ll.lat, ll.height));
+                    yCoords.push(cart.add(n.scaleTo(i * r)));
+                }
+                this.childEntities[0].polyline.setPathLonLatFast([lonCoords]);
+                this.childEntities[1].polyline.setPath3vFast([yCoords]);
+                this.childEntities[2].polyline.setPathLonLatFast([latCoords]);
+            }
+            else {
+                let zCoords = [], xCoords = [], yCoords = [];
+                let y = Vec3.UNIT_Y, x = Vec3.UNIT_X, z = Vec3.UNIT_Z;
+                let size = SEG_SIZE / 2;
+                for (let i = -size; i < size; i++) {
+                    xCoords.push(cart.add(x.scaleTo(i * r)));
+                    yCoords.push(cart.add(y.scaleTo(i * r)));
+                    zCoords.push(cart.add(z.scaleTo(i * r)));
+                }
+                this.childEntities[0].polyline.setPath3vFast([xCoords]);
+                this.childEntities[1].polyline.setPath3vFast([yCoords]);
+                this.childEntities[2].polyline.setPath3vFast([zCoords]);
+            }
+        }
+    }
+}

package/lib/js/control/geoObjectEditor/GeoObjectEditor.d.ts

@@ -0,0 +1,13 @@
+import { Control, IControlParams } from "../Control";
+import { GeoObjectEditorScene } from "./GeoObjectEditorScene";
+import { GeoObjectPropertiesDialog } from "./GeoObjectEditorDialog";
+export interface IGeoObjectEditorParams extends IControlParams {
+}
+export declare class GeoObjectEditor extends Control {
+    protected _geoObjectEditopScene: GeoObjectEditorScene;
+    protected _dialog: GeoObjectPropertiesDialog;
+    constructor(options?: IGeoObjectEditorParams);
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+}

package/lib/js/control/geoObjectEditor/GeoObjectEditor.js

@@ -0,0 +1,30 @@
+import { Control } from "../Control";
+import { GeoObjectEditorScene } from "./GeoObjectEditorScene";
+import { GeoObjectPropertiesDialog } from "./GeoObjectEditorDialog";
+import { CameraLock } from "../CameraLock";
+export class GeoObjectEditor extends Control {
+    constructor(options = {}) {
+        super(options);
+        this._geoObjectEditopScene = new GeoObjectEditorScene({
+            name: `geoObjectEditorScene:${this.__id}`
+        });
+        this._dialog = new GeoObjectPropertiesDialog({
+            model: this._geoObjectEditopScene
+        });
+    }
+    oninit() {
+        if (this.renderer) {
+            this.renderer.addControl(new CameraLock({ planet: this.planet }));
+            this._geoObjectEditopScene.bindPlanet(this.planet);
+            this._dialog.appendTo(this.renderer.div || document.body);
+            this.activate();
+        }
+    }
+    onactivate() {
+        this.renderer && this.renderer.addNode(this._geoObjectEditopScene);
+    }
+    ondeactivate() {
+        this.renderer && this.renderer.removeNode(this._geoObjectEditopScene);
+        this._dialog.hide();
+    }
+}

package/lib/js/control/geoObjectEditor/GeoObjectEditorDialog.d.ts

@@ -0,0 +1,69 @@
+import { Dialog, IDialogParams } from "../../ui/Dialog";
+import { GeoObjectEditorScene } from "./GeoObjectEditorScene";
+import { Entity } from "../../entity/Entity";
+import { Input } from "../../ui/Input";
+import { Checkbox } from "../../ui/Checkbox";
+import { Button } from "../../ui/Button";
+import { Vec3 } from "../../math/Vec3";
+interface IGeoObjectPropertiesDialog extends IDialogParams {
+    model: GeoObjectEditorScene;
+}
+export declare class GeoObjectPropertiesDialog extends Dialog<GeoObjectEditorScene> {
+    protected _relativePositionView: Checkbox;
+    protected _lonView: Input;
+    protected _latView: Input;
+    protected _heightView: Input;
+    protected _xView: Input;
+    protected _yView: Input;
+    protected _zView: Input;
+    protected _absXView: Input;
+    protected _absYView: Input;
+    protected _absZView: Input;
+    protected _pitchView: Input;
+    protected _yawView: Input;
+    protected _rollView: Input;
+    protected _absolutePitchView: Input;
+    protected _absoluteYawView: Input;
+    protected _absoluteRollView: Input;
+    protected _scaleView: Input;
+    protected _scaleXView: Input;
+    protected _scaleYView: Input;
+    protected _scaleZView: Input;
+    protected _groundBtn: Button;
+    constructor(params: IGeoObjectPropertiesDialog);
+    render(params: any): this;
+    protected _onVisibility: (vis: boolean) => void;
+    remove(): void;
+    protected _initSceneEvents(): void;
+    protected _clearSceneEvents(): void;
+    protected _onSelect: (entity: Entity) => void;
+    protected _refresh(entity: Entity): void;
+    hide(): void;
+    protected _onUnselect: (entity: Entity) => void;
+    protected _onChangeRelativePosition: (checked: boolean) => void;
+    protected _onPosition: (pos: Vec3, entity: Entity) => void;
+    protected _onPitch: (a: number, entity: Entity) => void;
+    protected _onYaw: (a: number, entity: Entity) => void;
+    protected _onRoll: (a: number, entity: Entity) => void;
+    protected _onChangeLon: (val: string) => void;
+    protected _onChangeLat: (val: string) => void;
+    protected _onChangeHeight: (val: string) => void;
+    protected _onChangeX: (val: string) => void;
+    protected _onChangeY: (val: string) => void;
+    protected _onChangeZ: (val: string) => void;
+    protected _onChangeAbsoluteX: (val: string) => void;
+    protected _onChangeAbsoluteY: (val: string) => void;
+    protected _onChangeAbsoluteZ: (val: string) => void;
+    protected _onChangePitch: (val: string) => void;
+    protected _onChangeYaw: (val: string) => void;
+    protected _onChangeRoll: (val: string) => void;
+    protected _onChangeAbsolutePitch: (val: string) => void;
+    protected _onChangeAbsoluteYaw: (val: string) => void;
+    protected _onChangeAbsoluteRoll: (val: string) => void;
+    protected _onChangeScale: (val: string) => void;
+    protected _onChangeScaleX: (val: string) => void;
+    protected _onChangeScaleY: (val: string) => void;
+    protected _onChangeScaleZ: (val: string) => void;
+    protected _onGround: () => void;
+}
+export {};