Unity默认Standard Shader BRDF函数计算详解

//基于PBS的全局光照（gi变量）的计算函数。计算结果是gi的参数（Light参数和Indirect参数）。注意这一步还没有做真的光照计算。
LightingStandard_GI(o, giInput, gi);
fixed4 c = 0;
// realtime lighting: call lighting function
//PBS计算
c += LightingStandard(o, worldViewDir, gi);

inline half4 LightingStandard (SurfaceOutputStandard s, float3 viewDir, UnityGI gi)
{
    s.Normal = normalize(s.Normal);// 法线归一化
    half oneMinusReflectivity;// 漫反射系数（Albedo中参与漫反射的比例）
    half3 specColor;//反射（高光反射）
    s.Albedo = DiffuseAndSpecularFromMetallic (s.Albedo, s.Metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity);
    // shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
    // this is necessary to handle transparency in physically correct way - only diffuse component gets affected by alpha
    // 计算只影响Diffuse的alpha值
    half outputAlpha;
    s.Albedo = PreMultiplyAlpha (s.Albedo, s.Alpha, oneMinusReflectivity, /*out*/ outputAlpha);
    
    half4 c = UNITY_BRDF_PBS (s.Albedo, specColor, oneMinusReflectivity, s.Smoothness, s.Normal, viewDir, gi.light, gi.indirect);
    c.a = outputAlpha;
    return c;
}

inline half3 DiffuseAndSpecularFromMetallic (half3 albedo, half metallic, out half3 specColor, out half oneMinusReflectivity)
{
    //unity_ColorSpaceDielectricSpec是Unity内置的非金属specular颜色值fixed3(0.04,0.04,0.04)。线性和非线性空间定义有不同。
    //求反射值
    specColor = lerp (unity_ColorSpaceDielectricSpec.rgb, albedo, metallic);
    //求漫反射系数(lerp(0.96,0,metallic));
    oneMinusReflectivity = OneMinusReflectivityFromMetallic(metallic);
    //求漫反射值并且返回
    return albedo * oneMinusReflectivity;
}

//根据不同的情况，对Diffuse进行处理，并对alpha进行处理
inline half3 PreMultiplyAlpha (half3 diffColor, half alpha, half oneMinusReflectivity, out half outModifiedAlpha)
{
    #if defined(_ALPHAPREMULTIPLY_ON)//如果开启了AlphaBlend
        // NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
        // Transparency 'removes' from Diffuse component
        diffColor *= alpha;
        //这里准确说应该是Albedo（包含Diffuse和SpecColor，但因为透明物体都是非金属，所以基本是Diffuse）需要因为透明的原因，Diffuse减弱。
        #if (SHADER_TARGET < 30)//如果是低版本的平台
            // SM2.0: instruction count limitation
            // Instead will sacrifice part of physically based transparency where amount Reflectivity is affecting Transparency
            // SM2.0: uses unmodified alpha
            outModifiedAlpha = alpha;//则Alpha受平台限制不能处理。
        #else
            // Reflectivity 'removes' from the rest of components, including Transparency
            // outAlpha = 1-(1-alpha)*(1-reflectivity) = 1-(oneMinusReflectivity - alpha*oneMinusReflectivity) =
            //          = 1-oneMinusReflectivity + alpha*oneMinusReflectivity
            outModifiedAlpha = 1-oneMinusReflectivity + alpha*oneMinusReflectivity;
            //3.0以上平台，Alpha要处理一下。当为金属时，Alpha=1，非金属时，Alpha = Alpha；
        #endif
    #else
        outModifiedAlpha = alpha;
    #endif
    return diffColor;
}

