[OpenGL]实现屏幕空间环境光遮蔽(Screen-Space Ambient Occlusion, SSAO)

🕗 发布于 2025-01-22 11:10 计算机图形学 OpenGL C++ glsl

一、简介

本文介绍了 屏幕空间环境光遮蔽(Screen-Space Ambient Occlusion, SSAO) 的基本概念，实现流程和简单的代码实现。实现 SSAO 时使用到了 OpenGL 中的延迟着色（Deferred shading）技术。
按照本文代码实现后，可以实现以下效果：

渲染结果

二、SSAO介绍以及实现流程

1. SSAO 介绍

(1). 什么是 Ambient Occlusion, AO

简单来说 Ambient Occlusion（AO）是一种全局照明（Global Illumination，GI）中的根据环境光（Ambient Light）参数和环境几何信息来计算场景中任何一点的光照强度系数的算法。
AO 描述了表面上的任何一点所接受到的环境光被周围几何体所遮蔽的百分比, 因此使得渲染的结果更加富有层次感，对比度更高。
例如：对于下图中的车辆缝隙处（红色），会受到周边模型面片的遮挡，导致接收到的环境光（Ambient light）较少，因此这些地方会更暗。而在车辆的边缘处（绿色），几乎不会受到周围模型面片的遮挡，接收到的环境光较多，因此这些地方会更亮。
AO示意图

(2). 什么是 Screen-Space Ambient Occlusion, SSAO

为了计算准确的 AO，可以使用光线跟踪算法。但是光线跟踪消耗计算资源太大，而 屏幕空间环境光遮蔽（Screen-Space Ambient Occlusion, SSAO） 是一种仅仅基于屏幕信息（例如，屏幕上各像素对应片元的空间位置信息）快速估计 AO 的算法。

SSAO 算法的基本思想为：
对于目标着色点，在其周围的一个球（或者面向相机方向的半球）内采样多个采样点，如果采样点大多被模型的其他面片遮挡，那么说明该目标着色点的 Ambien Occlusion 比较大，因此该着色点理应较暗些。而反之，目标着色点周围得到的采样点大部分并不会被模型的其他面片遮挡，那么说明该着色点的 Ambient Occlusion 更小，因此会更亮。

以下图为例：
在图中的红色着色点附近的一个球内采样，得到 8 个采样点，其中只有两个采样点（白色采样点）相比模型中的其他面片更靠近相机，不会被模型面片遮挡。而其他 6 个采样点（灰色采样点）都会被模型中的其他面片遮挡，则红色目标着色点的 Ambient Occlusion 更大，渲染结果中此着色点会更暗。
而图中的绿色着色点附近的大多数采样点（白色采样点）都不会被模型面片遮挡，只有两个采样点（灰色采样点）会被遮挡，则绿色目标着色点的 Ambient Occlusion 更小，渲染结果中此着色点会更亮。

SSAO 示意图
在实现时也可以在朝向相机的半球内采样，理论上这样的结果会更加准确，而不是上图中所示的整个球内采样。在计算得到各点的 AO 值后，也可以使用滤波操作对屏幕上各点的 AO 值进行滤波操作，平滑遮蔽效果，消除噪点。

2. SSAO 实现流程

实现 SSAO 主要分为 4 趟 pass。

(1). Geometry Pass

该 pass 对输入场景模型进行处理，将屏幕各像素对应片元的 texture_color, positon (in world space), normal 和 position (in view space) 输出到 GBuffer 中；

(2). Cal SSAO Pass

该 pass 根据屏幕各像素对应片元（目标着色点）的 position (in view space) 信息，在各片元周围采样，得到采样点，根据采样点是否会被模型遮挡计算目标着色点的 AO 值；

(3.) Blur SSAO Pass

该 pass 对上趟流程中计算得到的 AO 进行滤波操作，的到滤波后的 blurredAO；

(4). Lighting (Shading) Pass

该 pass 根据 pass (1) 中得到的 texture_color, positon (in world space), normal 和 pass (3) 中得到的 blurredAO 计算各着色点的颜色值。使用 Phong 着色模型，公式如下：
$I = I a * b l u rre d A O + I d + I s$

