deeptwins-engine-3d 0.1.69 → 0.1.71

package/dist/esm/index.js

@@ -7,8 +7,10 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 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); }
 //引入cesium基础库
 import * as Cesium from 'deeptwins-cesium';
+import LineOfSightAnalysis from "./analyze/LineOfSightAnalysis";
 import SubmergenceAnalysis from "./analyze/SubmergenceAnalysis";
 import SunLightAnalysis from "./analyze/SunLightAnalysis";
+import TerrainExcavationAnalysis from "./analyze/TerrainExcavationAnalysis";
 import ViewshedAnalysis from "./analyze/ViewshedAnalysis";
 import ModelRoamHistory from "./cameraControl/ModelRoamHistory";
 import ModelRoamRealTime from "./cameraControl/ModelRoamRealTime";
@@ -40,8 +42,10 @@ import PolylineTrailLinkMaterialProperty from "./material/entity/PolylineTrailLi
 import ImageGlowingMaterialAppearance from "./material/primitive/ImageGlowingMaterialAppearance";
 import ImageMaterialAppearance from "./material/primitive/ImageMaterialAppearance";
 import Measure from "./measure";
+import { BaseParticle, FireParticle, FountainParticle, SmokeParticle } from "./particle";
 import PositionProperty from "./property/PositionProperty";
 import ArcGisLayer from "./tileLayer/ArcGisLayer";
+import CustomRasterLayer from "./tileLayer/CustomRasterLayer";
 import MvtVectorLoad from "./tileLayer/MvtVectorLoad";
 import RasterLayer from "./tileLayer/RasterLayer";
 import WmsLayer from "./tileLayer/WmsLayer";
@@ -54,10 +58,13 @@ import { loadCss } from "./tool/utils";
 import ToolTip from "./toolTip";
 import VideoProject from "./videoFusion/VideoProject";
 import VideoTexture from "./videoFusion/VideoTexture";
+import DynamicWater from "./visualization/DynamicWater";
 import Frustum from "./visualization/Frustum";
 import Heatmap2d from "./visualization/Heatmap2d";
 import Heatmap3d from "./visualization/Heatmap3d";
+import MigrationEffect from "./visualization/MigrationEffect";
 import PointCluster from "./visualization/PointCluster";
+import RadarScan from "./visualization/RadarScan";
 // drawCommand
 import { ViewShedAnalyserLayer, VolumeClouds } from "./drawCommand";
 window.Cesium = Cesium;
@@ -66,14 +73,15 @@ DEEP_TWINS_BASE_URL && (window.CESIUM_BASE_URL = DEEP_TWINS_BASE_URL);
 // 全局加载css
 loadCss(Cesium.buildModuleUrl('Widgets/widgets.css'));
 // 打印版本信息
-console.log('DeepTwinsEngine3D Version:', "0.1.69");
+console.log('DeepTwinsEngine3D Version:', "0.1.71");
 export var DeepTwinsEngine3D = /*#__PURE__*/_createClass(function DeepTwinsEngine3D() {
   _classCallCheck(this, DeepTwinsEngine3D);
 });
-_defineProperty(DeepTwinsEngine3D, "Version", "0.1.69");
+_defineProperty(DeepTwinsEngine3D, "Version", "0.1.71");
 _defineProperty(DeepTwinsEngine3D, "Map", Map);
 _defineProperty(DeepTwinsEngine3D, "GroundSkyBox", GroundSkyBox);
 _defineProperty(DeepTwinsEngine3D, "RasterLayer", RasterLayer);
+_defineProperty(DeepTwinsEngine3D, "CustomRasterLayer", CustomRasterLayer);
 _defineProperty(DeepTwinsEngine3D, "WmsLayer", WmsLayer);
 _defineProperty(DeepTwinsEngine3D, "WmtsLayer", WmtsLayer);
 _defineProperty(DeepTwinsEngine3D, "ArcGisLayer", ArcGisLayer);
@@ -81,6 +89,10 @@ _defineProperty(DeepTwinsEngine3D, "BarrierLayer", BarrierLayer);
 _defineProperty(DeepTwinsEngine3D, "FactorLayer", FactorLayer);
 _defineProperty(DeepTwinsEngine3D, "DeepTwins", DeepTwins);
 _defineProperty(DeepTwinsEngine3D, "WeatherEffects", WeatherEffects);