//Unity提供三个质量级别级别的BRDF供选择，在quality菜单里可以设置，见右图
//质量从High到Low分别对应BRDF1到BRDF3
// Default BRDF to use:
#if !defined (UNITY_BRDF_PBS) // allow to explicitly override BRDF in custom shader//允许在自定义Shader内强制定义使用哪个BRDF
    // still add safe net for low shader models, otherwise we might end up with shaders failing to compile
    #if SHADER_TARGET < 30 || defined(SHADER_TARGET_SURFACE_ANALYSIS) // only need "something" for surface shader analysis pass; pick the cheap one
        #define UNITY_BRDF_PBS BRDF3_Unity_PBS//3.0以下平台直接使用最低级别PBS
    #elif defined(UNITY_PBS_USE_BRDF3)
        #define UNITY_BRDF_PBS BRDF3_Unity_PBS
    #elif defined(UNITY_PBS_USE_BRDF2)
        #define UNITY_BRDF_PBS BRDF2_Unity_PBS
    #elif defined(UNITY_PBS_USE_BRDF1)
        #define UNITY_BRDF_PBS BRDF1_Unity_PBS
    #else
        #error something broke in auto-choosing BRDF
        // 调试方法，假如走到这一条会在console里报error后的文字错误。
    #endif
#endif

half4 BRDF1_Unity_PBS (half3 diffColor, half3 specColor, half oneMinusReflectivity, 
half smoothness,float3 normal, float3 viewDir,UnityLight light, UnityIndirect gi)

float perceptualRoughness = SmoothnessToPerceptualRoughness (smoothness);
//=1-smoothness，光滑度转粗糙度。
float3 halfDir = Unity_SafeNormalize (float3(light.dir) + viewDir);
//求半角向量。Unity_SafeNormalize函数用于避免出现除零及负数的情况。

// 1、要避免dot(normal,viewDir)为负。但透视视角和法线贴图映射时有可能出现这种为负情况。
// 2、解决这个问题提供了两种方案。
//    1>把法线扭到偏向摄影机方向再做点积计算（准确但耗性能）
//    2>直接对点积取绝对值（不完全准确，但效果可接受，省性能）
#define UNITY_HANDLE_CORRECTLY_NEGATIVE_NDOTV 0//默认情况下走方法2，假如要走方法1需要注释此行
#if UNITY_HANDLE_CORRECTLY_NEGATIVE_NDOTV//方法1
    // The amount we shift the normal toward the view vector is defined by the dot product.
    half shiftAmount = dot(normal, viewDir);
    normal = shiftAmount < 0.0f ? normal + viewDir * (-shiftAmount + 1e-5f) : normal;
    // A re-normalization should be applied here but as the shift is small we don't do it to save ALU.
    //normal = normalize(normal);
    float nv = saturate(dot(normal, viewDir)); // TODO: this saturate should no be necessary here
#else//方法2，默认走此方法
    half nv = abs(dot(normal, viewDir));    // This abs allow to limit artifact
#endif

//剩余的点积计算 saturate限制非负范围。
float nl = saturate(dot(normal, light.dir));
float nh = saturate(dot(normal, halfDir));
half lv = saturate(dot(light.dir, viewDir));
half lh = saturate(dot(light.dir, halfDir));

diffColor * light.color * diffuseTerm

// HACK: theoretically we should divide diffuseTerm by Pi and not multiply specularTerm!
// BUT 1) that will make shader look significantly darker than Legacy ones
// and 2) on engine side "Non-important" lights have to be divided by Pi too in cases when they are injected into ambient SH
//在Unity中，因为和旧效果适配和非重要灯光的一些原因，所以在Diffuse层面没有根据迪士尼BRDF的Diffuse部分公式一样除以Pi；

//迪士尼的漫反射计算
// Note: Disney diffuse must be multiply by diffuseAlbedo / PI. This is done outside of this function.
//备注：baseColor/Pi的部分需要在方法外进行处理
half DisneyDiffuse(half NdotV, half NdotL, half LdotH, half perceptualRoughness)
{
    half fd90 = 0.5 + 2 * LdotH * LdotH * perceptualRoughness;//先计算F90
    // Two schlick fresnel term
    half lightScatter   = (1 + (fd90 - 1) * Pow5(1 - NdotL));//入射方向菲涅尔
    half viewScatter    = (1 + (fd90 - 1) * Pow5(1 - NdotV));//出射方向菲涅尔
    return lightScatter * viewScatter;
}
// Diffuse term//迪士尼BRDF漫反射系数计算
half diffuseTerm = DisneyDiffuse(nv, nl, lh, perceptualRoughness) * nl;

