遊戲裡的動態陰影-ShadowMap實現原理

bzt820801發表於2017-08-14
遊戲

ShadowMap是比較流行的實時陰影實現方案，原理比較簡單，但真正實現起來還是會遇到很多問題的，我這裡主要記錄下實現方式

先看效果

529271-20170724224922043-2029159821.png

實現原理

ShadowMap技術是從燈光空間用相機渲染一張RenderTexture，把深度值寫入其中所以稱之為 深度圖 ，在把接受陰影的物體從模型空間轉換到燈光空間中，獲取深度圖裡的深度進行比較，如果深度值比深度圖中取出的值大就說明該點為陰影。

《Cg教程_可程式設計實時圖形權威指南》書上說的原理
陰影對映是一個雙過程的技術：
1、 首先，場景以光源的位置為視點被渲染。每個渲染影象的畫素的深度被記錄在一個“深度紋理”中（這個紋理通常被稱為陰影貼圖）。
2、 然後，場景從眼睛的位置渲染，但是用標準的陰影紋理把陰影貼圖從燈的位置投影到場景中。在每個畫素，深度取樣（從被投影的陰影貼圖紋理）與片段到燈的距離進行比較。如果後者大，該畫素就不是最靠近燈源的表面。這意味著這個片段是陰影，它在著色過程中不應該接受光照。

第一步：生成深度圖shader

把視點空間的Z值深度傳入片段找色器裡除以w轉換為其次座標，為啥要傳入片段找色器處理呢？因為GPU會對片段找色器傳入的引數進行插值計算，這樣才能更精確的計算出深度。

計算出深度之後，要轉換到一張圖片裡儲存起來，如何把一個float存入圖片中呢？
float是4個位元組的，剛好可以對應RGBA4個分量，把一個float轉換成顏色值就可以存為圖片了，Unity中提供了一個內建函式：EncodeFloatRGBA幫助我們轉換

Shader "lijia/DeapthTextureShader"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
                float2 depth : TEXCOORD1;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                o.depth = o.vertex.zw;
                return o;
            }
            
            fixed4 frag (v2f i) : SV_Target
            {
                float depth = i.depth.x/i.depth.y;
                fixed4 col = EncodeFloatRGBA(depth);
                return col;
            }
            ENDCG
        }
    }
}

第二步：接受陰影的Shader

假如有一塊地板作為接受陰影的物體，在這個物體上執行該Shader

  1. 把深度值傳入片段著色器裡，在片段著色器中除以w轉換為其次座標的深度值（跟生成深度圖的Shader一樣處理）
  2. 把頂點轉換到燈光的視點空間，這裡是傳入一個lijia_ProjectionMatrix 矩陣計算的
  3. 取出該畫素對應深度圖上的顏色值，轉換成深度值
  4. 把該畫素的深度值跟深度圖裡取出來的值進行比較，如果比深度圖裡的大，該點就為陰影 
Shader "swan/ShadowMap/ShadowMapNormal"
{
    Properties
    {
        _MainTex("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #pragma multi_compile_fog

            #include "UnityCG.cginc"

            sampler2D _MainTex;
            float4 _MainTex_ST;

        
            // sampler2D unity_Lightmap;//若開啟光照貼圖，系統預設填值
            // float4 unity_LightmapST;//與上unity_Lightmap同理

            struct v2f {
                float4 pos:SV_POSITION;
                float2 uv:TEXCOORD0;
                float2 uv2:TEXCOORD1;
                UNITY_FOG_COORDS(2)
                float4 proj : TEXCOORD3;
                float2 depth : TEXCOORD4;
            };


            float4x4 lijia_ProjectionMatrix;
            sampler2D lijia_DepthTexture;

            v2f vert(appdata_full v)
            {
                v2f o;
                o.pos = mul(UNITY_MATRIX_MVP, v.vertex);

                //動態陰影
                o.depth = o.pos.zw;
                lijia_ProjectionMatrix = mul(lijia_ProjectionMatrix, unity_ObjectToWorld);
                o.proj = mul(lijia_ProjectionMatrix, v.vertex);
                //--------------------------------------------------
                o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
                o.uv2 = v.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
                UNITY_TRANSFER_FOG(o, o.pos);

                return o;
            }

            fixed4 frag(v2f v) : COLOR
            {
                //解密光照貼圖計算公式
                float3 lightmapColor = DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap,v.uv2));
                fixed4 col = tex2D(_MainTex, v.uv);

                col.rgb *= lightmapColor;

                UNITY_APPLY_FOG(v.fogCoord, col);

                float depth = v.depth.x / v.depth.y;
                fixed4 dcol = tex2Dproj(lijia_DepthTexture, v.proj);
                float d = DecodeFloatRGBA(dcol);
                float shadowScale = 1;
                if(depth > d)
                {
                    shadowScale = 0.55;
                }
                return col*shadowScale;
            }
            ENDCG
        }
    }
}

