Unity Shader-Ambient Occlusion环境光遮蔽（AO贴图，GPU AO贴图烘焙，SSAO，HBAO）

喜欢ヅ旅行 2022-05-09 06:14 205阅读 0赞

# 前言 #

十一放假很开心，正好赶上观望了了许久的《尼尔·机械纪元》打折啦。窝在家里搞了三天三夜，终于E结局通关啦！！！真的好久没玩过这么好玩的游戏了，于是乎我的废话应该会多不少，毕竟，写blog的另一个目的就是记录玩过的好玩的游戏，2333。

最开始听说这个游戏的时候，只是被2B小姐姐的人设吸引了，毕竟小姐姐还是很漂亮的。而且游戏类型也是我喜欢的类型，看起来打击感还不错，加上最近打《地铁》和《消失的光芒》玩出3D眩晕症了，就差嗑两片晕车药再打了，正好搞一个动作型的游戏换换口味。

![70][]

玩起来我才发现游戏的音乐太好听啦，最近简直每天在循环停不下来，场景也是体积光，SSAO之类的高级效果大量使用。

![70 1][]

但是游戏通关之后，我才发现游戏的故事本身就很让人深思，加上丰富的支线剧情。我不敢说玩的游戏很多，但是的确实本人最近玩过的画面，音乐，战斗，剧情都很给力的一款游戏了。

![70 2][]

好在三周目打完之后，加上读档几次，终于打出了E结局，还算比较完美。然而游戏竟然有26个结局，等到重温时争取都打出来。

![70 3][]

唉，一不小心就忍不住想贴贴贴，毕竟游戏太好玩了，但是到此为止了。我不想剧透，下面才是本文的正题。

# 简介 #

《尼尔·机械纪元》中有一个关卡--复制之街。刚一进这个场景，我不由得发出一声惊叹，“我靠，这场景贴图是不是丢了？”

![70 4][]

不过这个场景风格也是蛮不错的，同时也让我想起了一个略微进阶一些的图形技术，环境光遮蔽（AO）。整个场景看起来没有表示颜色的albedo，但是场景的阴影效果和AO效果还是存在的，这让场景的层次细节在即使没有颜色的情况下也可以展现出来，形成了一种特殊的风格。

环境光遮蔽对效果的提升有多重要，看一下顽皮狗在《Uncharted 2: HDR Lighting》的一个对比图，可以看到，左侧的车底遮挡了大部分光线，形成了阴影看起来很自然，而右侧的车感觉就像飘在上面一样，看起来比较假：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_16_color_FFFFFF_t_70][]

环境光遮蔽（Ambient Occlusion），最经常听到的应该是它的缩写AO。既然名字本身就带Ambient，说明其本身是对于环境光强度的一种控制，所以有必要来先了解一下环境光的计算。

光照是可以线性叠加的，一般来说最终的光照结果 = 直接光照 + 间接光照。我们计算物体的直接光照效果时，可以直接通过BRDF计算，而环境光属于间接光照，要想计算真正的环境光，需要在该点法线方向所对应的半球积分计算，在离线渲染的情况下也只能通过蒙特卡洛积分等方式近似计算，对于光线追踪的方式渲染的情况，自然可以得到比较好的效果，但是即使现在的RTX似乎也不能真正地实时跑光线追踪，所以在实时渲染领域，环境光一般使用的就是环境贴图（SkyBox，Reflection Probe），球谐光照（Spherical Harmonic Lighting），光照贴图（Light Map，需要用离线烘焙），甚至直接加一个固定的环境光值（简单粗暴，比如Unity中的UNITY\_LIGHTMODEL\_AMBIENT宏）。普通光源的遮挡效果也就是阴影，我们可以通过Shadow Map，模板阴影等来实现，但是对于环境光的遮挡效果，半球上的光线自然没有方法用普通的Shadow Map方式来计算了。所以研究怎样遮挡环境光的强度的就叫环境光遮蔽。

环境光遮蔽主要用来控制物体和物体相交，夹角，褶皱等位置遮挡漫反射光线的效果，简单来说就是某一点对于环境的暴露比例，如果是平面，那么没有遮蔽；如果是夹角，褶皱等那么周围的面就会遮蔽一部分环境光，就导致该点的环境光相对较弱。如果环境光没有遮蔽效果，那么不管褶皱还是平面，环境光照结果是一致的。而环境光遮蔽可以使褶皱，夹角等位置的光照效果变弱（比如一根管子，在管口的位置应该比较亮，而越向内，应该越暗），提高暗部阴影效果达到一种近似自阴影的效果，提升画面的层次感，增加细节。

在了解了环境光遮蔽的基本概念之后，本文主要实现几种主流的环境光遮蔽效果，AO贴图（使用预烘焙的贴图，实现离线的基于GPU的烘焙AO贴图的工具），SSAO（屏幕空间环境光遮蔽），HBAO（水平基准环境光遮蔽）。

### AO Map-环境光遮蔽贴图 ###

首先看一下最简单的AO贴图的使用，这也是性能最好的方式，但是这并不代表这种方法整体性能好，只是在运行时使用了预计算的结果。而AO贴图的生成是使用光线追踪的方式，反而是这几种AO方式种耗时最长但是效果相对更好的一种，毕竟只要一离线，时间什么的都是次要的。

### 使用美术工具烘焙AO贴图 ###

AO贴图技术已经比较古老了，现有的各种3D软件基本都支持AO的烘焙，如3dsMax，Maya等。我今天使用的是Substance Painter，这个功能很强大的软件，而且相比于前两者，烘焙比较方便，但是据说效果没有前两者好。不过这些都不重要，毕竟怎么烘焙，那是美术同学的事情。

使用Substance Painter的烘焙选项，支持直接烘焙Mesh，烘焙面板如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70][]

我们用一个小狮子的模型导入Substance Painter中，然后使用低模烘焙一发AO贴图，同时工具也支持带有法线贴图的低模烘焙AO贴图，可以把法线细节的AO效果也烘焙出来。烘焙的贴图如下，左侧为直接烘焙，右侧为带有法线贴图之后烘焙的AO效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 1][]

如果抓帧哪个游戏看到某个类似的通道，在褶皱处偏黑的，可能就是AO贴图啦。得到AO贴图之后，下面就需要看一下AO贴图的使用了。

### AO贴图的使用 ###

上面说过，光照是可以线性叠加的，全局光照 = 直接光照 + 间接光照。Unity也不例外，下面是Unity官方Shader的光照叠加部分：

