Unity实时阴影实现——Cascaded Shadow Mapping

Perspective aliasing in a shadow map is one of the most difficult problems to overcome. In the technical article, Common Techniques to Improve Shadow Depth Maps, perspective aliasing is described and some approaches to mitigate the problem are identified. In practice, CSMs tend to be the best solution, and are commonly employed in modern games.The basic concept of CSMs is easy to understand. Different areas of the camera frustum require shadow maps with different resolutions. Objects nearest the eye require a higher resolution than do more distant objects. In fact, when the eye moves very close to the geometry, the pixels nearest the eye can require so much resolution that even a 4096 × 4096 shadow map is insufficient.

= Camera.main.transform.TransformPoint(mainCamera_fcs.nearCorners);
    }

    Camera.main.span class="n">CalculateFrustumCorners(new Rect(0, 0, 1, 1), Camera.main.farClipPlane,  Camera.MonoOrStereoscopicEye.Mono, mainCamera_fcs.farCorners);

    for (int i = 0; i < 4; i++)
    {
        mainCamera_fcs.farCorners = Camera.main.transform.TransformPoint(mainCamera_fcs.farCorners);
    }
}这里用到了Unity的API：CalculateFrustumCorners，可方便获取相机Local的视锥顶点坐标，使用时需转换到World空间下。
计算灯光相机包围盒

因为计算得到的包围盒会被直接作为灯光相机的视锥，所以一般包围盒的计算转换到灯光相机空间进行。
void CalcLightCameraFrustum()
{

    if (dirLightCamera == null)
        return;

    for (int i = 0; i < 4; i++)
    {
        lightCamera_fcs.nearCorners = dirLightCamera.transform.InverseTransformPoint(mainCamera_fcs.nearCorners);
        lightCamera_fcs.farCorners = dirLightCamera.transform.InverseTransformPoint(mainCamera_fcs.farCorners);
    }

    float[] xs = { lightCamera_fcs.nearCorners[0].x, lightCamera_fcs.nearCorners[1].x, lightCamera_fcs.nearCorners[2].x, lightCamera_fcs.nearCorners[3].x,
                    lightCamera_fcs.farCorners[0].x, lightCamera_fcs.farCorners[1].x, lightCamera_fcs.farCorners[2].x, lightCamera_fcs.farCorners[3].x };

    float[] ys = { lightCamera_fcs.nearCorners[0].y, lightCamera_fcs.nearCorners[1].y, lightCamera_fcs.nearCorners[2].y, lightCamera_fcs.nearCorners[3].y,
                    lightCamera_fcs.farCorners[0].y, lightCamera_fcs.farCorners[1].y, lightCamera_fcs.farCorners[2].y, lightCamera_fcs.farCorners[3].y };

    float[] zs = { lightCamera_fcs.nearCorners[0].z, lightCamera_fcs.nearCorners[1].z, lightCamera_fcs.nearCorners[2].z, lightCamera_fcs.nearCorners[3].z,
                    lightCamera_fcs.farCorners[0].z, lightCamera_fcs.farCorners[1].z, lightCamera_fcs.farCorners[2].z, lightCamera_fcs.farCorners[3].z };

    float minX = Mathf.Min(xs);
    float maxX = Mathf.Max(xs);
    float minY = Mathf.Min(ys);
    float maxY = Mathf.Max(ys);
    float minZ = Mathf.Min(zs);
    float maxZ = Mathf.Max(zs);

    lightCamera_fcs.nearCorners[0] = new Vector3(minX, minY, minZ);
    lightCamera_fcs.nearCorners[1] = new Vector3(maxX, minY, minZ);
    lightCamera_fcs.nearCorners[2] = new Vector3(maxX, maxY, minZ);
    lightCamera_fcs.nearCorners[3] = new Vector3(minX, maxY, minZ);

    lightCamera_fcs.farCorners[0] = new Vector3(minX, minY, maxZ);
    lightCamera_fcs.farCorners[1] = new Vector3(maxX, minY, maxZ);
    lightCamera_fcs.farCorners[2] = new Vector3(maxX, maxY, maxZ);
    lightCamera_fcs.farCorners[3] = new Vector3(minX, maxY, maxZ);
    ...
}
得到的包围盒用线框绘制出来见下图：




