deeptwins-engine-3d 0.1.66 → 0.1.67

package/dist/esm/material/WeatherEffects.js

@@ -1,4 +1,12 @@
 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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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 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; }
@@ -6,160 +14,336 @@ function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key i
 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 { merge } from 'lodash';
 import { DEFAULT_FOG, DEFAULT_RAIN, DEFAULT_SNOW } from "../constant";
 import { colorString, toRadians } from "../tool/utils";
 /* babel-plugin-inline-import './shader/FogShader.glsl' */
 var FogShader = "float getDistance(sampler2D depthTexture, vec2 texCoords)\n{\n    float depth = czm_unpackDepth(texture(depthTexture, texCoords));\n    if (depth == 0.0) {\n        return czm_infinity;\n    }\n    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, depth);\n    return -eyeCoordinate.z / eyeCoordinate.w;\n}\n//\u6839\u636E\u8DDD\u79BB\uFF0C\u5728\u4E2D\u95F4\u8FDB\u884C\u63D2\u503C\nfloat interpolateByDistance(vec4 nearFarScalar, float distance)\n{\n    //\u6839\u636E\u5E38\u8BC6\uFF0C\u96FE\u5E94\u8BE5\u662F\u8DDD\u79BB\u8FDC\uFF0C\u8D8A\u770B\u4E0D\u6E05\uFF0C\u8FD1\u8DDD\u79BB\u5185\u7684\u7269\u4F53\u53EF\u4EE5\u770B\u6E05\n    //\u56E0\u6B64\u8FD1\u8DDD\u79BBalpha=0\uFF0C\u8FDC\u8DDD\u79BB\u7684alpha=1.0\n    //\u672C\u4F8B\u4E2D\u8BBE\u7F6E\u53EF\u89C1\u5EA6\u4E3A200\u7C73\n    //\u96FE\u7279\u6548\u7684\u8D77\u59CB\u8DDD\u79BB\n    float startDistance = nearFarScalar.x;\n    //\u96FE\u7279\u6548\u7684\u8D77\u59CBalpha\u503C\n    float startValue = nearFarScalar.y;\n    //\u96FE\u7279\u6548\u7684\u7ED3\u675F\u8DDD\u79BB\n    float endDistance = nearFarScalar.z;\n    //\u96FE\u7279\u6548\u7684\u7ED3\u675Falpha\u503C\n    float endValue = nearFarScalar.w;\n    //\u6839\u636E\u6BCF\u6BB5\u8DDD\u79BB\u5360\u603B\u957F\u5EA6\u7684\u5360\u6BD4\uFF0C\u63D2\u503Calpha\uFF0C\u8DDD\u79BB\u8D8A\u8FDC\uFF0Calpha\u503C\u8D8A\u5927\u3002\u63D2\u503C\u8303\u56F40,1\u3002\n    float t = clamp((distance - startDistance) / (endDistance - startDistance), 0.0, 1.0);\n    return mix(startValue, endValue, t);\n}\nvec4 alphaBlend(vec4 sourceColor, vec4 destinationColor)\n{\n    return sourceColor * vec4(sourceColor.aaa, 1.0) + destinationColor * (1.0 - sourceColor.a);\n}\nuniform sampler2D colorTexture;\nuniform sampler2D depthTexture;\nuniform vec4 fogByDistance;\nuniform vec4 fogColor;\nin vec2 v_textureCoordinates;\nvoid main(void)\n{\n    //\u83B7\u53D6\u5730\u7269\u8DDD\u76F8\u673A\u7684\u8DDD\u79BB\n    float distance = getDistance(depthTexture, v_textureCoordinates);\n    //\u83B7\u53D6\u573A\u666F\u539F\u672C\u7684\u7EB9\u7406\u989C\u8272\n    vec4 sceneColor = texture(colorTexture, v_textureCoordinates);\n    //\u6839\u636E\u8DDD\u79BB\uFF0C\u5BF9alpha\u8FDB\u884C\u63D2\u503C\n    float blendAmount = interpolateByDistance(fogByDistance, distance);\n    //\u5C06alpha\u53D8\u5316\u503C\u4EE3\u5165\u96FE\u7684\u539F\u59CB\u989C\u8272\u4E2D\uFF0C\u5E76\u5C06\u96FE\u4E0E\u573A\u666F\u539F\u59CB\u7EB9\u7406\u8FDB\u884C\u878D\u5408\n    vec4 finalFogColor = vec4(fogColor.rgb, fogColor.a * blendAmount);\n    out_FragColor = alphaBlend(finalFogColor, sceneColor);\n}\n";
 /* babel-plugin-inline-import './shader/RainShader.glsl' */