3. 主要代码讲解

(1). Geometry Pass Shader

geometryPassShader.vert:

#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 aNor;
layout(location = 2) in vec2 aTexCoord;
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

out vec3 vertexPos;
out vec3 vertexNor;
out vec2 textureCoord;
out vec4 vertexViewPos;

void main() {
  textureCoord = aTexCoord;
  // 裁剪空间坐标系 (clip space) 中 点的位置
  gl_Position = projection * view * model * vec4(aPos, 1.0f);
  // 世界坐标系 (world space) 中 点的位置
  vertexPos = (model * vec4(aPos, 1.0f)).xyz;
  // 世界坐标系 (world space) 中 点的法向
  vertexNor = mat3(transpose(inverse(model))) * aNor;
  // 视图坐标系 (view space) 中 点的位置
  vertexViewPos = view * model * vec4(aPos, 1.0f);
}

geometryPassShader.frag:

#version 330 core
layout(location = 0) out vec4 FragColor;   // diffuse color
layout(location = 1) out vec3 FragPos;     // position in world space
layout(location = 2) out vec3 FragNor;     // normal in world space
layout(location = 3) out vec4 FragViewPos; // position in view space

in vec3 vertexPos;
in vec3 vertexNor;
in vec2 textureCoord;
in vec4 vertexViewPos;

uniform sampler2D texture0;

void main() {
  FragPos = vertexPos;
  FragNor = vertexNor;
  FragColor = texture(texture0, textureCoord);
  FragViewPos = vertexViewPos;
}

(2). Cal SSAO Pass Shader

calSSAOPassShader.vert

#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 aNor;
layout(location = 2) in vec2 aTexCoord;
out vec2 textureCoord;
void main() {
  gl_Position = vec4(aPos, 1.0f);
  textureCoord = aTexCoord;
}

calSSAOPassShader.frag:

#version 330 core
out float AO;
in vec2 textureCoord;

uniform mat4 projection;

uniform sampler2D textureViewPos; // position (in view space)

uniform vec3 gKernel[64]; // random position offset

// 计算目标片段的 Ambient Occlusion (AO) 值
// AO in [0,1]
// 为了便于后续计算 代码中的 AO 规定为：
// AO 越接近 0，说明该片段被遮挡的越多（越暗）
// AO 越接近 1，说明该片段被遮挡的越多（越亮）
void main() {

  vec3 shadeViewPos = texture(textureViewPos, textureCoord)
                          .xyz; // 目标片段在 view space 中的坐标

  AO = 0.0;
  float gSampleRad = 1.5f;
  for (int i = 0; i < 64; i++) {
    vec3 sampleViewPos = shadeViewPos + gKernel[i]; // 在目标片段周围随机采样
    vec4 sampleProPos =
        vec4(sampleViewPos, 1.0); // 采样点 在 view space 中的坐标

    sampleProPos = projection * sampleProPos;
    sampleProPos.xy /= sampleProPos.w;
    // 采样点 投影到屏幕，再归一化到[0,1]的 xy 坐标 （即采样点对应的 uv 坐标）
    sampleProPos.xy = sampleProPos.xy * 0.5 + vec2(0.5, 0.5);

    // 相机-采样点 射线与场景相交点(场景表面点)对应的 z 值（在 view space 中）
    float surfaceDepth = texture(textureViewPos, sampleProPos.xy).z;

    if (abs(shadeViewPos.z - surfaceDepth) < gSampleRad) {
      // step(a,b) = if (a<b) return 1.0 else return 0.0;
      // 在 view sapce 中， camera position 为 (0,0,0)
      // 假如 abs(surfaceDepth) < abs(sampleViewPos.z) 说明 场景表面点 比
      // 采样点距离相机更近，那么 AO += 1
      // 假如 abs(surfaceDepth) >= abs(sampleViewPos.z) 说明 采样点 比
      // 场景表面点 距离相机更近，那么 AO += 0
      AO += step(abs(surfaceDepth), abs(sampleViewPos.z));
    }
  }
  // 前面 AO 记录的是 '采样点 被 场景表面 遮挡的次数'
  // 因此需要 令 AO = 1.0 - AO / (采样次数)
  // 最后得到的 AO 才是目标片段的 AO 值
  AO = 1.0 - AO / 64;
}

