Unity shader学习---更复杂的光照

Unity更复杂的光照

1.前言

本文可以看作是对Unity shader学习---基础光照模型(https://www.jianshu.com/p/c7405e771dc5)的拓展和补充。目的是能使用一个平行光和多个点光源(或者聚光灯)照亮物体。如下图

一个平行光和4个点光源

2.渲染路径

渲染路径(Rendering Path)决定了光照是如何应用到shader中的,需要为每个pass指定使用的渲染路径,才能让unity为我们提供正确的光照信息。
unity支持多种类型的渲染路径:
a.Forward (前向渲染)
b.Deferred (延迟渲染)
c.Legacy Vertex Lit (遗留的顶点照明渲染,被unity抛弃)
d.Legacy Deferred (遗留的延迟渲染,被unity抛弃)
需要注意的是:如果当前显卡不支持所设置的渲染路径,则 Unity 会自动使用更低一级的渲染路径,例如一个GPU不支持延迟渲染,unity会使用前向渲染。

LightMode标签支持的渲染路径设置选项

3.前向渲染

3.1.原理

每进行一次完整的前向渲染,都需要渲染该对象的渲染图元,并计算两个缓冲区的信息:颜色缓冲区,深度缓冲区。利用深度缓冲区来决定一个片元是否可见,如果可见就更新颜色缓冲区的颜色值。
每个逐像素光源,都需要进行一次完整的渲染流程。如果一个物体在多个逐像素光源的影响区域内,则这个物体需要执行多个Pass,每个Pass计算一个逐像素的的光照结果,然后在帧缓冲中把这些光照结果混合起来得到最终的颜色值。也就是如果有N个物体受M个光源影响,则需要执行N*M次的Pass。所以逐像素的光源如果多了就会有更多的Pass。因此引擎一般都会限制逐像素光照的数目。

3.2.unity的前向渲染

3.2.1.处理光照的方式
前向渲染路径有三种处理光照(即照亮物体)的方式:
a.逐顶点处理
b.逐像素处理
c.球谐函数
决定一个光源使用哪种处理模式取决于光源的类型和渲染的模式。光源的渲染模式指的是该光源是否是重要的(Important)。如果设置成Important,就意味着使用逐像素的方式。

3.2.2.前向渲染的规则
在前向渲染中,Unity会根据场景中各个光源的设置以及这些光源对物体的影响程度(距离物体的远近,光强度等)对场景中的光源进行一个重要度的排序。其中一定数目的光源按照逐像素的方式处理,最多有4个光源会逐顶点的方式处理,剩下的就会按照SH处理,具体规则如下:
(1)场景中最亮的平行光总是按照逐像素处理。
(2)渲染模式被设置成Not Important的会按照逐顶点或SH处理
(3)渲染模式被设置成Important的会按照逐像素处理
(4)如果场景中逐像素的光源数目小于Quality Setting中的逐像素光源数量,那么剩余的逐像素光源也会按照逐像素处理

前向渲染的两种pass

3.2.3.两种Pass的对光照的计算
(1)Base Pass
支持访问光照纹理(lightmap)、平行光默认支持阴影(平行光源开启阴影功能)、可以在Base Pass中计算环境光,自发光(因为这两种光只需要计算一次就可以)。既可以逐像素光照,也可以逐顶点。一般只执行一次。
(2)Addtional Pass
Addtional Pass中渲染的光源默认情况下没有阴影,即便光源本身设置了Shadow Type,但是可以使用编译指令:
#pragma multi_compile_fwadd_fullshadows
为点光源,聚光灯开启阴影效果。还需要开启混合模式,因为我们需要把Addtional Pass中的得到光照颜色和上一次的光照叠加起来,从而得到多个光照渲染的效果,如果没有混合,之前的颜色会覆盖掉,看起来像只受最后一个光源的影响,一般都是Blend One One,也是可以是其他。
通常对于前向渲染UnityShader只需要定义一个Base Pass(也可以定义多个,如双面渲染,需要先画后面,再画前面),一个Addtional Pass。一般Base Pass只会执行一次(定义多个就执行多次),而Addtional Pass会根据影响该物体的其他逐像素光源的数目被多次调用(逐顶点也可以)。
渲染路径的设置用于告诉Unity该Pass在前向渲染路径中的位置,引擎就会在相关计算中填充一些内置变量。至于如何使用这些变量,完全取决于开发者,如在BasePass和Addtional Pass中逐顶点光照而不是逐像素光照。

3.2.4 对前向渲染的总结
前向渲染是一种传统的渲染方式,工作原理也是比较简单的。通过上面的解释,我们也能够知道,前向渲染依赖于场景的复杂度,当场景中存在大量的实时光照时,程序的性能会快速下降。因为在多个光源中,每执行一个 Pass 都需要重新渲染 一遍,所以许多的计算实际上是重复了。为了解决这个问题,我们可以使用延迟渲染路径。

4.延迟渲染

4.1.工作原理

延迟渲染是一张更古老的渲染方法,相比于前向渲染,延迟渲染会利用额外的缓冲区,统称为 G (Geometry)缓冲(G - buffer)。延迟渲染包含两个 Pass,第一个 Pass 对每个片元进行深度测试,如果通过则把这些信息存储到 G 缓冲中;第二个 Pass 则利用 G 缓冲中各个片元信息进行光照计算,更新帧缓冲。

4.2.光源处理方式

在前向渲染中,光源的处理方法取决于多条规则,而在延迟渲染中,每个光源都可以按逐像素来处理,而且它的效率与光源数目无关。也就是延迟渲染不依赖于场景复杂度,而与屏幕空间大小有关。所以在这种情况下,点光源和聚光灯的消耗就会变得十分 “廉价”。
所以,如果场景中实时光照数目较多且因此造成性能下降时,可以考虑使用延迟渲染。

4.3.延迟渲染的缺点

(1)不支持真正的抗锯齿(anti-aliasing)
(2)无法处理半透明物体(半透明关闭了深度写入)
(3)显卡需要支持 MRT 、Shader Mode 3.0 以上、深度渲染纹理。
(4)在移动端,需要硬件支持 OpenGL ES 3.0 以上
需要注意的是:如果摄像机的 Projection 设置为了 Orthographi(正交),那么摄像机会回退到前向渲染。因为延迟渲染不支持正交投影。

4.4.延迟渲染的 Pass 块

(1)第一个 Pass 用来渲染 G 缓冲,把物体的漫反射颜色、高光反射颜色、平滑度等信息存储到 G 缓冲中,对于每个物体来说,这个 Pass 只执行一次。
(2)第二个 Pass 利用上一个 Pass 中的信息进行真正的光照计算,并存储到帧缓冲中。而默认 G 缓冲的渲染纹理:
--RT0,ARGB32格式:漫反射颜色(RGB),遮罩(A)
--RT1,ARGB32格式:镜面反射颜色(RGB),粗糙度(A)
--RT2,ARGB2101010格式:世界空间标准(RGB),未使用(A)
--RT3,ARGB2101010(非HDR)或ARGBHalf(HDR)格式:Emission + lighting + lightmaps + reflection probes
--深度+模板缓冲区

5.Unity 中的光源

Unity 中的光源有 4 种:平行光、点光源、聚光灯和面光源

6.光照衰减

Unity 选择使用一张纹理作为查找表(LUT)来在片元着色器中计算逐像素光照的点光源和聚光灯的衰减。

7.具体shader代码

Shader "Unity Shaders Book/Chapter 9/Forward Rendering" {
    Properties {
        _Diffuse ("Diffuse", Color) = (1, 1, 1, 1)
        _Specular ("Specular", Color) = (1, 1, 1, 1)
        _Gloss ("Gloss", Range(8.0, 256)) = 20
    }
    SubShader {
        Tags { "RenderType"="Opaque" }
        
        Pass {
            // Pass for ambient light & first pixel light (directional light)
            Tags { "LightMode"="ForwardBase" }
        
            CGPROGRAM
            
            // Apparently need to add this declaration 
            #pragma multi_compile_fwdbase   
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "Lighting.cginc"
            
            fixed4 _Diffuse;
            fixed4 _Specular;
            float _Gloss;
            
            struct a2v {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
            };
            
            struct v2f {
                float4 pos : SV_POSITION;
                float3 worldNormal : TEXCOORD0;
                float3 worldPos : TEXCOORD1;
            };
            
            v2f vert(a2v v) {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                
                return o;
            }
            
            fixed4 frag(v2f i) : SV_Target {
                fixed3 worldNormal = normalize(i.worldNormal);
                fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);
                
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;
                
                fixed3 diffuse = _LightColor0.rgb * _Diffuse.rgb * max(0, dot(worldNormal, worldLightDir));

                fixed3 viewDir = normalize(_WorldSpaceCameraPos.xyz - i.worldPos.xyz);
                fixed3 halfDir = normalize(worldLightDir + viewDir);
                fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(worldNormal, halfDir)), _Gloss);

                fixed atten = 1.0;
                
                return fixed4(ambient + (diffuse + specular) * atten, 1.0);
            }
            
            ENDCG
        }
    
        Pass {
            // Pass for other pixel lights
            Tags { "LightMode"="ForwardAdd" }
            
            Blend One One
        
            CGPROGRAM
            
            // Apparently need to add this declaration
            #pragma multi_compile_fwdadd
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "Lighting.cginc"
            #include "AutoLight.cginc"
            
            fixed4 _Diffuse;
            fixed4 _Specular;
            float _Gloss;
            
            struct a2v {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
            };
            
            struct v2f {
                float4 pos : SV_POSITION;
                float3 worldNormal : TEXCOORD0;
                float3 worldPos : TEXCOORD1;
            };
            
            v2f vert(a2v v) {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                
                return o;
            }
            
            fixed4 frag(v2f i) : SV_Target {
                fixed3 worldNormal = normalize(i.worldNormal);
                #ifdef USING_DIRECTIONAL_LIGHT
                    fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);
                #else
                    fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz - i.worldPos.xyz);
                #endif
                
                fixed3 diffuse = _LightColor0.rgb * _Diffuse.rgb * max(0, dot(worldNormal, worldLightDir));
                
                fixed3 viewDir = normalize(_WorldSpaceCameraPos.xyz - i.worldPos.xyz);
                fixed3 halfDir = normalize(worldLightDir + viewDir);
                fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(worldNormal, halfDir)), _Gloss);
                
                #ifdef USING_DIRECTIONAL_LIGHT
                    fixed atten = 1.0;
                #else
                    #if defined (POINT)
                        float3 lightCoord = mul(unity_WorldToLight, float4(i.worldPos, 1)).xyz;
                        //Unity 在内部使用一张名为_LightTexture0的纹理来计算光照衰减。
                        fixed atten = tex2D(_LightTexture0, dot(lightCoord, lightCoord).rr).UNITY_ATTEN_CHANNEL;
                    #elif defined (SPOT)
                        float4 lightCoord = mul(unity_WorldToLight, float4(i.worldPos, 1));
                        fixed atten = (lightCoord.z > 0) * tex2D(_LightTexture0, lightCoord.xy / lightCoord.w + 0.5).w * tex2D(_LightTextureB0, dot(lightCoord, lightCoord).rr).UNITY_ATTEN_CHANNEL;
                    #else
                        fixed atten = 1.0;
                    #endif
                #endif

                return fixed4((diffuse + specular) * atten, 1.0);
            }
            
            ENDCG
        }
    }
    FallBack "Specular"
}

你可能感兴趣的:(Unity shader学习---更复杂的光照)