half3 color = diffColor * (gi.diffuse + light.color * diffuseTerm)
                        + specularTerm * light.color * FresnelTerm (specColor, lh)
                        + surfaceReduction * gi.specular * FresnelLerp (specColor, grazingTerm, nv);

不考虑菲尼尔项的话，就是direct diffuse + direct specular + gi diffuse + gi specular，前两者通过BRDF计算，而后两者就是所谓的环境光，我们看一下Unity官方的GI Shader源代码：

inline UnityGI UnityGI_Base(UnityGIInput data, half occlusion, half3 normalWorld)
    {
        UnityGI o_gi;
        ResetUnityGI(o_gi);
    
        // Base pass with Lightmap support is responsible for handling ShadowMask / blending here for performance reason
        #if defined(HANDLE_SHADOWS_BLENDING_IN_GI)
            half bakedAtten = UnitySampleBakedOcclusion(data.lightmapUV.xy, data.worldPos);
            float zDist = dot(_WorldSpaceCameraPos - data.worldPos, UNITY_MATRIX_V[2].xyz);
            float fadeDist = UnityComputeShadowFadeDistance(data.worldPos, zDist);
            data.atten = UnityMixRealtimeAndBakedShadows(data.atten, bakedAtten, UnityComputeShadowFade(fadeDist));
        #endif
    
        o_gi.light = data.light;
        o_gi.light.color *= data.atten;
    
        #if UNITY_SHOULD_SAMPLE_SH
            o_gi.indirect.diffuse = ShadeSHPerPixel(normalWorld, data.ambient, data.worldPos);
        #endif
    
        #if defined(LIGHTMAP_ON)
            // Baked lightmaps
            half4 bakedColorTex = UNITY_SAMPLE_TEX2D(unity_Lightmap, data.lightmapUV.xy);
            half3 bakedColor = DecodeLightmap(bakedColorTex);
    
            #ifdef DIRLIGHTMAP_COMBINED
                fixed4 bakedDirTex = UNITY_SAMPLE_TEX2D_SAMPLER (unity_LightmapInd, unity_Lightmap, data.lightmapUV.xy);
                o_gi.indirect.diffuse += DecodeDirectionalLightmap (bakedColor, bakedDirTex, normalWorld);
    
                #if defined(LIGHTMAP_SHADOW_MIXING) && !defined(SHADOWS_SHADOWMASK) && defined(SHADOWS_SCREEN)
                    ResetUnityLight(o_gi.light);
                    o_gi.indirect.diffuse = SubtractMainLightWithRealtimeAttenuationFromLightmap (o_gi.indirect.diffuse, data.atten, bakedColorTex, normalWorld);
                #endif
    
            #else // not directional lightmap
                o_gi.indirect.diffuse += bakedColor;
    
                #if defined(LIGHTMAP_SHADOW_MIXING) && !defined(SHADOWS_SHADOWMASK) && defined(SHADOWS_SCREEN)
                    ResetUnityLight(o_gi.light);
                    o_gi.indirect.diffuse = SubtractMainLightWithRealtimeAttenuationFromLightmap(o_gi.indirect.diffuse, data.atten, bakedColorTex, normalWorld);
                #endif
    
            #endif
        #endif
    
        #ifdef DYNAMICLIGHTMAP_ON
            // Dynamic lightmaps
            fixed4 realtimeColorTex = UNITY_SAMPLE_TEX2D(unity_DynamicLightmap, data.lightmapUV.zw);
            half3 realtimeColor = DecodeRealtimeLightmap (realtimeColorTex);
    
            #ifdef DIRLIGHTMAP_COMBINED
                half4 realtimeDirTex = UNITY_SAMPLE_TEX2D_SAMPLER(unity_DynamicDirectionality, unity_DynamicLightmap, data.lightmapUV.zw);
                o_gi.indirect.diffuse += DecodeDirectionalLightmap (realtimeColor, realtimeDirTex, normalWorld);
            #else
                o_gi.indirect.diffuse += realtimeColor;
            #endif
        #endif
    
        o_gi.indirect.diffuse *= occlusion;
        return o_gi;
    }

虽然代码看起来比较长，不过绝大部分都不是我们关心的重点，我们重点在于UnityGI\_Base和UnityGI\_IndirectSpecular两个函数的倒数第二行代码，通过一个occlusion值调制了一下最终gi diffuse和gi specular的结果，而这个occlusion就是我们从AO贴图中采样得到的结果。实际上AO贴图的原理就是简单粗暴地将AO贴图采样出来的值乘以到GI的输出上，这样AO贴图中黑色的部分就会抑制环境光的强度达到环境光遮蔽的效果。

最后，我们对比一下使用AO贴图后的效果。使用上面两张烘焙贴图左的贴图，不带法线贴图烘焙后的结果。左侧为仅显示环境光效果，中间为带有AO贴图的效果，右侧为无AO贴图的效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 2][]

使用的右侧的AO贴图，烘焙时使用了法线贴图。左侧为仅显示环境光效果，中间为带有AO贴图的效果，右侧为无AO贴图的效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 3][]

可见，使用了AO贴图后，在小狮子的眼窝，嘴巴，爪子下，接缝，球底等部分环境光都降低了，使狮子的细节表现更加丰富，而最右侧的无AO贴图的效果则整体光照效果偏平，没有过渡。

## Bake AO-GPU AO贴图烘焙 ##

上面我们看到了AO贴图的使用，也使用了美术工具烘焙出了AO贴图，下面，为了更进一步理解AO贴图，我们来研究一下离线的AO贴图是怎样生成的，并且使用Shader实现一个非常简易的AO烘焙工具（娱乐而已，并不实用）。

### AO烘焙的原理 ###

离线烘焙，我们无需考虑过多近似的方法苟，直接使用光线追踪即可。关于光线追踪，之前看到好多知乎的大佬们都在玩，其实我之前也小玩了一下，实现过一版简易的方法。实际上主要就是参考了《RayTracing In one Weekend》这篇文章。不过，那时使用的是C++，纯单核CPU实现，速度慢到令人发指。所以，这次我决定改变一下思路，实现一个基于GPU的烘焙。

上面说过，AO所描述的就是一点对于周围环境暴露的比例。那么很简单，我们对于模型上的每一个点（对应展开uv到贴图上的每个像素点），向其法线所在的半球空间发射无数的光线，如果碰撞到了其他的三角形，就认为被遮挡了，当然，还需要判断是否超出了遮挡的范围，也就是我们控制AO半球的直径，为了效果更好，我们也可以再乘以一个距离的权重。

理想很美好，但是现实很残酷，我们没有办法发射无数的光线，所以我们只能用近似的方法模拟，也就是所谓的蒙特卡洛方法，当样本数达到一定量级的时候，概率也可以作为结果。

