deeptwins-engine-3d 0.1.69 → 0.1.71

package/dist/esm/visualization/DynamicWater.d.ts

@@ -0,0 +1,39 @@
+/// <reference path="../typings.d.ts" />
+import * as Cesium from 'deeptwins-cesium';
+import { MapContext } from '../map/Map';
+type DynamicWaterPosition = [number, number] | [number, number, number] | {
+    lng: number;
+    lat: number;
+    alt?: number;
+};
+interface DynamicWaterOptions {
+    positions?: DynamicWaterPosition[];
+    style?: any;
+}
+export default class DynamicWater {
+    _mapContext: MapContext | undefined;
+    id: string;
+    positions: DynamicWaterPosition[];
+    style: any;
+    primitive: Cesium.Primitive | null;
+    material: Cesium.Material | null;
+    isDestroyed: boolean;
+    private _cartesianPositions;
+    private _isAdded;
+    constructor(options?: DynamicWaterOptions);
+    getMap(): any;
+    addToMap(map: any): this | undefined;
+    remove(): void;
+    show(isShow: boolean): this | undefined;
+    setData(positions?: DynamicWaterPosition[]): this | undefined;
+    setStyle(style?: any): this | undefined;
+    flyTo(options?: any): void;
+    destroy(): void;
+    private _canOperate;
+    private _rebuildPrimitive;
+    private _updateMaterialUniforms;
+    private _getWaterUniforms;
+    private _transformPositions;
+    private _transformPosition;
+}
+export {};

package/dist/esm/visualization/DynamicWater.js

