deeptwins-engine-3d 0.0.42

package/dist/drawer/index.js

@@ -0,0 +1,350 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Color, defaultValue, JulianDate } from 'deeptwins-cesium';
+import Subscriber from "../tool/cesiumExtends/Subscriber";
+import ToolTip from "../toolTip/index";
+import Painter from "./painter";
+import Ellipse from "./shape/Ellipse";
+import Point from "./shape/Point";
+import Polygon from "./shape/Polygon";
+import Polyline from "./shape/Polyline";
+import Rectangle from "./shape/Rectangle";
+import { cartesian3ToLngLatAlt } from "../tool/utils";
+export * from "./typings";
+export var defaultOptions = {
+  terrain: false,
+  model: false,
+  operateType: {
+    START: 'LEFT_CLICK',
+    MOVING: 'MOUSE_MOVE',
+    CANCEL: 'RIGHT_CLICK',
+    END: 'LEFT_DOUBLE_CLICK'
+  },
+  /**
+   * 图形勾画时的Entity样式
+   */
+  dynamicGraphicsOptions: {
+    polyline: {
+      clampToGround: true,
+      width: 2,
+      material: Color.BLUE
+    },
+    polygon: {
+      outlineColor: Color.BLUE,
+      outlineWidth: 2,
+      material: Color.BLUE.withAlpha(0.5)
+    },
+    point: {
+      // HeightReference: HeightReference.CLAMP_TO_GROUND,
+      color: Color.BLUE,
+      pixelSize: 8,
+      outlineColor: Color.WHITE,
+      outlineWidth: 1
+    },
+    rectangle: {
+      material: Color.BLUE.withAlpha(0.5)
+    },
+    ellipse: {
+      material: Color.BLUE.withAlpha(0.5),
+      outline: true
+    }
+  },
+  sameStyle: true,
+  tips: {
+    init: '点击绘制',
+    start: '左键添加点，右键移除点，双击结束绘制',
+    end: ''
+  }
+};
+var Drawer = /*#__PURE__*/function () {
+  function Drawer(viewer, options) {
+    var _options$sameStyle;
+    _classCallCheck(this, Drawer);
+    _defineProperty(this, "_viewer", void 0);
+    _defineProperty(this, "_type", void 0);
+    _defineProperty(this, "_terrain", void 0);
+    _defineProperty(this, "_model", void 0);
+    _defineProperty(this, "_subscriber", void 0);
+    _defineProperty(this, "_status", void 0);
+    _defineProperty(this, "_painter", void 0);
+    _defineProperty(this, "_events", []);
+    _defineProperty(this, "_typeClass", void 0);
+    _defineProperty(this, "_option", void 0);
+    _defineProperty(this, "$Instance", void 0);
+    _defineProperty(this, "$AddedInstance", []);
+    _defineProperty(this, "_dropPoint", void 0);
+    _defineProperty(this, "_moving", void 0);
+    _defineProperty(this, "_cancel", void 0);
+    _defineProperty(this, "_playOff", void 0);
+    /**
+     * @desc 操作方式
+     */
+    _defineProperty(this, "_operateType", void 0);
+    _defineProperty(this, "_oneInstance", void 0);
+    _defineProperty(this, "_once", void 0);
+    /**
+     * @desc 动作回调
+     */
+    _defineProperty(this, "_action", void 0);
+    _defineProperty(this, "_sameStyle", void 0);
+    _defineProperty(this, "mouseTooltip", void 0);
+    _defineProperty(this, "_tips", void 0);
+    this._option = defaultValue(options, {});
+    if (!viewer) throw new Error('请输入Viewer对象！');
+
+    // 设置操作方式
+    this._operateType = _objectSpread(_objectSpread({}, defaultOptions.operateType), options === null || options === void 0 ? void 0 : options.operateType);
+    this._viewer = viewer;
+    this._terrain = defaultValue(this._option.terrain, defaultOptions.terrain);
+    this._model = defaultValue(this._option.model, defaultOptions.model);
+    this._action = this._option.action;
+    this._sameStyle = (_options$sameStyle = options === null || options === void 0 ? void 0 : options.sameStyle) !== null && _options$sameStyle !== void 0 ? _options$sameStyle : true;
+    this._tips = _objectSpread(_objectSpread({}, defaultOptions.tips), options === null || options === void 0 ? void 0 : options.tips);
+    if (this._terrain && !this._viewer.scene.pickPositionSupported) {
+      console.warn('浏览器不支持 pickPosition属性，无法在有地形的情况下正确选点');
+      this._terrain = false;
+    }
+    this._subscriber = new Subscriber(this._viewer);
+    this.mouseTooltip = new ToolTip(viewer);
+    this.mouseTooltip.show(false);
+    this._status = 'INIT';
+    // 为了防止产生侵入性bug，请在使用前确认相关事件是否可用，不再默认移除原生事件
+    // Object.keys(this._option.keyboard).forEach(key =>
+    //   Subscriber.removeNative(this._viewer, this._option.keyboard[key])
+    // )
+  }
+
+  /**
+   * @param finalOptions
+   * @param dynamicOptions
+   */
+  _createClass(Drawer, [{
+    key: "status",
+    get: function get() {
+      return this._status;
+    }
+  }, {
+    key: "operateType",
+    get: function get() {
+      return this._operateType;
+    }
+  }, {
+    key: "isDestroyed",
+    get: function get() {
+      return this._status === 'DESTROY';
+    }
+  }, {
+    key: "_initPainter",
+    value: function _initPainter(options) {
+      var painterOptions = {
+        viewer: this._viewer,
+        type: this._type,
+        terrain: this._terrain,
+        model: this._model
+      };
+      this._painter = new Painter(painterOptions);
+      if (this._type === 'polygon') {
+        this._typeClass = new Polygon(this._painter, options);
+      } else if (this._type === 'polyline') {
+        this._typeClass = new Polyline(this._painter, options);
+      } else if (this._type === 'point') {
+        this._typeClass = new Point(this._painter, options);
+      } else if (this._type === 'ellipse') {
+        this._typeClass = new Ellipse(this._painter, options);
+      } else if (this._type === 'rectangle') {
+        this._typeClass = new Rectangle(this._painter, options);
+      }
+      this._dropPoint = this._typeClass.dropPoint.bind(this._typeClass);
+      this._moving = this._typeClass.moving.bind(this._typeClass);
+      this._cancel = this._typeClass.cancel.bind(this._typeClass);
+      this._playOff = this._typeClass.playOff.bind(this._typeClass);
+    }
+  }, {
+    key: "_updateTips",
+    value: function _updateTips() {
+      if (!this._painter) return;
+      if (this._status === 'INIT' || this._status === 'DESTROY') {
+        this.mouseTooltip.show(false);
+        return;
+      }
+      if (this._status === 'PAUSE') {
+        this.mouseTooltip.setOptions({
+          text: this._tips.end
+        });
+        if (this._once) this.mouseTooltip.show(false);
+        return;
+      }
+      if (this._painter._breakPointEntities.length === 0) {
+        this.mouseTooltip.setOptions({
+          text: this._tips.init
+        });
+        this.mouseTooltip.show(true);
+      } else {
+        this.mouseTooltip.setOptions({
+          text: this._tips.start
+        });
+        this.mouseTooltip.show(true);
+      }
+    }
+
+    /**
+     * @desc 绘制函数,
+     * @param config 绘制配置，可以通过定义options直接改写结果而不再填第二个参数
+     * @param overrideFunc Entity 重写函数，用于重写绘制结果，如果 overrideFunc返回一个Entity,则将该Entity添加到Viewer中，否则结束函数无操作
+     * @returns
+     */
+  }, {
+    key: "start",
+    value: function start(config) {
+      var _this = this;
+      var overrideFunc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (action, entity) {
+        return entity;
+      };
+      config = defaultValue(config, {});
+      this._once = defaultValue(config.once, true);
+      this._oneInstance = defaultValue(config.oneInstance, false);
+      if (!this._isSupport(config.type)) {
+        throw new Error("the type '".concat(config.type, "' is not support"));
+      }
+      this._type = config.type;
+      var defaultOpts = defaultOptions.dynamicGraphicsOptions[this._type];
+      this._initPainter({
+        finalOptions: _objectSpread(_objectSpread({}, defaultOpts), config.finalOptions),
+        dynamicOptions: _objectSpread(_objectSpread({}, defaultOpts), config.dynamicOptions),
+        sameStyle: this._sameStyle,
+        complete: config.complete,
+        onPointsChange: config.onPointsChange
+      });
+      if (this._status === 'START') return;
+      this._status = 'START';
+      this._viewer.canvas.style.cursor = 'crosshair';
+      this._updateTips();
+
+      /**
+       * @desc 是否开始绘制
+       */
+      var isStartDraw = false;
+
+      // 开始事件
+      var startId = this._subscriber.addExternal(function (move) {
+        if (_this._oneInstance && _this.$Instance) {
+          _this._viewer.entities.remove(_this.$Instance);
+          _this.$AddedInstance = [];
+        }
+        _this._dropPoint(move);
+        if (_this._action) _this._action(_this._operateType.START, move);
+
+        // 如果是点，则此时执行点的结束绘制操作
+        if (_this._type === 'point') {
+          var _this$$Instance;
+          _this._typeClass.result = _this._viewer.addGraphicEntityToLayer(_this._typeClass.result.position, {
+            type: _this._type,
+            id: _this._typeClass.result.id,
+            entity: _this._typeClass.result
+          });
+          _this._complete(overrideFunc);
+          isStartDraw = false;
+          var positions = (_this$$Instance = _this.$Instance) === null || _this$$Instance === void 0 || (_this$$Instance = _this$$Instance.position) === null || _this$$Instance === void 0 ? void 0 : _this$$Instance.getValue(new JulianDate());
+          if (config.complete && _this.$Instance && positions) {
+            var point = cartesian3ToLngLatAlt(positions);
+            config.complete(_this.$Instance, positions, [point]);
+          }
+        }
+        _this._updateTips();
+        // 100ms后才能继续,避免热键冲突
+        setTimeout(function () {
+          isStartDraw = true;
+        }, 100);
+      }, this._operateType.START);
+
+      // 移动事件
+      var moveId = this._subscriber.addExternal(function (move) {
+        _this._viewer.canvas.style.cursor = 'crosshair';
+        if (!isStartDraw) return;
+        _this._moving(move);
+
+        // ActionCallback
+        if (_this._action) _this._action(_this._operateType.MOVING, move);
+      }, this._operateType.MOVING);
+
+      // Redraw the shape so it's not dynamic and remove the dynamic shape.
+      var cancelId = this._subscriber.addExternal(function (move) {
+        if (!isStartDraw) return;
+        _this._cancel(move);
+        _this._updateTips();
+
+        // ActionCallback
+        if (_this._action) _this._action(_this._operateType.CANCEL, move);
+      }, this._operateType.CANCEL);
+
+      // Redraw the shape so it's not dynamic and remove the dynamic shape.
+      var endId = this._subscriber.addExternal(function (move) {
+        if (!isStartDraw) return;
+
+        // 结束绘制，确定实体
+        _this._playOff(move);
+
+        // ActionCallback
+        if (_this._action) _this._action(_this._operateType.END, move);
+        if (_this._type === 'point') return;
+        _this._complete(overrideFunc);
+        _this._updateTips();
+        isStartDraw = false;
+      }, this._operateType.END);
+      this._events = [startId, moveId, cancelId, endId];
+    }
+  }, {
+    key: "_complete",
+    value: function _complete(override) {
+      // 如果是线和面，则此时将实例添加到Viewer中
+      if (this._once) this.pause();
+      this.$Instance = override.call(this, this._operateType.END, this._typeClass.result);
+      this.$AddedInstance.push(this.$Instance);
+      this._viewer.canvas.style.cursor = 'default';
+    }
+  }, {
+    key: "_isSupport",
+    value: function _isSupport(type) {
+      return ['polygon', 'polyline', 'point', 'ellipse', 'rectangle'].includes(type);
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      var _this$_painter;
+      this.pause();
+      this._status = 'INIT';
+      (_this$_painter = this._painter) === null || _this$_painter === void 0 || _this$_painter.clear();
+      this.$AddedInstance.map(function (layer) {
+        layer.remove();
+      });
+      this.$AddedInstance = [];
+      this._viewer.scene.requestRender();
+    }
+  }, {
+    key: "pause",
+    value: function pause() {
+      this._status = 'PAUSE';
+      this._updateTips();
+      this._subscriber.removeExternal(this._events);
+      this._events = [];
+      this._viewer.canvas.style.cursor = 'default';
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.reset();
+      this.mouseTooltip.destroy();
+      this._subscriber.destroy();
+      this._status = 'DESTROY';
+    }
+  }]);
+  return Drawer;
+}();
+export { Drawer as default };