+_defineProperty(DeepTwinsEngine3D, "BaseParticle", BaseParticle);
+_defineProperty(DeepTwinsEngine3D, "FireParticle", FireParticle);
+_defineProperty(DeepTwinsEngine3D, "SmokeParticle", SmokeParticle);
+_defineProperty(DeepTwinsEngine3D, "FountainParticle", FountainParticle);
 _defineProperty(DeepTwinsEngine3D, "Drawer", Drawer);
 _defineProperty(DeepTwinsEngine3D, "Measure", Measure);
 _defineProperty(DeepTwinsEngine3D, "Rotate", Rotate);
@@ -100,7 +112,10 @@ _defineProperty(DeepTwinsEngine3D, "ImageGlowingMaterialAppearance", ImageGlowin
 _defineProperty(DeepTwinsEngine3D, "VolumeCloud", VolumeCloud);
 _defineProperty(DeepTwinsEngine3D, "Heatmap2d", Heatmap2d);
 _defineProperty(DeepTwinsEngine3D, "Heatmap3d", Heatmap3d);
+_defineProperty(DeepTwinsEngine3D, "DynamicWater", DynamicWater);
+_defineProperty(DeepTwinsEngine3D, "MigrationEffect", MigrationEffect);
 _defineProperty(DeepTwinsEngine3D, "PointCluster", PointCluster);
+_defineProperty(DeepTwinsEngine3D, "RadarScan", RadarScan);
 _defineProperty(DeepTwinsEngine3D, "PositionProperty", PositionProperty);
 _defineProperty(DeepTwinsEngine3D, "Frustum", Frustum);
 _defineProperty(DeepTwinsEngine3D, "GridDraw", GridDraw);
@@ -131,12 +146,19 @@ _defineProperty(DeepTwinsEngine3D, "NearFarScalar", Cesium.NearFarScalar);
 _defineProperty(DeepTwinsEngine3D, "DistanceDisplayCondition", Cesium.DistanceDisplayCondition);
 _defineProperty(DeepTwinsEngine3D, "BoundingRectangle", Cesium.BoundingRectangle);
 _defineProperty(DeepTwinsEngine3D, "SplitDirection", Cesium.SplitDirection);
+_defineProperty(DeepTwinsEngine3D, "ParticleEmitter", Cesium.ParticleEmitter);
+_defineProperty(DeepTwinsEngine3D, "ParticleBurst", Cesium.ParticleBurst);
+_defineProperty(DeepTwinsEngine3D, "CircleEmitter", Cesium.CircleEmitter);
+_defineProperty(DeepTwinsEngine3D, "ConeEmitter", Cesium.ConeEmitter);
+_defineProperty(DeepTwinsEngine3D, "SphereEmitter", Cesium.SphereEmitter);
 _defineProperty(DeepTwinsEngine3D, "ImageGlowingMaterialProperty", ImageGlowingMaterialProperty);
 _defineProperty(DeepTwinsEngine3D, "SubmergenceAnalysis", SubmergenceAnalysis);
 _defineProperty(DeepTwinsEngine3D, "SunLightAnalysis", SunLightAnalysis);
 _defineProperty(DeepTwinsEngine3D, "KmlDataSource", Cesium.KmlDataSource);
 _defineProperty(DeepTwinsEngine3D, "Compass", Compass);
 _defineProperty(DeepTwinsEngine3D, "ViewshedAnalysis", ViewshedAnalysis);
+_defineProperty(DeepTwinsEngine3D, "LineOfSightAnalysis", LineOfSightAnalysis);
+_defineProperty(DeepTwinsEngine3D, "TerrainExcavationAnalysis", TerrainExcavationAnalysis);
 _defineProperty(DeepTwinsEngine3D, "VisitLayer", VisitLayer);
 _defineProperty(DeepTwinsEngine3D, "PoiLayer", PoiLayer);
 _defineProperty(DeepTwinsEngine3D, "FlightPlanning", FlightPlanning);

package/dist/esm/map/Map.d.ts

@@ -42,6 +42,7 @@ export default class Map extends Cesium.Viewer implements MapContext {
         roll: number;
     };
     setCameraView(cameraView: any, options?: any): void;
+    setCameraViewByBbox(bbox: number[], options?: any): void;
     cancelCameraFly(): void;
     completeCameraFly(): void;
     setDefaultLayer(name: string, index?: number): Cesium.ImageryLayerCollection | undefined;

package/dist/esm/map/Map.js

@@ -428,6 +428,24 @@ var Map = /*#__PURE__*/function (_Cesium$Viewer) {
       }, options));
     }
 