@@ -0,0 +1,289 @@
+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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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 * as Cesium from 'deeptwins-cesium';
+import { cloneDeep, merge } from 'lodash';
+import { v4 as uuidv4 } from 'uuid';
+import { DEFAULT_DYNAMIC_WATER_STYLE } from "../constant";
+import * as utils from "../tool/utils";
+var REBUILD_STYLE_KEYS = ['height', 'stRotation'];
+
+// 动态反射水面
+var DynamicWater = /*#__PURE__*/function () {
+  function DynamicWater() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, DynamicWater);
+    _defineProperty(this, "_mapContext", void 0);
+    _defineProperty(this, "id", void 0);
+    _defineProperty(this, "positions", []);
+    _defineProperty(this, "style", void 0);
+    _defineProperty(this, "primitive", null);
+    _defineProperty(this, "material", null);
+    _defineProperty(this, "isDestroyed", false);
+    _defineProperty(this, "_cartesianPositions", []);
+    _defineProperty(this, "_isAdded", false);
+    var _options$positions = options.positions,
+      positions = _options$positions === void 0 ? [] : _options$positions,
+      _options$style = options.style,
+      style = _options$style === void 0 ? {} : _options$style;
+    this.id = uuidv4();
+    this.positions = positions;
+    this.style = merge(DEFAULT_DYNAMIC_WATER_STYLE(), cloneDeep(style || {}));
+    this._cartesianPositions = this._transformPositions(this.positions);
+  }
+  _createClass(DynamicWater, [{
+    key: "getMap",
+    value: function getMap() {
+      var _this$_mapContext;
+      return (_this$_mapContext = this._mapContext) === null || _this$_mapContext === void 0 ? void 0 : _this$_mapContext.getMap();
+    }
+
+    // 添加到地图
+  }, {
+    key: "addToMap",
+    value: function addToMap(map) {
+      if (!this._canOperate()) {
+        return;
+      }
+      if (this._isAdded && this.getMap() === map) {
+        return this;
+      }
+      if (this._isAdded) {
+        this.remove();
+      }
+      this._mapContext = map._mapContext;
+      this._rebuildPrimitive();
+      return this;
+    }
+
+    // 移除水面
+  }, {
+    key: "remove",
+    value: function remove() {
+      if (this.isDestroyed || !this._isAdded) {
+        return;
+      }
+      var map = this.getMap();
+      if (map && this.primitive) {
+        map.scene.primitives.remove(this.primitive);
+      }
+      this.primitive = null;
+      this.material = null;
+      this._isAdded = false;
+    }
+
+    // 显示隐藏
+  }, {
+    key: "show",
+    value: function show(isShow) {
+      if (!this._canOperate()) {
+        return;
+      }
+      this.style.show = isShow;
+      if (this.primitive) {
+        this.primitive.show = isShow;
+      }
+      return this;
+    }
+
+    // 更新水面范围
+  }, {
+    key: "setData",
+    value: function setData() {
+      var positions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      if (!this._canOperate()) {
+        return;
+      }
+      this.positions = positions;
+      this._cartesianPositions = this._transformPositions(positions);
+      if (this._isAdded) {
+        this._rebuildPrimitive();
+      }
+      return this;
+    }
+
+    // 更新水面样式
+  }, {
+    key: "setStyle",
+    value: function setStyle() {
+      var style = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      if (!this._canOperate()) {
+        return;
+      }
+      var needRebuild = REBUILD_STYLE_KEYS.some(function (key) {
+        return Object.prototype.hasOwnProperty.call(style, key);
+      });
+      this.style = merge(this.style, cloneDeep(style || {}));
+      if (!this._isAdded) {
+        return this;
+      }
+      if (needRebuild) {
+        this._rebuildPrimitive();
+      } else {
+        this._updateMaterialUniforms();
+        this.show(this.style.show);
+      }
+      return this;
+    }
+
+    // 飞行至水面位置
+  }, {
+    key: "flyTo",
+    value: function flyTo() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      if (!this._canOperate() || !this.getMap()) {
+        return;
+      }
+      if (this._cartesianPositions.length < 3) {
+        return;
+      }
+      utils.cameraFlyToPositions(this.getMap().camera, this._cartesianPositions, _objectSpread({
+        scale: 1.4
+      }, options));
+    }
+
+    // 销毁
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (this.isDestroyed) {
+        return;
+      }
+      this.remove();
+      this.positions = [];
+      this._cartesianPositions = [];
+      this._mapContext = undefined;
+      this.isDestroyed = true;
+    }
+
+    // 是否能进行操作
+  }, {
+    key: "_canOperate",
+    value: function _canOperate() {
+      if (this.isDestroyed) {
+        utils.error('DynamicWater实例已销毁');
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "_rebuildPrimitive",
+    value: function _rebuildPrimitive() {
+      var map = this.getMap();
+      if (!map) {
+        return;
+      }
+      if (this.primitive) {
+        map.scene.primitives.remove(this.primitive);
+        this.primitive = null;
+        this.material = null;
+      }
+      if (this._cartesianPositions.length < 3) {
+        utils.error('DynamicWater至少需要3个有效点');
+        this._isAdded = false;
+        return;
+      }
+      var geometry = new Cesium.PolygonGeometry({
+        polygonHierarchy: new Cesium.PolygonHierarchy(this._cartesianPositions),
+        vertexFormat: Cesium.MaterialAppearance.MaterialSupport.ALL.vertexFormat,
+        height: this.style.height,
+        stRotation: utils.toRadians(this.style.stRotation || 0),
+        perPositionHeight: false
+      });
+      var material = Cesium.Material.fromType(Cesium.Material.WaterType, this._getWaterUniforms());
+      var primitive = map.scene.primitives.add(new Cesium.Primitive({
+        geometryInstances: new Cesium.GeometryInstance({
+          id: this.id,
+          geometry: geometry
+        }),
+        appearance: new Cesium.MaterialAppearance({
+          material: material,
+          faceForward: true,
+          translucent: true,
+          materialSupport: Cesium.MaterialAppearance.MaterialSupport.ALL
+        }),
+        asynchronous: false
+      }));
+      primitive.show = this.style.show;
+      this.material = material;
+      this.primitive = primitive;
+      this._isAdded = true;
+    }
+  }, {
+    key: "_updateMaterialUniforms",
+    value: function _updateMaterialUniforms() {
+      var material = this.material;
+      if (!material) {
+        return;
+      }
+      var uniforms = this._getWaterUniforms();
+      Object.keys(uniforms).forEach(function (key) {
+        material.uniforms[key] = uniforms[key];
+      });
+    }
+  }, {
+    key: "_getWaterUniforms",
+    value: function _getWaterUniforms() {
+      var _this$style = this.style,
+        baseWaterColor = _this$style.baseWaterColor,
+        blendColor = _this$style.blendColor,
+        specularMap = _this$style.specularMap,
+        normalMap = _this$style.normalMap,
+        frequency = _this$style.frequency,
+        animationSpeed = _this$style.animationSpeed,
+        amplitude = _this$style.amplitude,
+        specularIntensity = _this$style.specularIntensity,
+        fadeFactor = _this$style.fadeFactor;
+      return {
+        baseWaterColor: utils.colorString(baseWaterColor),
+        blendColor: utils.colorString(blendColor),
+        specularMap: specularMap,
+        normalMap: normalMap,
+        frequency: frequency,
+        animationSpeed: animationSpeed,
+        amplitude: amplitude,
+        specularIntensity: specularIntensity,
+        fadeFactor: fadeFactor
+      };
+    }
+  }, {
+    key: "_transformPositions",
+    value: function _transformPositions() {
+      var _this = this;
+      var positions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      return positions.map(function (position) {
+        return _this._transformPosition(position);
+      }).filter(Boolean);
+    }
+  }, {
+    key: "_transformPosition",
+    value: function _transformPosition(position) {
+      if (Array.isArray(position)) {
+        var _position = _slicedToArray(position, 3),
+          lng = _position[0],
+          lat = _position[1],
+          _position$ = _position[2],
+          alt = _position$ === void 0 ? 0 : _position$;
+        return utils.lngLatAltToCartesian3(lng, lat, alt);
+      }
+      if (position && _typeof(position) === 'object') {
+        return utils.lngLatAltToCartesian3(position.lng, position.lat, position.alt || 0);
+      }
+      return null;
+    }
+  }]);
+  return DynamicWater;
+}();
+export { DynamicWater as default };

package/dist/esm/visualization/MigrationEffect.d.ts

@@ -0,0 +1,36 @@
+/// <reference path="../typings.d.ts" />
+import * as Cesium from 'deeptwins-cesium';
+import { MapContext } from '../map/Map';
+export default class MigrationEffect {
+    _mapContext: MapContext | undefined;
+    id: string;
+    routes: any;
+    style: any;
+    lineLayer: any;
+    endpointEntities: Cesium.Entity[];
+    isDestroyed: boolean;
+    private _routeSamples;
+    private _isAdded;
+    constructor(routes?: any, style?: any);
+    getMap(): any;
+    addToMap(map: any): this | undefined;
+    remove(): this | undefined;
+    show(isShow: boolean): this | undefined;
+    setData(routes?: any): this | undefined;
+    setStyle(style?: any): this | undefined;
+    flyTo(options?: any): void;
+    destroy(): void;
+    private _canOperate;
+    private _rebuild;
+    private _clearLayers;
+    private _createLineLayer;
+    private _createEndpoints;
+    private _createEndpoint;
+    private _getEndpointPosition;
+    private _buildLineGeoJson;
+    private _buildRouteSamples;
+    private _sampleRoute;
+    private _normalizeCoordinate;
+    private _createNormalizedPosition;
+    private _isSamePosition;
+}