百人计划-图形-2.4 传统经验光照模型详解

kio0o0 发布于

最后更新于

光照模型

定义
  • 光照模型（illumination model），也称为明暗模型，用于计算物体某点处的光强（颜色值）。
  • 从算法理论基础而言，光照模型分为两类：
    • 基于物理理论的光照模型：偏重于使用物理的度量和统计方法，效果非常真实，但是计算复杂，实现起来 也较为困难。例：PBR
    • 经验模型：是对光照的一种模拟，通过实践总结出简化的方法，简化了真实的光照计算，并且能达到很不错的效果。例：Lambert，Billing-Phong。

为什么需要光照模型
  • 现实世界的光照是极其复杂的，而且会受到诸多因素的影响，有限的计算能力无法完全模拟。
  • 使用简化的光照模型对现实的情况进行近似，使得计算处理起来会更容易，并且令效果更符合需求。
  • 这些光照模型就是基于我们对光的物理特性的理解。
光照模型的发展

局部光照模型

定义

局部光照模型只关心直接光照部分，即直接从光源发出并照射到物体表面并反射至摄像头的光线。（不考虑间接光源）

局部光照模型的组成

局部光照模型满足叠加原理，可以基本将光线分为四个部分

  • 漫反射
  • 高光反射
  • 环境光
  • 自发光
漫反射
  • 在光照模型的定义中，当光线从光源照射到模型表面时，光线均匀被反射到各个方向，这种现象就是漫反射
  • 在漫反射的过程中，光线发生了发生了吸收和散射，而因此改变颜色和方向
  • 漫反射光照符合Lambert定律，反射光强与法线和光源方向之间的夹角的余弦值成正比

    • 在光学中通常使用辐射度来量化光

    • 其中光源每秒发出的能量为辐射通量P

    • 单位面积接收的光量为辐射通量密度（辐照度）P/A

    • 当光源垂直照射的单机面积的辐照度为E1 = P/A1

    • 将光束以某个角度照射到更大的平面上的辐射度为E2 = P/A2

    • 可以认为A1与A2的关系是

    • 简洁的来说：反射光线的强度与表面法线和光源方向之间的夹角的余弦成正比，值越大光源方向和法线方向越相似

    • 光照公式：

    • 漫反射的效果与观察者位置无关，与光源位置有关


高光反射（镜面反射）

  • 当光线到达物体表面并发生了反射，观察视线在反射光线的附近时，便能够观察到了高光反射

  • 高光反射描述了光线与物体表面发生的反射(光强不变，方向改变)

  • 高光反射的反射率是根据一种菲涅尔效应的物理现象决定

  • 通常使用对应的反射贴图描述物体表面的反射率，并且使用光泽度(粗糙度，反光度)描述高光范围的大小

  • 计算公式如下：

    • gloss表示了材质的光泽度
    • specular表示了材质的反射光
    • r表示反射光线
    • v表示视角向量

不同光泽度下的高光效果：

环境光
  • 实际的环境光计算需要考虑的因素非常多，而且计算复杂，所以在局部光照模型中不考虑间接光照的计算。
  • 间接光照是指，光线通常会在多个物体之间反射，最后进入摄像机，也就是说，在光线进入摄像机之前，经过了不止一次的物体反射。
  • 在标准光照模型中，我们使用了一种被称为环境光的部分来近似模拟间接光照。环境光的计算非常简单，它通常是一个全局变量，即场景中的所有物体都使用这个环境光。
  • 通常使用漫反射的反射率来指示环境光照的反射光量
  • 该模型假定场景中发生多次散射和反射，并在所有方向上均等地射向目标物体
自发光
  • 光线也可以直接由光源发射进入摄像机，而不需要经过任何物体的反射。
  • 标准光照模型使用自发光来计算这个部分的贡献度。它的计算也很简单，就是直接使用了该材质的自发光颜色
  • 通常在实时渲染中，自发光的表面往往并不会照亮周围的表面，也就是说，这个物体并不会被当成一个光源。
  • Unity5引入的全局光照系统则可以模拟这类自发光物体对周围物体的影响。
局部光照模型的整体效果

经典光照模型

Lambert模型

漫反射光照是用于对那些被物体表面随机散射到各个方向的辐射度进行建模的。漫反射中，视角的位置不重要，因为反射是完全随机的，因此可以认为在任何反射方向上的分布都是一样的。但是，入射光线的角度很重要。