// Specular term
//获得1-smooth（即Roughness）的平方，即科学意义上的roughness
float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
#if UNITY_BRDF_GGX//默认会直接定义这个关键字
    // GGX with roughtness to 0 would mean no specular at all, using max(roughness, 0.002) here to match HDrenderloop roughtness remapping.
    roughness = max(roughness, 0.002);//限制roughness不为0（避免高光反射完全消失）。
    float V = SmithJointGGXVisibilityTerm (nl, nv, roughness);
    float D = GGXTerm (nh, roughness);
#else
    // Legacy//旧版本保留而已，不会被用到，除非注释掉UnityStandardConfig.cginc中关于UNITY_BRDF_GGX的定义
    half V = SmithBeckmannVisibilityTerm (nl, nv, roughness);
    half D = NDFBlinnPhongNormalizedTerm (nh, PerceptualRoughnessToSpecPower(perceptualRoughness));
#endif
float specularTerm = V*D * UNITY_PI; // Torrance-Sparrow model, Fresnel is applied later
//Cook-Torrance的反射部分。菲涅尔项后面再处理。因为Diffuse项没有除Pi，所以这里乘Pi以保证比例相等（配平）。
#   ifdef UNITY_COLORSPACE_GAMMA//Gamma空间需要开方的原理是？
specularTerm = sqrt(max(1e-4h, specularTerm));
#   endif
// specularTerm * nl can be NaN on Metal in some cases, use max() to make sure it's a sane value
specularTerm = max(0, specularTerm * nl);// 在渲染方程中，高光项最终要乘以dot（n,l）。使用max方法避免负数。
#if defined(_SPECULARHIGHLIGHTS_OFF)
    specularTerm = 0.0;// 材质面板中的specular Highlight开关
#endif
//渲染方程计算
fixed3 directSpecular = specularTerm * light.color * FresnelTerm (specColor, lh)；

// Specular term
//获得1-smooth（即Roughness）的平方，即科学意义上的roughness
float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
// GGX with roughtness to 0 would mean no specular at all, using max(roughness, 0.002) here to match HDrenderloop roughtness remapping.
roughness = max(roughness, 0.002);//限制roughness不为0（避免高光反射完全消失）。
float V = SmithJointGGXVisibilityTerm (nl, nv, roughness);
float D = GGXTerm (nh, roughness);
float specularTerm = V*D * UNITY_PI; // Torrance-Sparrow model, Fresnel is applied later
//Cook-Torrance的反射部分。菲涅尔项后面再处理。因为Diffuse项没有除Pi，所以这里乘Pi以保证比例相等（配平）。
// specularTerm * nl can be NaN on Metal in some cases, use max() to make sure it's a sane value
specularTerm = max(0, specularTerm * nl);// 在渲染方程中，高光项最终要乘以dot（n,l）。使用max方法避免负数。
#if defined(_SPECULARHIGHLIGHTS_OFF)
    specularTerm = 0.0;// 材质面板中的specular Highlight开关
#endif
//渲染方程计算
fixed3 directSpecular = specularTerm * light.color * FresnelTerm (specColor, lh)；

//法线分布函数计算
inline half GGXTerm (half NdotH, half roughness)
{
    half a2 = roughness * roughness;
    half d = (NdotH * a2 - NdotH) * NdotH + 1.0f; // 2 mad//2mad啥意思（很疯狂？）。。。
    //这里是分母括号内的项，为了优化做了一下变换，和公式略有不同
    return UNITY_INV_PI * a2 / (d * d + 1e-7f); 
    // This function is not intended to be running on Mobile,
    // therefore epsilon is smaller than what can be represented by half
    //直译：这个函数没有打算在移动端运行，所以（要让？）它的返回值精确度比half小。
    //最后的1e-7f是一个极小的小数，为了保证分母不为零。
    //UNITY_INV_PI即Unity自带的变量1/π。
}