### AO烘焙的实现 ###

下面看一下实现，首先，我们要烘焙一张贴图，那么最重要的就是怎样把贴图直接展开到uv上并且显示出来，其实也比较简单，我们可以在vertex shader中得到uv，但是我们不进行正常的mvp变换，而是直接把uv坐标的位置作为输出的位置，就可以把模型展开的uv再渲染到RT上，vertex关键代码：

v2f vert (appdata v)
    {
    	v2f o;
    	float2 uv = v.uv;
    	uv.y = 1 - v.uv.y;
    	o.vertex = float4(uv * 2 - 1, 0, 1);
    	return o;
    }

还是上面的小狮子模型，这下被拍扁到屏幕上了，好惨：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_16_color_FFFFFF_t_70 1][]

不过接下来，我们就可以比较容易地实现AO的烘焙了。首先，我们围绕半球空间构建一系列的随机采样点，然后将这些点通过模型的tbn基坐标转化到模型空间，然后对于每个采样点的方向，计算该方向与其他所有三角形是否相交且小于遮挡半径。最终平均多个采样点的结果，得到最终的AO贴图。

关键部分代码如下，此处将三角形的顶点信息直接传递到了uniform中，但是目前有顶点数限制，1300顶点以上烘焙显卡就会崩溃，不过实验的话，已经足够啦。

float aovalue = 0;
    for (int s = 0; s < (int)_SampleDirCount; s++)
    {
    	float3 sampleDir = _SampleDir[s];
    	sampleDir = normalize(sampleDir);
    	float3 objDir = i.objTangent * sampleDir.x + i.objBiNormal * sampleDir.y + i.objNormal * sampleDir.z;
    	float currentLength = _AOTracingRadius;
    	for (int j = 0; j < (int)_TriangleCount; j++)
    	{
    		float3 p0 = _TriangleX[j].xyz;
    		float3 p1 = _TriangleY[j].xyz;
    		float3 p2 = _TriangleZ[j].xyz;
    		float raylength;
    		bool result = RayTriangleTest(objDir, i.objPos, p0, p1, p2, raylength);
    		if (result && raylength < currentLength)
    		{
    			currentLength = raylength;
    		}
    	}
    	float ao = clamp(currentLength, 0, _AOTracingRadius) / _AOTracingRadius;
    	aovalue += ao;
    }
    aovalue /= _SampleDirCount;
    aovalue = pow(aovalue, _AOStrength);

烘焙后的效果，左侧为带有AO贴图效果，右侧为无AO的效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_16_color_FFFFFF_t_70 2][]

关于三角形与射线相交的代码，可以参考[《射线和三角形的相交检测（ray triangle intersection test） 》][ray triangle intersection test_]这篇blog，这位大佬写得非常清楚啦，膜拜一波。

关于AO烘焙，不想花太多的时间去做优化了，毕竟目前美术工具烘焙AO已经很成熟了，下面才是本文的重点，屏幕空间的AO算法，SSAO和HBAO。

## SSAO-屏幕空间环境光遮蔽 ##

屏幕空间环境光遮蔽（Screen Space Ambient Occlusion），简称SSAO。最早是07年CryTek开始在《孤岛危机2》中提出的一项技术。由于环境光遮蔽的计算比较复杂，即使是使用蒙特卡洛积分的方式，仅仅是进行随机采样进行计算，如果逐物体计算也是不太可能的，而屏幕空间计算可以保证计算复杂度与场景复杂度解耦，只计算屏幕对应像素的环境光遮蔽，再配合jitter以及降低分辨率等计算，使实时近似的环境遮蔽成为可能，并且真正在游戏中运用。从此这项技术便一发不可收拾，成为了各大游戏必备的选项，并且后续衍生出了各种进化版本如HBAO，SSDO，TSSAO等基于屏幕空间计算的环境光遮蔽效果。（当年的CryEngine真的是引领了一大波渲染技术的热潮啊）。

### SSAO的原理 ###

关于SSAO相关的一些原理，可以参考[《Comparative Study of SSAO Methods》][Comparative Study of SSAO Methods]这篇论文，文中比对了各种SSAO的计算。下文中几张SSAO的原理图引用自该论文。

前面说过，环境光本身是基于当前点法线半球上的积分计算，想真正求积分是不可能滴。近似求积分的话，最容易的就是蒙特卡洛积分，说的通俗易懂一点的话，就是概率，当样本数达到一定程度之后，我们就不求计算精确的值，而是直接使用一些样本进行采样。那么，我们在法线的半球上计算环境光遮蔽的因子时，我们就可以采用概率的方式。在法线的半球上设置一系列随机的采样点，然后遍历每一个采样点，判断采样点的深度值是否小于该点对应的深度，如果小于说明这个采样点没有被平面挡住，遍历完成后除以总采样点数，就可以得到当前半球上环境光显示的百分比，1-环境光百分比得到最终的环境光遮蔽值。

不过SSAO技术在最早在CryTek使用的时候并非是在半球上进行的计算，而是在一个球形内进行的概率计算，如下图，P为当前像素点，在该点一定范围的球形分布着随机采样点，绿色为未被遮蔽的，红色为被遮蔽的：

![70 5][]

CryTek使用球形进行计算的话有一个好处就是无需屏幕空间法线，对于前向渲染的话仅有深度就可以实现SSAO的计算，无需额外考虑全屏Normal，但是也有一个不好的地方，在于整个球进行概率计算的话，不管怎么样，都会有50%的点被遮蔽。这也是导致CryTek最早版本的SSAO效果很奇怪的原因，对于褶皱处AO效果很明显，但是平面上也会被计算出遮蔽值（图片来自《Finding Next Gen – CryEngine 2》）：

![70 6][]

所以后续的版本就采用了更加精确的方式，即只在法线对应方向的半球上进行遮蔽概率计算，使环境光遮蔽效果大大提升。如下图所示，P点为当前像素点，n为对应法线方向，所在半球上分布着随机采样点，其中绿色的采样点为未被遮蔽的，红色的为为被遮蔽的：

![70 7][]

### SSAO的优缺点 ###

SSAO还是有很多优点的：

1.速度较快，相对于离线的AO烘焙，至少使实时计算AO成为了可能。

2.无需预处理，不需要预先烘焙AO贴图，降低美术工作成本，降低贴图数量（少一个通道也是省啊，干点啥不好）。

3.支持动态AO遮挡，动态物体没有办法烘焙AO，只能使用SSAO。

