WaterFlush/Assets/Art/Shader/WaterPlaneClip.shader

Shader "Custom/WaterClip"
{
    Properties
    {
        _Color("Color", Color) = (1,1,1,1)
        _MainTex("Albedo (RGB)", 2D) = "white" {}
        _NormalSpeed1("NormalSpeed1",Vector) = (1,1,2,0.5)
        _NormalSpeed2("NormalSpeed2",Vector) = (1,1,2,0.5)
        _NormalSpeed3("NormalSpeed3",Vector) = (1,1,2,0.5)
        _DetailNormal("DetailNormal",2D) = "bump"{}
        _Glossiness("Smoothness", Range(0,1)) = 0.5
        _Metallic("Metallic", Range(0,1)) = 0.0
        _Depth("Depth",float) = 15

            /* _Wavelength("Wavelength",Range(0.01,10)) = 6.28
             _WaveSpeed("WaveSpeed",Range(0,10)) = 1
             _Amplitude("Amplitude",Range(0,10)) = 1*/
             /*_Wave1("Wave1(direct(xy),Wavelength(z),Amplitude(w))",Vector) = (1,1,2,0.5)
             _Wave2("Wave1(direct(xy),Wavelength(z),Amplitude(w))",Vector) = (1,0,0,0.5)
             _Wave3("Wave1(direct(xy),Wavelength(z),Amplitude(w))",Vector) = (0,1,2,0.5)*/
        _ClipTex("ClipTex",2D) = "white" {}
        _ClipLength("ClipLength",Range(0,1))=0.5
        _ClipOffset("ClipOffset",Range(-0.5,0.5))=0

    }
        SubShader
        {
            Tags { "Queue" = "Geometry" "RenderType" = "Transparent" }
            //ZWrite On
            GrabPass{}
            CGPROGRAM
            // Physically based Standard lighting model, and enable shadows on all light types
            #pragma surface surf Standard  fullforwardshadows 

            // Use shader model 3.0 target, to get nicer looking lighting
            #pragma target 3.0

            sampler2D _CameraDepthTexture;

            sampler2D _MainTex, _GrabTexture, _ClipTex;
            sampler2D _DetailNormal;
            float _ClipLength, _ClipOffset;
        struct Input
        {
            float2 uv_MainTex;
            float2 uv_DetailNormal;
            float2 uv_ClipTex;
            float4 screenPos;
            float3 worldPos;
            //float VextexNormal;                
            float3 viewDir;


        };
        float _Depth;
        half _Glossiness;
        half _Metallic;
        fixed4 _Color;
        /* float _Wavelength, _WaveSpeed, _Amplitude;*/
         //float4 _Wave1, _Wave2, _Wave3;
         float4 _NormalSpeed1, _NormalSpeed2, _NormalSpeed3;
         // Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
         // See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
         // #pragma instancing_options assumeuniformscaling
         UNITY_INSTANCING_BUFFER_START(Props)
             // put more per-instance properties here
         UNITY_INSTANCING_BUFFER_END(Props)

         void surf(Input IN, inout SurfaceOutputStandard o)
         {
             float clipCount = tex2D(_ClipTex, IN.uv_ClipTex).r;
             clip(clipCount+ _ClipOffset - _ClipLength);
             //²ÉÑùÉî¶Èͼ
              float2 uv = IN.screenPos.xy / IN.screenPos.w;
              //uv = (uv + 1) / 2;
              float depth = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv));

              float surfaceDepth = UNITY_Z_0_FAR_FROM_CLIPSPACE(IN.screenPos.z);
              surfaceDepth = max(((1.0 - (IN.screenPos.z) / _ProjectionParams.y) * _ProjectionParams.z), 0);
              float colfactor = smoothstep(0, _Depth, depth - surfaceDepth);

              float3 bCol = tex2D(_GrabTexture, uv);


              o.Metallic = _Metallic;
              o.Smoothness = _Glossiness;
              half3 MyNormal1 = UnpackNormal(tex2D(_DetailNormal, IN.uv_DetailNormal * _NormalSpeed1.zw + _Time.y * normalize(_NormalSpeed1.xy) * 0.3));
              half3 MyNormal2 = UnpackNormal(tex2D(_DetailNormal, IN.uv_DetailNormal * _NormalSpeed2.zw + _Time.y * normalize(_NormalSpeed2.xy) * 0.3));
              half3 MyNormal3 = UnpackNormal(tex2D(_DetailNormal, IN.uv_DetailNormal * _NormalSpeed3.zw + _Time.y * normalize(_NormalSpeed3.xy) * 0.3));

              o.Normal = MyNormal1 + MyNormal2 + MyNormal3;
              o.Normal.z *= 3;

              o.Normal = normalize(o.Normal);


              float FFactor = pow(1 - saturate(dot(o.Normal, normalize(IN.viewDir))),10);
              FFactor = lerp(0.2, 2, FFactor);
              o.Albedo = _Color.rgb * FFactor;

              o.Albedo = lerp(bCol, o.Albedo, colfactor);
              o.Alpha = 1;


          }

          float3 GenerateWave(float4 wave,float3 clipPos,inout float3 tangent, inout float3 bNormal) {
              float2 Dirc = normalize(wave.xy);
              float3 p = clipPos.xyz;
              float k = 2 * UNITY_PI / wave.z;
              float _Amplitude = wave.w / k;
              float c = sqrt(9.8 / k);
              float f = k * (dot(p.xz, Dirc) - c * _Time.y);
              float Dx = Dirc.x;
              float Dy = Dirc.y;

              /*   p.x += Dx * _Amplitude * cos(f);
                 p.y += _Amplitude * sin(f);
                 p.z += Dy * _Amplitude * cos(f);*/

                  tangent += float3(1 - Dx * Dx * k * _Amplitude * sin(f), k * _Amplitude * cos(f), -Dx * Dy * k * _Amplitude * sin(f));
                  bNormal += float3(-Dx * Dy * k * _Amplitude * sin(f), k * _Amplitude * cos(f), 1 - Dy * Dy * k * _Amplitude * sin(f));

                 return float3(
                     Dx * _Amplitude * cos(f),
                     _Amplitude * sin(f),
                     Dy * _Amplitude * cos(f)
                     );
             }

             void MyVertext(inout appdata_full v, out Input o) {
                 UNITY_INITIALIZE_OUTPUT(Input, o);

                 /*  float2 Dirc = normalize(_Direction.xy);
                   float3 p = v.vertex.xyz;
                   float k = 2 * UNITY_PI / _Wavelength;
                   float c = sqrt(9.8 / k);
                   float f = k * (dot(p.xz, Dirc) - c * _Time.y);
                   float Dx = Dirc.x;
                   float Dy = Dirc.y;
                   p.x += Dx *_Amplitude * cos(f);
                   p.y += _Amplitude * sin(f);
                   p.z += Dy *_Amplitude * cos(f);
                   v.vertex.xyz = p;
                   float3 tangent = normalize(float3(1 - Dx * Dx * k * _Amplitude * sin(f), k * _Amplitude * cos(f), -Dx * Dy * k * _Amplitude * sin(f)));
                   float3 bNorm = normalize( float3( - Dx * Dy * k * _Amplitude * sin(f), k * _Amplitude * cos(f),1-Dy * Dy * k * _Amplitude * sin(f)));*/

                   /*  float3 tangent = float3(1, 0, 0);
                     float3 bNormal = float3(0, 0, 1);
                     float3 clipPos = v.vertex.xyz;
                     clipPos += GenerateWave(_Wave1, v.vertex.xyz, tangent, bNormal);
                     clipPos += GenerateWave(_Wave2, v.vertex.xyz, tangent, bNormal);
                     clipPos += GenerateWave(_Wave3, v.vertex.xyz, tangent, bNormal);

                     v.normal =normalize( cross(bNormal, tangent));
                     v.tangent.xyz = normalize( tangent);
                     o.VextexNormal = smoothstep(-2, 10, clipPos.y - v.vertex.y);
                     v.vertex.xyz = clipPos;*/


                 }

                 ENDCG
        }
            FallBack "Diffuse"
}