[PBS真的可以为所欲为] Unreal材质模型源码分析

本文主要是介绍[PBS真的可以为所欲为] Unreal材质模型源码分析，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

http://blog.sina.com.cn/s/blog_76d02ce90102xr4x.html

unreal应该算是现在最实用的开源渲染引擎之一了

基于物理的渲染（PBS）用起来真的是为所欲为

这里决定花点时间研究下unreal低层的渲染代码，这里假设读者具有基本的渲染知识，至少知道BRDF是什么

引擎中的着色器代码都在Engine/Shaders中，不同版本之间会有些差别，不过不会差太多就是了

这里使用的版本是4.17

打开Engine/Shaders/Private文件夹，可以看见大量的.usf和.ush文件，这些就是unreal渲染的核心

两者的语法都类似GLSL或HLSL，区别是ush没有入口函数，只能被其他ush或usf来引用，而usf有入口函数，不可被应用。

整个Engine/Shaders/Private中有近300个文件，一行一行解释显然不现实，这篇决定优先分析引擎中material的源码

这部分源码主要在ShadingModels.ush中，会引用其他的BRDF.ush，下面来慢慢分析

首先是下面两个函数：

NormalText Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

// @param DiffSpecMask .r: diffuse, .g:specular e.g. float2(1,1) for both, float2(1,0) for diffuse only
float3 SurfaceShading( FGBufferData GBuffer, float3 LobeRoughness, float3 LobeEnergy, float3 L, float3 V, half3 N, uint2 Random )
{
switch( GBuffer.ShadingModelID )
{
case SHADINGMODELID_UNLIT:
case SHADINGMODELID_DEFAULT_LIT:
case SHADINGMODELID_SUBSURFACE:
case SHADINGMODELID_PREINTEGRATED_SKIN:
case SHADINGMODELID_SUBSURFACE_PROFILE:
case SHADINGMODELID_TWOSIDED_FOLIAGE:
return StandardShading( GBuffer.DiffuseColor, GBuffer.SpecularColor, LobeRoughness, LobeEnergy, L, V, N );
case SHADINGMODELID_CLEAR_COAT:
return ClearCoatShading( GBuffer, LobeRoughness, LobeEnergy, L, V, N );
case SHADINGMODELID_CLOTH:
return ClothShading( GBuffer, LobeRoughness, LobeEnergy, L, V, N );
case SHADINGMODELID_EYE:
return EyeShading( GBuffer, LobeRoughness, LobeEnergy, L, V, N );
default:
return 0;
}
}

float3 SubsurfaceShading( FGBufferData GBuffer, float3 L, float3 V, half3 N, float Shadow, uint2 Random )
{
float3 SubsurfaceColor = ExtractSubsurfaceColor(GBuffer);

switch( GBuffer.ShadingModelID )
{
case SHADINGMODELID_SUBSURFACE:
return SubsurfaceShadingSubsurf ace( GBuffer, L, V, N );
case SHADINGMODELID_PREINTEGRATED_SKIN:
return SubsurfaceShadingPreinte gratedSkin( GBuffer, L, V, N );
case SHADINGMODELID_TWOSIDED_FOLIAGE:
return SubsurfaceShadingTwoSide d( SubsurfaceColor, L, V, N );
case SHADINGMODELID_HAIR:
return HairShading( GBuffer, L, V, N, Shadow, 1, 0, Random );
case SHADINGMODELID_EYE:
return EyeSubsurfaceShading( GBuffer, L, V, N );
default:
return 0;
}
}

与引擎中的shading model完全一致

从函数中的switch中不难看出用途，这两个函数就定义了不同shading model使用的基础算法和subsurface算法

这两个函数在DeferredLightngCommon.ush中被调用，比如下面

NormalText Code

1
2

float3 Shading = SurfaceShading( GBuffer, LobeRoughness, 1, L, V, N, Random ) * NoL;
Shading += SubsurfaceShading( GBuffer, L, V, N, 1, Random );

就是直接把结果线性相加....

SurfaceShading