4.SS系列的共性优点，与场景复杂度无关，仅与屏幕分辨率有关。

5.无CPU消耗，纯GPU逻辑，易集成，有Depth Normal即可，与当今的延迟渲染非常契合。甚至NVIDIA显卡自身都可以开。

SSAO的缺点：

1.GPU瓶颈，虽然不耗CPU，但是这个真的是超级费GPU，手机上本人曾经测试小米8开启后帧率直接下降15帧左右！

2.SS系列的共性缺点，屏幕外面的东西如果遮挡了，是没有效果的。比如车底，本身不在DepthBuffer中，取不到信息，自然也就算不出遮挡以及AO了。不过好在这个问题不像SSR那样明显。

3.前向渲染不划算，和SSR一样，这个SSAO需要全屏幕的Depth以及Normal，全场景先来一遍你懂得。

### SSAO的实现 ###

要使用SSAO，需要有全屏幕的深度来反算视空间位置；而为了保证采样点集中在法线所在半球，需要有全屏幕的法线图。如果是延迟渲染，那么这两个都可以免费得到，通过DepthTexture和GBuffer得到。但是前向渲染下我们就只能通过CameraDepthNormalTexture来得到深度+法线纹理。

下面看一下SSAO的实现，首先，我们生成一系列的随机采样点，为了让遮蔽效果更好，我们尽量保证在靠近采样点的位置分布更多的随机点：

private void GenerateAOSampleKernel()
    {
        if (SampleKernelCount == sampleKernelList.Count)
            return;
        sampleKernelList.Clear();
        for(int i = 0; i < SampleKernelCount; i++)
        {
            var vec = new Vector4(Random.Range(-1.0f, 1.0f), Random.Range(-1.0f, 1.0f), Random.Range(0, 1.0f), 1.0f);
            vec.Normalize();
            var scale = (float)i / SampleKernelCount;
            //使分布符合二次方程的曲线
            scale = Mathf.Lerp(0.01f, 1.0f, scale * scale);
            vec *= scale;
            sampleKernelList.Add(vec);
        }
    }

关键Shader部分代码如下：

fixed4 frag_ao (v2f i) : SV_Target
    {
    	fixed4 col = tex2D(_MainTex, i.uv);
    	
    	float linear01Depth;
    	float3 viewNormal;
    	
    	float4 cdn = tex2D(_CameraDepthNormalsTexture, i.uv);
    	DecodeDepthNormal(cdn, linear01Depth, viewNormal);
    	
    	float3 viewPos = linear01Depth * i.viewRay;
    	float3 viewDir = normalize(viewPos);
    	viewNormal = normalize(viewNormal);
    	
    	int sampleCount = _SampleKernelCount;
    
    	float oc = 0.0;
    	for(int i = 0; i < sampleCount; i++)
    	{
    		float3 randomVec = _SampleKernelArray[i].xyz;
    		//如果随机点的位置与法线反向，那么将随机方向取反，使之保证在法线半球
    		randomVec = dot(randomVec, viewNormal) < 0 ? -randomVec : randomVec;
    		
    		float3 randomPos = viewPos + randomVec * _SampleKeneralRadius;
    		float3 rclipPos = mul((float3x3)unity_CameraProjection, randomPos);
    		float2 rscreenPos = (rclipPos.xy / rclipPos.z) * 0.5 + 0.5;
    		
    		float randomDepth;
    		float3 randomNormal;
    		float4 rcdn = tex2D(_CameraDepthNormalsTexture, rscreenPos);
    		DecodeDepthNormal(rcdn, randomDepth, randomNormal);
    		float range = abs(randomDepth - linear01Depth) * _ProjectionParams.z < _SampleKeneralRadius ? 1.0 : 0.0;
    		float ao = randomDepth + _DepthBiasValue < linear01Depth  ? 1.0 : 0.0;
    		oc += ao * range;
    	}
    	oc /= sampleCount;
    	oc = max(0.0, 1 - oc * _AOStrength);
    
    	col.rgb = oc;
    	return col;
    }

我们没有使用Tangent进行旋转来保证采样点在法线半球，而是直接使用屏幕空间的法线与随机采样方向点乘，如果二者方向相反，说明没在同一半球，再将其取反。在最终计算深度进行比较时，我们增加了一个BiasValue，为了防止在平面上产生自阴影的问题，同时也需要增加一个深度差的比较，我们需要保证深度差小于采样半径，否则可能会出现相距很远的物体也产生遮蔽的情况，如下图，左侧为没有添加距离判断的情况，人物距离后面的墙面已经很远了，但是仍然产生了不正常的遮蔽效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 4][]

最后，在计算遮蔽权重时，我们并非直接计算非0即1的遮蔽值，而是乘以了一个距离的权重，使AO有一个更好的渐变效果，AO的效果如下，在台阶的拐角处，夹缝等地方都有比较明显的环境光遮蔽的效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 5][]

但是仔细观察上图，我们会发现AO贴图中有一些噪点，并不平滑，有些许颗粒感。这和我们之前使用Dither RayMarching的体积光，屏幕空间反射的道理一样，都是因为我们引入了随机噪声。所以下一步就是需要使用一个滤波的Pass对AO的结果进行去噪。最简单的方式肯定就是高斯模糊了，但是如果们使用高斯模糊的话，整个图片就都会被模糊掉了，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 6][]

显然，这不是我们想要的效果，所以我们需要引入一种能够保持明显边界，而又可以去噪的滤波。也就是所谓的双边滤波（Bilateral Filter）。双边滤波可以在模糊的同时保持图像中的边缘信息。除了考虑正常高斯滤波的空域信息（domain）外，还要考虑另外的一个图像本身携带的值域信息（range）。这个值域信息的选择并非唯一的，可以是采样点间像素颜色的差异，可以是采样点像素对应的法线信息，可以是采样点像素对应的深度信息。使用双边滤波可以实现一些好玩的效果，比如用于美颜的磨皮滤镜。关于详细的双边滤波，实现，这里不再赘述，可以参考本人之前的blog-[《UnityShader-BilateralFilter（双边滤波，磨皮滤镜）》][UnityShader-BilateralFilter]。还是上面的AO效果，使用双边滤波进行去噪后的结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 7][]

可见，使用双边滤波后的AO效果已经达到了可以接受的程度。最后，我们要做的就是将AO贴图与原始图像进行混合，用AO值来调制原始图像的颜色。如果是延迟渲染，自然我们可以在GBuffer渲染之后进行SSAO计算，然后在最终光照时将SSAO运用到环境光遮蔽上，但是对于前向渲染来说，我们没有办法这么做（当然，如果每个Shader里面都ComputeScreenPos的话也不是不可以，但是我想基本没有人想这么干吧），直接将SSAO运用到整个图像上也可以达到很好的效果了。

