@anov/3d 0.0.286 → 0.0.288

package/dist/module/environment/season/index.js

@@ -1,10 +1,6 @@
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 function _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); }
+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 { DoubleSide, MeshPhysicalMaterial, RepeatWrapping, SRGBColorSpace, TextureLoader, use } from '@anov/3d-core';
 var SeasonEnum = /*#__PURE__*/function (SeasonEnum) {
   SeasonEnum["Spring"] = "Spring";
@@ -13,7 +9,7 @@ var SeasonEnum = /*#__PURE__*/function (SeasonEnum) {
   SeasonEnum["Winter"] = "Winter";
   return SeasonEnum;
 }(SeasonEnum || {}); // 冬
-var PresetValue = {
+const PresetValue = {
   Spring: {
     treeSize: 1.0,
     landSnowSize: 0.0,
@@ -55,9 +51,8 @@ var PresetValue = {
     changeColor: [0.996, 0.960, 0.764]
   }
 };
-var Season = /*#__PURE__*/function () {
-  function Season(app) {
-    _classCallCheck(this, Season);
+class Season {
+  constructor(app) {
     _defineProperty(this, "app", void 0);
     _defineProperty(this, "textureLeaf", void 0);
     _defineProperty(this, "textureBole", void 0);
@@ -72,186 +67,349 @@ var Season = /*#__PURE__*/function () {
     this.app = app;
     this.init();
   }
-  _createClass(Season, [{
-    key: "init",
-    value: function init() {
-      var path = this.app.caseInstance.usePath;
-      var textureLoader = new TextureLoader();
-      this.textureLeaf = textureLoader.load("".concat(path, "season/Image_tree2.png"));
-      this.textureLeaf.colorSpace = SRGBColorSpace;
-      this.textureNoise = textureLoader.load("".concat(path, "season/T_TileNoise.png"));
-      this.textureNoise.colorSpace = SRGBColorSpace;
-      this.textureBole = textureLoader.load("".concat(path, "season/Image_tree3.png"));
-      this.textureBole.colorSpace = SRGBColorSpace;
-      this.uniforms = {
-        time: {
-          value: 1.0
-        },
-        treeSize: {
-          value: 0.3
-        },
-        noGran: {
-          value: 0.9
-        },
-        landSnowSize: {
-          value: 0.0
-        },
-        treeColor1: {
-          value: [0.0, 0.58, 0.0]
-        },
-        targetColor: {
-          value: [0.0, 0.58, 0.0]
-        },
-        changeColor: {
-          value: [0.5, 0.58, 0.5]
-        },
-        texture1: {
-          value: this.textureLeaf
-        },
-        texture2: {
-          value: this.textureNoise
-        }
-      };
-      this.uniforms.texture1.value.wrapS = this.uniforms.texture1.value.wrapT = RepeatWrapping;
-      this.uniforms.texture2.value.wrapS = this.uniforms.texture2.value.wrapT = RepeatWrapping;
-    }
-  }, {
-    key: "setSeason",
-    value: function setSeason(type) {
-      var _this = this;
-      var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2.0;
-      if (!this.haveSetMaterial) {
-        this.haveSetMaterial = true;
-        this.setLeafMaterial();
-        this.setLandMaterial();
-        this.setMassifMaterial();
-        use.useframe(function () {
-          _this.uniforms.time.value += 0.2;
-        });
+  init() {
+    const path = this.app.caseInstance.usePath;
+    const textureLoader = new TextureLoader();
+    this.textureLeaf = textureLoader.load(`${path}season/Image_tree2.png`);
+    this.textureLeaf.colorSpace = SRGBColorSpace;
+    this.textureNoise = textureLoader.load(`${path}season/T_TileNoise.png`);
+    this.textureNoise.colorSpace = SRGBColorSpace;
+    this.textureBole = textureLoader.load(`${path}season/Image_tree3.png`);
+    this.textureBole.colorSpace = SRGBColorSpace;
+    this.uniforms = {
+      time: {
+        value: 1.0
+      },
+      treeSize: {
+        value: 0.3
+      },
+      noGran: {
+        value: 0.9
+      },
+      landSnowSize: {
+        value: 0.0
+      },
+      treeColor1: {
+        value: [0.0, 0.58, 0.0]
+      },
+      targetColor: {
+        value: [0.0, 0.58, 0.0]
+      },
+      changeColor: {
+        value: [0.5, 0.58, 0.5]
+      },
+      texture1: {
+        value: this.textureLeaf
+      },
+      texture2: {
+        value: this.textureNoise
       }
-      PresetValue[type] && Object.keys(PresetValue[type]).forEach(function (key) {
-        _this.uniforms[key].value = PresetValue[type][key];
+    };
+    this.uniforms.texture1.value.wrapS = this.uniforms.texture1.value.wrapT = RepeatWrapping;
+    this.uniforms.texture2.value.wrapS = this.uniforms.texture2.value.wrapT = RepeatWrapping;
+  }
+  setSeason(type, duration = 2.0) {
+    if (!this.haveSetMaterial) {
+      this.haveSetMaterial = true;
+      this.setLeafMaterial();
+      this.setLandMaterial();
+      this.setMassifMaterial();
+      use.useframe(() => {
+        this.uniforms.time.value += 0.2;
       });
     }
-  }, {
-    key: "setLeafMaterial",
-    value: function setLeafMaterial() {
-      var _this2 = this;
-      this.leafMaterial = new MeshPhysicalMaterial({
-        map: this.textureBole,
-        alphaTest: 0.2,
-        roughness: 1,
-        metalness: 0,
-        emissive: 0,
-        side: DoubleSide,
-        transparent: true,
-        depthWrite: true
-      });
-      this.leafMaterial.onBeforeCompile = function (shader, renderer) {
-        shader.vertexShader = "\n      \n      uniform float time;\n      varying vec3 vWorldPosition;\n      varying vec2 vUv;\n      \n      float hash( vec2 p ) {\n          return fract( sin( dot( p, vec2( 127.1, 311.7 ) ) ) * 43758.5453123 );\n      }\n      \n      float noise( vec2 p ) {\n          vec2 i = floor( p );\n          vec2 f = fract( p );\n          vec2 u = f * f * ( 3.0 - 2.0 * f );\n      \n          return mix( mix( hash( i + vec2( 0.0, 0.0 ) ), \n                           hash( i + vec2( 1.0, 0.0 ) ), u.x),\n                      mix( hash( i + vec2( 0.0, 1.0 ) ), \n                           hash( i + vec2( 1.0, 1.0 ) ), u.x), u.y);\n      }\n      \n      ".concat(shader.vertexShader);
-        shader.vertexShader = shader.vertexShader.replace('#include <begin_vertex>', "#include <begin_vertex>\n                      vUv = uv;\n      vNormal = normalize(normal);\n      vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;\n      \n      vec3 wind = vec3(\n          noise(position.xy * 0.5 + time * 0.1),\n          noise(position.yz * 0.5 + time * 0.1),\n          noise(position.zx * 0.5 + time * 0.1)\n      );\n      float strength = 0.5;  // Adjust the strength of the wind effect\n      vec3 displacedPosition = position + wind * strength;\n      transformed = displacedPosition;\n      ");
-        shader.fragmentShader = "\n      uniform sampler2D texture1;\n      uniform sampler2D texture2;\n      uniform float treeSize;\n      uniform vec3 treeColor1;\n      uniform float landSnowSize;\n      varying vec3 vWorldPosition;\n      varying vec2 vUv;\n      \n      vec4 T3dPoi (sampler2D T,vec3 Position,vec3 normal, float loop){\n          vec2 xy = vec2(Position.x,Position.y);\n          vec2 xz = vec2(Position.x,Position.z);\n          vec2 yz = vec2(Position.y,Position.z);\n          float ix =clamp((abs(normal.x)-0.4)*2.,0.,1.);\n          float iy =clamp((abs(normal.y)-0.4)*2.,0.,1.);\n          return mix((mix(texture2D( T, xy*loop),texture2D( T, yz*loop),ix)),texture2D( T, xz*loop),iy);\n      }\n      ".concat(shader.fragmentShader, "\n      ");
-        shader.fragmentShader = shader.fragmentShader.replace('#include <map_fragment>', " \n      #include <map_fragment>  \n      vec4 T1 = texture2D(texture1, vUv)*vec4(treeColor1,1.);\n      vec4 nT = texture2D(texture2, vUv);\n      \n      vec4 noiseT=T3dPoi(texture2,vWorldPosition,vNormal,0.02);\n      \n      diffuseColor = mix(diffuseColor, T1,pow(nT.r,treeSize) ); // \u53E0\u52A0\u6548\u679C\uFF0C\u8C03\u6574\u6DF7\u5408\u65B9\u5F0F\n      float Si= clamp(pow(noiseT.r,(10.-landSnowSize))*landSnowSize*0.1,0.,1.);\n      diffuseColor = mix(diffuseColor,vec4(1.,1.,1.,diffuseColor.a), Si);\n      \n      \n       // diffuseColor =vec4(Si,Si,Si,1.) ;\n      \n      ");
-        shader.uniforms.time = _this2.uniforms.time;
-        shader.uniforms.texture1 = {
-          value: _this2.textureLeaf
-        };
-        shader.uniforms.texture2 = {
-          value: _this2.textureNoise
-        };
-        shader.uniforms.treeSize = _this2.uniforms.treeSize;
-        shader.uniforms.treeColor1 = _this2.uniforms.treeColor1;
-        shader.uniforms.landSnowSize = _this2.uniforms.landSnowSize;
-
-        // material.userData.shader = shader;
+    PresetValue[type] && Object.keys(PresetValue[type]).forEach(key => {
+      this.uniforms[key].value = PresetValue[type][key];
+    });
+  }
+  setLeafMaterial() {
+    this.leafMaterial = new MeshPhysicalMaterial({
+      map: this.textureBole,
+      alphaTest: 0.2,
+      roughness: 1,
+      metalness: 0,
+      emissive: 0,
+      side: DoubleSide,
+      transparent: true,
+      depthWrite: true
+    });
+    this.leafMaterial.onBeforeCompile = (shader, renderer) => {
+      shader.vertexShader = `
+      
+      uniform float time;
+      varying vec3 vWorldPosition;
+      varying vec2 vUv;
+      
+      float hash( vec2 p ) {
+          return fract( sin( dot( p, vec2( 127.1, 311.7 ) ) ) * 43758.5453123 );
+      }
+      
+      float noise( vec2 p ) {
+          vec2 i = floor( p );
+          vec2 f = fract( p );
+          vec2 u = f * f * ( 3.0 - 2.0 * f );
+      
+          return mix( mix( hash( i + vec2( 0.0, 0.0 ) ), 
+                           hash( i + vec2( 1.0, 0.0 ) ), u.x),
+                      mix( hash( i + vec2( 0.0, 1.0 ) ), 
+                           hash( i + vec2( 1.0, 1.0 ) ), u.x), u.y);
+      }
+      
+      ${shader.vertexShader}`;
+      shader.vertexShader = shader.vertexShader.replace('#include <begin_vertex>', `#include <begin_vertex>
+                      vUv = uv;
+      vNormal = normalize(normal);
+      vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;
+      
+      vec3 wind = vec3(
+          noise(position.xy * 0.5 + time * 0.1),
+          noise(position.yz * 0.5 + time * 0.1),
+          noise(position.zx * 0.5 + time * 0.1)
+      );
+      float strength = 0.5;  // Adjust the strength of the wind effect
+      vec3 displacedPosition = position + wind * strength;
+      transformed = displacedPosition;
+      `);
+      shader.fragmentShader = `
+      uniform sampler2D texture1;
+      uniform sampler2D texture2;
+      uniform float treeSize;
+      uniform vec3 treeColor1;
+      uniform float landSnowSize;
+      varying vec3 vWorldPosition;
+      varying vec2 vUv;
+      
+      vec4 T3dPoi (sampler2D T,vec3 Position,vec3 normal, float loop){
+          vec2 xy = vec2(Position.x,Position.y);
+          vec2 xz = vec2(Position.x,Position.z);
+          vec2 yz = vec2(Position.y,Position.z);
+          float ix =clamp((abs(normal.x)-0.4)*2.,0.,1.);
+          float iy =clamp((abs(normal.y)-0.4)*2.,0.,1.);
+          return mix((mix(texture2D( T, xy*loop),texture2D( T, yz*loop),ix)),texture2D( T, xz*loop),iy);
+      }
+      ${shader.fragmentShader}
+      `;
+      shader.fragmentShader = shader.fragmentShader.replace('#include <map_fragment>', ` 
+      #include <map_fragment>  
+      vec4 T1 = texture2D(texture1, vUv)*vec4(treeColor1,1.);
+      vec4 nT = texture2D(texture2, vUv);
+      
+      vec4 noiseT=T3dPoi(texture2,vWorldPosition,vNormal,0.02);
+      
+      diffuseColor = mix(diffuseColor, T1,pow(nT.r,treeSize) ); // 叠加效果，调整混合方式
+      float Si= clamp(pow(noiseT.r,(10.-landSnowSize))*landSnowSize*0.1,0.,1.);
+      diffuseColor = mix(diffuseColor,vec4(1.,1.,1.,diffuseColor.a), Si);
+      
+      
+       // diffuseColor =vec4(Si,Si,Si,1.) ;
+      
+      `);
+      shader.uniforms.time = this.uniforms.time;
+      shader.uniforms.texture1 = {
+        value: this.textureLeaf
       };
-      this.app.caseInstance.treesMesh.forEach(function (object) {
-        object.material = _this2.leafMaterial;
-      });
-    }
-  }, {
-    key: "setLandMaterial",
-    value: function setLandMaterial() {
-      var _this3 = this;
-      this.landMaterial = new MeshPhysicalMaterial({
-        // alphaTest: 0.2,
-        roughness: 1,
-        metalness: 0,
-        emissive: 0,
-        envMapIntensity: 0.2,
-        side: DoubleSide,
-        // transparent: true,
-        depthWrite: false
-      });
-      this.landMaterial.onBeforeCompile = function (shader, renderer) {
-        shader.vertexShader = "  \n      varying vec3 vWorldPosition;\n      varying vec2 vUv;\n      ".concat(shader.vertexShader);
-        shader.vertexShader = shader.vertexShader.replace('#include <begin_vertex>', "#include <begin_vertex>\n      vUv = uv;\n      vNormal = normalize(normal);\n      vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;\n      ");
-        shader.fragmentShader = "\n      uniform sampler2D texture1;\n      uniform sampler2D texture2;\n      uniform float treeSize;\n      uniform float noGran;\n      uniform vec3 treeColor1;\n      uniform vec3 targetColor;\n      uniform vec3 changeColor;\n      uniform float landSnowSize;\n      varying vec3 vWorldPosition;\n      varying vec2 vUv;\n      //varying vec2 vUv;\n      vec4 T3dPoi (sampler2D T,vec3 Position,vec3 normal, float loop){\n          vec2 xy = vec2(Position.x,Position.y);\n          vec2 xz = vec2(Position.x,Position.z);\n          vec2 yz = vec2(Position.y,Position.z);\n          float ix =clamp((abs(normal.x)-0.4)*2.,0.,1.);\n          float iy =clamp((abs(normal.y)-0.4)*2.,0.,1.);\n          return mix((mix(texture2D( T, xy*loop),texture2D( T, yz*loop),ix)),texture2D( T, xz*loop),iy);\n      }\n      \n      ".concat(shader.fragmentShader, "\n      ");
-        shader.fragmentShader = shader.fragmentShader.replace('#include <map_fragment>', " \n      #include <map_fragment>  \n      vec4 T1 = texture2D(texture1, vUv);\n      \n      float d = distance(T1.rgb, targetColor);\n      float factor = smoothstep(0.4, 0.6, d);\n      //  T1.rgb = mix(treeColor1, T1.rgb, factor);\n      \n      float gray = dot(T1.rgb, vec3(0.299, 0.587, 0.114));\n      vec4 T1_gray =vec4(vec3(gray)*changeColor,1.);\n      \n      T1.rgb = mix(T1_gray.rgb, T1.rgb, factor);\n      \n      \n      vec4 nT = texture2D(texture2, vUv);\n      \n      vec4 noiseT2d=pow(texture2D(texture2, vWorldPosition.xz*0.002),vec4(10.-landSnowSize));\n      \n      diffuseColor = mix(diffuseColor, T1,pow(nT.r,treeSize) ); // \u53E0\u52A0\u6548\u679C\uFF0C\u8C03\u6574\u6DF7\u5408\u65B9\u5F0F\n       diffuseColor=T1;\n      \n      vec3 upDirection = vec3(0.0, 1.0, 0.0);\n      float dotProduct = dot(vNormal, upDirection);\n      float snowAmount = smoothstep(0.5, 1.0, dotProduct);\n      diffuseColor = mix(diffuseColor, vec4(1.0, 1., 1.,1.), snowAmount*landSnowSize*noiseT2d*0.1);\n           \n      \n      ");
-        shader.uniforms.time = _this3.uniforms.time;
-        // shader.uniforms.texture1 = { value: matLandT0 };
-        shader.uniforms.texture1 = {
-          value: _this3.textureLand
-        };
-        shader.uniforms.texture2 = {
-          value: _this3.textureNoise
-        };
-        shader.uniforms.treeSize = _this3.uniforms.treeSize;
-        shader.uniforms.noGran = _this3.uniforms.noGran;
-        shader.uniforms.treeColor1 = _this3.uniforms.treeColor1;
-        shader.uniforms.targetColor = _this3.uniforms.targetColor;
-        shader.uniforms.changeColor = _this3.uniforms.changeColor;
-        shader.uniforms.landSnowSize = _this3.uniforms.landSnowSize;
+      shader.uniforms.texture2 = {
+        value: this.textureNoise
       };
-      this.app.caseInstance.grasslandMesh.forEach(function (object) {
-        _this3.textureLand = object.material.map;
-        object.material = _this3.landMaterial;
-      });
-    }
-  }, {
-    key: "setMassifMaterial",
-    value: function setMassifMaterial() {
-      var _this4 = this;
-      this.massifMaterial = new MeshPhysicalMaterial({
-        alphaTest: 0.2,
-        roughness: 1,
-        metalness: 0,
-        emissive: 0,
-        envMapIntensity: 0.2,
-        side: DoubleSide,
-        transparent: true,
-        depthWrite: false
-      });
-      this.massifMaterial.onBeforeCompile = function (shader, renderer) {
-        // console.log(shader.vertexShader);
-        shader.vertexShader = "  \n            varying vec3 vWorldPosition;\n            varying vec2 vUv;\n            ".concat(shader.vertexShader);
-        shader.vertexShader = shader.vertexShader.replace('#include <begin_vertex>', "#include <begin_vertex>\n            vUv = uv;\n                    \n            vNormal = normalize(normal);\n            vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;\n            ");
-        shader.fragmentShader = "\n            uniform sampler2D texture1;\n            uniform sampler2D texture2;\n            uniform float treeSize;\n            uniform float noGran;\n            uniform vec3 treeColor1;\n            uniform vec3 targetColor;\n            uniform vec3 changeColor;\n            uniform float landSnowSize;\n            varying vec3 vWorldPosition;\n            varying vec2 vUv;\n    \n            vec4 T3dPoi (sampler2D T,vec3 Position,vec3 normal, float loop){\n                vec2 xy = vec2(Position.x,Position.y);\n                vec2 xz = vec2(Position.x,Position.z);\n                vec2 yz = vec2(Position.y,Position.z);\n                float ix =clamp((abs(normal.x)-0.4)*2.,0.,1.);\n                float iy =clamp((abs(normal.y)-0.4)*2.,0.,1.);\n                return mix((mix(texture2D( T, xy*loop),texture2D( T, yz*loop),ix)),texture2D( T, xz*loop),iy);\n            }\n    \n            ".concat(shader.fragmentShader, "\n        ");
-        shader.fragmentShader = shader.fragmentShader.replace('#include <map_fragment>', " \n            #include <map_fragment>  \n            vec4 T1 = texture2D(texture1, vUv);\n    \n        float d = distance(T1.rgb, targetColor);\n        float factor = smoothstep(0.4, 0.6, d);\n      //  T1.rgb = mix(treeColor1, T1.rgb, factor);\n    \n        float gray = dot(T1.rgb, vec3(0.299, 0.587, 0.114));\n        vec4 T1_gray =vec4(vec3(gray)*changeColor,1.);\n    \n        T1.rgb = mix(T1_gray.rgb, T1.rgb, factor);\n    \n        diffuseColor=T1;\n            vec4 nT = texture2D(texture2, vUv);\n    \n            float noiseT=pow( clamp(texture2D(texture2, vWorldPosition.xz*0.002).r,0.,1.),(10.0-landSnowSize));\n            vec4 noiseT2d=pow(texture2D(texture2, vWorldPosition.xz*0.002),vec4(10.0-landSnowSize));\n    \n           //diffuseColor = mix(diffuseColor, T1,pow(nT.r,1.) ); // \u53E0\u52A0\u6548\u679C\uFF0C\u8C03\u6574\u6DF7\u5408\u65B9\u5F0F\n         \n    \n            vec3 upDirection = vec3(0.0, 1.0, 0.0);\n            float dotProduct = dot(vNormal, upDirection);\n            float snowAmount = smoothstep(0.5, 1.0, dotProduct);\n            diffuseColor = mix(diffuseColor, vec4(5.0, 5., 5.,5.),snowAmount* noiseT*0.5*landSnowSize);\n            //diffuseColor=nT;\n    \n            ");
-        shader.uniforms.time = _this4.uniforms.time;
-        // shader.uniforms.texture1 = { value: matLandT0 };
-        shader.uniforms.texture1 = {
-          value: _this4.textureMassif
-        };
-        shader.uniforms.texture2 = {
-          value: _this4.textureNoise
-        };
-        shader.uniforms.treeSize = _this4.uniforms.treeSize;
-        shader.uniforms.noGran = _this4.uniforms.noGran;
-        shader.uniforms.treeColor1 = _this4.uniforms.treeColor1;
-        shader.uniforms.targetColor = _this4.uniforms.targetColor;
-        shader.uniforms.changeColor = _this4.uniforms.changeColor;
-        shader.uniforms.landSnowSize = _this4.uniforms.landSnowSize;
+      shader.uniforms.treeSize = this.uniforms.treeSize;
+      shader.uniforms.treeColor1 = this.uniforms.treeColor1;
+      shader.uniforms.landSnowSize = this.uniforms.landSnowSize;
 
-        // material.userData.shader = shader;
+      // material.userData.shader = shader;
+    };
+    this.app.caseInstance.treesMesh.forEach(object => {
+      object.material = this.leafMaterial;
+    });
+  }
+  setLandMaterial() {
+    this.landMaterial = new MeshPhysicalMaterial({
+      // alphaTest: 0.2,
+      roughness: 1,
+      metalness: 0,
+      emissive: 0,
+      envMapIntensity: 0.2,
+      side: DoubleSide,
+      // transparent: true,
+      depthWrite: false
+    });
+    this.landMaterial.onBeforeCompile = (shader, renderer) => {
+      shader.vertexShader = `  
+      varying vec3 vWorldPosition;
+      varying vec2 vUv;
+      ${shader.vertexShader}`;
+      shader.vertexShader = shader.vertexShader.replace('#include <begin_vertex>', `#include <begin_vertex>
+      vUv = uv;
+      vNormal = normalize(normal);
+      vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;
+      `);
+      shader.fragmentShader = `
+      uniform sampler2D texture1;
+      uniform sampler2D texture2;
+      uniform float treeSize;
+      uniform float noGran;
+      uniform vec3 treeColor1;
+      uniform vec3 targetColor;
+      uniform vec3 changeColor;
+      uniform float landSnowSize;
+      varying vec3 vWorldPosition;
+      varying vec2 vUv;
+      //varying vec2 vUv;
+      vec4 T3dPoi (sampler2D T,vec3 Position,vec3 normal, float loop){
+          vec2 xy = vec2(Position.x,Position.y);
+          vec2 xz = vec2(Position.x,Position.z);
+          vec2 yz = vec2(Position.y,Position.z);
+          float ix =clamp((abs(normal.x)-0.4)*2.,0.,1.);
+          float iy =clamp((abs(normal.y)-0.4)*2.,0.,1.);
+          return mix((mix(texture2D( T, xy*loop),texture2D( T, yz*loop),ix)),texture2D( T, xz*loop),iy);
+      }
+      
+      ${shader.fragmentShader}
+      `;
+      shader.fragmentShader = shader.fragmentShader.replace('#include <map_fragment>', ` 
+      #include <map_fragment>  
+      vec4 T1 = texture2D(texture1, vUv);
+      
+      float d = distance(T1.rgb, targetColor);
+      float factor = smoothstep(0.4, 0.6, d);
+      //  T1.rgb = mix(treeColor1, T1.rgb, factor);
+      
+      float gray = dot(T1.rgb, vec3(0.299, 0.587, 0.114));
+      vec4 T1_gray =vec4(vec3(gray)*changeColor,1.);
+      
+      T1.rgb = mix(T1_gray.rgb, T1.rgb, factor);
+      
+      
+      vec4 nT = texture2D(texture2, vUv);
+      
+      vec4 noiseT2d=pow(texture2D(texture2, vWorldPosition.xz*0.002),vec4(10.-landSnowSize));
+      
+      diffuseColor = mix(diffuseColor, T1,pow(nT.r,treeSize) ); // 叠加效果，调整混合方式
+       diffuseColor=T1;
+      
+      vec3 upDirection = vec3(0.0, 1.0, 0.0);
+      float dotProduct = dot(vNormal, upDirection);
+      float snowAmount = smoothstep(0.5, 1.0, dotProduct);
+      diffuseColor = mix(diffuseColor, vec4(1.0, 1., 1.,1.), snowAmount*landSnowSize*noiseT2d*0.1);
+           
+      
+      `);
+      shader.uniforms.time = this.uniforms.time;
+      // shader.uniforms.texture1 = { value: matLandT0 };
+      shader.uniforms.texture1 = {
+        value: this.textureLand
       };
-      this.app.caseInstance.massifMesh.forEach(function (object) {
-        _this4.textureMassif = object.material.map;
-        object.material = _this4.massifMaterial;
-      });
-    }
-  }]);
-  return Season;
-}();
+      shader.uniforms.texture2 = {
+        value: this.textureNoise
+      };
+      shader.uniforms.treeSize = this.uniforms.treeSize;
+      shader.uniforms.noGran = this.uniforms.noGran;
+      shader.uniforms.treeColor1 = this.uniforms.treeColor1;
+      shader.uniforms.targetColor = this.uniforms.targetColor;
+      shader.uniforms.changeColor = this.uniforms.changeColor;
+      shader.uniforms.landSnowSize = this.uniforms.landSnowSize;
+    };
+    this.app.caseInstance.grasslandMesh.forEach(object => {
+      this.textureLand = object.material.map;
+      object.material = this.landMaterial;
+    });
+  }
+  setMassifMaterial() {
+    this.massifMaterial = new MeshPhysicalMaterial({
+      alphaTest: 0.2,
+      roughness: 1,
+      metalness: 0,
+      emissive: 0,
+      envMapIntensity: 0.2,
+      side: DoubleSide,
+      transparent: true,
+      depthWrite: false
+    });
+    this.massifMaterial.onBeforeCompile = (shader, renderer) => {
+      // console.log(shader.vertexShader);
+      shader.vertexShader = `  
+            varying vec3 vWorldPosition;
+            varying vec2 vUv;
+            ${shader.vertexShader}`;
+      shader.vertexShader = shader.vertexShader.replace('#include <begin_vertex>', `#include <begin_vertex>
+            vUv = uv;
+                    
+            vNormal = normalize(normal);
+            vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;
+            `);
+      shader.fragmentShader = `
+            uniform sampler2D texture1;
+            uniform sampler2D texture2;
+            uniform float treeSize;
+            uniform float noGran;
+            uniform vec3 treeColor1;
+            uniform vec3 targetColor;
+            uniform vec3 changeColor;
+            uniform float landSnowSize;
+            varying vec3 vWorldPosition;
+            varying vec2 vUv;
+    
+            vec4 T3dPoi (sampler2D T,vec3 Position,vec3 normal, float loop){
+                vec2 xy = vec2(Position.x,Position.y);
+                vec2 xz = vec2(Position.x,Position.z);
+                vec2 yz = vec2(Position.y,Position.z);
+                float ix =clamp((abs(normal.x)-0.4)*2.,0.,1.);
+                float iy =clamp((abs(normal.y)-0.4)*2.,0.,1.);
+                return mix((mix(texture2D( T, xy*loop),texture2D( T, yz*loop),ix)),texture2D( T, xz*loop),iy);
+            }
+    
+            ${shader.fragmentShader}
+        `;
+      shader.fragmentShader = shader.fragmentShader.replace('#include <map_fragment>', ` 
+            #include <map_fragment>  
+            vec4 T1 = texture2D(texture1, vUv);
+    
+        float d = distance(T1.rgb, targetColor);
+        float factor = smoothstep(0.4, 0.6, d);
+      //  T1.rgb = mix(treeColor1, T1.rgb, factor);
+    
+        float gray = dot(T1.rgb, vec3(0.299, 0.587, 0.114));
+        vec4 T1_gray =vec4(vec3(gray)*changeColor,1.);
+    
+        T1.rgb = mix(T1_gray.rgb, T1.rgb, factor);
+    
+        diffuseColor=T1;
+            vec4 nT = texture2D(texture2, vUv);
+    
+            float noiseT=pow( clamp(texture2D(texture2, vWorldPosition.xz*0.002).r,0.,1.),(10.0-landSnowSize));
+            vec4 noiseT2d=pow(texture2D(texture2, vWorldPosition.xz*0.002),vec4(10.0-landSnowSize));
+    
+           //diffuseColor = mix(diffuseColor, T1,pow(nT.r,1.) ); // 叠加效果，调整混合方式
+         
+    
+            vec3 upDirection = vec3(0.0, 1.0, 0.0);
+            float dotProduct = dot(vNormal, upDirection);
+            float snowAmount = smoothstep(0.5, 1.0, dotProduct);
+            diffuseColor = mix(diffuseColor, vec4(5.0, 5., 5.,5.),snowAmount* noiseT*0.5*landSnowSize);
+            //diffuseColor=nT;
+    
+            `);
+      shader.uniforms.time = this.uniforms.time;
+      // shader.uniforms.texture1 = { value: matLandT0 };
+      shader.uniforms.texture1 = {
+        value: this.textureMassif
+      };
+      shader.uniforms.texture2 = {
+        value: this.textureNoise
+      };
+      shader.uniforms.treeSize = this.uniforms.treeSize;
+      shader.uniforms.noGran = this.uniforms.noGran;
+      shader.uniforms.treeColor1 = this.uniforms.treeColor1;
+      shader.uniforms.targetColor = this.uniforms.targetColor;
+      shader.uniforms.changeColor = this.uniforms.changeColor;
+      shader.uniforms.landSnowSize = this.uniforms.landSnowSize;
+
+      // material.userData.shader = shader;
+    };
+    this.app.caseInstance.massifMesh.forEach(object => {
+      this.textureMassif = object.material.map;
+      object.material = this.massifMaterial;
+    });
+  }
+}
 export default Season;
 //# sourceMappingURL=index.js.map