SpeedTreeLightMapped shader

Shader "Nature/SpeedTreeLightMapped"
{
    Properties
    {
        _Color ("Main Color", Color) = (1,1,1,1)
        _SpecColor ("Specular Color", Color) = (0,0,0,0)
        _HueVariation ("Hue Variation", Color) = (1.0,0.5,0.0,0.1)
        _Shininess ("Shininess", Range (0.01, 1)) = 0.1
        _MainTex ("Base (RGB) Trans (A)", 2D) = "white" {}
        _DetailTex ("Detail", 2D) = "black" {}
        _BumpMap ("Normal Map", 2D) = "bump" {}
        _Cutoff ("Alpha Cutoff", Range(0,1)) = 0.333
        [MaterialEnum(Off,0,Front,1,Back,2)] _Cull ("Cull", Int) = 2
        [MaterialEnum(None,0,Fastest,1,Fast,2,Better,3,Best,4,Palm,5)] _WindQuality ("Wind Quality", Range(0,5)) = 0
    }

    // targeting SM3.0+
    SubShader
    {
        Tags
        {
            "Queue"="Geometry"
            "IgnoreProjector"="True"
            "RenderType"="Opaque"
            "DisableBatching"="LODFading"
        }
        LOD 400
        Cull [_Cull]

        CGPROGRAM
            #pragma surface surf Lambert vertex:SpeedTreeVert
            #pragma target 4.0
            #pragma multi_compile __ LOD_FADE_PERCENTAGE LOD_FADE_CROSSFADE
            #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
            #pragma shader_feature EFFECT_BUMP
            #pragma shader_feature EFFECT_HUE_VARIATION
            #define ENABLE_WIND
            #include "SpeedTreeCommon.cginc"

            void SpeedTreeFrag2(Input IN, out SpeedTreeFragOut OUT)
            {
                UNITY_APPLY_DITHER_CROSSFADE(IN)

                half4 diffuseColor = tex2D(_MainTex, IN.mainTexUV);

                OUT.Alpha = diffuseColor.a * _Color.a;
                #ifdef SPEEDTREE_ALPHATEST
                    clip(OUT.Alpha - _Cutoff);
                #endif

                #ifdef GEOM_TYPE_BRANCH_DETAIL
                    half4 detailColor = tex2D(_DetailTex, IN.Detail.xy);
                    diffuseColor.rgb = lerp(diffuseColor.rgb, detailColor.rgb, IN.Detail.z < 2.0f ? saturate(IN.Detail.z) : detailColor.a);
                #endif

                #ifdef EFFECT_HUE_VARIATION
                    half3 shiftedColor = lerp(diffuseColor.rgb, _HueVariation.rgb, IN.HueVariationAmount);
                    half maxBase = max(diffuseColor.r, max(diffuseColor.g, diffuseColor.b));
                    half newMaxBase = max(shiftedColor.r, max(shiftedColor.g, shiftedColor.b));
                    maxBase /= newMaxBase;
                    maxBase = maxBase * 0.5f + 0.5f;
                    // preserve vibrance
                    shiftedColor.rgb *= maxBase;
                    diffuseColor.rgb = saturate(shiftedColor);
                #endif

                OUT.Albedo = 0;//diffuseColor.rgb * IN.color.rgb;
                OUT.Gloss = 1;//diffuseColor.a;
                OUT.Specular = 1;//_Shininess;

                #ifdef EFFECT_BUMP
                    OUT.Normal = UnpackNormal(tex2D(_BumpMap, IN.mainTexUV));
                #endif
            }



            inline fixed4 UnityLambertLight2 (SurfaceOutput s, UnityLight light)
            {
                fixed diff = max (0, dot (s.Normal, light.dir));

                fixed4 c;
                c.rgb = s.Albedo * light.color * diff;
                c.a = s.Alpha;
                return c;
            }

            inline fixed4 LightingLambert2 (SurfaceOutput s, UnityGI gi)
            {
                fixed4 c;
                c = UnityLambertLight2 (s, gi.light);

                #if defined(DIRLIGHTMAP_SEPARATE)
                    #ifdef LIGHTMAP_ON
                        c += UnityLambertLight2 (s, gi.light2);
                    #endif
                    #ifdef DYNAMICLIGHTMAP_ON
                        c += UnityLambertLight2 (s, gi.light3);
                    #endif
                #endif

                #ifdef UNITY_LIGHT_FUNCTION_APPLY_INDIRECT
                    c.rgb += s.Albedo * gi.indirect.diffuse;
                #endif

                return c;
            }

            inline half4 LightingLambert2_Deferred (SurfaceOutput s, UnityGI gi, out half4 outDiffuseOcclusion, out half4 outSpecSmoothness, out half4 outNormal)
            {
                outDiffuseOcclusion = half4(s.Albedo, 1);
                outSpecSmoothness = 0.0;
                outNormal = half4(s.Normal * 0.5 + 0.5, 1);
                /*
                half4 emission = half4(s.Emission, 1);

                #ifdef UNITY_LIGHT_FUNCTION_APPLY_INDIRECT
                    emission.rgb += s.Albedo * gi.indirect.diffuse;
                #endif

                return emission;
                */
                return 0;
            }

            inline void LightingLambert2_GI (
                SurfaceOutput s,
                UnityGIInput data,
                inout UnityGI gi)
            {
                gi = UnityGlobalIllumination (data, 1.0, s.Normal);
            }

            inline fixed4 LightingLambert2_PrePass (SurfaceOutput s, half4 light)
            {
                fixed4 c;
                c.rgb = s.Albedo * light.rgb;
                c.a = s.Alpha;
                return c;
            }

            void surf(Input IN, inout SurfaceOutput OUT)
            {
                SpeedTreeFragOut o;
                SpeedTreeFrag(IN, o);
                SPEEDTREE_COPY_FRAG(OUT, o)
                //OUT.Albedo = 1;
                //OUT.Normal = o.Normal;
                //OUT.Emission = 0;
                //OUT.Gloss = 0;
                //OUT.Specular = 0;
                //OUT.Alpha = 0;
            }
        ENDCG

        Pass
        {
            Tags { "LightMode" = "ShadowCaster" }

            CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                #pragma target 3.0
                #pragma multi_compile __ LOD_FADE_PERCENTAGE LOD_FADE_CROSSFADE
                #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
                #pragma multi_compile_shadowcaster
                #define ENABLE_WIND
                #include "SpeedTreeCommon.cginc"

                struct v2f
                {
                    V2F_SHADOW_CASTER;
                    #ifdef SPEEDTREE_ALPHATEST
                        half2 uv : TEXCOORD1;
                    #endif
                    UNITY_DITHER_CROSSFADE_COORDS_IDX(2)
                };

                v2f vert(SpeedTreeVB v)
                {
                    v2f o;
                    #ifdef SPEEDTREE_ALPHATEST
                        o.uv = v.texcoord.xy;
                    #endif
                    OffsetSpeedTreeVertex(v, unity_LODFade.x);
                    TRANSFER_SHADOW_CASTER_NORMALOFFSET(o)
                    UNITY_TRANSFER_DITHER_CROSSFADE_HPOS(o, o.pos)

                    return o;
                }

                float4 frag(v2f i) : SV_Target
                {
                    #ifdef SPEEDTREE_ALPHATEST
                        clip(tex2D(_MainTex, i.uv).a * _Color.a - _Cutoff);
                    #endif
                    UNITY_APPLY_DITHER_CROSSFADE(i)
                    SHADOW_CASTER_FRAGMENT(i)
                }
            ENDCG
        }

        Pass
        {
            Tags { "LightMode" = "Vertex" }

            CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                #pragma target 3.0
                #pragma multi_compile_fog
                #pragma multi_compile __ LOD_FADE_PERCENTAGE LOD_FADE_CROSSFADE
                #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
                #pragma shader_feature EFFECT_HUE_VARIATION
                #define ENABLE_WIND
                #include "SpeedTreeCommon.cginc"

                struct v2f
                {
                    float4 vertex   : SV_POSITION;
                    UNITY_FOG_COORDS(0)
                    Input data      : TEXCOORD1;
                };

                v2f vert(SpeedTreeVB v)
                {
                    v2f o;
                    SpeedTreeVert(v, o.data);
                    o.data.color.rgb *= ShadeVertexLightsFull(v.vertex, v.normal, 4, true);
                    o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                    UNITY_TRANSFER_FOG(o,o.vertex);
                    return o;
                }

                fixed4 frag(v2f i) : SV_Target
                {
                    SpeedTreeFragOut o;
                    SpeedTreeFrag(i.data, o);
                    fixed4 c = fixed4(o.Albedo, o.Alpha);
                    UNITY_APPLY_FOG(i.fogCoord, c);
                    return c;
                }
            ENDCG
        }

    }

    // targeting SM2.0: Cross-fading, Normal-mapping, Hue variation and Wind animation are turned off for less instructions
    SubShader
    {
        Tags
        {
            "Queue"="Geometry"
            "IgnoreProjector"="True"
            "RenderType"="Opaque"
            "DisableBatching"="LODFading"
        }
        LOD 400
        Cull [_Cull]

        CGPROGRAM
            #pragma surface surf Lambert vertex:SpeedTreeVert nolightmap
            #pragma multi_compile __ LOD_FADE_PERCENTAGE
            #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
            #include "SpeedTreeCommon.cginc"

            void surf(Input IN, inout SurfaceOutput OUT)
            {
                SpeedTreeFragOut o;
                SpeedTreeFrag(IN, o);
                SPEEDTREE_COPY_FRAG(OUT, o)
            }
        ENDCG

        Pass
        {
            Tags { "LightMode" = "ShadowCaster" }

            CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                #pragma multi_compile __ LOD_FADE_PERCENTAGE
                #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
                #pragma multi_compile_shadowcaster
                #include "SpeedTreeCommon.cginc"

                struct v2f
                {
                    V2F_SHADOW_CASTER;
                    #ifdef SPEEDTREE_ALPHATEST
                        half2 uv : TEXCOORD1;
                    #endif
                };

                v2f vert(SpeedTreeVB v)
                {
                    v2f o;
                    #ifdef SPEEDTREE_ALPHATEST
                        o.uv = v.texcoord.xy;
                    #endif
                    OffsetSpeedTreeVertex(v, unity_LODFade.x);
                    TRANSFER_SHADOW_CASTER_NORMALOFFSET(o)
                    return o;
                }

                float4 frag(v2f i) : SV_Target
                {
                    #ifdef SPEEDTREE_ALPHATEST
                        clip(tex2D(_MainTex, i.uv).a * _Color.a - _Cutoff);
                    #endif
                    SHADOW_CASTER_FRAGMENT(i)
                }
            ENDCG
        }

        Pass
        {
            Tags { "LightMode" = "Vertex" }

            CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                #pragma multi_compile_fog
                #pragma multi_compile __ LOD_FADE_PERCENTAGE
                #pragma shader_feature GEOM_TYPE_BRANCH GEOM_TYPE_BRANCH_DETAIL GEOM_TYPE_FROND GEOM_TYPE_LEAF GEOM_TYPE_MESH
                #include "SpeedTreeCommon.cginc"

                struct v2f
                {
                    float4 vertex   : SV_POSITION;
                    UNITY_FOG_COORDS(0)
                    Input data      : TEXCOORD1;
                };

                v2f vert(SpeedTreeVB v)
                {
                    v2f o;
                    SpeedTreeVert(v, o.data);
                    o.data.color.rgb *= ShadeVertexLightsFull(v.vertex, v.normal, 2, false);
                    o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                    UNITY_TRANSFER_FOG(o,o.vertex);
                    return o;
                }

                fixed4 frag(v2f i) : SV_Target
                {
                    SpeedTreeFragOut o;
                    SpeedTreeFrag(i.data, o);
                    fixed4 c = fixed4(o.Albedo, o.Alpha);
                    UNITY_APPLY_FOG(i.fogCoord, c);
                    return c;
                }
            ENDCG
        }
    }

    FallBack "Transparent/Cutout/VertexLit"
    CustomEditor "SpeedTreeMaterialInspector"
}