也就是兰伯特定律：反射光线的强度与表面发现和光源方向之间夹角的余弦值成正比。只有当入射光线与平面垂直的时候才能完整的接受所有的光能量，入射角度越倾斜，损失的能量越大。

Phong模型

Phong光照模型就是第一个有影响力的光照模型，考虑直接光照的反射作用，使用环境光代替间接光照。

变量 描述
环境光量
入射光量
漫反射率
镜面反射率
l 指向光源入射光向量
n 物体表面法线
r 反射向量
gloss 光泽度，控制高光反射区域

Blinn-Phong模型

Blinn-Phong模型不再依赖于反射向量，而是采用了所谓的半程向量(Halfway Vector)，即光线与视线夹角一半方向上的一个单位向量。当半程向量与法线向量越接近时，镜面光分量就越大。

Phone模型和Blinn-Phone模型的区别

通过对Phone模型的公式和Blinn-Phone模型公式的对比，可以知道公式的不同之处在于使用了半角向量与法线的点积代替了反射向量与视线的点积结果。
半角向量的使用带来了什么变化？

  • 计算更加简洁，半角向量比反射向量的计算更加简洁
  • 当光源与视线都在物体表面之上时，半角向量与法线的角度永远不大于90度
    • 设想一种情况，当材质的反光度非常低，因此物体的被光线照射的大部分区域都会发生高光反射。
    • 这些区域中一部分高光部分的反射向量与视线的夹角超过了90度。
    • 如果使用Phone模型就会导致高光区域一部分发生缺失。
    • 这是由于phone模型只考虑视线与光照分布在法线两侧的情况。
    • 当视线与光照在法线同侧时且高光反射对亮度有较大影响时，就会发生断层。

着色方法

上面我们介绍完了经典局部光照模型，其中主要利用了观察方向，入射光线与法线向量的位置关系，但并没有具体说究竟是三角形面的法线向量还是三角形顶点的法线向量，即我们要确认着色方式，如到底是逐顶点着色还是逐像素着色或是逐面着色。这三种着色方式对应着不同的表现效果。

Flat Shading

面着色，即逐面进行着色，顾名思义以面作为一个着色单位。模型数据，大多以很多歌三角面进行储存，因此也就记录了每个面的法线向量，利用每个面的法线向量进行一次Blinn-Phong反射光照模型的计算，将该颜色赋予整个面，效果如下：

逐面进行着色虽然计算很快，只需对每一个面进行一次着色计算，但是效果是很差的，可以很明显的看到一块块面的形状（实际上，这种LowPoly的风格比较适合做风格化的，更加卡通风格的场景，只是不适合用来给追求写实的画面使用），因此一种改进方法就是对三角形面的每个顶点进行着色，再对三角形面内的颜色插值，也就是高洛德着色方式（Gouraud Shading）

Gouraud Shading

Gouraud Shading（高洛德着色，逐顶点着色）会对每个三角形的顶点进行一次着色，我们需要将所有共享这个点的面法线加起来求均值，最后再标准化就得了该顶点的法线向量了。

有了每个三角形的顶点向量之后，自然就可以计算出每个顶点的颜色了，那么对于三角形内部的每一个点应该怎么办？我们可以用重心插值坐标来计算，这样就能得到每个点的颜色，效果如下：

Phong Shading

我们既然能得到每个顶点的法线向量，那么对于三角形内部的每点的法线向量自然也可以像差值颜色一样得到，然后逐像素进行着色，三种着色方式的对比如下。

其实可以看到Phong Shading对于高光的显示相比于，Gouraud Shading是更真实的。有一点的要注意的是，这里所有的茶壶所使用的都是低精度模型，即模型的精度越高，逐顶点的效果更好。这里给出一张根据面数的增加，各个着色方法的对比。

局部光照模型的URP实现