+    // 设置相机到bbox范围
+  }, {
+    key: "setCameraViewByBbox",
+    value: function setCameraViewByBbox(bbox) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!Array.isArray(bbox) || bbox.length < 4) return;
+      var _bbox = _slicedToArray(bbox, 4),
+        west = _bbox[0],
+        south = _bbox[1],
+        east = _bbox[2],
+        north = _bbox[3];
+      var isValidBbox = [west, south, east, north].every(Number.isFinite);
+      if (!isValidBbox) return;
+      this.camera.flyTo(_objectSpread({
+        destination: Cesium.Rectangle.fromDegrees(west, south, east, north)
+      }, options));
+    }
+
     // 取消镜头的飞行和setCameraView等操作
   }, {
     key: "cancelCameraFly",

package/dist/esm/particle/BaseParticle.d.ts

@@ -0,0 +1,61 @@
+/// <reference path="../typings.d.ts" />
+import * as Cesium from 'deeptwins-cesium';
+import { MapContext } from '../map/Map';
+export type ParticlePosition = Cesium.Cartesian3 | [number, number] | [number, number, number];
+export type ParticleColor = string | Cesium.Color;
+export type ParticleImageSize = Cesium.Cartesian2 | [number, number];
+export interface BaseParticleOptions {
+    show?: boolean;
+    position?: ParticlePosition;
+    heading?: number;
+    pitch?: number;
+    roll?: number;
+    updateCallback?: Cesium.ParticleSystem.updateCallback;
+    emitter?: Cesium.ParticleEmitter;
+    emissionRate?: number;
+    bursts?: Cesium.ParticleBurst[];
+    loop?: boolean;
+    scale?: number;
+    startScale?: number;
+    endScale?: number;
+    color?: ParticleColor;
+    startColor?: ParticleColor;
+    endColor?: ParticleColor;
+    image?: any;
+    imageSize?: ParticleImageSize;
+    minimumImageSize?: ParticleImageSize;
+    maximumImageSize?: ParticleImageSize;
+    sizeInMeters?: boolean;
+    speed?: number;
+    minimumSpeed?: number;
+    maximumSpeed?: number;
+    lifetime?: number;
+    particleLife?: number;
+    minimumParticleLife?: number;
+    maximumParticleLife?: number;
+    mass?: number;
+    minimumMass?: number;
+    maximumMass?: number;
+}
+export default class BaseParticle {
+    _mapContext: MapContext | undefined;
+    particleSystem: Cesium.ParticleSystem | null;
+    options: BaseParticleOptions;
+    isDestroyed: boolean;
+    constructor(map: any, options?: BaseParticleOptions);
+    getMap(): any;
+    getPrimitive(): Cesium.ParticleSystem | null;
+    show(isShow: boolean): void;
+    destroy(): void;
+    private _assertMap;
+    private _canOperate;
+    private _createParticleSystem;
+    private _resolveParticleOptions;
+    private _resolveModelMatrix;
+    private _resolveEmitterModelMatrix;
+    private _createCameraViewEmitterModelMatrix;
+    private _hasEmitterOrientation;
+    private _resolvePosition;
+    private _resolveColor;
+    private _resolveImageSize;
+}

package/dist/esm/particle/BaseParticle.js

@@ -0,0 +1,196 @@
+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 * as utils from "../tool/utils";
+import { getInternalParticleOptions, omitExternalMatrixOptions } from "./common";
+var CAMERA_HEADING_OFFSET_DEGREES = 90;
+var EMITTER_FORWARD_AXIS_CORRECTION = Cesium.Matrix3.fromRotationY(Cesium.Math.PI_OVER_TWO);
+var BaseParticle = /*#__PURE__*/function () {
+  function BaseParticle(map) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, BaseParticle);
+    _defineProperty(this, "_mapContext", void 0);
+    _defineProperty(this, "particleSystem", null);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "isDestroyed", false);
+    this._assertMap(map);
+    this._mapContext = map._mapContext || {
+      getMap: function getMap() {
+        return map;
+      }
+    };
+    var internalOptions = getInternalParticleOptions(options);
+    var safeOptions = omitExternalMatrixOptions(options);
+    this.options = safeOptions;
+    this.particleSystem = this._createParticleSystem(safeOptions, internalOptions);
+    this.getMap().scene.primitives.add(this.particleSystem);
+  }
+  _createClass(BaseParticle, [{
+    key: "getMap",
+    value: function getMap() {
+      return this._mapContext && this._mapContext.getMap();
+    }
+  }, {
+    key: "getPrimitive",
+    value: function getPrimitive() {
+      return this.particleSystem;
+    }
+  }, {
+    key: "show",
+    value: function show(isShow) {
+      if (!this._canOperate()) {
+        return;
+      }
+      this.particleSystem && (this.particleSystem.show = isShow);
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      var _map$scene;
+      if (this.isDestroyed) {
+        return;
+      }
+      this.isDestroyed = true;
+      var primitive = this.particleSystem;
+      var map = this.getMap();
+      if (primitive && map !== null && map !== void 0 && (_map$scene = map.scene) !== null && _map$scene !== void 0 && (_map$scene = _map$scene.primitives) !== null && _map$scene !== void 0 && _map$scene.contains(primitive)) {
+        map.scene.primitives.remove(primitive);
+      } else if (primitive && !primitive.isDestroyed()) {
+        primitive.destroy();
+      }
+      this.particleSystem = null;
+      this._mapContext = undefined;
+    }
+  }, {
+    key: "_assertMap",
+    value: function _assertMap(map) {
+      var _map$scene2;
+      if (!(map !== null && map !== void 0 && (_map$scene2 = map.scene) !== null && _map$scene2 !== void 0 && _map$scene2.primitives)) {
+        throw new Error('BaseParticle需要传入有效的Cesium Viewer实例');
+      }
+    }
+  }, {
+    key: "_canOperate",
+    value: function _canOperate() {
+      if (this.isDestroyed) {
+        utils.error('BaseParticle实例已销毁');
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "_createParticleSystem",
+    value: function _createParticleSystem(options, internalOptions) {
+      return new Cesium.ParticleSystem(this._resolveParticleOptions(options, internalOptions));
+    }
+  }, {
+    key: "_resolveParticleOptions",
+    value: function _resolveParticleOptions(options, internalOptions) {
+      var particleInputOptions = _objectSpread({}, options);
+      delete particleInputOptions.heading;
+      delete particleInputOptions.pitch;
+      delete particleInputOptions.roll;
+      var particleOptions = _objectSpread(_objectSpread({}, particleInputOptions), {}, {
+        modelMatrix: this._resolveModelMatrix(options, internalOptions),
+        color: this._resolveColor(particleInputOptions.color),
+        startColor: this._resolveColor(particleInputOptions.startColor),
+        endColor: this._resolveColor(particleInputOptions.endColor),
+        imageSize: this._resolveImageSize(particleInputOptions.imageSize),
+        minimumImageSize: this._resolveImageSize(particleInputOptions.minimumImageSize),
+        maximumImageSize: this._resolveImageSize(particleInputOptions.maximumImageSize)
+      });
+      var emitterModelMatrix = this._resolveEmitterModelMatrix(options, internalOptions);
+      if (emitterModelMatrix) {
+        return _objectSpread(_objectSpread({}, particleOptions), {}, {
+          emitterModelMatrix: emitterModelMatrix
+        });
+      }
+      return particleOptions;
+    }
+  }, {
+    key: "_resolveModelMatrix",
+    value: function _resolveModelMatrix(options, internalOptions) {
+      if (internalOptions !== null && internalOptions !== void 0 && internalOptions.modelMatrix) {
+        return Cesium.Matrix4.clone(internalOptions.modelMatrix);
+      }
+      if (options.position) {
+        return Cesium.Transforms.eastNorthUpToFixedFrame(this._resolvePosition(options.position));
+      }
+      return Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY);
+    }
+  }, {
+    key: "_resolveEmitterModelMatrix",
+    value: function _resolveEmitterModelMatrix(options, internalOptions) {
+      if (internalOptions !== null && internalOptions !== void 0 && internalOptions.emitterModelMatrix) {
+        return Cesium.Matrix4.clone(internalOptions.emitterModelMatrix);
+      }
+      if (!this._hasEmitterOrientation(options)) {
+        return undefined;
+      }
+      return this._createCameraViewEmitterModelMatrix(options);
+    }
+  }, {
+    key: "_createCameraViewEmitterModelMatrix",
+    value: function _createCameraViewEmitterModelMatrix(options) {
+      var headingPitchRoll = Cesium.HeadingPitchRoll.fromDegrees((options.heading || 0) - CAMERA_HEADING_OFFSET_DEGREES, options.pitch || 0, options.roll || 0);
+      var cameraViewRotation = Cesium.Matrix3.fromHeadingPitchRoll(headingPitchRoll);
+      var emitterRotation = Cesium.Matrix3.multiply(cameraViewRotation, EMITTER_FORWARD_AXIS_CORRECTION, new Cesium.Matrix3());
+      return Cesium.Matrix4.fromRotationTranslation(emitterRotation, Cesium.Cartesian3.ZERO);
+    }
+  }, {
+    key: "_hasEmitterOrientation",
+    value: function _hasEmitterOrientation(options) {
+      return options.heading !== undefined || options.pitch !== undefined || options.roll !== undefined;
+    }
+  }, {
+    key: "_resolvePosition",
+    value: function _resolvePosition(position) {
+      if (position instanceof Cesium.Cartesian3) {
+        return Cesium.Cartesian3.clone(position);
+      }
+      var _position = _slicedToArray(position, 3),
+        lng = _position[0],
+        lat = _position[1],
+        _position$ = _position[2],
+        alt = _position$ === void 0 ? 0 : _position$;
+      return Cesium.Cartesian3.fromDegrees(lng, lat, alt);
+    }
+  }, {
+    key: "_resolveColor",
+    value: function _resolveColor(color) {
+      if (!color) {
+        return color;
+      }
+      return utils.colorString(color);
+    }
+  }, {
+    key: "_resolveImageSize",
+    value: function _resolveImageSize(imageSize) {
+      if (!imageSize) {
+        return imageSize;
+      }
+      if (imageSize instanceof Cesium.Cartesian2) {
+        return Cesium.Cartesian2.clone(imageSize);
+      }
+      var _imageSize = _slicedToArray(imageSize, 2),
+        width = _imageSize[0],
+        height = _imageSize[1];
+      return new Cesium.Cartesian2(width, height);
+    }
+  }]);
+  return BaseParticle;
+}();
+export { BaseParticle as default };

