Main Shader - July 2013

Shader "Base_Texture"
{
    Properties
    {
        _DiffuseAmount ( "Diffuse Amount", Range( 0.0, 1.0 ) ) = 0.25
        _Roughness ( "Diffuse Roughness", Range( 0.0, 1.0 ) ) = 1.0
        _TexAmount ( "Texture Amount", Range( 0.0, 1.0 ) ) = 0.25
        _SpecAmount ( "Specular Amount", Range( 0.0, 16.0 ) ) = 1.0
        _SpecTexAmount ( "Spec Texture Amount", Range( 0.0, 1.0 ) ) = 0.25
        //_MainMap ( "Main Texture", 2D ) = "main" {}
        _Normalmap ( "Normalmap", 2D ) = "normal" {}
        _Specmap ( "Specmap", 2D ) = "spec" {}

        _FresnelPower ( "Fresnel Power", Range( 0.0, 4.0 ) ) = 1.0
        _FresnelPrimarySecondary ( "Primary/Secondary Fresnel Degree", Range( 0.0, 1.0 ) ) = 1.0
        //_FresnelTertiary ( "Fresnel Tertiary Infusion", Range( 0.0, 0.25 ) ) = 0.25
        _FresnelBalance ( "Fresnel Balance", Range( 0.0, 1.0 ) ) = 0.25

        _FresnelEmitColor ( "Fresnel Emit Color", Color ) = ( 0.89, 0.945, 1.0, 0.0 )
        _FresnelEmitPrimarySecondary ( "Primary/Secondary Emit Fresnel Degree", Range( 0.0, 1.0 ) ) = 1.0
        _FresnelEmitPower ( "Fresnel Emit Power", Range( 0.0, 16.0 ) ) = 8.0

        _PrimarySecondary ( "Primary/Secondary Degree", Range( 0.0, 1.0 ) ) = 1.0
        //_Tertiary ( "Tertiary Infusion", Range( 0.0, 0.25 ) ) = 0.25
        _Gloss ( "Gloss", Range( 0.0, 2.0 ) ) = 1.0
    }

    SubShader
    {
        Tags
        {
          "Queue"="Geometry+0"
          "IgnoreProjector"="False"
          "RenderType"="Opaque"
        }

        Cull Back
        ZWrite On
        ZTest LEqual

        CGPROGRAM
        #pragma target 3.0
        #pragma surface surf SimpleSpecular novertexlights fullforwardshadows
        //fullforwardshadows approxview dualforward

        float _Gloss;
        float _PrimarySecondary;
        fixed _SpecAmount;
        float _Roughness;

        float CalculateGauss( float angleNormalHalf, float blob )
        {
            float exponent = angleNormalHalf / blob;
            exponent = -( exponent * exponent );
            return exp( exponent );
        }

        float CalculateSpecular( fixed3 lDir, fixed3 vDir, fixed3 norm, float lightSize, float gloss )
        {
            fixed n_dot_l = saturate( dot( norm, lDir ) );
            float3 halfVector = normalize( lDir + vDir );
            float specDot = saturate( dot( halfVector, norm ) );
            float angleNormalHalf = acos( dot( halfVector, norm ) );

            float fresnel = pow( 1.0 - dot( halfVector, vDir ), 5.0 );
            fresnel = 0.75 + ( 1.0 - fresnel ) * fresnel;

            // Gaussian Microfacet Approximation
            float modGloss = gloss + lightSize * _WorldSpaceLightPos0.w;
            float normalisation_term = ( modGloss + 2.0f ) / 8.0f;

            float primaryBlob = CalculateGauss( angleNormalHalf, 1.0 / ( modGloss * 8.0 ) );
            float secondaryBlob = CalculateGauss( angleNormalHalf, 1.0 / ( modGloss * 4.0 ) );

            float tripleSpec = lerp( primaryBlob, secondaryBlob, _PrimarySecondary );

            return fresnel * normalisation_term * tripleSpec * n_dot_l;
        }

        float CalculateDiffuse( fixed3 lDir, fixed3 vDir, fixed3 norm )
        {
            float VdotN = dot( vDir, norm );
            float LdotN = dot( lDir, norm );

            float AngleViewNormal = acos( VdotN );
            float AngleLightNormal = acos( LdotN );
            float AngleDifference = saturate( dot( normalize( vDir - norm * VdotN ), normalize( lDir - norm * LdotN ) ) );

            float Alpha = max( AngleViewNormal, AngleLightNormal );
            float Beta = min( AngleViewNormal, AngleLightNormal );

            float A = 1.0f - ( 0.5f * _Roughness ) / ( _Roughness + 0.33f );
            float B = ( 0.45f * _Roughness ) / ( _Roughness + 0.09f );

            float OrenNayar = ( A + B * AngleDifference * sin( Alpha ) * tan( Beta ) ) * saturate( LdotN );
            return OrenNayar;
        }

        float _FresnelBalance;

        fixed4 LightingSimpleSpecular( SurfaceOutput s, fixed3 lightDir, fixed3 viewDir, fixed atten )
        {
            float lightDistance = ( 1.0 - pow( atten, _LightColor0.w ) ); //length( _WorldSpaceLightPos0.rgb - s.Albedo ) * _WorldSpaceLightPos0.w;
            fixed spec = CalculateSpecular( lightDir, viewDir, s.Normal, lightDistance, s.Gloss - lerp( s.Specular, 0.0, _FresnelBalance ) ) * _SpecAmount * lerp( s.Specular, 1.0, _FresnelBalance );
            fixed diff = CalculateDiffuse( lightDir, viewDir, s.Normal ) * s.Albedo;

            diff = lerp( diff, 0.0, spec );

            fixed4 c;
            c.rgb = diff * _LightColor0.rgb;
            c.rgb += _LightColor0.rgb * spec;
            c.rgb *= atten;
            c.a = s.Alpha;

            return c;
        }

        fixed4 LightingSimpleSpecular_DirLightmap( SurfaceOutput s, fixed4 color, fixed4 scale, fixed3 viewDir, bool surfFuncWritesNormal, out fixed3 specColor )
        {
            UNITY_DIRBASIS
            half3 scalePerBasisVector;

            half3 lm = DirLightmapDiffuse( unity_DirBasis, color, scale, s.Normal, surfFuncWritesNormal, scalePerBasisVector );
            half3 lightDir = normalize( scalePerBasisVector.x * unity_DirBasis[0] + scalePerBasisVector.y * unity_DirBasis[1] + scalePerBasisVector.z * unity_DirBasis[2 ]);

            specColor = lm * CalculateSpecular( lightDir, viewDir, s.Normal, 1.0f, s.Gloss - lerp( s.Specular, 0.0, _FresnelBalance ) ) * _SpecAmount * lerp( s.Specular, 1.0, _FresnelBalance );

            return half4( lm * 0.5, 1.0 );
        }

        struct Input
        {
            //float2 uv_MainMap;
            float2 uv_Normalmap;
            float2 uv_Specmap;
            float3 viewDir;
        };

        //sampler2D _MainMap;
        sampler2D _Normalmap;
        sampler2D _Specmap;

        fixed _SpecTexAmount;
        fixed _TexAmount;
        fixed _DiffuseAmount;

        float _FresnelPower;
        float _FresnelPrimarySecondary;
        float4 _FresnelEmitColor;
        float _FresnelEmitPower;
        float _FresnelEmitPrimarySecondary;

        void surf( Input IN, inout SurfaceOutput o )
        {
            o.Normal = UnpackNormal( tex2D( _Normalmap, IN.uv_Normalmap ) );

            float fresnelDot = saturate( 1.0 - dot( normalize( IN.viewDir ), o.Normal ) );
            float fresnelPrimaryBlob = pow( fresnelDot, _FresnelPower * 2.0 );
            float fresnelSecondaryBlob = pow( fresnelDot, _FresnelPower );
            float fresnel = lerp( fresnelPrimaryBlob, fresnelSecondaryBlob, _FresnelPrimarySecondary );
            //fresnel *= ( _FresnelPower + 2.0f ) / 4.0f;

            float emitPrimaryBlob = pow( fresnelDot, _FresnelEmitPower * 2.0 );
            float emitSecondaryBlob = pow( fresnelDot, _FresnelEmitPower );
            float emitFresnel = lerp( emitPrimaryBlob, emitSecondaryBlob, _FresnelEmitPrimarySecondary );
            o.Emission = emitFresnel * _FresnelEmitColor.rgb * ( _FresnelEmitColor.a * 16.0f );

            float spec = tex2D( _Specmap, IN.uv_Specmap ).r;
            o.Gloss = lerp( spec, 1.0, _SpecTexAmount ) * _Gloss;
            o.Specular = fresnel;
            o.Albedo = _DiffuseAmount * lerp( spec, 1.0, _TexAmount ) ;
        }

        ENDCG
    }

    Fallback "Diffuse"
}