//可见性项（包括几何函数和配平系数一起）的计算
// Ref: http://jcgt.org/published/0003/02/03/paper.pdf
inline half SmithJointGGXVisibilityTerm (half NdotL, half NdotV, half roughness)
{
    #if 0// 这部分默认关闭。
        // 备注，这里是 Frostbite的GGX-Smith Joint方案（精确，但是需要开方两次，很不经济）
        // 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);
        // Reorder code to be more optimal
        half a          = roughness;
        half a2         = a * a;
        half lambdaV    = NdotL * sqrt((-NdotV * a2 + NdotV) * NdotV + a2);
        half lambdaL    = NdotV * sqrt((-NdotL * a2 + NdotL) * NdotL + a2);
        // Simplify visibility term: (2.0f * NdotL * NdotV) /  ((4.0f * NdotL * NdotV) * (lambda_v + lambda_l + 1e-5f));
        return 0.5f / (lambdaV + lambdaL + 1e-5f);  // This function is not intended to be running on Mobile,
        // therefore epsilon is smaller than can be represented by half
    #else// 主要走这个部分
        // Approximation of the above formulation (simplify the sqrt, not mathematically correct but close enough)
        //这个部分是Respawn Entertainment的 GGX-Smith Joint近似方案
        half a = roughness;
        half lambdaV = NdotL * (NdotV * (1 - a) + a);
        half lambdaL = NdotV * (NdotL * (1 - a) + a);
        return 0.5f / (lambdaV + lambdaL + 1e-5f);
    #endif
}

//可见性项（包括几何函数和配平系数一起）的计算
inline half SmithJointGGXVisibilityTerm (half NdotL, half NdotV, half roughness)
{
        // Approximation of the above formulation (simplify the sqrt, not mathematically correct but close enough)
        //这个部分是Respawn Entertainment的 GGX-Smith Joint近似方案
        half a = roughness;
        half lambdaV = NdotL * (NdotV * (1 - a) + a);
        half lambdaL = NdotV * (NdotL * (1 - a) + a);
        return 0.5f / (lambdaV + lambdaL + 1e-5f);
}

//F菲涅尔项
inline half3 FresnelTerm (half3 F0, half cosA)
{
    half t = Pow5 (1 - cosA);   // ala Schlick interpoliation
    //公式中使用的是dot(v,h)。而Unity默认传入的是dot(l,h)
    //是因为BRDF大量的计算使用的是l,h的点积，而h是l和v的半角向量，所以lh和vh的夹角是一样的。不需要多来一个变量。
    return F0 + (1-F0) * t;
}

 directSpecular = specularTerm * light.color * FresnelTerm (specColor, lh)

half3 IBLDiffuse = diffColor*gi.diffuse

half3 IBLSpecular = surfaceReduction * gi.specular * FresnelLerp (specColor, grazingTerm, nv);

// surfaceReduction = Int D(NdotH) * NdotH * Id(NdotL>0) dH = 1/(roughness^2+1)
half surfaceReduction;
//可能是经过观测，在物体的粗糙度越来越强时，反射会相对减弱，所以在这里假如一个根据粗糙度减弱反射的变量。
//（roughness = 1，reflect = 0.5）
//因为roughnes是通过smoothness贴图采样得到，所以分线性和非线性进行不同的处理。
#   ifdef UNITY_COLORSPACE_GAMMA
surfaceReduction = 1.0-0.28*roughness*perceptualRoughness;     
 // 1-0.28*x^3 as approximation for (1/(x^4+1))^(1/2.2) on the domain [0;1]
#   else
surfaceReduction = 1.0 / (roughness*roughness + 1.0);           
// fade in [0.5;1]
#   endif

half grazingTerm = saturate(smoothness + (1-oneMinusReflectivity));

inline half3 FresnelLerp (half3 F0, half3 F90, half cosA)
{
    half t = Pow5 (1 - cosA);   // ala Schlick interpoliation
    return lerp (F0, F90, t);
}