URP的BRDF计算的疑惑，与论文中的公式不一样？

note · 我的 UWA 问答 本文收录我在 UWA 问答发表的公开回答。问题内容归原提问者；回答保留当时语境，技术结论可能受 Unity 版本、平台和项目条件限制。

问题

最近在看URP shader的时候发现个问题，不知道是不是我理解的不对

首先贴代码

先是URP的Lighting.hlsl里初始化BRDF的部分

inline void InitializeBRDFData(half3 albedo, half metallic, half3 specular, half smoothness, half alpha, out BRDFData outBRDFData)

{

#ifdef _SPECULAR_SETUP

    half reflectivity = ReflectivitySpecular(specular);

    half oneMinusReflectivity = 1.0 - reflectivity;

    outBRDFData.diffuse = albedo * (half3(1.0h, 1.0h, 1.0h) - specular);

    outBRDFData.specular = specular;

#else

    half oneMinusReflectivity = OneMinusReflectivityMetallic(metallic);

    half reflectivity = 1.0 - oneMinusReflectivity;

    outBRDFData.diffuse = albedo * oneMinusReflectivity;

    outBRDFData.specular = lerp(kDieletricSpec.rgb, albedo, metallic);

#endif

    outBRDFData.grazingTerm = saturate(smoothness + reflectivity);

    outBRDFData.perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(smoothness);

    outBRDFData.roughness = max(PerceptualRoughnessToRoughness(outBRDFData.perceptualRoughness), HALF_MIN);

    outBRDFData.roughness2 = outBRDFData.roughness * outBRDFData.roughness;

    outBRDFData.normalizationTerm = outBRDFData.roughness * 4.0h + 2.0h;

    outBRDFData.roughness2MinusOne = outBRDFData.roughness2 - 1.0h;

#ifdef _ALPHAPREMULTIPLY_ON

    outBRDFData.diffuse *= alpha;

    alpha = alpha * oneMinusReflectivity + reflectivity;

#endif

}

按照我的理解

outBRDFData.perceptualRoughness 是我们说的粗糙度

outBRDFData.roughness 是粗糙度的平方

outBRDFData.roughness2 是粗糙度的4次方

再看URP的Lighting.hlsl里计算BRDF的部分

// Based on Minimalist CookTorrance BRDF

// Implementation is slightly different from original derivation: http://www.thetenthplanet.de/archives/255

//

// * NDF [Modified] GGX

// * Modified Kelemen and Szirmay-Kalos for Visibility term

// * Fresnel approximated with 1/LdotH

half3 DirectBDRF(BRDFData brdfData, half3 normalWS, half3 lightDirectionWS, half3 viewDirectionWS)

{

#ifndef _SPECULARHIGHLIGHTS_OFF

    float3 halfDir = SafeNormalize(float3(lightDirectionWS) + float3(viewDirectionWS));

    float NoH = saturate(dot(normalWS, halfDir));

    half LoH = saturate(dot(lightDirectionWS, halfDir));

    // GGX Distribution multiplied by combined approximation of Visibility and Fresnel

    // BRDFspec = (D * V * F) / 4.0

    // D = roughness^2 / ( NoH^2 * (roughness^2 - 1) + 1 )^2

    // V * F = 1.0 / ( LoH^2 * (roughness + 0.5) )

    // See "Optimizing PBR for Mobile" from Siggraph 2015 moving mobile graphics course

    // https://community.arm.com/events/1155

    // Final BRDFspec = roughness^2 / ( NoH^2 * (roughness^2 - 1) + 1 )^2 * (LoH^2 * (roughness + 0.5) * 4.0)

    // We further optimize a few light invariant terms

    // brdfData.normalizationTerm = (roughness + 0.5) * 4.0 rewritten as roughness * 4.0 + 2.0 to a fit a MAD.

    float d = NoH * NoH * brdfData.roughness2MinusOne + 1.00001f;

    half LoH2 = LoH * LoH;

    half specularTerm = brdfData.roughness2 / ((d * d) * max(0.1h, LoH2) * brdfData.normalizationTerm);

    // On platforms where half actually means something, the denominator has a risk of overflow

    // clamp below was added specifically to "fix" that, but dx compiler (we convert bytecode to metal/gles)

    // sees that specularTerm have only non-negative terms, so it skips max(0,..) in clamp (leaving only min(100,...))

#if defined (SHADER_API_MOBILE) || defined (SHADER_API_SWITCH)

    specularTerm = specularTerm - HALF_MIN;

    specularTerm = clamp(specularTerm, 0.0, 100.0); // Prevent FP16 overflow on mobiles

#endif

    half3 color = specularTerm * brdfData.specular + brdfData.diffuse;

    return color;

#else

    return brdfData.diffuse;

#endif

}

这里最终的公式是BRDFspec = roughness2 / ( NoH2 *(roughness**2 - 1) + 1 )*2 (LoH^2 (roughness + 0.5) 4.0)

然后看unity 2015年的论文，也就是代码里写的那个地址https://community.arm.com/events/1155