package/dist/drawer/painter.d.ts

@@ -0,0 +1,41 @@
+import { Cartesian2, Cartesian3, Entity, PointGraphics, Viewer } from 'deeptwins-cesium';
+interface DrawOption {
+    viewer: Viewer;
+    type: any;
+    terrain?: boolean;
+    model?: boolean;
+}
+/**
+ * @desc 画笔工具
+ */
+export default class Painter {
+    _viewer: any;
+    _type: any;
+    _terrain: boolean | undefined;
+    _model?: boolean;
+    _activeShapePoints: Cartesian3[];
+    _dynamicShapeEntity: Entity | undefined;
+    _breakPointEntities: Entity[];
+    _addedEntitys: Entity[];
+    constructor(options: DrawOption);
+    /**
+     * 将entity添加到视图
+     * @param {Entity | Entity.ConstructorOptions} entity entity实体或者构造参数
+     * @returns {Entity} entity
+     */
+    addView(entity: Entity | Entity.ConstructorOptions): Entity;
+    /**
+     * 移除entity
+     * @param {Entity} entity entity实体
+     * @returns {boolean} 是否移除成功
+     */
+    removeEntity(entity: Entity): boolean;
+    createPoint(worldPosition: Cartesian3, options?: PointGraphics.ConstructorOptions): Entity;
+    pickCartesian3(position: Cartesian2): Cartesian3 | undefined;
+    /**
+     * 重置绘画结果，清空间断点和动态图形
+     */
+    reset(): void;
+    clear(): void;
+}
+export {};

