Shader "Grass/GrassShader"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color ("Color", Color) = (1, 1, 1, 1)

        [Space]

        _WindDirection ("Wind Direction", Vector) = (1, 0, 0, 0)
        _WindSpeed ("Wind Speed", float) = 8
        _WindDensity ("Wind Density", float) = 0.1
        _WindStrength ("Wind Strength", float) = 1

        [Space]

        _MaxDistance ("Radius", float) = 0.5
        _Falloff ("Falloff", float) = 0.5
        _PushAwayStrength ("Push Away Strength", float) = 0.5
        _PushDownStrength ("Push Down Strength", float) = 0.5
    }
    SubShader
    {
        Tags {
            "Queue" = "Transparent"
            "IgnoreProjectors" = "True"
            "RenderType" = "Transparent" }

        Blend SrcAlpha OneMinusSrcAlpha
        ZWrite Off
        Cull Off

        Pass
        {
            CGPROGRAM

            #include "UnityCG.cginc"

            #pragma target 2.5
            #pragma vertex vert
            #pragma fragment frag

            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed4 _Color;

            float3 _WindDirection;
            float _WindSpeed;
            float _WindDensity;
            float _WindStrength;

            int _TramplesCount;
            float4 _TramplePositions[64];
            float _TramplesStrength[64];
            float _MaxDistance;
            float _Falloff;
            float _PushAwayStrength;
            float _PushDownStrength;


            struct meshData
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct vertexOut
            {
                float4 pos : SV_POSITION;
                float2 uv : TEXCOORD0;
            };


            float2 GradientNoiseDir(float2 p)
            {
                p = p % 289;

                float x = float(34 * p.x + 1) * p.x % 289 + p.y;
                x = (34 * x + 1) * x % 289;
                x = frac(x / 41) * 2 - 1;

                return normalize(float2(x - floor(x + 0.5), abs(x) - 0.5));
            }

            float GradientNoise(float2 uv, float scale)
            {
                float2 p = uv * scale;
                float2 ip = floor(p);
                float2 fp = frac(p);

                float d00 = dot(GradientNoiseDir(ip), fp);
                float d01 = dot(GradientNoiseDir(ip + float2(0, 1)), fp - float2(0, 1));
                float d10 = dot(GradientNoiseDir(ip + float2(1, 0)), fp - float2(1, 0));
                float d11 = dot(GradientNoiseDir(ip + float2(1, 1)), fp - float2(1, 1));

                fp = fp * fp * fp * (fp * (fp * 6 - 15) + 10);

                return lerp(lerp(d00, d01, fp.y), lerp(d10, d11, fp.y), fp.x) + 0.5;
            }

            float3 CalculteWindOffset_WS(float3 worldPos)
            {
                float2 noiseUV = worldPos + _WindSpeed * _Time;
                float noise = (GradientNoise(noiseUV, _WindDensity) - 0.5) * _WindStrength;

                float3 offset = normalize(_WindDirection).xyz * noise;
                return offset;
            }

            float3 CalculateTrampleOffset_WS(float3 worldPos)
            {
                float maxStrength = 0;
                float3 maxDistanceVector = worldPos;

                for (int i = 0; i < _TramplesCount; i++)
                {
                    float3 distanceVector = worldPos - _TramplePositions[i];

                    float distance = length(distanceVector);
                    float strength = (1 - pow(saturate(distance / _MaxDistance), _Falloff)) * _TramplesStrength[i];

                    distanceVector.y = 0;

                    int c1 = maxStrength > strength;
                    int c2 = !c1;

                    maxStrength = max(maxStrength, strength);
                    maxDistanceVector = maxDistanceVector * c1 + distanceVector * c2;
                }

                float3 pushAwayOffset = normalize(maxDistanceVector) * _PushAwayStrength * maxStrength;
                float3 pushDownOffset = float3(0, -1, 0) * _PushDownStrength * maxStrength;

                return (pushAwayOffset + pushDownOffset);
            }


            vertexOut vert (meshData v)
            {
                vertexOut o;

                float4 localPos = v.vertex;

                if (v.uv.y > 0)
                {
                    float3 worldPos = mul(unity_ObjectToWorld, v.vertex);

                    float3 windOffset = CalculteWindOffset_WS(worldPos);
                    worldPos += windOffset;

                    float3 trampleOffset = CalculateTrampleOffset_WS(worldPos);
                    worldPos += trampleOffset;

                    localPos = mul(unity_WorldToObject, float4(worldPos.xyz, 1));
                }

                o.pos = UnityObjectToClipPos(localPos);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);

                return o;
            }

            fixed4 frag (vertexOut i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv) * _Color;

                return col;
            }

            ENDCG
        }
    }
}