正常实现
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
Shader "URPLearn/BaseShading"
{
    //lambert
    //phong
    //blinn-phong
    //GGX等
    //使用EnableKeyword开启变体
    Properties
    {
        _Diffuse ("Diffuse", Color) = (1,1,1,1)
        _Specular ("Specular", Color) = (1,1,1,1)
        _Gloss ("Gloss", Range(1.0, 255)) = 20
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalRenderPipeline"}
        LOD 200
        Pass 
        {
            Tags { "LightMode" = "UniversalForward" }
            HLSLPROGRAM
  
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

            #pragma shader_feature _PHONG
            #pragma shader_feature _BLINNPHONG
            #pragma shader_feature _LAMBERT
            #pragma shader_feature _GOURAND

            #pragma vertex vert
            #pragma fragment frag

            // 常量缓冲区的定义，GPU现在里面某一块区域，这一块区域可以非常快速的和GPU传输数据
            // 因为要占GPU显存，所以其容量不是很大。
            // CBUFFER_START = 常量缓冲区的开始，CBUFFER_END = 常量缓冲区的结束。
            // UnityPerMaterial = 每一个材质球都用这一个Cbuffer，凡是在Properties里面定义的数据(Texture除外)，
            // 都需要在常量缓冲区进行声明，并且都用这一个Cbuffer，通过这些操作可以享受到SRP的合批功能
            CBUFFER_START(UnityPerMaterial)
            float4 _Diffuse;
            float4 _Specular;
            float _Gloss;
            CBUFFER_END

            struct VertexInput
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
            };

            struct VertexOutput
            {
                float4 pos : SV_POSITION;
                float3 worldNormal : NORMAL;
                float3 worldPos : TEXCOORD0;
                float3 color : TEXCOORD1;
            };

            VertexOutput vert(VertexInput i)
            {
                VertexOutput o;
                // 计算裁剪空间的位置
                o.pos = TransformObjectToHClip(i.vertex);
                // 计算片元着色需要的世界法线和世界坐标
                o.worldNormal = TransformObjectToWorldNormal(i.normal);
                o.worldPos = TransformObjectToWorld(i.vertex.xyz);

                //Gourand着色模型
                #if defined(_GOURAND)
                    // 环境光
                    float3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * _Diffuse;
                    Light mainLight = GetMainLight();
                    half3 lightDir = normalize(TransformObjectToWorld(mainLight.direction));
                    float3 worldNormal = normalize(o.worldNormal);
                    //计算法线与光线的余弦
                    float NdotL = max(0.0, dot(worldNormal, lightDir));
                    float3 diffuse = mainLight.color.rgb * _Diffuse.rgb * NdotL;

                    float viewDir = normalize(_WorldSpaceCameraPos.xyz - o.worldPos);
                    // 计算反射方向R，worldLight要指向光源的方向
                    float3 reflectDir = normalize(reflect(-lightDir, worldNormal));
                    // 反射光方向与观察方向的夹角
                    float VdotR = max(0.0, dot(reflectDir, viewDir));
                    // 计算高光值
                    float3 specular = mainLight.color.rgb * _Specular.rgb * pow(VdotR, _Gloss);

                    o.color = diffuse + ambient + specular;
                #endif
  
                return o;
  
            }

            half4 frag(VertexOutput i) : SV_TARGET
            {
                // 环境光
                float3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * _Diffuse;
                Light mainLight = GetMainLight();
                half3 lightDir = normalize(TransformObjectToWorld(mainLight.direction));
                float3 worldNormal = normalize(i.worldNormal);
                //计算法线与光线的余弦
                float NdotL = max(0.0, dot(worldNormal, lightDir));
                float3 diffuse = mainLight.color.rgb * _Diffuse.rgb * NdotL;

                float3 specular;
                float3 color;
  
                float viewDir = normalize(_WorldSpaceCameraPos.xyz - i.worldPos);
                // =======Lambert模型=======
                #if defined(_LAMBERT)
                    color = diffuse;
                #endif

                // =======Phong模型=======
                #if defined(_PHONG)
                    // 计算反射方向R，worldLight要指向光源的方向
                    float3 reflectDir = normalize(reflect(-lightDir, worldNormal));
                    // 反射光方向与观察方向的夹角
                    float VdotR = max(0.0, dot(reflectDir, viewDir));
                    // 计算高光值
                    specular = mainLight.color.rgb * _Specular.rgb * pow(VdotR, _Gloss);
                    color = diffuse + ambient + specular;
                #endif

                // =======Blinn-Phong模型=======
                #if defined(_BLINNPHONG)
                    // 计算半程向量
                    float3 halfDir = normalize(viewDir + lightDir);
                    // 半程向量与法线方向的夹角
                    float NdotH = max(0.0, dot(worldNormal, halfDir));
                    //计算高光值
                    specular = mainLight.color.rgb * _Specular.rgb * pow(NdotH, _Gloss);
                    color = diffuse + ambient + specular;
                #endif

                // =======GOURAND着色模型=======
                #if defined(_GOURAND)
                    color = i.color;
                #endif
  
                return half4(color, 1.0);
            }
  
            ENDHLSL
        }
    }
}
模仿PBR效果（用了几个Trick，并不基于物理）
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
Shader "URPLearn/BaseShader"
{
    ///////////目录/////////////
    //lambert
    //phong
    //blinn-phong
    //GGX等
    ///////////////////////////
    //法线贴图
    //cube环境贴图 > IBL
    Properties
    {
        _Diffuse ("Diffuse", Color) = (1,1,1,1)
        _MainTex ("MainTex", 2D) = "while" {}
    
        _Specular ("Specular", Color) = (1,1,1,1)
        _Gloss ("Gloss", Range(1.0, 255)) = 20
    
        _Normalmap ("Normalmap", 2D) = "white" {}
        _LocalNormalSlide ("LocalNormal", Range(0, 1)) = 0
        _Cubemap ("EnvMap", CUBE) = "" {}
        _MipScale ("MipScale", Range(0, 10)) = 0
        _EnvScale ("EnvScale", Range(0, 1)) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalRenderPipeline"}
        LOD 200
        Pass 
        {
            Tags { "LightMode" = "UniversalForward" }
            HLSLPROGRAM
        
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
        

            #pragma vertex vert
            #pragma fragment frag

            // 常量缓冲区的定义，GPU现在里面某一块区域，这一块区域可以非常快速的和GPU传输数据
            // 因为要占GPU显存，所以其容量不是很大。
            // CBUFFER_START = 常量缓冲区的开始，CBUFFER_END = 常量缓冲区的结束。
            // UnityPerMaterial = 每一个材质球都用这一个Cbuffer，凡是在Properties里面定义的数据(Texture除外)，
            // 都需要在常量缓冲区进行声明，并且都用这一个Cbuffer，通过这些操作可以享受到SRP的合批功能
            CBUFFER_START(UnityPerMaterial)
            float4 _Diffuse;
            float4 _Specular;
            float _Gloss;
            float _LocalNormalSlide;
            float _MipScale;
            float _EnvScale;
        
            uniform float4 _Normalmap_ST;
            float4 _MainTex_ST;
            CBUFFER_END

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);

            uniform TEXTURE2D(_Normalmap);
            SAMPLER(sampler_Normalmap);

            TEXTURECUBE(_Cubemap);
            SAMPLER(sampler_Cubemap);

            struct VertexInput
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float4 tangent : TANGENT;
                float2 texcoord0 : TEXCOORD0;
            };

            struct VertexOutput
            {
                float4 pos : SV_POSITION;
                float3 worldNormal : NORMAL;
                float2 uv0 : TEXCOORD0;
                float3 normalDir : TEXCOORD1;
                float3 tangentDir : TEXCOORD2;
                float3 bitangentDir : TEXCOORD3;
                float3 worldPos : TEXCOORD4;
            };

            VertexOutput vert(VertexInput i)
            {
                VertexOutput o;
                o.uv0 = i.texcoord0;
                // 计算裁剪空间的位置
                o.pos = TransformObjectToHClip(i.vertex);
                // 计算片元着色需要的世界法线和世界坐标
                o.worldNormal = TransformObjectToWorldNormal(i.normal);
                o.worldPos = TransformObjectToWorld(i.vertex.xyz);

                //计算TBN矩阵
                o.normalDir = TransformObjectToWorldNormal(i.normal);
                o.tangentDir = TransformObjectToWorldDir(i.tangent);
                o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * i.tangent.w);
            
                return o;
            
            }

            half4 frag(VertexOutput i) : SV_TARGET
            {
                float4 MainTex = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, TRANSFORM_TEX(i.uv0, _MainTex));
            
                // 环境光
                float3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * _Diffuse * MainTex.rgb;
                Light light = GetMainLight();
                // 归一化光方向
                float worldLight = TransformObjectToWorldDir(light.direction);
                // 再次归一化worldNormal
                float3 worldNormal = normalize(i.worldNormal);

                //////Normal
                i.normalDir = worldNormal;
                float3x3 tangentTransform = float3x3(i.tangentDir, i.bitangentDir, i.normalDir);

                // 获取映射过的法线贴图数据
                float3 normalLocal = UnpackNormal(SAMPLE_TEXTURE2D(_Normalmap, sampler_Normalmap, TRANSFORM_TEX(i.uv0, _Normalmap)));
                float3 normalWorld = normalize(mul(normalLocal.rgb, tangentTransform));

                // 计算漫反射Lambert公式
                float finalNormal = lerp(worldNormal, normalWorld, _LocalNormalSlide);

                float NdotL = max(0.0, dot(finalNormal, worldLight));
                // float NdotNormalTex = dot(finalNormal, worldLight);

                // trick：兰伯特模型黑的部分显示为环境光
                float3 diffuse = lerp(ambient.rgb * _Diffuse.rgb * MainTex.rgb, light.color.rgb * _Diffuse.rgb * MainTex.rgb, NdotL);

                // ========Phong模型==========
                // 计算反射方向R，worldLight表示光源方向（指向光源），入射方向为-worldLight，通过reflect函数计算
                float3 reflectDir = normalize(reflect(-worldLight, finalNormal));
                // 计算观察方向
                float3 viewDir = normalize(_WorldSpaceCameraPos.xyz - i.worldPos.xyz);
                // 反射光方向与观察方向的夹角
                float VdotR = max(0.0, dot(viewDir, reflectDir));
                // 计算高光值
                float3 specular = light.color.rgb * _Specular.rgb * pow(VdotR, _Gloss);
                // 冯式模型
                float3 color = diffuse + ambient + specular;

                // =======Phong模型改进Blinn-Phong========
                // 计算半程向量（光线方向 + 视角方向， 结果归一化）
                float3 halfDir = normalize(worldLight + viewDir);

                // 半程向量与法线方向的夹角
                float NdotH = max(0.0, dot(halfDir, finalNormal));

                // 环境贴图
                float3 worldRef = normalize(reflect(-viewDir, finalNormal));
                float4 reflCol = _Cubemap.SampleLevel(sampler_Cubemap, worldRef.rgb, (255-_Gloss)*8/(255)) * _EnvScale;

                // 计算Specular
                specular = light.color.rgb * _Specular.rgb * pow(NdotH, _Gloss);
                // trick：根据高光程度来决定漫反射是否影响高光（为了模仿PBR效果）
                specular = lerp(diffuse * specular, specular, _Gloss/255);
                reflCol.rgb = lerp(reflCol * diffuse.rgb, reflCol, _Gloss/255);

                color = diffuse + reflCol.rgb + specular;

                return half4(color.rgb, 1.0);

            }
        
            ENDHLSL
        }
    }
}