package/dist/drawer/painter.js

@@ -0,0 +1,115 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Entity } from 'deeptwins-cesium';
+import { defaultOptions } from "./index";
+/**
+ * @desc 画笔工具
+ */
+var Painter = /*#__PURE__*/function () {
+  function Painter(options) {
+    _classCallCheck(this, Painter);
+    _defineProperty(this, "_viewer", void 0);
+    _defineProperty(this, "_type", void 0);
+    _defineProperty(this, "_terrain", void 0);
+    _defineProperty(this, "_model", void 0);
+    _defineProperty(this, "_activeShapePoints", []);
+    _defineProperty(this, "_dynamicShapeEntity", void 0);
+    _defineProperty(this, "_breakPointEntities", []);
+    _defineProperty(this, "_addedEntitys", []);
+    this._viewer = options.viewer;
+    this._type = options.type;
+    this._terrain = options.terrain;
+    this._model = options.model;
+  }
+
+  /**
+   * 将entity添加到视图
+   * @param {Entity | Entity.ConstructorOptions} entity entity实体或者构造参数
+   * @returns {Entity} entity
+   */
+  _createClass(Painter, [{
+    key: "addView",
+    value: function addView(entity) {
+      var newEntity = this._viewer.entities.add(entity);
+      this._viewer.scene.requestRender();
+      this._addedEntitys.push(newEntity);
+      return newEntity;
+    }
+
+    /**
+     * 移除entity
+     * @param {Entity} entity entity实体
+     * @returns {boolean} 是否移除成功
+     */
+  }, {
+    key: "removeEntity",
+    value: function removeEntity(entity) {
+      this._addedEntitys = this._addedEntitys.filter(function (item) {
+        return item !== entity;
+      });
+      var bool = this._viewer.entities.remove(entity);
+      this._viewer.scene.requestRender();
+      return bool;
+    }
+  }, {
+    key: "createPoint",
+    value: function createPoint(worldPosition, options) {
+      var _defaultOptions$dynam;
+      return new Entity({
+        position: worldPosition,
+        point: _objectSpread(_objectSpread({}, (_defaultOptions$dynam = defaultOptions.dynamicGraphicsOptions) === null || _defaultOptions$dynam === void 0 ? void 0 : _defaultOptions$dynam.point), options)
+      });
+    }
+  }, {
+    key: "pickCartesian3",
+    value: function pickCartesian3(position) {
+      // We use `viewer.scene.pickPosition` here instead of `viewer.camera.pickEllipsoid` so that
+      // we get the correct point when mousing over terrain.
+      if (this._model) {
+        return this._viewer.scene.pickPosition(position);
+      }
+      if (this._terrain) {
+        var ray = this._viewer.camera.getPickRay(position);
+        if (ray) return this._viewer.scene.globe.pick(ray, this._viewer.scene);
+      } else {
+        return this._viewer.camera.pickEllipsoid(position);
+      }
+      return undefined;
+    }
+
+    /**
+     * 重置绘画结果，清空间断点和动态图形
+     */
+  }, {
+    key: "reset",
+    value: function reset() {
+      if (this._dynamicShapeEntity) {
+        this._viewer.entities.remove(this._dynamicShapeEntity);
+        this._dynamicShapeEntity = undefined;
+      }
+      while (this._breakPointEntities.length) {
+        var entity = this._breakPointEntities.pop();
+        if (entity) this._viewer.entities.remove(entity);
+      }
+      this._activeShapePoints = [];
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.reset();
+      while (this._addedEntitys.length) {
+        var entity = this._addedEntitys.pop();
+        if (entity) this._viewer.entities.remove(entity);
+      }
+    }
+  }]);
+  return Painter;
+}();
+export { Painter as default };