下面看一下使用AO前后的效果对比，原始的场景如下，仅有一盏主平行光源，开启ShadowMap的效果，画面整体偏平，没有细节过渡：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 8][]

开启SSAO之后，在楼梯折角，缝隙，草根，墙角等地方光照强度都降低了，使画面细节大大增加（AO强度开得大了点，不过，我喜欢^\_^）：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 9][]

下面附上SSAO代码，C\#部分代码如下：

/********************************************************************
     FileName: ScreenSpaceAOEffect.cs
     Description: SSAO屏幕空间环境光遮蔽效果
     history: 6:10:2018 by puppet_master
     https://blog.csdn.net/puppet_master
    *********************************************************************/
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    [ExecuteInEditMode]
    public class ScreenSpaceAOEffect : MonoBehaviour
    {
        private Material ssaoMaterial = null;
        private Camera currentCamera = null;
        private List<Vector4> sampleKernelList = new List<Vector4>();
    
        [Range(0, 0.002f)]
        public float DepthBiasValue = 0.002f;
        [Range(0.010f, 1.0f)]
        public float SampleKernelRadius = 1.0f;
        [Range(4, 32)]
        public int SampleKernelCount = 16;
        [Range(0.0f, 5.0f)]
        public float AOStrength = 1.0f;
        [Range(0, 2)]
        public int DownSample = 0;
    
        [Range(1, 4)]
        public int BlurRadius = 1;
        [Range(0, 0.2f)]
        public float BilaterFilterStrength = 0.2f;
    
        public bool OnlyShowAO = false;
    
        public enum SSAOPassName
        {
            GenerateAO = 0,
            BilateralFilter = 1,
            Composite = 2,
        }
    
        private void Awake()
        {
            var shader = Shader.Find("AO/ScreenSpaceAOEffect");
            ssaoMaterial = new Material(shader);
            currentCamera = GetComponent<Camera>();
        }
    
        private void OnEnable()
        {
            currentCamera.depthTextureMode |= DepthTextureMode.DepthNormals;
        }
    
        private void OnDisable()
        {
            currentCamera.depthTextureMode &= ~DepthTextureMode.DepthNormals;
        }
    
        private void OnRenderImage(RenderTexture source, RenderTexture destination)
        {
            GenerateAOSampleKernel();
    
            var aoRT = RenderTexture.GetTemporary(source.width >> DownSample, source.height >> DownSample, 0);
    
            ssaoMaterial.SetMatrix("_InverseProjectionMatrix", currentCamera.projectionMatrix.inverse);
            ssaoMaterial.SetFloat("_DepthBiasValue", DepthBiasValue);
            ssaoMaterial.SetVectorArray("_SampleKernelArray", sampleKernelList.ToArray());
            ssaoMaterial.SetFloat("_SampleKernelCount", sampleKernelList.Count);
            ssaoMaterial.SetFloat("_AOStrength", AOStrength);
            ssaoMaterial.SetFloat("_SampleKeneralRadius", SampleKernelRadius);
            Graphics.Blit(source, aoRT, ssaoMaterial, (int)SSAOPassName.GenerateAO);
    
            var blurRT = RenderTexture.GetTemporary(source.width >> DownSample, source.height >> DownSample, 0);
            ssaoMaterial.SetFloat("_BilaterFilterFactor", 1.0f - BilaterFilterStrength);
    
            ssaoMaterial.SetVector("_BlurRadius", new Vector4(BlurRadius, 0, 0, 0));
            Graphics.Blit(aoRT, blurRT, ssaoMaterial, (int)SSAOPassName.BilateralFilter);
    
            ssaoMaterial.SetVector("_BlurRadius", new Vector4(0, BlurRadius, 0, 0));
            if (OnlyShowAO)
            {
                Graphics.Blit(blurRT, destination, ssaoMaterial, (int)SSAOPassName.BilateralFilter);
            }
            else
            {
                Graphics.Blit(blurRT, aoRT, ssaoMaterial, (int)SSAOPassName.BilateralFilter);
                ssaoMaterial.SetTexture("_AOTex", aoRT);
                Graphics.Blit(source, destination, ssaoMaterial, (int)SSAOPassName.Composite);
            }
    
            RenderTexture.ReleaseTemporary(aoRT);
            RenderTexture.ReleaseTemporary(blurRT);
        }
    
        private void GenerateAOSampleKernel()
        {
            if (SampleKernelCount == sampleKernelList.Count)
                return;
            sampleKernelList.Clear();
            for(int i = 0; i < SampleKernelCount; i++)
            {
                var vec = new Vector4(Random.Range(-1.0f, 1.0f), Random.Range(-1.0f, 1.0f), Random.Range(0, 1.0f), 1.0f);
                vec.Normalize();
                var scale = (float)i / SampleKernelCount;
                //使分布符合二次方程的曲线
                scale = Mathf.Lerp(0.01f, 1.0f, scale * scale);
                vec *= scale;
                sampleKernelList.Add(vec);
            }
        }
    
    }

Shader部分代码如下：