TASK

说出能量守恒的理念在基础光照模型中的作用

一束光打在物体上，最终回到人眼的有反射光和漫射光。能量守恒在这里最重要的一点是入射光的能量要大于等于出射光的能量，能量不可能凭空增加。最直接的呈现是画面不能越来越亮。

基础光照模型是基于经验总结的，由不同部分叠加而成，其漫反射部分认为光会被均匀地反射到不同的方向，并不遵循能量守恒的理念，渲染结果很大程度依赖于参数的搭配，好的参数可以接近基于物理观察的效果，不适当的参数给人第一眼很怪异。

而微表面模型是基于物理渲染的，其理论在很多大佬的文章中已提到，这里不过多赘述（引用中可查看）。总而言之我认为遵循能量守恒定律可以科学地让场景看起来更符合物理、更真实，而不用将重点放在调参以及一些HACK的实现方案。

基于能量守恒的理念，自己写一条完整的光照模型，需要包含环境光照

主要参考了以下文章，大佬解释的非常好。（TODO:增加软硬阴影支持、法线贴图支持）

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
//=========金属/粗糙度工作流=============
Shader "URPLearn/CustomPBR"
{
    Properties
    {
        _Diffuse ("Diffuse", Color) = (1,1,1,1)
        _MainTex ("MainTex", 2D) = "while" {}
    
        // 金属度贴图要伽马校正
        [Gamma] _Metallic ("Metallic", Range(0,1)) = 0
        // 光滑度（1-粗糙度）
        _Smoothness ("Smoothness", Range(0, 1)) = 0.5
        // 环境光BRDF积分部分
        _LUT ("LUT", 2D) = "white" {}
    }
    SubShader
    {
        Tags 
        {
            "RenderType"="Opaque"
            "RenderPipeline"="UniversalRenderPipeline"
        }
        LOD 200
        Pass 
        {
            Tags { "LightMode" = "UniversalForward" }
            HLSLPROGRAM
        
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/UnityInput.hlsl"
        
            #pragma vertex vert
            #pragma fragment frag

            // 常量缓冲区的定义，GPU现在里面某一块区域，这一块区域可以非常快速的和GPU传输数据
            // 因为要占GPU显存，所以其容量不是很大。
            // CBUFFER_START = 常量缓冲区的开始，CBUFFER_END = 常量缓冲区的结束。
            // UnityPerMaterial = 每一个材质球都用这一个Cbuffer，凡是在Properties里面定义的数据(Texture除外)，
            // 都需要在常量缓冲区进行声明，并且都用这一个Cbuffer，通过这些操作可以享受到SRP的合批功能
            CBUFFER_START(UnityPerMaterial)
            float4 _Diffuse;
            float _Metallic;
            float _Smoothness;
            float4 _MainTex_ST;
            CBUFFER_END

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);

            TEXTURE2D(_LUT);
            SAMPLER(sampler_LUT);

            struct VertexInput
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 texcoord : TEXCOORD0;
            };

            struct VertexOutput
            {
                float4 pos : SV_POSITION;
                float2 uv : TEXCOORD0;
                float3 worldNormal : TEXCOORD1;
                float3 worldPos : TEXCOORD2;
            };

            VertexOutput vert(VertexInput i)
            {
                VertexOutput o;
                o.uv = TRANSFORM_TEX(i.texcoord, _MainTex);
                // 计算裁剪空间的位置
                o.pos = TransformObjectToHClip(i.vertex);
                // 计算片元着色需要的世界法线和世界坐标
                o.worldNormal = TransformObjectToWorldNormal(i.normal);
                o.worldPos = TransformObjectToWorld(i.vertex.xyz);
            
                return o;
            }

            // Schlick近似法计算菲涅尔系数
            float3 fresnelSchlickRoughness(float cosTheta, float3 F0, float roughness)
            {       
                return F0 + (max(float3(1.0 - roughness, 1.0 - roughness, 1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0);
            }

            half4 frag(VertexOutput i) : SV_TARGET
            {
                //-------------------
                //渲染方程需要的数据
                //-------------------
                i.worldNormal = normalize(i.worldNormal);
                Light light = GetMainLight();
                float3 lightDir = TransformObjectToWorldDir(light.direction);
                float3 viewDir = normalize(_WorldSpaceCameraPos.xyz - i.worldPos);
                float3 halfDir = normalize(viewDir + lightDir);

                // 粗糙度系列（闫老师说没必要用光滑度hh）
                float roughness = 1 - _Smoothness;
                float squareRoughness = roughness * roughness;
                float quadRoughness = squareRoughness * squareRoughness;

                // 点积
                float NdotL = max(dot(i.worldNormal, lightDir), 0.000001);
                float NdotV = max(dot(i.worldNormal, viewDir), 0.000001);
                float NdotH = max(dot(i.worldNormal, halfDir), 0.000001);
                float VdotH = max(dot(viewDir, halfDir), 0.000001);
                float LdotH = max(dot(lightDir, halfDir), 0.000001);

                // ----------------直接光----------------
                float4 albedo = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv);

                // 镜面反射部分
                //（1）法线分布函数:Trowbridge-Reitz GGX
                float D = squareRoughness / (pow((pow(NdotH, 2) * (squareRoughness - 1) + 1), 2) * PI);

                //（2）几何函数: Schlick-GGX
                float kDirect = pow((roughness + 1), 2) / 8;
                float kIbl = squareRoughness / 2;  //间接光的k项计算不同
                float Gnv = NdotV / (NdotV * (1 - kDirect) + kDirect);
                float Gnl = NdotL / (NdotL * (1 - kDirect) + kDirect);
                float G = Gnv * Gnl;

                //（3）菲涅尔方程:
                // *做插值，使得得到的F0可以在金属和非金属中通用
                // float3(0.04, 0.04, 0.04)这个是Unity里面有定义的一个常数unity_ColorSpaceDielectricSpec.rgb。
                // F0的计算在这个常数和表面颜色间根据金属度进行一个插值运算。
                float3 F0 = float3(0.04, 0.04, 0.04);
                F0 = lerp(F0, albedo, _Metallic);
                //  1）Fresnel-Schlick近似法
                float F = F0 + (1 - F0) * pow((1 - (VdotH)), 5);
                //  2）UE4使用的菲涅尔方程近似方法 - 效率貌似更高
                //float3 F = F0 + (1 - F0) * exp2((-5.55473 * VdotH - 6.98316) * VdotH);
             
                // 镜面反射的计算结果
                float3 SpecularResult = (D * G * F * 0.25) / (NdotV * NdotL);

                // 漫反射部分
                // 计算漫反射系数            
                // *F便是镜面反射系数Ks，(1 - F)是为了保证能量守恒
                // *乘以(1 - _Metallic)是因为，金属更多地吸收折射光以导致漫反射光变少。
                float3 Kd_Direct = (1 - F)*(1 - _Metallic);
            
                float3 specular = F * SpecularResult * light.color.rgb * NdotL * PI;  // 这个*UNITY_PI还是无法理解
                float3 diffuse = Kd_Direct * albedo * light.color.rgb * NdotL;
            
                float3 directLightResult = diffuse + specular;

                // ----------------间接光----------------
                // --间接漫反射光--
                // 采样环境贴图
                // *由于我们并不需要传入真正的Cubemap供其采样，unity自己将环境贴图Cubemap积分成模糊的全局光照贴图，再将其投影到球谐光照的基函数上存储起来
                // *总而言之，我们调用SampleSH函数，传入法线，就可以获得对应的环境光照信息了。
                // *可以将这个过程理解为对积分后的全局光照贴图的采样
                half ambient_contrib = SampleSH(i.worldNormal);
                // 类似Phong模型中的ambient，我们给一个很小的值即可
                float3 ambient = 0.03 * albedo;   
                // 计算间接漫反射光
                float3 iblDiffuse = max(half3(0, 0, 0), ambient.rgb + ambient_contrib);
                // 计算漫反射系数
                float F_Indirect = fresnelSchlickRoughness(max(0.0, NdotV), F0, roughness);
                float kd_Indirect = (1 - F_Indirect) * (1 - _Metallic);
 
                // 最后的间接漫反射结果
                float3 iblDiffuseResult = kd_Indirect * iblDiffuse * albedo;
                // --间接镜面反射光--
                // *基于Epic Games的分割求和近似法实现(split sum)
                // 计算公式的前半部分：
                //1、计算采样mipmap需要用的粗糙度
                float mip_roughness = roughness * (1.7 - 0.7 * roughness);
                //2、获得反射方向
                float3 reflectDir = reflect(-viewDir, i.worldNormal);
                //3、计算粗糙度对应的mipmap层级
                half mip = mip_roughness * UNITY_SPECCUBE_LOD_STEPS;
                //4、对mipmap进行采样
                half4 rgbm = unity_SpecCube0.SampleLevel(samplerunity_SpecCube0, reflectDir, mip);
                //5、解码HDR，将结果转换为RGB格式
                float3 iblSpecular_Front = DecodeHDREnvironment(rgbm, unity_SpecCube0_HDR);  // 这便是公式前半部分的结果
 
                // 计算公式的后半部分：
                // *这个部分是一个定值，我们通过nv和粗糙度对一张LUT采样即可得到结果
                float2 BRDF_LUT = SAMPLE_TEXTURE2D(_LUT, sampler_LUT, float2(lerp(0, 0.99, NdotV), lerp(0, 0.99, roughness))).rg;  // 在[0, 0.99]之间插值是为了防止两个值都为1时产生的亮度突变
                // 计算后半部分的结果
                float3 iblSpecular_Rear = F_Indirect * BRDF_LUT.r + BRDF_LUT.g;
                // 间接镜面反射光的最后结果
                float3 iblSpecularResult = iblSpecular_Front * iblSpecular_Rear;  
                // ------------------
 
                // 间接光的最后结果
                float3 indirectLightResult = iblDiffuseResult + iblSpecularResult;
                // ------------------------------------------------
 
                // 最终光照结果！
                float4 result = float4(directLightResult + indirectLightResult, 1.0);
 
                return result;
            }
        
            ENDHLSL
        }
    }
}

引用

kio0o0

kio0o0

如果可以做到不懂就问，做不到的事情就拒绝，或许可以活得更轻松点

107
6
27
NOTICE

正在努力学习图形学中！

CATEGORYS
TAGS
AMD OS X C#笔记 Github技巧 Hackintosh Lua笔记 Unity Unity Shader入门精要 c++笔记 cocos c语言笔记 drcom shader 代码设计 卡通渲染 图形学 学习 平板 性能优化 搞机 数据结构 游戏开发 百人计划 解题 计划 设计模式 路由器 重构