package/dist/esm/particle/FireParticle.d.ts

@@ -0,0 +1,8 @@
+import BaseParticle, { BaseParticleOptions } from './BaseParticle';
+export type FireParticleOptions = BaseParticleOptions & {
+    emitterRadius?: number;
+};
+export default class FireParticle extends BaseParticle {
+    constructor(map: any, options?: FireParticleOptions);
+    private static _resolveOptions;
+}

package/dist/esm/particle/FireParticle.js

@@ -0,0 +1,65 @@
+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); }
+var _excluded = ["emitter", "emitterRadius"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+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 _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 _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 * as Cesium from 'deeptwins-cesium';
+import { colorString, getDeepTwinsFile } from "../tool/utils";
+import BaseParticle from "./BaseParticle";
+var DEFAULT_FIRE_PARTICLE_OPTIONS = {
+  image: getDeepTwinsFile('Image/fire.png'),
+  emissionRate: 80,
+  loop: true,
+  startColor: colorString('#FFD95CE6'),
+  endColor: colorString('#E51A0000'),
+  startScale: 1.0,
+  endScale: 3.5,
+  minimumImageSize: new Cesium.Cartesian2(1.0, 1.0),
+  maximumImageSize: new Cesium.Cartesian2(2.8, 2.8),
+  sizeInMeters: true,
+  minimumSpeed: 1.0,
+  maximumSpeed: 4.0,
+  minimumParticleLife: 0.8,
+  maximumParticleLife: 1.8,
+  minimumMass: 0.8,
+  maximumMass: 1.2,
+  emitterRadius: 1.5
+};
+var FireParticle = /*#__PURE__*/function (_BaseParticle) {
+  _inherits(FireParticle, _BaseParticle);
+  var _super = _createSuper(FireParticle);
+  function FireParticle(map) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, FireParticle);
+    var particleOptions = FireParticle._resolveOptions(options);
+    return _super.call(this, map, particleOptions);
+  }
+  _createClass(FireParticle, null, [{
+    key: "_resolveOptions",
+    value: function _resolveOptions(options) {
+      var nextOptions = _objectSpread(_objectSpread({}, DEFAULT_FIRE_PARTICLE_OPTIONS), options);
+      var emitter = nextOptions.emitter,
+        emitterRadius = nextOptions.emitterRadius,
+        particleOptions = _objectWithoutProperties(nextOptions, _excluded);
+      return _objectSpread(_objectSpread({}, particleOptions), {}, {
+        emitter: emitter || new Cesium.CircleEmitter(emitterRadius)
+      });
+    }
+  }]);
+  return FireParticle;
+}(BaseParticle);
+export { FireParticle as default };