-var RainShader = "precision highp float;\n\nuniform sampler2D colorTexture;\nuniform float direction;\nuniform float size;\nuniform float speed;\nin vec2 v_textureCoordinates;\nout vec4 fragColor;\n\nfloat hash(float x) {\n    return fract(sin(x * 133.3) * 13.13);\n}\n\nvoid main() {\n    float time = czm_frameNumber / speed;\n    vec2 resolution = czm_viewport.zw;\n    vec2 uv = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);\n    vec3 c = vec3(0.6, 0.7, 0.8);\n    float a = direction;\n    float si = sin(a), co = cos(a);\n    uv *= mat2(co, -si, si, co);\n    uv *= length(uv + vec2(0.0, 4.9)) * size + 1.0;\n    float v = 1.0 - sin(hash(floor(uv.x * 100.0)) * 2.0);\n    float b = clamp(abs(sin(20.0 * time * v + uv.y * (5.0 / (2.0 + v)))) - 0.95, 0.0, 1.0) * 20.0;\n    c *= v * b;\n\n    fragColor = mix(texture(colorTexture, v_textureCoordinates), vec4(c, 1.0), 0.5);\n}\n";
+var RainShader = "precision highp float;\n\nuniform sampler2D colorTexture;\nuniform float direction;\nuniform float size;\nuniform float speed;\nuniform float density;\nuniform float opacity;\nuniform float gloominess;\nuniform vec4 rainColor;\nin vec2 v_textureCoordinates;\nout vec4 fragColor;\n\nfloat hash(float x) {\n    return fract(sin(x * 133.3) * 13.13);\n}\n\nfloat rainLayer(vec2 uv, float time, float densityFactor, float scaleFactor, float seed) {\n    vec2 warpedUv = uv;\n    warpedUv *= scaleFactor;\n\n    float v = 1.0 - sin(hash(floor((warpedUv.x + seed) * 100.0 * densityFactor)) * 2.0);\n    float b = clamp(\n        abs(sin((20.0 + seed * 2.5) * time * v + warpedUv.y * (5.0 / (2.0 + v)))) - 0.95,\n        0.0,\n        1.0\n    ) * (18.0 + densityFactor * 2.0);\n\n    return v * b;\n}\n\nvec3 applyGloominess(vec3 sceneColor) {\n    float gloomFactor = clamp(gloominess, 0.0, 1.0);\n    float luminance = dot(sceneColor, vec3(0.299, 0.587, 0.114));\n    vec3 mutedScene = mix(sceneColor, vec3(luminance), gloomFactor * 0.45);\n    return mutedScene * (1.0 - gloomFactor * 0.55);\n}\n\nvoid main() {\n    float time = czm_frameNumber / speed;\n    vec2 resolution = czm_viewport.zw;\n    vec2 uv = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);\n    float a = direction;\n    float si = sin(a), co = cos(a);\n    uv *= mat2(co, -si, si, co);\n\n    vec2 primaryUv = uv;\n    primaryUv *= length(primaryUv + vec2(0.0, 4.9)) * size + 1.0;\n\n    float densityFactor = mix(0.65, 2.1, clamp(density / 100.0, 0.0, 1.0));\n    float primaryLayer = rainLayer(primaryUv, time, densityFactor, 1.0, 0.0);\n\n    vec2 secondaryUv = primaryUv * 1.35;\n    secondaryUv.x += time * 0.25;\n    secondaryUv.y += hash(floor(primaryUv.x * 8.0) + 17.0) * 0.75;\n    float secondaryLayer = rainLayer(secondaryUv, time * 1.15, densityFactor * 0.85, 1.0, 3.7) * 0.65;\n\n    float rainMask = clamp(primaryLayer + secondaryLayer, 0.0, 1.0);\n\n    vec4 scene = texture(colorTexture, v_textureCoordinates);\n    vec3 baseScene = applyGloominess(scene.rgb);\n    vec3 rainLayerColor = rainColor.rgb * rainMask * opacity;\n    vec3 finalColor = clamp(baseScene + rainLayerColor, 0.0, 1.0);\n\n    fragColor = vec4(finalColor, scene.a);\n}\n";
 /* babel-plugin-inline-import './shader/SnowShader.glsl' */
 var SnowShader = "precision highp float;\n\nuniform sampler2D colorTexture;\nuniform float speed;\nuniform float size;\nin vec2 v_textureCoordinates;\nout vec4 fragColor;\n\nfloat snow(vec2 uv, float sc) {\n    float scale = sc * size;\n    float time = float(czm_frameNumber) / speed;\n    float w = smoothstep(1.0, 0.0, -uv.y * (scale / 10.0));\n    if (w < 0.1) return 0.0;\n    uv += time / scale;\n    uv.y += time * 2.0 / scale;\n    uv.x += sin(uv.y + time * 0.5) / scale;\n    uv *= scale;\n    vec2 s = floor(uv), f = fract(uv), p;\n    float k = 3.0, d;\n    p = 0.5 + 0.35 * sin(11.0 * fract(sin((s + p + scale) * mat2(7, 3, 6, 5)) * 5.0)) - f;\n    d = length(p);\n    k = min(d, k);\n    k = smoothstep(0.0, k, sin(f.x + f.y) * 0.01);\n    return k * w;\n}\n\nvoid main() {\n    vec2 resolution = czm_viewport.zw;\n    vec2 uv = (gl_FragCoord.xy * 2.0 - resolution.xy) / min(resolution.x, resolution.y);\n    vec3 finalColor = vec3(0.0);\n    float c = 0.0;\n    c += snow(uv, 10.);\n    c += snow(uv, 8.);\n    c += snow(uv, 7.);\n    c += snow(uv, 6.);\n    c += snow(uv, 5.);\n    c += snow(uv, 4.);\n    c += snow(uv, 3.);\n    c += snow(uv, 2.);\n    c += snow(uv, 1.);\n    c += snow(uv, .6);\n    finalColor = vec3(c);\n\n    // \u8C03\u6574\u4EAE\u5EA6\n    finalColor = finalColor * 2.2;\n\n    fragColor = mix(texture(colorTexture, v_textureCoordinates), vec4(finalColor, 1.0), 0.2);\n}\n";