第三步：寫一個指令碼呼叫上面的2個Shader

上面我們已經建立好了2個Shader

  1. 生成深度圖的DeapthTextureShader.shader
  2. 接受陰影的ShadowMapNormal（我這裡把T4M跟接收光照貼圖的處理都寫進去了）

指令碼主要做的事情

  1. 建立一個相機把角度設定的跟燈光一樣，渲染出一張深度圖傳入給接受陰影的Shader（畫素越高陰影的精度越高，但是消耗也就越大）
  2. 計算好頂點轉換到燈光空間的矩陣傳入給接受陰影的shader 
using UnityEngine;
using System.Collections;
namespace SwanEngine.Core
{
    /// <summary>
    /// 建立depth相機
    /// by lijia
    /// </summary>
    public class DepthTextureCamera : MonoBehaviour
    {
        Camera _camera;

        RenderTexture _rt;
        /// <summary>
        /// 光照的角度
        /// </summary>
        public Transform lightTrans;

        Matrix4x4 sm = new Matrix4x4();

        void Start()
        {
            _camera = new GameObject().AddComponent<Camera>();
            _camera.name = "DepthCamera";
            _camera.depth = 2;
            _camera.clearFlags = CameraClearFlags.SolidColor;
            _camera.backgroundColor = new Color(1, 1, 1, 0);

            _camera.cullingMask = LayerMask.GetMask("Player");
            _camera.aspect = 1;
            _camera.transform.position = this.transform.position;
            _camera.transform.rotation = this.transform.rotation;
            _camera.transform.parent = this.transform;

            _camera.orthographic = true;
            _camera.orthographicSize = 10;

            sm.m00 = 0.5f;
            sm.m11 = 0.5f;
            sm.m22 = 0.5f;
            sm.m03 = 0.5f;
            sm.m13 = 0.5f;
            sm.m23 = 0.5f;
            sm.m33 = 1;

            _rt = new RenderTexture(1024, 1024, 0);
            _rt.wrapMode = TextureWrapMode.Clamp;
            _camera.targetTexture = _rt;
            _camera.SetReplacementShader(Shader.Find("lijia/DeapthTextureShader"), "RenderType");
        }

        void Update()
        {
            this.transform.eulerAngles = new Vector3(37.2f, -46.109f, -90.489f);
            _camera.Render();
            Matrix4x4 tm = GL.GetGPUProjectionMatrix(_camera.projectionMatrix, false) * _camera.worldToCameraMatrix;

            tm = sm * tm;

            Shader.SetGlobalMatrix("lijia_ProjectionMatrix", tm);
            Shader.SetGlobalTexture("lijia_DepthTexture", _rt);
        }


    }
}

後面的話

幾乎所有的程式碼我都貼上來了，有一些Shader基礎的話應該是可以實現出效果的，希望能夠幫助到你們理解ShadowMap

在Unity裡動態陰影的實現方式還有很多，這裡有個大合集
https://blog.uwa4d.com/archives/sparkle_shadow.html

相關文章