package/dist/esm/particle/FountainParticle.d.ts

@@ -0,0 +1,10 @@
+import BaseParticle, { BaseParticleOptions } from './BaseParticle';
+export type FountainParticleOptions = BaseParticleOptions & {
+    emitterAngle?: number;
+    gravity?: number;
+};
+export default class FountainParticle extends BaseParticle {
+    constructor(map: any, options?: FountainParticleOptions);
+    private static _resolveOptions;
+    private static _createGravityCallback;
+}

package/dist/esm/particle/FountainParticle.js

@@ -0,0 +1,80 @@
+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); }
+var _excluded = ["emitter", "emitterAngle", "gravity", "updateCallback"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+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 _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 _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 * as Cesium from 'deeptwins-cesium';
+import { colorString, getDeepTwinsFile } from "../tool/utils";
+import BaseParticle from "./BaseParticle";
+var DEFAULT_FOUNTAIN_GRAVITY = 9.8;
+var FOUNTAIN_GRAVITY_SCRATCH = new Cesium.Cartesian3();
+var DEFAULT_FOUNTAIN_PARTICLE_OPTIONS = {
+  image: getDeepTwinsFile('Image/fountain.png'),
+  emissionRate: 180,
+  loop: true,
+  startColor: colorString('#BDEBFFFF'),
+  endColor: colorString('#FFFFFF00'),
+  startScale: 0.6,
+  endScale: 1.8,
+  minimumImageSize: new Cesium.Cartesian2(0.3, 0.3),
+  maximumImageSize: new Cesium.Cartesian2(1.1, 1.1),
+  sizeInMeters: true,
+  minimumSpeed: 6.0,
+  maximumSpeed: 12.0,
+  minimumParticleLife: 1.2,
+  maximumParticleLife: 2.4,
+  minimumMass: 0.8,
+  maximumMass: 1.2,
+  emitterAngle: Cesium.Math.toRadians(25),
+  gravity: DEFAULT_FOUNTAIN_GRAVITY
+};
+var FountainParticle = /*#__PURE__*/function (_BaseParticle) {
+  _inherits(FountainParticle, _BaseParticle);
+  var _super = _createSuper(FountainParticle);
+  function FountainParticle(map) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, FountainParticle);
+    var particleOptions = FountainParticle._resolveOptions(options);
+    return _super.call(this, map, particleOptions);
+  }
+  _createClass(FountainParticle, null, [{
+    key: "_resolveOptions",
+    value: function _resolveOptions(options) {
+      var nextOptions = _objectSpread(_objectSpread({}, DEFAULT_FOUNTAIN_PARTICLE_OPTIONS), options);
+      var emitter = nextOptions.emitter,
+        emitterAngle = nextOptions.emitterAngle,
+        gravity = nextOptions.gravity,
+        updateCallback = nextOptions.updateCallback,
+        particleOptions = _objectWithoutProperties(nextOptions, _excluded);
+      return _objectSpread(_objectSpread({}, particleOptions), {}, {
+        emitter: emitter || new Cesium.ConeEmitter(emitterAngle),
+        updateCallback: updateCallback || FountainParticle._createGravityCallback(gravity !== null && gravity !== void 0 ? gravity : DEFAULT_FOUNTAIN_GRAVITY)
+      });
+    }
+  }, {
+    key: "_createGravityCallback",
+    value: function _createGravityCallback(gravity) {
+      return function (particle, dt) {
+        var gravityVector = Cesium.Cartesian3.normalize(particle.position, FOUNTAIN_GRAVITY_SCRATCH);
+        Cesium.Cartesian3.multiplyByScalar(gravityVector, -gravity * dt, gravityVector);
+        particle.velocity = Cesium.Cartesian3.add(particle.velocity, gravityVector, particle.velocity);
+      };
+    }
+  }]);
+  return FountainParticle;
+}(BaseParticle);
+export { FountainParticle as default };