上图的灰色线框表示主相机视锥，绿色线框表示包围盒，红色线框表示近平面。
构造灯光相机

Vector3 pos = lightCamera_fcs.nearCorners[0] + (lightCamera_fcs.nearCorners[2] - lightCamera_fcs.nearCorners[0]) * 0.5f;
        dirLightCamera.transform.position = dirLightCamera.transform.TransformPoint(pos);
        dirLightCamera.transform.rotation = dirLight.transform.rotation;
        dirLightCamera.nearClipPlane = minZ;
        dirLightCamera.farClipPlane = maxZ;
        dirLightCamera.aspect = Vector3.Magnitude(lightCamera_fcs.nearCorners[0] - lightCamera_fcs.nearCorners[1]) / Vector3.Magnitude(lightCamera_fcs.nearCorners[1] - lightCamera_fcs.nearCorners[2]);
        dirLightCamera.orthographicSize = Vector3.Magnitude(lightCamera_fcs.nearCorners[1] - lightCamera_fcs.nearCorners[2]) * 0.5f;
上述代码设置灯光相机的视锥参数(也是灯光相机的投影矩阵)nearClipPlane，farClipPlane，aspect和orthographicSize。
灯光相机的位置和朝向也需要设置，其中位置为近平面的中点，计算方法见下图：




主相机视锥分割

Unity的QualitySettings里提供了对相机视锥的分割设置，见下图：
Unity4级视锥分割参数
UnityShaderVariables.cginc用以下变量保存分割参数：
    float4 _LightSplitsNear;
    float4 _LightSplitsFar;
这里类似实现：
    float[] _LightSplitsNear;
    float[] _LightSplitsFar;

    ...

    float[] nears = { near, far * 0.067f + near, far * 0.133f + far * 0.067f + near, far * 0.267f + far * 0.133f + far * 0.067f + near };
    float[] fars = { far * 0.067f + near, far * 0.133f + far * 0.067f + near, far * 0.267f + far * 0.133f + far * 0.067f + near, far };

    _LightSplitsNear = nears;
    _LightSplitsFar = fars;

    ...

    for (int i = 0; i < 4; i++)
    {
        //计算主相机分割视锥
        ...
        //计算分割视锥的灯光相机包围盒
        ...
    }
得到的分割包围盒见下图：
Unity4级视锥分割俯视图


级联阴影图生成

级联灯光相机通过设置各个级别的视锥依次绘制便得到各自对应阴影图：
List<Matrix4x4> world2ShadowMats = new List<Matrix4x4>(4);
RenderTexture[] depthTextures = new RenderTexture[4];

...

for (int i = 0; i < 4; i++)
{
    depthTextures = new RenderTexture(1024, 1024, 24, rtFormat);
    Shader.SetGlobalTexture("_gShadowMapTexture" + i, depthTextures);
}

...

world2ShadowMats.Clear();

for (int i = 0; i < 4; i++)
{
    ConstructLightCameraSplits(i);
    dirLightCamera.targetTexture = depthTextures;
    dirLightCamera.RenderWithShader(shadowCaster, "");
    projectionMatrix = GL.GetGPUProjectionMatrix(dirLightCamera.projectionMatrix, false);
    world2ShadowMats.Add(projectionMatrix * dirLightCamera.worldToCameraMatrix);
}            

Shader.SetGlobalMatrixArray("_gWorld2Shadow", world2ShadowMats);
Unity底层实现是用一张2x2阴影图集来保存4级阴影图。由于我使用的Unity版本原因，这里使用4张单独的rt来分别保存。
Unity2017新版本里已经加入对RenderTexture分区域更新的特性，这样便也可以在上层实现类似底层的级联阴影图集。


4级级联阴影图
级联阴影图采样

UnityShaderVariables.cginc用以下变量保存分割后的世界坐标到光源空间投影坐标的矩阵变换：
float4x4 unity_WorldToShadow[4];
配合视锥分割参数和片段深度可获取对应级联索引，Internal-ScreenSpaceShadows.cginc：
inline fixed4 getCascadeWeights(float3 wpos, float z)
{
    fixed4 zNear = float4( z >= _LightSplitsNear );
    fixed4 zFar = float4( z < _LightSplitsFar );
    fixed4 weights = zNear * zFar;

    return weights;
}上面函数传进来的片段世界坐标wpos并没有用：（，返回值4个分量均为布尔值，比如z值0.4得到的返回值为fixed4（0,0,1,0)，表示对应3级的矩阵变换和阴影图。
这里类似实现：
uniform float4x4 _gWorld2Shadow[4];