/********************************************************************
     FileName: ScreenSpaceAOEffect.cs
     Description: SSAO屏幕空间环境光遮蔽效果
     history: 6:10:2018 by puppet_master
     https://blog.csdn.net/puppet_master
    *********************************************************************/
    Shader "AO/ScreenSpaceAOEffect"
    {
    	Properties
    	{
    		_MainTex ("Texture", 2D) = "black" {}
    	}
    	CGINCLUDE
    	#include "UnityCG.cginc"
    	
    	struct appdata
    	{
    		float4 vertex : POSITION;
    		float2 uv : TEXCOORD0;
    	};
    	
    	struct v2f
    	{
    		float2 uv : TEXCOORD0;
    		float4 vertex : SV_POSITION;
    		float3 viewRay : TEXCOORD1;
    	};
    	
    	#define MAX_SAMPLE_KERNEL_COUNT 32
    	sampler2D _MainTex;
    	sampler2D _CameraDepthNormalsTexture;
    	float4x4 _InverseProjectionMatrix;
    	float _DepthBiasValue;
    	float4 _SampleKernelArray[MAX_SAMPLE_KERNEL_COUNT];
    	float _SampleKernelCount;
    	float _AOStrength;
    	float _SampleKeneralRadius;
    	
    	float4 _MainTex_TexelSize;
    	float4 _BlurRadius;
    	float _BilaterFilterFactor;
    	
    	sampler2D _AOTex;
    	
    	float3 GetNormal(float2 uv)
    	{
    		float4 cdn = tex2D(_CameraDepthNormalsTexture, uv);
    		return DecodeViewNormalStereo(cdn);
    	}
    	
    	half CompareNormal(float3 normal1, float3 normal2)
    	{
    		return smoothstep(_BilaterFilterFactor, 1.0, dot(normal1, normal2));
    	}
    	
    	v2f vert_ao (appdata v)
    	{
    		v2f o;
    		o.vertex = UnityObjectToClipPos(v.vertex);
    		o.uv = v.uv;
    		float4 clipPos = float4(v.uv * 2 - 1.0, 1.0, 1.0);
    		float4 viewRay = mul(_InverseProjectionMatrix, clipPos);
    		o.viewRay = viewRay.xyz / viewRay.w;
    		return o;
    	}
    	
    	fixed4 frag_ao (v2f i) : SV_Target
    	{
    		fixed4 col = tex2D(_MainTex, i.uv);
    		
    		float linear01Depth;
    		float3 viewNormal;
    		
    		float4 cdn = tex2D(_CameraDepthNormalsTexture, i.uv);
    		DecodeDepthNormal(cdn, linear01Depth, viewNormal);
    		float3 viewPos = linear01Depth * i.viewRay;
    		viewNormal = normalize(viewNormal) * float3(1, 1, -1);
    		
    		int sampleCount = _SampleKernelCount;
    	
    		float oc = 0.0;
    		for(int i = 0; i < sampleCount; i++)
    		{
    			float3 randomVec = _SampleKernelArray[i].xyz;
    			//如果随机点的位置与法线反向，那么将随机方向取反，使之保证在法线半球
    			randomVec = dot(randomVec, viewNormal) < 0 ? -randomVec : randomVec;
    			
    			float3 randomPos = viewPos + randomVec * _SampleKeneralRadius;
    			float3 rclipPos = mul((float3x3)unity_CameraProjection, randomPos);
    			float2 rscreenPos = (rclipPos.xy / rclipPos.z) * 0.5 + 0.5;
    			
    			float randomDepth;
    			float3 randomNormal;
    			float4 rcdn = tex2D(_CameraDepthNormalsTexture, rscreenPos);
    			DecodeDepthNormal(rcdn, randomDepth, randomNormal);
    			float range = abs(randomDepth - linear01Depth) * _ProjectionParams.z < _SampleKeneralRadius ? 1.0 : 0.0;
    			float ao = randomDepth + _DepthBiasValue < linear01Depth  ? 1.0 : 0.0;
    			oc += ao * range;
    		}
    		oc /= sampleCount;
    		oc = max(0.0, 1 - oc * _AOStrength);
    	
    		col.rgb = oc;
    		return col;
    	}
    	
    	fixed4 frag_blur (v2f i) : SV_Target
    	{
    		float2 delta = _MainTex_TexelSize.xy * _BlurRadius.xy;
    		
    		float2 uv = i.uv;
    		float2 uv0a = i.uv - delta;
    		float2 uv0b = i.uv + delta;	
    		float2 uv1a = i.uv - 2.0 * delta;
    		float2 uv1b = i.uv + 2.0 * delta;
    		float2 uv2a = i.uv - 3.0 * delta;
    		float2 uv2b = i.uv + 3.0 * delta;
    		
    		float3 normal = GetNormal(uv);
    		float3 normal0a = GetNormal(uv0a);
    		float3 normal0b = GetNormal(uv0b);
    		float3 normal1a = GetNormal(uv1a);
    		float3 normal1b = GetNormal(uv1b);
    		float3 normal2a = GetNormal(uv2a);
    		float3 normal2b = GetNormal(uv2b);
    		
    		fixed4 col = tex2D(_MainTex, uv);
    		fixed4 col0a = tex2D(_MainTex, uv0a);
    		fixed4 col0b = tex2D(_MainTex, uv0b);
    		fixed4 col1a = tex2D(_MainTex, uv1a);
    		fixed4 col1b = tex2D(_MainTex, uv1b);
    		fixed4 col2a = tex2D(_MainTex, uv2a);
    		fixed4 col2b = tex2D(_MainTex, uv2b);
    		
    		half w = 0.37004405286;
    		half w0a = CompareNormal(normal, normal0a) * 0.31718061674;
    		half w0b = CompareNormal(normal, normal0b) * 0.31718061674;
    		half w1a = CompareNormal(normal, normal1a) * 0.19823788546;
    		half w1b = CompareNormal(normal, normal1b) * 0.19823788546;
    		half w2a = CompareNormal(normal, normal2a) * 0.11453744493;
    		half w2b = CompareNormal(normal, normal2b) * 0.11453744493;
    		
    		half3 result;
    		result = w * col.rgb;
    		result += w0a * col0a.rgb;
    		result += w0b * col0b.rgb;
    		result += w1a * col1a.rgb;
    		result += w1b * col1b.rgb;
    		result += w2a * col2a.rgb;
    		result += w2b * col2b.rgb;
    		
    		result /= w + w0a + w0b + w1a + w1b + w2a + w2b;
    		return fixed4(result, 1.0);
    	}
    	
    	fixed4 frag_composite(v2f i) : SV_Target
    	{
    		fixed4 ori = tex2D(_MainTex, i.uv);
    		fixed4 ao = tex2D(_AOTex, i.uv);
    		ori.rgb *= ao.r;
    		return ori;
    	}
    
    	ENDCG
    	
    	SubShader
    	{
    		
    		Cull Off ZWrite Off ZTest Always
    
    		//Pass 0 : Generate AO 
    		Pass
    		{
    			CGPROGRAM
    			#pragma vertex vert_ao
    			#pragma fragment frag_ao
    			ENDCG
    		}
    		
    		//Pass 1 : Bilateral Filter Blur
    		Pass
    		{
    			CGPROGRAM
    			#pragma vertex vert_ao
    			#pragma fragment frag_blur
    			ENDCG
    		}
    		
    		//Pass 2 : Composite AO
    		Pass
    		{
    			CGPROGRAM
    			#pragma vertex vert_ao
    			#pragma fragment frag_composite
    			ENDCG
    		}
    	}
    }

关于TSSAO其实是SSAO的一种优化，主体的思想是没有变的，主要是使用了Reverse Reprojection技术加速计算，这个等以后玩Temporal的时候再说啦。下面看一种与SSAO本身实现差异较大的一种AO实现。

## HBAO-水平基准环境光遮蔽 ##