package/dist/drawer/shape/Ellipse.d.ts

@@ -0,0 +1,10 @@
+import { CallbackProperty, Entity } from 'deeptwins-cesium';
+import BasicGraphics from '../base';
+import { Cartesian3 } from 'deeptwins-cesium';
+import type { LifeCycle } from '../base';
+export default class Ellipse extends BasicGraphics implements LifeCycle {
+    dropPoint(move: any): void;
+    playOff(): Entity;
+    cancel(): void;
+    createShape(hierarchy: Cartesian3[] | CallbackProperty, isDynamic?: boolean): Entity;
+}

package/dist/drawer/shape/Ellipse.js

@@ -0,0 +1,62 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import { CallbackProperty, ClassificationType, Entity, JulianDate } from 'deeptwins-cesium';
+import BasicGraphics from "../base";
+import { Cartesian3 } from 'deeptwins-cesium';
+var Ellipse = /*#__PURE__*/function (_BasicGraphics) {
+  _inherits(Ellipse, _BasicGraphics);
+  var _super = _createSuper(Ellipse);
+  function Ellipse() {
+    _classCallCheck(this, Ellipse);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Ellipse, [{
+    key: "dropPoint",
+    value: function dropPoint(move) {
+      this._dropPoint(move, this.createShape.bind(this));
+    }
+  }, {
+    key: "playOff",
+    value: function playOff() {
+      return this._playOff(this.createShape.bind(this));
+    }
+  }, {
+    key: "cancel",
+    value: function cancel() {
+      this._cancel(this.createShape.bind(this));
+    }
+  }, {
+    key: "createShape",
+    value: function createShape(hierarchy) {
+      var isDynamic = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var target = Array.isArray(hierarchy) ? hierarchy : hierarchy.getValue(JulianDate.now());
+      var radiusFuc = new CallbackProperty(function () {
+        var distance = Cartesian3.distance(target[0], target[target.length - 1]);
+        return distance || 1;
+      }, false);
+      var ellipse = Object.assign({}, isDynamic && !this.sameStyle ? this.dynamicOptions : this.finalOptions, {
+        semiMinorAxis: radiusFuc,
+        semiMajorAxis: radiusFuc,
+        classificationType: this.painter._model ? ClassificationType.CESIUM_3D_TILE : undefined
+      });
+      var position = this.painter._activeShapePoints[0];
+      return new Entity({
+        position: position,
+        ellipse: ellipse
+      });
+    }
+  }]);
+  return Ellipse;
+}(BasicGraphics);
+export { Ellipse as default };