...

float4 SampleShadowTexture(float4 wPos, fixed4 cascadeWeights)
{
    float4 shadowCoord0 = mul(_gWorld2Shadow[0], wPos);
    float4 shadowCoord1 = mul(_gWorld2Shadow[1], wPos);
    float4 shadowCoord2 = mul(_gWorld2Shadow[2], wPos);
    float4 shadowCoord3 = mul(_gWorld2Shadow[3], wPos);

    shadowCoord0.xy /= shadowCoord0.w;
    shadowCoord1.xy /= shadowCoord1.w;
    shadowCoord2.xy /= shadowCoord2.w;
    shadowCoord3.xy /= shadowCoord3.w;

    shadowCoord0.xy = shadowCoord0.xy*0.5 + 0.5;
    shadowCoord1.xy = shadowCoord1.xy*0.5 + 0.5;
    shadowCoord2.xy = shadowCoord2.xy*0.5 + 0.5;
    shadowCoord3.xy = shadowCoord3.xy*0.5 + 0.5;

    float4 sampleDepth0 = tex2D(_gShadowMapTexture0, shadowCoord0.xy);
    float4 sampleDepth1 = tex2D(_gShadowMapTexture1, shadowCoord1.xy);
    float4 sampleDepth2 = tex2D(_gShadowMapTexture2, shadowCoord2.xy);
    float4 sampleDepth3 = tex2D(_gShadowMapTexture3, shadowCoord3.xy);

    float depth0 = shadowCoord0.z / shadowCoord0.w;
    float depth1 = shadowCoord1.z / shadowCoord1.w;
    float depth2 = shadowCoord2.z / shadowCoord2.w;
    float depth3 = shadowCoord3.z / shadowCoord3.w;

    #if defined (SHADER_TARGET_GLSL)
        depth0 = depth0*0.5 + 0.5; //(-1, 1)-->(0, 1)
        depth1 = depth1*0.5 + 0.5;
        depth2 = depth2*0.5 + 0.5;
        depth3 = depth3*0.5 + 0.5;
    #elif defined (UNITY_REVERSED_Z)
        depth0 = 1 - depth0;       //(1, 0)-->(0, 1)
        depth1 = 1 - depth1;
        depth2 = 1 - depth2;
        depth3 = 1 - depth3;
    #endif

    float shadow0 = sampleDepth0 < depth0 ? _gShadowStrength : 1;
    float shadow1 = sampleDepth1 < depth1 ? _gShadowStrength : 1;
    float shadow2 = sampleDepth2 < depth2 ? _gShadowStrength : 1;
    float shadow3 = sampleDepth3 < depth3 ? _gShadowStrength : 1;

    //return col0;
    float shadow = shadow0*cascadeWeights[0] + shadow1*cascadeWeights[1] + shadow2*cascadeWeights[2] + shadow3*cascadeWeights[3];
    return shadow;
}
Shadow Cascadeds查看模式

Unity的Scene模式下有一个Shadow Cascadeds查看模式，可以方便查看整个场景的级联阴影图分布。
这种效果简单实现可以把级联级别作为颜色参数叠加到阴影颜色上即可：
return shadow*cascadeWeights;


Unity自带和自实现的Shadow Cascadeds查看模式对比
结论

CSM能有效解决透视相机下的阴影锯齿问题，基本的SM通过增加阴影图大小可改善阴影质量，但不能根本解决问题。
下面展示了同场景下SM和CSM的阴影质量对比，明显可看出CSM使用相同大小的阴影图(2048x2048 = 4x1024x1024)，但获得了好得多的阴影质量。


单张2048的阴影贴图和4张1024级联阴影贴图阴影效果对比
当然，CSM存在重复绘制和多次采样的问题，这也是Unity的CSM方案对mobile平台缺省为1个cascade的原因。


完整代码见：
参考文献：
Cascaded Shadow Maps
Cascaded Shadow Mapping