HBAO，是NVIDIA提出的另一种实现SSAO的方式，全称Horizon-Based Ambient Occlusion为水平基准环境光遮蔽。这个技术最早是在08年时提出的，在CryTek之后。而后在最近几年吸取了Scalable Ambient Obscurance等方法的优点，在14年左右进化成了HBAO+，一度成为了当时效果最好的环境光遮蔽。不过当时基于距离场的方法还没火哈。15年的时候被游戏评测爆吹了一顿，[《SSAO进化之巅峰—水平基准环境光遮蔽HBAO+》][SSAO_HBAO]，当年我看到这个文章的时候就是，“哇塞，看不懂，收藏，告辞“，其实现在HBAO+我也没懂，今天要玩的就是最普通的HBAO，甚至是简化版本的HBAO，但是个人感觉效果已经比32随机采样点的SSAO效果要好。

### HBAO实现原理 ###

HBAO的实现原理首先可以参考08年Siggraph上NVIDIA分享的PPT[《Image Space Horizon-Based Ambient Occlusion》][Image Space Horizon-Based Ambient Occlusion]以及《ShaderX7》，书中有一整章讲Ambient Occlusion的章节，当然还有SSAO中提到的那篇对比各种SSAO实现方式的论文。注意：本文实现的并非正统HBAO，感兴趣的可以去看原论文。我只是玩了个简化的版本，可能原理上是错误的，但是简单，粗暴，效果差不太远。（对我来说，苟出一个省一些的效果，要远比基于“物理”更重要。）

SSAO中判断是否遮挡是通过深度来判断的，而HBAO做得更加彻底，直接将屏幕空间的一个方向对应的深度信息作为高度信息，沿着这个方向进行Ray Marching判断是否遮挡。关于Ray Marching，之前我们在体积光，屏幕空间反射都使用过Ray Marching，不过都是通过屏幕空间深度反算视空间位置，在视空间进行的Ray Marching，而HBAO的Ray Marching方向略有不同，是直接在屏幕空间进行Ray Marching，如下图所示（来自上文NVIDIA的PPT）：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 10][]

首先，在屏幕空间任意一点，将其周围360的角度进行均分，每个方向分别做RayMarching，入图中左半部分，分为四个方向进行Ray Marching。而对于每个方向来说，则如右图所示，沿着Ray Marching的方向为Image Plane所示的方向，每步进一次，采样一次深度信息判断角度：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 11][]

如图，P点为当前像素点，+X方向为Ray Marching的方向，S0为第一个采样点，该点的角度值大于Bias值（预先设定的阈值）即认为遮挡，而第二个采样点S1，角度小于PS0，不遮挡不计，而S2的角度大于了S0的角度，计入遮挡，S3同理。这样的好处在于可以处理类似S1这样的假遮挡点，使最终的AO结果更加精确。最终每个遮挡点根据距离权重计入，每个方向进行遮挡计算的和，除以方向数，就得到最终的遮挡结果了。

原论文的HBAO，所指的夹角是Z轴（或XY平面）和PS之间的夹角，还需要考虑进来真正的顶点所对应的法线方向以及tangent平面，即最终是AO值 = sin h（Horizon Angle，atan(H.z / H.xy)） - sin t（Tangent Angle，atan（T.z / T.xy）），为了简化，本人直接使用P点对应平面与PS之间的夹角进行计算，再一步转化就可以用P点对应Normal与PS之间夹角进行计算，测试也可以得到不错的效果。

### HBAO效果实现 ###

HBAO关键部分Shader代码如下：

inline float2 RotateDirections(float2 dir, float2 rot) {
    	return float2(dir.x * rot.x - dir.y * rot.y,
    				  dir.x * rot.y + dir.y * rot.x);
    }
    
    inline float Falloff2(float distance, float radius)
    {
    	float a = distance / radius;
    	return clamp(1.0 - a * a, 0.0, 1.0);
    }
    
    float3 GetViewPos(v2f i, float2 uv)
    {
    	float linear01Depth;
    	float3 viewNormal;
    	float4 cdn = tex2D(_CameraDepthNormalsTexture, uv);
    	DecodeDepthNormal(cdn, linear01Depth, viewNormal);
    	float3 viewPos = linear01Depth * i.viewRay;
    	return viewPos;
    }
    
    // Reconstruct view-space position from UV and depth.
    // p11_22 = (unity_CameraProjection._11, unity_CameraProjection._22)
    // p13_31 = (unity_CameraProjection._13, unity_CameraProjection._23)
    float3 ReconstructViewPos(float2 uv)
    {
    	float3x3 proj = (float3x3)unity_CameraProjection;
    	float2 p11_22 = float2(unity_CameraProjection._11, unity_CameraProjection._22);
    	float2 p13_31 = float2(unity_CameraProjection._13, unity_CameraProjection._23);
    	float depth;
    	float3 viewNormal;
    	float4 cdn = tex2D(_CameraDepthNormalsTexture, uv);
    	DecodeDepthNormal(cdn, depth, viewNormal);
    	depth *= _ProjectionParams.z;
    	return float3((uv * 2.0 - 1.0 - p13_31) / p11_22 * (depth), depth);
    }
    
    inline float2 GetRayMarchingDir(float angle)
    {
    	float sinValue, cosValue;
    	sincos(angle, sinValue, cosValue);
    	return RotateDirections(float2(cosValue, sinValue), float2(1.0, 0));
    }
    
    fixed4 frag_ao (v2f i) : SV_Target
    {
    	float2 InvScreenParams = _ScreenParams.zw - 1.0;
    	fixed4 col = tex2D(_MainTex, i.uv);
    	float3 viewPos = ReconstructViewPos(i.uv);
    
    	float4 cdn = tex2D(_CameraDepthNormalsTexture, i.uv);
    	float3 viewNormal =  DecodeViewNormalStereo(cdn) * float3(1.0, 1.0, -1.0);
    
    	float rayMarchingRadius = min(_SampleRadius / viewPos.z, _MaxPixelRadius);
    	float rayMarchingStepSize =  rayMarchingRadius / _RayMarchingStep;
    	float rayAngleSize = 2.0 * UNITY_PI / _RayAngleStep;	
    	
    	float oc = 0.0;
    	for(int j = 0; j < _RayAngleStep; j++)
    	{
    		float2 rayMarchingDir = GetRayMarchingDir(j * rayAngleSize);
    		float oldangle = _AngleBiasValue;
    		float2 deltauv = round(1 + rayMarchingDir * rayMarchingStepSize) * InvScreenParams;
    		
    		for(int k = 1; k < _RayMarchingStep; k++)
    		{
    			float2 uv = k * deltauv + i.uv;
    			float3 sviewPos = ReconstructViewPos(uv);
    
    			float3 svdir = sviewPos - viewPos;
    			float l = length(svdir);
    			float angle = UNITY_PI * 0.5 - acos(dot(viewNormal, normalize(svdir)));
    			if (angle > oldangle)
    			{
    				float value = sin(angle) - sin(oldangle);
    				float atten = Falloff2(l, _AORadius);
    				oc += value * atten;
    				oldangle = angle;
    			}
    		}
    	}
    	oc *= 1.0 / (_RayAngleStep) * _AOStrength;
    	oc = 1.0 - oc;
    
    	col.rgb = oc;
    	return col;
    }