(3). Blur SSAO Pass Shader

blurSSAOPassShader.vert:

#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 aNor;
layout(location = 2) in vec2 aTexCoord;
out vec2 textureCoord;
void main() {
  gl_Position = vec4(aPos, 1.0f);
  textureCoord = aTexCoord;
}

blurSSAOPassShader.frag:

#version 330 core
// out vec4 FragColor;
out float blurredAO;

in vec2 textureCoord;

uniform sampler2D textureAO;

void main() {
  blurredAO = 0.0;
  float Offsets[4] = float[](-1.5, -0.5, 0.5, 1.5);
  float originAO = texture(textureAO, textureCoord).x;

  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      float AO = texture(textureAO, textureCoord).r;
      vec2 tc = textureCoord;
      tc.x = textureCoord.x + Offsets[j] / textureSize(textureAO, 0).x;
      tc.y = textureCoord.y + Offsets[i] / textureSize(textureAO, 0).y;
      blurredAO += texture(textureAO, tc).x;
    }
  }

  blurredAO /= 16.0;
}

(4). Lighting (Shading) Pass Shader

lightingSSAOPassShader.vert:

#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 aNor;
layout(location = 2) in vec2 aTexCoord;
out vec2 textureCoord;
void main() {
  gl_Position = vec4(aPos, 1.0f);
  textureCoord = aTexCoord;
}

lightingSSAOPassShader.frag:

#version 330 core
out vec4 FragColor;

in vec2 textureCoord;

uniform int state;

uniform vec3 lightPos;

uniform vec3 cameraPos;
uniform vec3 k;

uniform sampler2D textureColor;     // color
uniform sampler2D texturePos;       // position (in world space)
uniform sampler2D textureNor;       // normal (in world space)
uniform sampler2D textureBlurredAO; // blurredAO

void main() {
  vec3 vertexPos = texture(texturePos, textureCoord).xyz;
  vec3 vertexNor = texture(textureNor, textureCoord).xyz;
  vec3 lightColor = vec3(1.0f, 1.0f, 1.0f);

  // Ambient
  // Ia = ka * La
  float ambientStrenth = k[0];
  vec3 ambient = ambientStrenth * lightColor;
  float blurredAO = texture(textureBlurredAO, textureCoord).x;

  if (state == 0) {
    // Rendering scene with SSAO on.
    ambient = ambient * vec3(blurredAO);
  } else if (state == 1) {
    // Rendering scene with SSAO off.
  } else {
    // Rendering AO.
    FragColor = vec4(blurredAO);
    return;
  }
  vec3 diffuse = vec3(0, 0, 0);
  vec3 specular = vec3(0, 0, 0);
  // Diffuse
  // Id = kd * max(0, normal dot light) * Ld
  float diffuseStrenth = k[1];
  vec3 normalDir = normalize(vertexNor);

  vec3 lightDir = normalize(lightPos - vertexPos);
  diffuse = diffuseStrenth * max(dot(normalDir, lightDir), 0.0) * lightColor;

  // Specular (Phong)
  // Is = ks * (view dot reflect)^s * Ls

  float specularStrenth = k[2];
  vec3 viewDir = normalize(cameraPos - vertexPos);
  vec3 reflectDir = reflect(-lightDir, normalDir);
  specular = specularStrenth * pow(max(dot(viewDir, reflectDir), 0.0f), 2) *
             lightColor;

  // Specular (Blinn-Phong)
  // Is = ks * (normal dot halfway)^s Ls
  // float specularStrenth = k[2];
  // vec3 viewDir = normalize(cameraPos - vertexPos);
  // vec3 halfwayDir = normalize(lightDir + viewDir);
  // vec3 temp_specular = specularStrenth *
  //                      pow(max(dot(normalDir, halfwayDir), 0.0f), 2) *
  //                      lightColor;

  diffuse = clamp(diffuse, 0.0, 1.0);
  specular = clamp(specular, 0.0, 1.0);

  // Obejct color
  vec3 objectColor = texture(textureColor, textureCoord).xyz;

  // Color = Ambient + Diffuse + Specular
  // I = Ia + Id + Is
  FragColor = vec4((ambient + diffuse + specular) * objectColor, 1.0f);
}