package/dist/esm/particle/SmokeParticle.d.ts

@@ -0,0 +1,8 @@
+import BaseParticle, { BaseParticleOptions } from './BaseParticle';
+export type SmokeParticleOptions = BaseParticleOptions & {
+    emitterRadius?: number;
+};
+export default class SmokeParticle extends BaseParticle {
+    constructor(map: any, options?: SmokeParticleOptions);
+    private static _resolveOptions;
+}

package/dist/esm/particle/SmokeParticle.js

@@ -0,0 +1,65 @@
+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); }
+var _excluded = ["emitter", "emitterRadius"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+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 _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 _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 * as Cesium from 'deeptwins-cesium';
+import { colorString, getDeepTwinsFile } from "../tool/utils";
+import BaseParticle from "./BaseParticle";
+var DEFAULT_SMOKE_PARTICLE_OPTIONS = {
+  image: getDeepTwinsFile('Image/smoke.png'),
+  emissionRate: 45,
+  loop: true,
+  startColor: colorString('#B8B8B8A6'),
+  endColor: colorString('#3F3F3F00'),
+  startScale: 1.2,
+  endScale: 6.0,
+  minimumImageSize: new Cesium.Cartesian2(1.0, 1.0),
+  maximumImageSize: new Cesium.Cartesian2(3.0, 3.0),
+  sizeInMeters: true,
+  minimumSpeed: 0.4,
+  maximumSpeed: 1.6,
+  minimumParticleLife: 2.0,
+  maximumParticleLife: 4.0,
+  minimumMass: 0.8,
+  maximumMass: 1.5,
+  emitterRadius: 2
+};
+var SmokeParticle = /*#__PURE__*/function (_BaseParticle) {
+  _inherits(SmokeParticle, _BaseParticle);
+  var _super = _createSuper(SmokeParticle);
+  function SmokeParticle(map) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, SmokeParticle);
+    var particleOptions = SmokeParticle._resolveOptions(options);
+    return _super.call(this, map, particleOptions);
+  }
+  _createClass(SmokeParticle, null, [{
+    key: "_resolveOptions",
+    value: function _resolveOptions(options) {
+      var nextOptions = _objectSpread(_objectSpread({}, DEFAULT_SMOKE_PARTICLE_OPTIONS), options);
+      var emitter = nextOptions.emitter,
+        emitterRadius = nextOptions.emitterRadius,
+        particleOptions = _objectWithoutProperties(nextOptions, _excluded);
+      return _objectSpread(_objectSpread({}, particleOptions), {}, {
+        emitter: emitter || new Cesium.CircleEmitter(emitterRadius)
+      });
+    }
+  }]);
+  return SmokeParticle;
+}(BaseParticle);
+export { SmokeParticle as default };