先看SurfaceShading函数，这个函数表示了material除了subsurface之外的全部内容，可以看出，除了Clear Coat，Cloth , Eye有自己独有的着色算法以外，其他的shading model都用的共通的StandardShading，那么就来看看StandardShading里是什么吧

NormalText Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

float3 StandardShading( float3 DiffuseColor, float3 SpecularColor, float3 LobeRoughness, float3 LobeEnergy, float3 L, float3 V, half3 N )
{
float NoL = dot(N, L);
float NoV = dot(N, V);
float LoV = dot(L, V);
float InvLenH = rsqrt( 2 + 2 * LoV );
float NoH = saturate( ( NoL + NoV ) * InvLenH );
float VoH = saturate( InvLenH + InvLenH * LoV );
NoL = saturate(NoL);
NoV = saturate(abs(NoV) + 1e-5);

// Generalized microfacet specular
float D = D_GGX( LobeRoughness[1], NoH ) * LobeEnergy[1];
float Vis = Vis_SmithJointApprox( LobeRoughness[1], NoV, NoL );
float3 F = F_Schlick( SpecularColor, VoH );

float3 Diffuse = Diffuse_Lambert( DiffuseColor );
//float3 Diffuse = Diffuse_Burley( DiffuseColor, LobeRoughness[1], NoV, NoL, VoH );
//float3 Diffuse = Diffuse_OrenNayar( DiffuseColor, LobeRoughness[1], NoV, NoL, VoH );

return Diffuse * LobeEnergy[2] + (D * Vis) * F;
}

基本遵循了epic在siggraph2013上发表的paper[1]上的算法

其中D是D_GGX，G是Vis_SmithJointApprox，F是F_Schlick。具体代码在BRDF.ush中都有。

再加上Lambert的diffuse构成了基础的shading。

Clear Coat比较复杂，有空可能会单独写一篇

Cloth其实是定义了两种不同的BRDF，在这两者间作插值

NormalText Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

float3 ClothShading( FGBufferData GBuffer, float3 LobeRoughness, float3 LobeEnergy, float3 L, float3 V, half3 N )
{
const float3 FuzzColor = saturate(GBuffer.CustomData.rgb);
const float Cloth = saturate(GBuffer.CustomData.a);

float NoL = dot(N, L);
float NoV = dot(N, V);
float LoV = dot(L, V);
float InvLenH = rsqrt( 2 + 2 * LoV );
float NoH = saturate( ( NoL + NoV ) * InvLenH );
float VoH = saturate( InvLenH + InvLenH * LoV );
NoL = saturate(NoL);
NoV = saturate(abs(NoV) + 1e-5);

// Diffuse
float3 Diffuse = Diffuse_Lambert( GBuffer.DiffuseColor );
float3 Diff = Diffuse * LobeEnergy[2];

// Cloth - Asperity Scattering - Inverse Beckmann Layer
float3 F1 = F_Schlick( FuzzColor, VoH );
float D1 = D_InvGGX( LobeRoughness[1], NoH );
float V1 = Vis_Cloth( NoV, NoL );

float3 Spec1 = D1 * V1 * F1;

// Generalized microfacet specular
float3 F2 = F_Schlick( GBuffer.SpecularColor, VoH );
float D2 = D_GGX( LobeRoughness[1], NoH ) * LobeEnergy[1];
float V2 = Vis_SmithJointApprox( LobeRoughness[1], NoV, NoL );

float3 Spec2 = D2 * V2 * F2;

float3 Spec = lerp(Spec2, Spec1, Cloth);

return Diff + Spec;
}

Spec2和standShading的高光部分一样，Spec1的D和G则略有不同，用GBuffer中的custom.a做插值，得到最终的输出（Diffuse还是Lambert)

Eye的部分更加简单，就是StandShading去掉Diffuse的部分

NormalText Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