直接使用HBAO，在步进次数和方向数足够大（8-16左右）时，个人感觉不适用滤波操作，效果也可以接受：

无AO的效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 12][]

开启HBAO效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 13][]

仅显示AO效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 14][]

可以控制\_RayMarchingStep和\_RayAngleStep两个值控制步进次数和步进方向分割。另外，既然是RayMarching，我们在体积光和屏幕空间反射的老套路就又可以使用了，通过Dither + 模糊实现Jitter Ray Marching来大大降低光线追踪的消耗。此处的模糊我们仍然使用双边滤波，在去噪的同时保持边缘。上图中的步进次数为8x8，计算相当的费。而如果我们把次数改为3x3效果就很差了：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 15][]

已经无法很明确地区分出AO部分，下面我们把采样方向和每次步进的起始位置加上Dither值后，仍然是3x3的采样：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 16][]

效果很奇怪，但是这只是中间结果，下面我们加入双边滤波去噪，3x3采样后的效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 17][]

与上面8x8采样效果虽然还是差了一些，但是已经不会出现错误的情况，但是计算量极大地降低了。

## 总结 ##

本文主要实现了目前游戏中主要的几种环境光遮蔽的方法。基于AO贴图的遮蔽，通过GPU烘焙AO贴图，屏幕空间环境光遮蔽SSAO，水平基准环境光遮蔽（HBAO）。几种技术各有优缺点，技术本身不分好坏，只有适合自己项目的。实际上，这些AO技术通常会同时使用，最常见的就是AO贴图和各种屏幕空间的AO算法同时使用。《Making it Large, Beautiful, Fast and Consistent: Lessons Learned Developing Just Cause 2》所介绍的，正当防卫这款游戏中，就包含了三种AO，除上述两种外，还有一种称之为AO Volumes的技术，简单来说就是为了弥补Bake AO无法实现动态物体遮挡的问题，使用一个圆柱或者立方体实现一个假的AO遮挡效果，这种技术用于人物脚底，或者车底，可以增加不少细节效果。关于AO，实际上还有很多很多进阶的技术，如Bent Normal，AAO，TSSAO，VXAO，[UE4的Distance Filed Ambient Occlusion][UE4_Distance Filed Ambient Occlusion]等等，有机会再玩啦。。

这篇blog拖了很久才写完，主要最近游戏买的有点多，加上周末要看英雄联盟的比赛，感觉有点颓废。不过好在刚好又通关了一个很不错的游戏《心灵杀手（Alan Wake）》，下篇blog的开头又有东西写啦！

[70]: /images/20220509/dc151608425f4e36a525550e036de7dd.png
[70 1]: /images/20220509/cfe7aef7bdfb42aebc2c60a286ca9afb.png
[70 2]: /images/20220509/1b389d9fd8e14a23a65ef99b5ae0e491.png
[70 3]: /images/20220509/48268fab3597458b8cee9e1a43591876.png
[70 4]: /images/20220509/10633f6ddec14fa4a8e9402d1288f42f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_16_color_FFFFFF_t_70]: /images/20220509/fe17e5b948c94f20adea420a0e89963f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70]: /images/20220509/826c8c817bd24d69915e9b32966767c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 1]: /images/20220509/93c337bcde0045c4b361980eb3430107.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 2]: /images/20220509/e857246ec81f406eaa519436352ab05a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 3]: /images/20220509/3ad550f57eab4a7186db72b8dec5d0b9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_16_color_FFFFFF_t_70 1]: /images/20220509/b681301ff684490f9f3e199d8faca819.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_16_color_FFFFFF_t_70 2]: /images/20220509/611bef955cb0479499abe4a265947eb8.png
[ray triangle intersection test_]: https://www.cnblogs.com/graphics/archive/2010/08/09/1795348.html
[Comparative Study of SSAO Methods]: https://www.gamedevs.org/uploads/comparative-study-of-ssao-methods.pdf
[70 5]: /images/20220509/ad603dd65b93466983a2f5c682e11ef0.png
[70 6]: /images/20220509/ce9ec58cf36e4fce996a2328fa4d4534.png
[70 7]: /images/20220509/ab0f451087924aadbc5db7ba08f04158.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 4]: /images/20220509/822665aaedcf4d3e8d91644b7331c2b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 5]: /images/20220509/962cb64c7fd34194946a167872daf743.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 6]: /images/20220509/3cbefa80700347b08434dd6e03b7554b.png
[UnityShader-BilateralFilter]: https://blog.csdn.net/puppet_master/article/details/83066572
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 7]: /images/20220509/f00e209b03574880a9ea42dc3cfec9b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 8]: /images/20220509/eb9e417a52314ce9b5a12245b3834fad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 9]: /images/20220509/7c96e944be21410289c5a7e522d77709.png
[SSAO_HBAO]: http://vga.zol.com.cn/522/5225024.html
[Image Space Horizon-Based Ambient Occlusion]: https://developer.download.nvidia.com/presentations/2008/SIGGRAPH/HBAO_SIG08b.pdf
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 10]: /images/20220509/0213f99ff8b249319412e315f1fbf478.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 11]: /images/20220509/e24aee32f7844fd0893edb5f89a11d85.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 12]: /images/20220509/d280cedb954042428b489dced35348fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 13]: /images/20220509/e6bcb29c05944bba853f03c16c39f491.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 14]: /images/20220509/ac211b5747534c638ba72e669480f0d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 15]: /images/20220509/86d423699f184700a678f1b1cd7a79dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 16]: /images/20220509/f6c03809ad334aa4a8fa7a483b30bf57.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1cHBldF9tYXN0ZXI_size_27_color_FFFFFF_t_70 17]: /images/20220509/8aaccd1af96c4a4ea1e7f85e7fbe838c.png
[UE4_Distance Filed Ambient Occlusion]: https://docs.unrealengine.com/en-us/Engine/Rendering/LightingAndShadows/DistanceFieldAmbientOcclusion