4. 全部代码及模型文件

使用OpenGL实现屏幕空间环境光遮蔽(Screen-Space Ambient Occlusion, SSAO) 的全部代码以及模型文件可以在 OpenGL实现屏幕空间环境光遮蔽(Screen-Space Ambient Occlusion, SSAO) 中下载。程序运行后按下空格键在使用SSAO渲染场景、直接渲染场景和渲染AO值三种模式中切换。
渲染结果如下：

三、参考

[1].ogl-tutorial45 Screen Space Ambient Occlusion
[2].游戏后期特效第四发 – 屏幕空间环境光遮蔽(SSAO)

原文地址：https://blog.csdn.net/Strengthennn/article/details/144849932

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：亚博microros小车-原生ubuntu支持系列：5-姿态检测
下一篇：thinkphp8在使用apidoc时, 4层的接口会有问题解决办法

SpringDoc和Swagger使用
Swagger和Springdoc是两个常用的工具，用于生成和维护API文档，特别是针对基于REST的Web服务。它们有效地提升了API的可读性和可维护性，帮助开发者、产品经理和其他利益相关者更好地理
阅读更多2025-01-22
算法随笔_15: 找到K个最接近的元素
找到K个最接近的元素题目解析，通俗易懂。
阅读更多2025-01-22
Yocto项目 - 学习与实践中的挑战
Yocto项目是一种功能强大的工具集合，专为嵌入式Linux开发设计。它允许开发者构建高度定制化的Linux系统镜像。然而，尽管Yocto项目在嵌入式领域的地位毋庸置疑，许多开发者在学习和实践过程中会
阅读更多2025-01-22
智能运维分析决策系统：赋能数字化转型的智慧引擎
智能运维分析决策系统是基于大数据平台的智能化运维解决方案，它利用机器学习算法对海量运维数据进行实时分析，自动识别异常、预测故障、优化资源配置，并通过自然语言处理等技术实现运维知识的自动化学习和传播。A
阅读更多2025-01-22
鸿蒙操作系统的安全架构
在当今数字化时代，数据安全与隐私保护成为人们日益关注的焦点。随着智能设备的普及和互联网技术的发展，个人数据泄露的风险也在不断增加。作为中国自主研发的操作系统，鸿蒙（HarmonyOS）从设计之初就将数
阅读更多2025-01-22
Vue3+Elementplus物流订单信息跟踪管理
Vue3+Elementplus物流订单信息跟踪管理(CRUD)
阅读更多2025-01-22
如何使用 Pytest -k 选项轻松筛选测试用例
关注开源优测不迷路大数据测试过程、策略及挑战测试框架原理，构建成功的基石在自动化测试工作之前，你应该知道的10条建议在自动化测试中，重要的不是工具你是否曾不得不从成百上千个测试中费力筛选，只为运行几个
阅读更多2025-01-22
【二叉树的深搜】计算布尔二叉树的值 && 求根节点到叶节点数字之和
在遍历期间要注意的是我们可以不需要在递归函数开头给出递归函数的出口，因为题目节点个数是大于零的，所以保证一开始是不会访问空指针的，我们只需要在递归左右子树之前判断左右孩子节点是否存在即可，其它的
阅读更多2025-01-22
[Qt]系统相关-多线程、线程安全问题以及线程的同步机制
Qt多线程编程是开发中的重要部分。首先介绍多线程概念及操作，包括线程创建、QThread常用API和使用案例，阐述其使用场景。接着是线程安全问题，互斥锁可保证资源独占访问，会介绍并给出使用案例；读写锁
阅读更多2025-01-22
php怎么接入AI人工智能
PHP可以通过HTTP请求与AI服务（如Google的AI服务，Microsoft的AI服务，或者其他第三方AI服务）进行交互。为你的AI服务的实际URL和需要发送的数据。将取决于AI服务的具体响应格
阅读更多2025-01-22