float3 EyeShading( FGBufferData GBuffer, float3 LobeRoughness, float3 LobeEnergy, float3 L, float3 V, half3 N )
{
float NoL = dot(N, L);
float NoV = dot(N, V);
float LoV = dot(L, V);
float InvLenH = rsqrt( 2 + 2 * LoV );
float NoH = saturate( ( NoL + NoV ) * InvLenH );
float VoH = saturate( InvLenH + InvLenH * LoV );
NoL = saturate(NoL);
NoV = saturate(abs(NoV) + 1e-5);

// Generalized microfacet specular
float D = D_GGX( LobeRoughness[1], NoH ) * LobeEnergy[1];
float Vis = Vis_SmithJointApprox( LobeRoughness[1], NoV, NoL );
float3 F = F_Schlick( GBuffer.SpecularColor, VoH );

return D * Vis * F;
}

不过要注意，NoH和VoH的计算方法和StandShading是不同的。

SubsurfaceShading

说完了surfaceShading，下面就来说Subsurface的部分。

首先是最普通的SubsurfaceShading:

NormalText Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

float3 SubsurfaceShadingSubsurf ace( FGBufferData GBuffer, float3 L, float3 V, half3 N )
{
float3 SubsurfaceColor = ExtractSubsurfaceColor(GBuffer);
float Opacity = GBuffer.CustomData.a;

float3 H = normalize(V + L);

// to get an effect when you see through the material
// hard coded pow constant
float InScatter = pow(saturate(dot(L, -V)), 12) * lerp(3, .1f, Opacity);
// wrap around lighting, /(PI*2) to be energy consistent (hack do get some view dependnt and light dependent effect)
// Opacity of 0 gives no normal dependent lighting, Opacity of 1 gives strong normal contribution
float NormalContribution = saturate(dot(N, H) * Opacity + 1 - Opacity);
float BackScatter = GBuffer.GBufferAO * NormalContribution / (PI * 2);

// lerp to never exceed 1 (energy conserving)
return SubsurfaceColor * lerp(BackScatter, 1, InScatter);
}

观察NormalContribution项，显然Opacity=1时，NormalContribution=dot(N,H)。也就是说次表面的深度受到法线和半角的点积影响。

然后是皮肤的次表面

NormalText Code

1
2
3
4
5
6
7
8

float3 SubsurfaceShadingPreinte gratedSkin( FGBufferData GBuffer, float3 L, float3 V, half3 N )
{
float3 SubsurfaceColor = ExtractSubsurfaceColor(GBuffer);
float Opacity = GBuffer.CustomData.a;

float3 PreintegratedBRDF = Texture2DSampleLevel(PreIntegratedBRDF, PreIntegratedBRDFSampler , float2(saturate(dot(N, L) * .5 + .5), 1 - Opacity), 0).rgb;
return PreintegratedBRDF * SubsurfaceColor;
}

意外的简单，其实就是查找一张LUT的值。

这张图很容易找到，打开unreal4，在content browser的View Options里选择Show Engine Content

这样就可以在Engine Content/EngineMaterials/中找到这张LUT了

然后是twosided的次表面：

NormalText Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14

float3 SubsurfaceShadingTwoSide d( float3 SubsurfaceColor, float3 L, float3 V, half3 N )
{
// http://blog.stevemcauley.com/2011/12/03/energy-conserving-wrapped-diffuse/
float Wrap = 0.5;
float NoL = saturate( ( dot(-N, L) + Wrap ) / Square( 1 + Wrap ) );

// GGX scatter distribution
float VoL = saturate( dot(V, -L) );
float a = 0.6;
float a2 = a * a;
float d = ( VoL * a2 - VoL ) * VoL + 1; // 2 mad
float GGX = (a2 / PI) / (d * d); // 2 mul, 1 rcp
return NoL * GGX * SubsurfaceColor;
}

NoL经过了Wrap来保证能量守恒，乘以GGX的NormalDistribution得到最终结果

这里注意GGX没有使用roughness，而是将a=roughness*roughness设成0.6。相当于roughness=0.77

hair的次表面特别复杂，分R、TT、TRT等很多部分，以后单独拿出来讲。eye也一样

Reference

[1] https://de45xmedrsdbp.Resources/files/2013SiggraphPresentation sNotes-26915738.pdf

这篇关于[PBS真的可以为所欲为] Unreal材质模型源码分析的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！