+/* babel-plugin-inline-import './shader/lightning.glsl' */
+var LightningShader = "precision highp float;\n\nfloat hash(float x)\n{\n  return fract(21654.6512 * sin(385.51 * x));\n}\nfloat hash(vec2 p)\n{\n  return fract(1654.65157 * sin(15.5134763 * p.x + 45.5173247 * p.y + 5.21789));\n}\nvec2 hash2(vec2 p)\n{\n  return vec2(hash(p * .754), hash(1.5743 * p + 4.5476351));\n}\nconst vec2 hashAdd = vec2(1.0, 0.0);\nvec2 noise2(vec2 x)\n{\n  vec2 p = floor(x);\n  vec2 f = fract(x);\n  f = f * f * (3.0 - 2.0 * f);\n  vec2 res = mix(mix(hash2(p),\n  hash2(p + hashAdd.xy), f.x),\n  mix(hash2(p + hashAdd.yx), hash2(p + hashAdd.xx), f.x), f.y);\n  return res;\n}\nvec2 fbm2(vec2 x)\n{\n  vec2 r = vec2(0.0);\n  float a = 1.0;\n  for (int i = 0; i < 8; i++)\n  {\n    r += noise2(x) * a;\n    x *= 2.;\n    a *= .5;\n  }\n  return r;\n}\nfloat dseg(vec2 ba, vec2 pa)\n{\n  float h = clamp(dot(pa, ba) / dot(ba, ba), -0.2, 1.);\n  return length(pa - ba * h);\n}\nuniform sampler2D colorTexture;\nuniform float fall_interval;\nuniform float mix_factor;\nin vec2 v_textureCoordinates;\nout vec4 fragColor;\nvoid main(void){\n  float iTime = czm_frameNumber * fall_interval * clamp(fall_interval * 0.1, 0.01, 0.1);\n  vec2 p = gl_FragCoord.xy / czm_viewport.zw;\n  vec2 d;\n  vec2 tgt = vec2(1., -1.);\n  vec3 col = vec3(0.);\n  float mdist = 100000.;\n  float t = hash(floor(5. * iTime));\n  tgt += 4. * hash2(tgt + t) - 1.5;\n  if (hash(t + 2.3) > .6)\n  for (int i = 0; i < 100; i++) {\n    vec2 dtgt = tgt - p;\n    d = .05 * (vec2(-.5, -1.) + hash2(vec2(float(i), t)));\n    float dist = dseg(d, dtgt);\n    mdist = min(mdist, dist);\n    tgt -= d;\n    float bolt = exp(-1.2 * dist) + exp(-55. * mdist);\n    col = max(col, bolt * vec3(.7, .8, 1.));\n  }\n  vec4 scene = texture(colorTexture, v_textureCoordinates);\n  vec3 finalColor = clamp(scene.rgb + col * mix_factor, 0.0, 1.0);\n  fragColor = vec4(finalColor, scene.a);\n}\n";
+var WEATHER_EFFECT_TYPES = ['snow', 'rain', 'fog'];
+// 天气效果
 var WeatherEffects = /*#__PURE__*/function () {
   function WeatherEffects(type) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var _this = this;
+    var _options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     _classCallCheck(this, WeatherEffects);
     _defineProperty(this, "_mapContext", void 0);
     _defineProperty(this, "type", void 0);
     _defineProperty(this, "options", void 0);
     _defineProperty(this, "stage", void 0);
-    this.type = type;
-    this.options = options;
-    switch (this.type) {
-      case 'snow':
-        this._snowEffect(options);
-        break;
-      case 'rain':
-        this._rainEffect(options);
-        break;
-      case 'fog':
-        this._fogEffect(options);
-        break;
-    }
+    _defineProperty(this, "isDestroyed", false);
+    _defineProperty(this, "_isAdded", false);
+    // 雨天除了主雨层外，还会挂一个独立的闪电后处理层。
+    _defineProperty(this, "_extraStages", []);
+    _defineProperty(this, "_stageConfigBuilders", {
+      snow: function snow(options) {
+        return _this._buildSnowStageConfig(options);
+      },
+      rain: function rain(options) {
+        return _this._buildRainStageConfig(options);
+      },
+      fog: function fog(options) {
+        return _this._buildFogStageConfig(options);
+      }
+    });
+    this.type = this._assertWeatherEffectType(type);
+    var stageConfig = this._buildStageConfig(this.type, _options);
+    this.options = stageConfig.options;
+    this.stage = this._createStage(stageConfig.mainStage);
+    this._extraStages = this._createExtraStages(stageConfig.extraStages);
   }
   _createClass(WeatherEffects, [{
     key: "getMap",
     value: function getMap() {
-      return this._mapContext && this._mapContext.getMap();
+      var _this$_mapContext;
+      return (_this$_mapContext = this._mapContext) === null || _this$_mapContext === void 0 ? void 0 : _this$_mapContext.getMap();
     }
 
     // 移除
   }, {
     key: "remove",
     value: function remove() {
-      if (!this.getMap()) return;
-      this.getMap().scene.postProcessStages.remove(this.stage);
+      if (this.isDestroyed || !this._isAdded) {
+        return;
+      }
+      this._removeStagesFromMap();
+      this._resetStagesFromCurrentOptions();
     }
 
     // 添加到地图
   }, {
     key: "addToMap",
     value: function addToMap(map) {
-      this._mapContext = map._mapContext;
-      map.scene.postProcessStages.add(this.stage);
+      this._assertNotDestroyed();
+      if (this._isAdded) {
+        var currentMap = this.getMap();
+        if (currentMap === map) {
+          return this;
+        }
+        this.remove();
+      }
+      this._mapContext = map;
+      this._getStages().forEach(function (stage) {
+        map.scene.postProcessStages.add(stage);
+      });
+      this._isAdded = true;
+      return this;
     }
 
     // 修改参数
   }, {
     key: "setEffect",
-    value: function setEffect(options) {
-      this.options = merge(this.options, options);
-      var effects = {};
-      switch (this.type) {
-        case 'snow':
-          effects = this._handleSnowOptions(this.options);
-          break;
-        case 'rain':
-          effects = this._handleRainOptions(this.options);
-          break;
-        case 'fog':
-          effects = this._handleFogOptions(this.options);
-          break;
+    value: function setEffect() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this._assertNotDestroyed();
+      var stageConfig = this._buildStageConfig(this.type, _objectSpread(_objectSpread({}, this.options), options));
+      this.options = stageConfig.options;
+      this._applyStageConfig(stageConfig);
+      return this;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (this.isDestroyed) {
+        return;
       }
-      for (var key in effects) {
-        this.stage.uniforms[key] = effects[key];
+      if (this._isAdded) {
+        this._removeStagesFromMap();
+      } else if (!this.stage.isDestroyed()) {
+        this._destroyStages();
       }
+      this._extraStages = [];
+      this.isDestroyed = true;
     }
   }, {
-    key: "_handleSnowOptions",
-    value: function _handleSnowOptions(options) {
-      var _merge = merge(DEFAULT_SNOW(), options),
-        size = _merge.size,
-        speed = _merge.speed;
-      if (size < 1 || size > 30) {
-        throw new Error('size属性超出限制');
+    key: "_assertWeatherEffectType",
+    value: function _assertWeatherEffectType(type) {
+      if (WEATHER_EFFECT_TYPES.includes(type)) {
+        return type;
       }
-      if (speed < 1 || speed > 100) {
-        throw new Error('speed属性超出限制');
+      throw new Error("\u4E0D\u652F\u6301\u7684\u5929\u6C14\u7C7B\u578B: ".concat(type));
+    }
+  }, {
+    key: "_assertNotDestroyed",
+    value: function _assertNotDestroyed() {
+      if (this.isDestroyed) {
+        throw new Error('WeatherEffects实例已销毁');
       }
-      return {
-        size: 20 / size,
-        speed: 1800 / speed
-      };
     }
   }, {
-    key: "_snowEffect",
-    value: function _snowEffect(options) {
-      this.stage = new Cesium.PostProcessStage({
-        fragmentShader: SnowShader,
-        uniforms: this._handleSnowOptions(options)
+    key: "_createStage",
+    value: function _createStage(stageConfig) {
+      var _stageConfig$enabled;
+      var stage = new Cesium.PostProcessStage({
+        fragmentShader: stageConfig.fragmentShader,
+        uniforms: stageConfig.uniforms
       });
+      stage.enabled = (_stageConfig$enabled = stageConfig.enabled) !== null && _stageConfig$enabled !== void 0 ? _stageConfig$enabled : true;
+      return stage;
     }
   }, {
-    key: "_handleRainOptions",
-    value: function _handleRainOptions(options) {
-      var _merge2 = merge(DEFAULT_RAIN(), options),
-        direction = _merge2.direction,
-        size = _merge2.size,
-        speed = _merge2.speed;
-      if (direction < -90 || direction > 90) {
-        throw new Error('direction属性超出限制');
+    key: "_createExtraStages",
+    value: function _createExtraStages(stageConfigs) {
+      var _this2 = this;
+      return stageConfigs.map(function (stageConfig) {
+        return _this2._createStage(stageConfig);
+      });
+    }
+  }, {
+    key: "_resetStagesFromCurrentOptions",
+    value: function _resetStagesFromCurrentOptions() {
+      var stageConfig = this._buildStageConfig(this.type, this.options);
+      this.stage = this._createStage(stageConfig.mainStage);
+      this._extraStages = this._createExtraStages(stageConfig.extraStages);
+    }
+  }, {
+    key: "_getStages",
+    value: function _getStages() {
+      return [this.stage].concat(_toConsumableArray(this._extraStages));
+    }
+  }, {
+    key: "_removeStagesFromMap",
+    value: function _removeStagesFromMap() {
+      var map = this.getMap();
+      var weatherStages = this._getStages();
+      if (map) {
+        var stages = map.scene.postProcessStages;
+        weatherStages.forEach(function (stage) {
+          if (stages.contains(stage)) {
+            stages.remove(stage);
+          } else if (!stage.isDestroyed()) {
+            stage.destroy();
+          }
+        });
+      } else {
+        this._destroyStages();
       }
-      if (size < 1 || size > 100) {
-        throw new Error('size属性超出限制');
+      this._isAdded = false;
+      this._mapContext = undefined;
+    }
+  }, {
+    key: "_destroyStages",
+    value: function _destroyStages() {
+      this._getStages().forEach(function (stage) {
+        if (!stage.isDestroyed()) {
+          stage.destroy();
+        }
+      });
+    }
+  }, {
+    key: "_applyUniforms",
+    value: function _applyUniforms(stage, uniforms) {
+      Object.keys(uniforms).forEach(function (key) {
+        stage.uniforms[key] = uniforms[key];
+      });
+    }
+  }, {
+    key: "_applyStageConfig",
+    value: function _applyStageConfig(stageConfig) {
+      var _stageConfig$mainStag,
+        _this3 = this;
+      var nextExtraStages = stageConfig.extraStages;
+      if (nextExtraStages.length !== this._extraStages.length) {
+        var map = this.getMap();
+        var shouldReAdd = this._isAdded && !!map;
+        if (shouldReAdd) {
+          this._removeStagesFromMap();
+        } else {
+          this._destroyStages();
+        }
+        this.stage = this._createStage(stageConfig.mainStage);
+        this._extraStages = this._createExtraStages(nextExtraStages);
+        if (shouldReAdd && map) {
+          this.addToMap(map);
+        }
+        return;
+      }
+      this._applyUniforms(this.stage, stageConfig.mainStage.uniforms);
+      this.stage.enabled = (_stageConfig$mainStag = stageConfig.mainStage.enabled) !== null && _stageConfig$mainStag !== void 0 ? _stageConfig$mainStag : true;
+      nextExtraStages.forEach(function (extraStageConfig, index) {
+        var _extraStageConfig$ena;
+        var extraStage = _this3._extraStages[index];
+        _this3._applyUniforms(extraStage, extraStageConfig.uniforms);
+        extraStage.enabled = (_extraStageConfig$ena = extraStageConfig.enabled) !== null && _extraStageConfig$ena !== void 0 ? _extraStageConfig$ena : true;
+      });
+    }
+  }, {
+    key: "_buildStageConfig",
+    value: function _buildStageConfig(type, options) {
+      return this._stageConfigBuilders[type](options);
+    }
+  }, {
+    key: "_assertNumberInRange",
+    value: function _assertNumberInRange(key, value, min, max) {
+      if (!Number.isFinite(value) || value < min || value > max) {
+        throw new Error("".concat(key, "\u5C5E\u6027\u8D85\u51FA\u9650\u5236\uFF0C\u53D6\u503C\u8303\u56F4\u4E3A").concat(min, "~").concat(max));
       }
-      if (speed < 1 || speed > 100) {
-        throw new Error('speed属性超出限制');
+    }
+  }, {
+    key: "_assertBoolean",
+    value: function _assertBoolean(key, value) {
+      if (typeof value !== 'boolean') {
+        throw new Error("".concat(key, "\u5C5E\u6027\u5FC5\u987B\u662F\u5E03\u5C14\u503C"));
       }
+    }
+  }, {
+    key: "_buildSnowStageConfig",
+    value: function _buildSnowStageConfig() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var nextOptions = _objectSpread(_objectSpread({}, DEFAULT_SNOW()), options);
+      this._assertNumberInRange('size', nextOptions.size, 1, 30);
+      this._assertNumberInRange('speed', nextOptions.speed, 1, 100);
       return {
-        direction: toRadians(direction),
-        size: 10 / size,
-        speed: 1800 / speed
+        mainStage: {
+          fragmentShader: SnowShader,
+          uniforms: {
+            size: 20 / nextOptions.size,
+            speed: 1800 / nextOptions.speed
+          }
+        },
+        extraStages: [],
+        options: nextOptions
       };
     }
   }, {
-    key: "_rainEffect",
-    value: function _rainEffect(options) {
-      this.stage = new Cesium.PostProcessStage({
-        fragmentShader: RainShader,
-        uniforms: this._handleRainOptions(options)
-      });
+    key: "_isRainLightningActive",
+    value: function _isRainLightningActive(options) {
+      return options.lightningEnabled && options.lightningFrequency > 0 && options.lightningIntensity > 0;
     }
   }, {
-    key: "_handleFogOptions",
-    value: function _handleFogOptions(options) {
-      var _merge3 = merge(DEFAULT_FOG(), options),
-        startDistance = _merge3.startDistance,
-        endDistance = _merge3.endDistance,
-        color = _merge3.color;
-      if (startDistance < 1 || startDistance > 5000) {
-        throw new Error('startDistance属性超出限制');
-      }
-      if (endDistance < 5000 || endDistance > 50000) {
-        throw new Error('endDistance属性超出限制');
-      }
+    key: "_mapRainLightningInterval",
+    value: function _mapRainLightningInterval(lightningFrequency) {
+      return 0.18 + lightningFrequency / 100 * 0.78;
+    }
+  }, {
+    key: "_buildRainLightningStageConfig",
+    value: function _buildRainLightningStageConfig(options) {
       return {
-        fogByDistance: new Cesium.Cartesian4(startDistance, 0.1, endDistance, 0.8),
-        fogColor: colorString(color)
+        fragmentShader: LightningShader,
+        uniforms: {
+          fall_interval: this._mapRainLightningInterval(options.lightningFrequency),
+          mix_factor: options.lightningIntensity
+        },
+        enabled: this._isRainLightningActive(options)
       };
     }
   }, {
-    key: "_fogEffect",
-    value: function _fogEffect(options) {
-      this.stage = new Cesium.PostProcessStage({
-        fragmentShader: FogShader,
-        uniforms: this._handleFogOptions(options)
-      });
+    key: "_buildRainStageConfig",
+    value: function _buildRainStageConfig() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var nextOptions = _objectSpread(_objectSpread({}, DEFAULT_RAIN()), options);
+      this._assertNumberInRange('direction', nextOptions.direction, -90, 90);
+      this._assertNumberInRange('size', nextOptions.size, 1, 100);
+      this._assertNumberInRange('speed', nextOptions.speed, 1, 100);
+      this._assertNumberInRange('density', nextOptions.density, 0, 100);
+      this._assertNumberInRange('opacity', nextOptions.opacity, 0, 1);
+      this._assertNumberInRange('gloominess', nextOptions.gloominess, 0, 1);
+      this._assertBoolean('lightningEnabled', nextOptions.lightningEnabled);
+      this._assertNumberInRange('lightningFrequency', nextOptions.lightningFrequency, 0, 100);
+      this._assertNumberInRange('lightningIntensity', nextOptions.lightningIntensity, 0, 1);
+      this._assertNumberInRange('lightningDuration', nextOptions.lightningDuration, 0, 1);
+      return {
+        mainStage: {
+          fragmentShader: RainShader,
+          uniforms: {
+            direction: toRadians(nextOptions.direction),
+            size: 10 / nextOptions.size,
+            speed: 1800 / nextOptions.speed,
+            density: nextOptions.density,
+            opacity: nextOptions.opacity,
+            gloominess: nextOptions.gloominess,
+            rainColor: colorString(nextOptions.color)
+          }
+        },
+        extraStages: [this._buildRainLightningStageConfig(nextOptions)],
+        options: nextOptions
+      };
+    }
+  }, {
+    key: "_buildFogStageConfig",
+    value: function _buildFogStageConfig() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var nextOptions = _objectSpread(_objectSpread({}, DEFAULT_FOG()), options);
+      this._assertNumberInRange('startDistance', nextOptions.startDistance, 1, 5000);
+      this._assertNumberInRange('endDistance', nextOptions.endDistance, 5000, 50000);
+      if (nextOptions.startDistance >= nextOptions.endDistance) {
+        throw new Error('startDistance必须小于endDistance');
+      }
+      return {
+        mainStage: {
+          fragmentShader: FogShader,
+          uniforms: {
+            fogByDistance: new Cesium.Cartesian4(nextOptions.startDistance, 0.1, nextOptions.endDistance, 0.8),
+            fogColor: colorString(nextOptions.color)
+          }
+        },
+        extraStages: [],
+        options: nextOptions
+      };
     }
   }]);
   return WeatherEffects;

package/dist/esm/material/shader/RainShader.glsl

@@ -4,6 +4,10 @@ uniform sampler2D colorTexture;
 uniform float direction;
 uniform float size;
 uniform float speed;
+uniform float density;
+uniform float opacity;
+uniform float gloominess;
+uniform vec4 rainColor;
 in vec2 v_textureCoordinates;
 out vec4 fragColor;
 
@@ -11,18 +15,52 @@ float hash(float x) {
     return fract(sin(x * 133.3) * 13.13);
 }
 
+float rainLayer(vec2 uv, float time, float densityFactor, float scaleFactor, float seed) {
+    vec2 warpedUv = uv;
+    warpedUv *= scaleFactor;
+
+    float v = 1.0 - sin(hash(floor((warpedUv.x + seed) * 100.0 * densityFactor)) * 2.0);
+    float b = clamp(
+        abs(sin((20.0 + seed * 2.5) * time * v + warpedUv.y * (5.0 / (2.0 + v)))) - 0.95,
+        0.0,
+        1.0
+    ) * (18.0 + densityFactor * 2.0);
+
+    return v * b;
+}
+
+vec3 applyGloominess(vec3 sceneColor) {
+    float gloomFactor = clamp(gloominess, 0.0, 1.0);
+    float luminance = dot(sceneColor, vec3(0.299, 0.587, 0.114));
+    vec3 mutedScene = mix(sceneColor, vec3(luminance), gloomFactor * 0.45);
+    return mutedScene * (1.0 - gloomFactor * 0.55);
+}
+
 void main() {
     float time = czm_frameNumber / speed;
     vec2 resolution = czm_viewport.zw;
     vec2 uv = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);
-    vec3 c = vec3(0.6, 0.7, 0.8);
     float a = direction;
     float si = sin(a), co = cos(a);
     uv *= mat2(co, -si, si, co);
-    uv *= length(uv + vec2(0.0, 4.9)) * size + 1.0;
-    float v = 1.0 - sin(hash(floor(uv.x * 100.0)) * 2.0);
-    float b = clamp(abs(sin(20.0 * time * v + uv.y * (5.0 / (2.0 + v)))) - 0.95, 0.0, 1.0) * 20.0;
-    c *= v * b;
 
-    fragColor = mix(texture(colorTexture, v_textureCoordinates), vec4(c, 1.0), 0.5);
+    vec2 primaryUv = uv;
+    primaryUv *= length(primaryUv + vec2(0.0, 4.9)) * size + 1.0;
+
+    float densityFactor = mix(0.65, 2.1, clamp(density / 100.0, 0.0, 1.0));
+    float primaryLayer = rainLayer(primaryUv, time, densityFactor, 1.0, 0.0);
+
+    vec2 secondaryUv = primaryUv * 1.35;
+    secondaryUv.x += time * 0.25;
+    secondaryUv.y += hash(floor(primaryUv.x * 8.0) + 17.0) * 0.75;
+    float secondaryLayer = rainLayer(secondaryUv, time * 1.15, densityFactor * 0.85, 1.0, 3.7) * 0.65;
+
+    float rainMask = clamp(primaryLayer + secondaryLayer, 0.0, 1.0);
+
+    vec4 scene = texture(colorTexture, v_textureCoordinates);
+    vec3 baseScene = applyGloominess(scene.rgb);
+    vec3 rainLayerColor = rainColor.rgb * rainMask * opacity;
+    vec3 finalColor = clamp(baseScene + rainLayerColor, 0.0, 1.0);
+
+    fragColor = vec4(finalColor, scene.a);
 }

package/dist/esm/material/shader/lightning.glsl

@@ -0,0 +1,70 @@
+precision highp float;
+
+float hash(float x)
+{
+  return fract(21654.6512 * sin(385.51 * x));
+}
+float hash(vec2 p)
+{
+  return fract(1654.65157 * sin(15.5134763 * p.x + 45.5173247 * p.y + 5.21789));
+}
+vec2 hash2(vec2 p)
+{
+  return vec2(hash(p * .754), hash(1.5743 * p + 4.5476351));
+}
+const vec2 hashAdd = vec2(1.0, 0.0);
+vec2 noise2(vec2 x)
+{
+  vec2 p = floor(x);
+  vec2 f = fract(x);
+  f = f * f * (3.0 - 2.0 * f);
+  vec2 res = mix(mix(hash2(p),
+  hash2(p + hashAdd.xy), f.x),
+  mix(hash2(p + hashAdd.yx), hash2(p + hashAdd.xx), f.x), f.y);
+  return res;
+}
+vec2 fbm2(vec2 x)
+{
+  vec2 r = vec2(0.0);
+  float a = 1.0;
+  for (int i = 0; i < 8; i++)
+  {
+    r += noise2(x) * a;
+    x *= 2.;
+    a *= .5;
+  }
+  return r;
+}
+float dseg(vec2 ba, vec2 pa)
+{
+  float h = clamp(dot(pa, ba) / dot(ba, ba), -0.2, 1.);
+  return length(pa - ba * h);
+}
+uniform sampler2D colorTexture;
+uniform float fall_interval;
+uniform float mix_factor;
+in vec2 v_textureCoordinates;
+out vec4 fragColor;
+void main(void){
+  float iTime = czm_frameNumber * fall_interval * clamp(fall_interval * 0.1, 0.01, 0.1);
+  vec2 p = gl_FragCoord.xy / czm_viewport.zw;
+  vec2 d;
+  vec2 tgt = vec2(1., -1.);
+  vec3 col = vec3(0.);
+  float mdist = 100000.;
+  float t = hash(floor(5. * iTime));
+  tgt += 4. * hash2(tgt + t) - 1.5;
+  if (hash(t + 2.3) > .6)
+  for (int i = 0; i < 100; i++) {
+    vec2 dtgt = tgt - p;
+    d = .05 * (vec2(-.5, -1.) + hash2(vec2(float(i), t)));
+    float dist = dseg(d, dtgt);
+    mdist = min(mdist, dist);
+    tgt -= d;
+    float bolt = exp(-1.2 * dist) + exp(-55. * mdist);
+    col = max(col, bolt * vec3(.7, .8, 1.));
+  }
+  vec4 scene = texture(colorTexture, v_textureCoordinates);
+  vec3 finalColor = clamp(scene.rgb + col * mix_factor, 0.0, 1.0);
+  fragColor = vec4(finalColor, scene.a);
+}

package/dist/esm/tileLayer/MvtVectorLoad.d.ts

@@ -152,8 +152,13 @@ declare class MvtVectorLoad {
     _tilesToUpdate: VectorLoadTile[];
     _loadedTiles: Record<string, LoadedTile>;
     _pendingTiles: Map<string, Promise<LoadedTile>>;
+    private _pendingRequestControllers;
+    private _pendingRequestTiles;
     private _cacheOrder;
     _requestToken: number;
+    private _requestQueue;
+    private _queuedTileKeys;
+    private _activeRequestCount;
     private _levelZeroMaximumGeometricError;
     private _decodeWithWorker;
     private _autoDisplayLayers;
@@ -178,6 +183,9 @@ declare class MvtVectorLoad {
     private _doInit;
     private _validateOptions;
     private _emitError;
+    private _isAbortError;
+    private _markTileLoading;
+    private _resetTileRequestState;
     private _createRootTiles;
     private _getTileKey;
     private _touchTileCache;
@@ -212,11 +220,14 @@ declare class MvtVectorLoad {
     private _loadTile;
     tileToGeoJSON(tile: LoadedTile): TileGeoJSONResult;
     update(frameState: FrameStateLike): void;
+    private _cancelStaleRequests;
     private _updateTiles;
+    private _drainRequestQueue;
     private _loadVisibleTile;
     getLoadedTiles(): LoadedTile[];
     getTile(x: number, y: number, z: number): LoadedTile | undefined;
     clearCache(): void;
+    private _abortAllPendingRequests;
     private _resetTileStates;
     destroy(): void;
     isDestroyed(): boolean;
@@ -234,6 +245,7 @@ declare class VectorLoadTile {
     distanceToCamera: number;
     visibility: Cesium.Intersect;
     state: TileState;
+    requestVersion: number;
     constructor(options: VectorLoadTileOptions);
     createChildren(): void;
     visit(frameState: FrameStateLike, visitor: TileVisitor, getScreenSpaceError: ScreenSpaceErrorCalculator): void;