Shader "PBR/CustomPBR"
{
    Properties
    {
        _Color ("Color", Color) = (1, 1, 1, 1)
        _MainTex ("Texture", 2D) = "white" {}
        _Glossiness ("Smoothness", Range(0.0, 1.0)) = 0.5
        _SpecularColor ("Specular", Color) = (0.2, 0.2, 0.2)
        _SpecGlossMap ("Specular (RGB) Smoothness (A)", 2D) = "white" {}
        _BumpScale ("Bump Scale", Float) = 1.0
        _BumpMap ("Normal Map", 2D) = "bump" {}
        _EmissionColor ("Color", Color) = (0, 0, 0)
        _EmissionMap ("Emission", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        
        Pass
        {
            Tags{"LightMode" = "ForwardBase"}
            
            CGPROGRAM
            #pragma target 3.0
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fwdbase
            #pragma multi_compile_fog

            #include "UnityCG.cginc"
            #include "AutoLight.cginc"
            #include "Lighting.cginc"
            
            float4 _Color;
            float4 _SpecularColor;
            float4 _EmissionColor;
            sampler2D _MainTex; float4 _MainTex_ST;
            sampler2D _SpecGlossMap; float _SpecGlossMap_ST;
            sampler2D _BumpMap; float _BumpMap_ST;
            sampler2D _EmissionMap; float _EmissionMap_ST;
            float _Glossiness;
            float _BumpScale;
            
            
            struct a2v
            {
                float4 vertex:POSITION;
                float4 texcoord:TEXCOORD0;
                float3 normal: NORMAL;
                float4 tangent:TANGENT;
                
            };
            
            struct v2f
            {
                float4 pos : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 TtoW0 : TEXCOORD1;
                float4 TtoW1 : TEXCOORD2;
                float4 TtoW2 : TEXCOORD3; 
                SHADOW_COORDS(4)
                UNITY_FOG_COORDS(5) // Defined in UnityCG.cginc
            };


            v2f vert (a2v v)
            {
                v2f o;
                UNITY_INITIALIZE_OUTPUT(v2f,o); // Defined in HLSLSupport.cginc
                o.pos = UnityObjectToClipPos(v.vertex); // Defined in UnityCG.cginc
                o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);// Defined in UnityCG.cginc
                
                // Calculate the world vertex position
                float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                // Calculate the world normal position
                fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);
                // Calculate the world tangent position
                fixed3 worldTangent = UnityObjectToWorldDir(v.tangent.xyz);
                // Calculate the world Binormal position
                fixed3 worldBinormal = cross(worldNormal,worldTangent) * v.tangent.w;
                
                o.TtoW0 = float4(worldTangent.x,worldBinormal.x,worldNormal.x,worldPos.x);
                o.TtoW1 = float4(worldTangent.y,worldBinormal.y,worldNormal.y,worldPos.y);
                o.TtoW2 = float4(worldTangent.z,worldBinormal.z,worldNormal.z,worldPos.z);
                
                TRANSFER_SHADOW(o); // Defined in AutoLight.cginc
                UNITY_TRANSFER_FOG(o,o.vertex);
                return o;
            }
            
             inline half3 CustomDisneyDiffuseTerm(half NdotV, half NdotL, half LdotH, half roughness, half3 baseColor)
            {
                half fd90 = 0.5 + 2 * LdotH * LdotH * roughness;
                
                // two fresnel term
                half lightScatter = (1 + (fd90 - 1) * pow(1 - NdotL, 5));
                half viewScatter = (1 + (fd90 - 1) * pow(1 - NdotV, 5));
                
                // UNITY_INV_PI defined at UnityCG.cginc 
                return baseColor * UNITY_INV_PI * lightScatter * viewScatter;
            }
            
            inline half CustomSmithJointGGXVisibilityTerm(half NdotL, half NdotV, half roughness)
            {
                half a2 = roughness * roughness;
                
                // Original Formulation
                // lambda_v = (-1 + sqrt(a2*(1-NdotL2)/NdotL2+1))*0.5f;
                // lambda_l = (-1 + sqrt(a2*(1-NdotV2)/NdotV2+1))*0.5f;
                // G = 1/(1+lambda_v+lambda_l);
                
                // Approximation of the above formulation 
                // (simplify the sqrt, not mathematically correct but close enough)
                
                half lambdaV = NdotL * (NdotV * (1 - a2) + a2);
                half lambdaL = NdotV * (NdotL * (1 - a2) + a2);
                
                return 0.5f / (lambdaL + lambdaV - 1e-5f);
            }
            
            inline half CustomGGXTerm(half NdotH, half roughness)
            {
                half a2 = roughness*roughness;
                half d = (NdotH*a2-NdotH)*NdotH+1.0f;
                return UNITY_INV_PI * a2 / (d*d + 1e-7f);
            }
            
            inline half3 CustomFresnelTerm(half3 c, half cosA)
            {
                half t = pow(1-cosA,5);
                return c+(1-c)*t;
            }
            
            inline half3 CustomFresnelLerp(half3 c0,half3 c1, half cosA)
            {
                half t = pow(1-cosA,5);
                return lerp(c0, c1, t);
            }
            
            

            fixed4 frag (v2f i) : SV_Target
            {
               /* =========== Prepare all the inputs ========== */
               half4 specGloss = tex2D(_SpecGlossMap,i.uv);
               specGloss.a *= _Glossiness;
               half3 specColor = specGloss.rgb * _SpecularColor.rgb;
               half roughness = 1-specGloss.a;
               
               // 计算了入射角的余角的反射颜色,从而得到更好的菲涅尔(Fresnel)反射效果.
               half oneMinusReflectivity = 1-max(max(specColor.r,specColor.g),specColor.b);
               
               half3 diffColor = _Color.rgb * tex2D(_MainTex,i.uv).rgb * oneMinusReflectivity;
               
               fixed4 packedNormal = tex2D(_BumpMap,i.uv);
               // UnpackNormal(packedNormal) = packedNormal.xy*2-1 
               half3 normalTangent =UnpackNormal(packedNormal);
               normalTangent.xy *= _BumpScale;
               normalTangent.z = sqrt(1-saturate(dot(normalTangent.xy,normalTangent.xy)));
               
               // Convert normal from tangent space to worldSpace
               half3 normalWorld = normalize(half3(dot(i.TtoW0.xyz,normalTangent),
                                dot(i.TtoW1,normalTangent),dot(i.TtoW2,normalTangent)));
               
               // TtoW's w component stored the world vertex position
               float3 worldPos = float3(i.TtoW0.w,i.TtoW1.w,i.TtoW2.w);
               
               half3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));// Defined in UnityCG.cginc
               
               half3 viewDir = normalize(UnityWorldSpaceViewDir(worldPos));// Defined in UnityCG.cginc
               
               half3 reflDir = reflect(-viewDir,normalWorld);
               
               UNITY_LIGHT_ATTENUATION(atten, i, worldPos); // Defined in AutoLight.cginc
               
               /* =========== Compute BRDF terms ========== */
               half3 halfDir = normalize(lightDir+viewDir);
               // saturate to avoid backlight illumination
               half nv = saturate(dot(normalWorld,viewDir));
               half nl = saturate(dot(normalWorld,lightDir));
               half nh = saturate(dot(normalWorld, halfDir));
               half lv = saturate(dot(lightDir,viewDir));
               half lh = saturate(dot(lightDir, halfDir));
               
               // Diffuse term
               half3 diffuseTerm = CustomDisneyDiffuseTerm(nv,nl,lh,roughness,diffColor); 
               
               // Specular Term
               // 可见项 V, 它计算的是阴影-遮掩函数除以高光反射项的分母部分后的结果 
               half V = CustomSmithJointGGXVisibilityTerm(nl,nv,roughness);
               half D = CustomGGXTerm(nh,roughness*roughness);
               half3 F = CustomFresnelTerm(specColor,lh);
               half3 specularTerm = F * V * D;
               
               // Emission Term
               half3 emissionTerm = tex2D(_EmissionMap,i.uv).rgb * _EmissionColor.rgb;
               
               // IBL (Calculate the lighting based on the image for more realistic lighting )
               // IBL 部分的主要思想是使用材质粗糙度对环境贴图进行LOD采样,
               // 因为粗糙度越大的材质,反射的环境光照应该越模糊, 而这可以通过mipmaps进行采样来模拟得到.
               half perceptualRoughness = roughness * (1.7 - 0.7 * roughness);
               half mip = perceptualRoughness * 6;
               
               half4 envMap = UNITY_SAMPLE_TEXCUBE_LOD(unity_SpecCube0, reflDir, mip);// Defined in HLSLSupport.cginc
               half grazingTerm = saturate((1 - roughness) + (1 - oneMinusReflectivity));
               half surfaceReduction = 1.0 / (roughness*roughness + 1.0);
               half3 indirectSpecular = surfaceReduction * envMap.rgb * CustomFresnelLerp(specColor, grazingTerm, nv);
               
               // Combine All Together
               half3 col = emissionTerm + UNITY_PI*(diffuseTerm + specularTerm) * _LightColor0.rgb * nl * atten + indirectSpecular;
               
               
               UNITY_APPLY_FOG(i.fogCoord, c.rgb); // Defined in UnityCG.cginc
               return half4(col,1);              
            } 
            ENDCG
        }
    }
}