package/dist/drawer/shape/Point.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from 'deeptwins-cesium';
+import BasicGraphics from '../base';
+import type { Cartesian3 } from 'deeptwins-cesium';
+import type { EventArgs } from '../../tool/cesiumExtends/Subscriber';
+import type { LifeCycle } from '../base';
+export default class Point extends BasicGraphics implements LifeCycle {
+    dropPoint(event: EventArgs): void;
+    moving(): void;
+    playOff(): Entity;
+    cancel(): void;
+    createDynamicShape(position: Cartesian3): Entity;
+}

package/dist/drawer/shape/Point.js

@@ -0,0 +1,59 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import { defined, Entity } from 'deeptwins-cesium';
+import BasicGraphics from "../base";
+var Point = /*#__PURE__*/function (_BasicGraphics) {
+  _inherits(Point, _BasicGraphics);
+  var _super = _createSuper(Point);
+  function Point() {
+    _classCallCheck(this, Point);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Point, [{
+    key: "dropPoint",
+    value: function dropPoint(event) {
+      if (!event.position) return;
+      var earthPosition = this.painter.pickCartesian3(event.position);
+      if (earthPosition && defined(earthPosition)) this.result = this.createDynamicShape(earthPosition);
+    }
+  }, {
+    key: "moving",
+    value: function moving() {
+      return undefined;
+    }
+  }, {
+    key: "playOff",
+    value: function playOff() {
+      this.painter.reset();
+      return this.result;
+    }
+  }, {
+    key: "cancel",
+    value: function cancel() {
+      this.painter.reset();
+      return undefined;
+    }
+  }, {
+    key: "createDynamicShape",
+    value: function createDynamicShape(position) {
+      var point = Object.assign({}, this.finalOptions);
+      return new Entity({
+        position: position,
+        point: point
+      });
+    }
+  }]);
+  return Point;
+}(BasicGraphics);
+export { Point as default };

package/dist/drawer/shape/Polygon.d.ts

@@ -0,0 +1,10 @@
+import { CallbackProperty, Entity } from 'deeptwins-cesium';
+import BasicGraphics from '../base';
+import type { Cartesian3 } from 'deeptwins-cesium';
+import type { LifeCycle } from '../base';
+export default class Polygon extends BasicGraphics implements LifeCycle {
+    dropPoint(event: any): void;
+    playOff(): Entity;
+    cancel(): void;
+    createShape(hierarchy: Cartesian3[] | CallbackProperty, isDynamic?: boolean): Entity;
+}