deeptwins-engine-3d 0.0.42 → 0.0.44

package/dist/material/PolylineTrailLinkMaterialProperty.js

@@ -1,102 +1,96 @@
+var _excluded = ["duration"],
+  _excluded2 = ["color", "count"];
 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 _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 _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 _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); }
 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 { v4 as uuidv4 } from 'uuid';
+import { cloneDeep, isEqual, merge } from 'lodash';
+import { DEFAULT_POLYLINE_TRAIL_LINK_MATERIAL_STYLE } from "../constant";
 import * as utils from "../tool/utils";
-var PolylineTrailLinkMaterialProperty = /*#__PURE__*/function () {
-  function PolylineTrailLinkMaterialProperty(options) {
+import BaseMaterialProperty from "./BaseMaterialProperty";
+import PolylineTrailLinkShader from "./shader/PolylineTrailLinkShader.glsl";
+
+// 流动线材质
+var PolylineTrailLinkMaterialProperty = /*#__PURE__*/function (_BaseMaterialProperty) {
+  _inherits(PolylineTrailLinkMaterialProperty, _BaseMaterialProperty);
+  var _super = _createSuper(PolylineTrailLinkMaterialProperty);
+  function PolylineTrailLinkMaterialProperty(style) {
+    var _this;
     _classCallCheck(this, PolylineTrailLinkMaterialProperty);
-    _defineProperty(this, "_definitionChanged", new Cesium.Event());
-    _defineProperty(this, "_color", void 0);
-    _defineProperty(this, "_time", void 0);
-    _defineProperty(this, "color", void 0);
-    _defineProperty(this, "mixRatio", void 0);
-    _defineProperty(this, "duration", void 0);
-    _defineProperty(this, "image", void 0);
-    _defineProperty(this, "count", void 0);
-    _defineProperty(this, "materialType", void 0);
-    this.materialType = 'PolylineTrailLink' + uuidv4();
-    this._definitionChanged = new Cesium.Event();
-    this.color = utils.colorString(options.color) || Cesium.Color.BLUE;
-    this.mixRatio = options.mixRatio || 0.5;
-    this.duration = options.duration || 2;
-    this.count = options.count || 1;
-    this.image = options.image || utils.getDeepTwinsFile('Image/line.png');
-    this._time = new Date().getTime();
-    this._init();
+    var mergeStyle = merge(DEFAULT_POLYLINE_TRAIL_LINK_MATERIAL_STYLE(), cloneDeep(style || {}));
+    _this = _super.call(this, 'PolylineTrailLink', mergeStyle);
+    _defineProperty(_assertThisInitialized(_this), "currStyle", void 0);
+    _this.currStyle = PolylineTrailLinkMaterialProperty.handleStyle(mergeStyle);
+    _this._init();
+    return _this;
   }
+
+  // 处理参数
   _createClass(PolylineTrailLinkMaterialProperty, [{
     key: "_init",
     value: function _init() {
       // @ts-ignore
-      Cesium.Material._materialCache.addMaterial(this.materialType, {
+      Cesium.Material._materialCache.addMaterial(this.type, {
         fabric: {
-          type: this.materialType,
-          uniforms: {
-            color: new Cesium.Color(1.0, 0.0, 0.0, 0.5),
-            image: this.image,
-            count: this.count,
-            time: 0,
-            mixRatio: this.mixRatio
-          },
-          source: this.getShader()
+          type: this.type,
+          uniforms: _objectSpread(_objectSpread({}, this.currStyle), {}, {
+            time: this._time
+          }),
+          source: PolylineTrailLinkShader
         },
         translucent: function translucent() {
           return true;
         }
       });
     }
-  }, {
-    key: "isConstant",
-    get: function get() {
-      return false;
-    }
-  }, {
-    key: "definitionChanged",
-    get: function get() {
-      return this._definitionChanged;
-    }
-  }, {
-    key: "getType",
-    value: function getType() {
-      return this.materialType;
-    }
   }, {
     key: "getValue",
     value: function getValue(time, result) {
+      var _Object$keys;
       if (!Cesium.defined(result)) {
         result = {};
       }
-      // @ts-ignore
-      result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.Color.WHITE, result.color);
-      result.image = this.image;
-      result.count = this.count;
-      result.time = (new Date().getTime() - this._time) % (this.duration * 1000) / (this.duration * 1000);
-      result.mixRatio = this.mixRatio;
+      var _this$currStyle = this.currStyle,
+        duration = _this$currStyle.duration,
+        options = _objectWithoutProperties(_this$currStyle, _excluded);
+      (_Object$keys = Object.keys(options)) === null || _Object$keys === void 0 || _Object$keys.forEach(function (key) {
+        result[key] = options[key];
+      });
+      result.time = (new Date().getTime() - this._time) % (duration * 1000) / (duration * 1000);
       return result;
     }
   }, {
     key: "equals",
     value: function equals(other) {
-      return this === other || other instanceof PolylineTrailLinkMaterialProperty &&
-      // @ts-ignore
-      Cesium.Property.equals(this._color, other._color) && this.duration === other.duration && this.count === other.count && this.image === other.image && this.mixRatio === other.mixRatio;
+      return other instanceof PolylineTrailLinkMaterialProperty && isEqual(this.style, other.style);
     }
-  }, {
-    key: "getShader",
-    value: function getShader() {
-      return "czm_material czm_getMaterial(czm_materialInput materialInput)\n\t                                                      {\n\t                                                           czm_material material = czm_getDefaultMaterial(materialInput);\n\t                                                           vec2 st = vec2(fract(materialInput.st.s * count - time), materialInput.st.t * 1.0);\n\t                                                           vec4 colorImage = texture(image, vec2(fract(st.s - time), st.t));\n\t                                                           material.alpha = colorImage.a * color.a;\n\t                                                           material.diffuse = mix(colorImage.rgb, color.rgb, mixRatio);\n\t                                                           return material;\n\t                                                       }\n\t        ";
+  }], [{
+    key: "handleStyle",
+    value: function handleStyle(style) {
+      var color = style.color,
+        count = style.count,
+        options = _objectWithoutProperties(style, _excluded2);
+      var backStyle = _objectSpread({}, options);
+      backStyle.color = utils.colorString(color);
+      backStyle.count = count <= 0 ? 1 : count;
+      return backStyle;
     }
   }]);
   return PolylineTrailLinkMaterialProperty;
-}();
-export { PolylineTrailLinkMaterialProperty as default };
-Object.defineProperties(PolylineTrailLinkMaterialProperty.prototype, {
-  // @ts-ignore
-  color: Cesium.createPropertyDescriptor('color')
-});
+}(BaseMaterialProperty);
+export { PolylineTrailLinkMaterialProperty as default };

package/dist/material/WeatherEffects.js

@@ -9,9 +9,9 @@ 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";
-var fsSnow = "\n    precision highp float;\n\n    uniform sampler2D colorTexture;\n    uniform float speed;\n    uniform float size;\n    in vec2 v_textureCoordinates;\n    out vec4 fragColor;\n\n    float 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\n    void 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  ";
-var fsRain = "\n      precision highp float;\n\n      uniform sampler2D colorTexture;\n      uniform float direction;\n      uniform float size;\n      uniform float speed;\n      in vec2 v_textureCoordinates;\n      out vec4 fragColor;\n\n      float hash(float x){\n          return fract(sin(x * 133.3) * 13.13);\n      }\n\n      void 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 fsFog = "\n    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\n  float 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  }\n  vec4 alphaBlend(vec4 sourceColor, vec4 destinationColor)\n  {\n      return sourceColor * vec4(sourceColor.aaa, 1.0) + destinationColor * (1.0 - sourceColor.a);\n  }\n  uniform sampler2D colorTexture;\n  uniform sampler2D depthTexture;\n  uniform vec4 fogByDistance;\n  uniform vec4 fogColor;\n  in vec2 v_textureCoordinates;\n  void 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  }";
+import FogShader from "./shader/FogShader.glsl";
+import RainShader from "./shader/RainShader.glsl";
+import SnowShader from "./shader/SnowShader.glsl";
 var WeatherEffects = /*#__PURE__*/function () {
   function WeatherEffects(type) {
     var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -93,7 +93,7 @@ var WeatherEffects = /*#__PURE__*/function () {
     key: "_snowEffect",
     value: function _snowEffect(options) {
       this.stage = new Cesium.PostProcessStage({
-        fragmentShader: fsSnow,
+        fragmentShader: SnowShader,
         uniforms: this._handleSnowOptions(options)
       });
     }
@@ -123,7 +123,7 @@ var WeatherEffects = /*#__PURE__*/function () {
     key: "_rainEffect",
     value: function _rainEffect(options) {
       this.stage = new Cesium.PostProcessStage({
-        fragmentShader: fsRain,
+        fragmentShader: RainShader,
         uniforms: this._handleRainOptions(options)
       });
     }
@@ -149,7 +149,7 @@ var WeatherEffects = /*#__PURE__*/function () {
     key: "_fogEffect",
     value: function _fogEffect(options) {
       this.stage = new Cesium.PostProcessStage({
-        fragmentShader: fsFog,
+        fragmentShader: FogShader,
         uniforms: this._handleFogOptions(options)
       });
     }

package/dist/material/shader/CircleWaveShader.glsl

@@ -0,0 +1,32 @@
+czm_material czm_getMaterial(czm_materialInput materialInput) {
+    czm_material material = czm_getDefaultMaterial(materialInput);
+    material.diffuse = 1.5 * color.rgb;
+    vec2 st = materialInput.st;
+    vec3 str = materialInput.str;
+    float dis = distance(st, vec2(0.5, 0.5));
+    float per = fract(time);
+    if (abs(str.z) > 0.001) {
+        discard;
+    }
+    if (dis > 0.5) {
+        discard;
+    } else {
+        float perDis = 0.5 / count;
+        float disNum;
+        float bl = .0;
+        for (int i = 0; i <= 9; i++) {
+            if (float(i) <= count) {
+                disNum = perDis * float(i) - dis + per / count;
+                if (disNum > 0.0) {
+                    if (disNum < perDis) {
+                        bl = 1.0 - disNum / perDis;
+                    } else if (disNum - perDis < perDis) {
+                        bl = 1.0 - abs(1.0 - disNum / perDis);
+                    }
+                    material.alpha = pow(bl, gradient);
+                }
+            }
+        }
+    }
+    return material;
+}

package/dist/material/shader/DynamicWallShader.glsl

@@ -0,0 +1,35 @@
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+    vec2 st = materialInput.st;
+    float vertical = 1.0;
+    float directionAdd = 1.0;
+    vec2 uv = vec2(0, 0);
+    // 判断排列方向
+    if (freely == vertical) {
+        // 判断运动方向
+        if (direction == directionAdd) {
+            uv = vec2(fract(st.s), fract(count * st.t + time));
+        } else {
+            uv = vec2(fract(st.s), fract(count * st.t - time));
+        }
+    } else {
+        // 判断运动方向
+        if (direction == directionAdd) {
+            uv = vec2(fract(count * st.s + time), fract(st.t));
+        } else {
+            uv = vec2(fract(count * st.s - time), fract(st.t));
+        }
+    }
+    vec4 colorImage = texture(image, uv);
+    vec3 mixedColor = mix(colorImage.rgb, color.rgb, mixRatio);
+    vec4 fragColor;
+    fragColor.rgb = mixedColor;
+    fragColor = czm_gammaCorrect(fragColor);
+
+    material.diffuse = mixedColor;
+    material.alpha = colorImage.a * color.a; // 可根据需要决定是否相乘
+    material.emission = fragColor.rgb;
+
+    return material;
+}

package/dist/material/shader/FogShader.glsl

@@ -0,0 +1,48 @@
+float getDistance(sampler2D depthTexture, vec2 texCoords)
+{
+    float depth = czm_unpackDepth(texture(depthTexture, texCoords));
+    if (depth == 0.0) {
+        return czm_infinity;
+    }
+    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, depth);
+    return -eyeCoordinate.z / eyeCoordinate.w;
+}
+//根据距离，在中间进行插值
+float interpolateByDistance(vec4 nearFarScalar, float distance)
+{
+    //根据常识，雾应该是距离远，越看不清，近距离内的物体可以看清
+    //因此近距离alpha=0，远距离的alpha=1.0
+    //本例中设置可见度为200米
+    //雾特效的起始距离
+    float startDistance = nearFarScalar.x;
+    //雾特效的起始alpha值
+    float startValue = nearFarScalar.y;
+    //雾特效的结束距离
+    float endDistance = nearFarScalar.z;
+    //雾特效的结束alpha值
+    float endValue = nearFarScalar.w;
+    //根据每段距离占总长度的占比，插值alpha，距离越远，alpha值越大。插值范围0,1。
+    float t = clamp((distance - startDistance) / (endDistance - startDistance), 0.0, 1.0);
+    return mix(startValue, endValue, t);
+}
+vec4 alphaBlend(vec4 sourceColor, vec4 destinationColor)
+{
+    return sourceColor * vec4(sourceColor.aaa, 1.0) + destinationColor * (1.0 - sourceColor.a);
+}
+uniform sampler2D colorTexture;
+uniform sampler2D depthTexture;
+uniform vec4 fogByDistance;
+uniform vec4 fogColor;
+in vec2 v_textureCoordinates;
+void main(void)
+{
+    //获取地物距相机的距离
+    float distance = getDistance(depthTexture, v_textureCoordinates);
+    //获取场景原本的纹理颜色
+    vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
+    //根据距离，对alpha进行插值
+    float blendAmount = interpolateByDistance(fogByDistance, distance);
+    //将alpha变化值代入雾的原始颜色中，并将雾与场景原始纹理进行融合
+    vec4 finalFogColor = vec4(fogColor.rgb, fogColor.a * blendAmount);
+    out_FragColor = alphaBlend(finalFogColor, sceneColor);
+}

package/dist/material/shader/PolylineTrailLinkShader.glsl

@@ -0,0 +1,9 @@
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+    vec2 st = vec2(fract(materialInput.st.s * count - time), materialInput.st.t * 1.0);
+    vec4 colorImage = texture(image, vec2(fract(st.s - time), st.t));
+    material.alpha = colorImage.a * color.a;
+    material.diffuse = mix(colorImage.rgb, color.rgb, mixRatio);
+    return material;
+}

package/dist/material/shader/RainShader.glsl

@@ -0,0 +1,28 @@
+precision highp float;
+
+uniform sampler2D colorTexture;
+uniform float direction;
+uniform float size;
+uniform float speed;
+in vec2 v_textureCoordinates;
+out vec4 fragColor;
+
+float hash(float x) {
+    return fract(sin(x * 133.3) * 13.13);
+}
+
+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);
+}

package/dist/material/shader/SnowShader.glsl

@@ -0,0 +1,48 @@
+precision highp float;
+
+uniform sampler2D colorTexture;
+uniform float speed;
+uniform float size;
+in vec2 v_textureCoordinates;
+out vec4 fragColor;
+
+float snow(vec2 uv, float sc) {
+    float scale = sc * size;
+    float time = float(czm_frameNumber) / speed;
+    float w = smoothstep(1.0, 0.0, -uv.y * (scale / 10.0));
+    if (w < 0.1) return 0.0;
+    uv += time / scale;
+    uv.y += time * 2.0 / scale;
+    uv.x += sin(uv.y + time * 0.5) / scale;
+    uv *= scale;
+    vec2 s = floor(uv), f = fract(uv), p;
+    float k = 3.0, d;
+    p = 0.5 + 0.35 * sin(11.0 * fract(sin((s + p + scale) * mat2(7, 3, 6, 5)) * 5.0)) - f;
+    d = length(p);
+    k = min(d, k);
+    k = smoothstep(0.0, k, sin(f.x + f.y) * 0.01);
+    return k * w;
+}
+
+void main() {
+    vec2 resolution = czm_viewport.zw;
+    vec2 uv = (gl_FragCoord.xy * 2.0 - resolution.xy) / min(resolution.x, resolution.y);
+    vec3 finalColor = vec3(0.0);
+    float c = 0.0;
+    c += snow(uv, 10.);
+    c += snow(uv, 8.);
+    c += snow(uv, 7.);
+    c += snow(uv, 6.);
+    c += snow(uv, 5.);
+    c += snow(uv, 4.);
+    c += snow(uv, 3.);
+    c += snow(uv, 2.);
+    c += snow(uv, 1.);
+    c += snow(uv, .6);
+    finalColor = vec3(c);
+
+    // 调整亮度
+    finalColor = finalColor * 2.2;
+
+    fragColor = mix(texture(colorTexture, v_textureCoordinates), vec4(finalColor, 1.0), 0.2);
+}

package/dist/typings.d.ts

@@ -0,0 +1,4 @@
+declare module '*.glsl' {
+  const value: string;
+  export default value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deeptwins-engine-3d",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "description": "map for 3d",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -72,6 +72,7 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^4.2.1",
     "father": "^4.1.0",
+    "glslify": "^7.1.1",
     "gulp": "^5.0.0",
     "husky": "^8.0.1",
     "lint-staged": "^13.0.3",
@@ -79,6 +80,7 @@
     "prettier-eslint": "^16.3.0",
     "prettier-plugin-organize-imports": "^3.0.0",
     "prettier-plugin-packagejson": "^2.2.18",
+    "raw-loader": "^4.0.2",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
     "stylelint": "^14.9.1",
@@ -91,13 +93,13 @@
     "@turf/random": "^6.5.0",
     "@turf/turf": "^6.5.0",
     "@turf/voronoi": "^6.5.0",
+    "beidou-grid-location-codec": "^1.1.12",
     "deeptwins-cesium": "0.0.21",
     "heatmap.js": "^2.0.5",
     "hls.js": "^1.5.20",
     "kdbush": "^4.0.2",
     "lodash": "^4.17.21",
     "uuid": "^11.0.3",
-    "wellknown": "^0.5.0",
-    "beidou-grid-location-codec": "^1.1.12"
+    "wellknown": "^0.5.0"
   }
 }

package/dist/cameraControl/ModelRoamRunTime.d.ts

@@ -1,32 +0,0 @@
-export default class ModelRoamRunTime {
-    polylineLayer: any;
-    polylineEntity: any;
-    polylineOptions: any;
-    modelLayer: any;
-    modelEntity: any;
-    modelOptions: any;
-    startPosition: any;
-    positionProperty: any;
-    isFlyTo: any;
-    clampToGround: boolean;
-    timeDiff: number;
-    status: string;
-    private _map;
-    private readonly _eventRunning;
-    private _startTime;
-    private _positions;
-    private _positionsCartesian3;
-    private _path;
-    private _listenScene;
-    private _listenRunning;
-    constructor(map: any, options?: any);
-    private _init;
-    updatePosition(position: any): void;
-    setFollowFirst(distance?: number): void;
-    setFollowThird(): void;
-    cancelFollow(): void;
-    on(type: any, event: any): any;
-    updatePolyline(style: any): void;
-    updateModel(style: any): void;
-    destroy(): void;
-}