DX12 快速教程(8) —— 画玻璃
快速导航
- 新建项目 "008-AlphaBlend"
- 移除解决方案中的原有项目
- 安装扩展
- 更改项目结构
- 在 Main 文件夹下新建项目
- 画玻璃
- 添加玻璃、门、床模型
- PSO：现代渲染管线的杰出之作
- 修改 ModelManager
- 创建输入布局：CreateInputLayout
- 创建不透明物体 PSO：CreateOpaquePSO
- 创建透明物体 PSO：CreateTransparentPSO
- 创建半透明物体 PSO：CreateTranslucencePSO
- 修改渲染代码：Render
- 第八节全代码
- main.cpp
- OpaqueShader.hlsl
- TransparentShader.hlsl
- TranslucenceShader.hlsl
从第 8 章开始，我们的教程分道扬镳，分为若干支线，不同分支的教程内容不同，代码结构也会大相径庭，本章第 8 章教程将是主线最终章。
新建项目 “008-AlphaBlend”
移除解决方案中的原有项目
将解决方案中的 7 个项目，右键点击，移除：
安装扩展
上方"扩展" -> “管理扩展”：
搜索 solution folder，下拉找到 “Add Multiple Projects To Solution V2” 这个插件，点击安装：
更改项目结构
关闭 VS2022 以安装扩展，安装完重新打开。在你的解决方案文件夹下新建 6 个文件夹 (不要在 VS2022 的解决方案管理器视图弄，视图新建的 “文件夹” 只是个项目筛选器，不是真实的文件夹)：
将上方七个项目 001 - 007 拖动到 Main 文件夹中：
回到 VS2022，右键点击解决方案 -> “添加” -> “Multiple Projects”:
按照下方步骤添加 Main 文件夹，一次批量添加 Main 文件夹及其里面的 7 个项目即可：
最后我们可以看到，整个文件夹带着项目确实加进来了：
在 Main 文件夹下新建项目
在 VS2022 右键 Main -> “添加” -> “新建项目” -> “空项目”，项目名为 “008-AlphaBlend”，项目位置要选 Main 文件夹，否则会建在外面：
新建 main.cpp、OpaqueShader.hlsl、TransparentShader.hlsl、TranslucenceShader.hlsl 这四个文件，如图所示：
玻璃、门、床这些纹理资源可以来我的 Github 仓库上找：
dgaf 的 《DirectX 12 快速教程》配套代码 (A Sample of dgaf’s DirectX 12 Quick Beginner Tutorial)
画玻璃
添加玻璃、门、床模型
在 ModelManager 类的 ModelGroup 上添加玻璃，门和床模型：
然而令人困扰的是，玻璃渲染后整个都变背景色了，门和床原先的透明部分也变黑了，这是怎么回事？想要解决这两个问题，我们需要从 Pipeline State Object 渲染管线状态对象 这里开刀。
PSO：现代渲染管线的杰出之作
想要理解 Pipeline State Object (PSO) 的产生，就必须了解微软旧先为其打工的 OpenGL 牢标准。OpenGL 它本身就是一个大大的状态机，封装了大量的底层细节，因为早些时代的显卡其实是比较简陋的，生产显卡的产商也不是 NVIDIA、AMD 这两大显卡专厂，而是四海八方的厂商，有主机厂商，游戏机厂商，半导体公司等等，在 90 年代相当于图形学的春秋战国年代，然而这些图形加速卡 (显卡起源) 到应用层就得绑定厂商提供的 API 和硬件设备，这使得应用层开发和软件宣发很不方便。
曾经死去的图形厂商 -bilibili
为了解决这个问题，一家名为 SGI 的研究图形硬件的专厂做了一个大胆的举措：砍掉自身 API 所有与图形学无关的功能，在 1992 年向公众发布第一代 OpenGL 标准，成为了第一个用于实时计算机图形的跨平台标准化 API；同年，还拉拢多家知名软硬件供应商，共同成立了 ARB（OpenGL Architecture Review Board，OpenGL 架构审查委员会，以前微软也是其中的一名成员，后来因为利益问题离开做 DirectX 了），这个委员会就是现在 Vulkan 的开源组织 Khronos Group 的前身。
[OpenGL] OpenGL简介 - 刘好念的博客
然而 OpenGL 的封装又造成了极大的不自由度，所以才有了 Extension 拓展，一个大版本将拓展标准化，可编程着色器当初甚至还是拓展，直到 OpenGL 2.0 版本才正式进标准 (彼时正是 DirectX 9 大红大紫的时代)，更重要的是，相比同时代的 API，虽然方便，但它的渲染性能相当差，其中包括了大量在运行期间 (哪怕在 Draw Call 运行时，OpenGL 是 immediate 立即串行渲染) 对管线与资源状态的更改与验证，例如下面的代码：
// 启用深度测试
glEnable(GL_DEPTH_TEST);
// 使用着色器程序1，绘制第一个物体
glUseProgram(shaderProgram1);
glBindTexture(GL_TEXTURE_2D, texture1);
glDrawArrays(GL_TRIANGLES, 0, 36);
// 切换到着色器程序2，绘制第二个物体
glUseProgram(shaderProgram2);
glBindTexture(GL_TEXTURE_2D, texture2);
glDrawArrays(GL_TRIANGLES, 0, 36);
// 启用混合模式，绘制第三个物体
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(shaderProgram3);
glBindTexture(GL_TEXTURE_2D, texture3);
glDrawArrays(GL_TRIANGLES, 0, 36);
// 禁用混合模式
glDisable(GL_BLEND);
大量 glEnable/glDisable 用起来是方便了，但是这样做就会频繁更改渲染管线的状态，压力会给到硬件层执行的 Draw Call 绘制调用，硬件层会在这之前检查一遍管线的所有状态，确认无误后方可执行。
然而 OpenGL API 把这些状态验证操作全部隐藏了，开发者无法获得有效反馈，也无法有效控制，文档也只能建议这些开发者尽量减少状态切换和 Draw Call，这个就是 OpenGL 遗留的历史包裹。为什么现代 API (DirectX 12，Vulkan，Metal) 把底层设备开放+解耦，新增了 Pipeline State Object，归根揭底是能在编译期做的工作就不要放在运行期，PSO 对象包含了一套管线状态的二进制信息，能直接在编译期进行资源验证，运行期直接少一大堆繁琐的操作，增强 API 的可扩展性，加快渲染效率。
和 Vulkan 一样，DirectX 12 也是为了解决 DX11 运行期验证这个问题，而新增的 PSO 渲染管线状态和 Root Signature 根签名对象。游戏要切换不同的场景，设置不同的着色器，渲染出不同的效果，就需要 PSO 对象。
我们的程序涉及到三种不同状态的物体，需要用三套不相同的 PSO 来绘制。注意，透明混合与顺序相关，不可以随意绘制：
修改 ModelManager
我们需要将 ModelGroup 分成三组不同的模型：
// 非透明模型组，存储 Model 类指针的 vector，注意存储的是指针，指针可以指向不同类的对象
std::vector<Model*> OpaqueGroup;
// 透明模型组
std::vector<Model*> TransparentGroup;
// 半透明模型组
std::vector<Model*> TranslucenceGroup;
而且需要写不同的渲染函数：
// 渲染半透明模型
// 调用该函数的前提是: 完成上面的 CreateModelResource
void RenderTranslucenceModel(ComPtr<ID3D12GraphicsCommandList>& pCommandList)
{
// 遍历模型组
for (const auto& model : TranslucenceGroup)
{
model->DrawModel(pCommandList);
}
}
// 渲染透明模型
// 调用该函数的前提是: 完成上面的 CreateModelResource
void RenderTransparentModel(ComPtr<ID3D12GraphicsCommandList>& pCommandList)
{
// 遍历模型组
for (const auto& model : TransparentGroup)
{
model->DrawModel(pCommandList);
}
}
// 渲染不透明模型
// 调用该函数的前提是: 完成上面的 CreateModelResource
void RenderOpaqueModel(ComPtr<ID3D12GraphicsCommandList>& pCommandList)
{
// 遍历模型组
for (const auto& model : OpaqueGroup)
{
model->DrawModel(pCommandList);
}
}
创建输入布局：CreateInputLayout
我们的三套渲染管线 PSO 都需要共用一组输入布局，需要先写一个函数来创建输入布局：
// 创建输入布局，因为下文的渲染管线需要共用输入布局，数组不能在函数内声明，否则出作用域会销毁，所以单独写一个创建函数
void CreateInputLayout()
{
// 第 0 号输入槽: 输入顶点位置与纹理 UV 坐标
InputElementDesc[0].SemanticName = "POSITION"; // 要锚定的语义
InputElementDesc[0].SemanticIndex = 0; // 语义索引，目前我们填 0 就行
InputElementDesc[0].Format = DXGI_FORMAT_R32G32B32A32_FLOAT; // 输入格式
InputElementDesc[0].InputSlot = 0; // 输入槽编号，目前我们填 0 就行
InputElementDesc[0].AlignedByteOffset = 0; // 在输入槽中的偏移
// 输入流类型，一种是我们现在用的 D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA 逐顶点输入流,还有一种叫逐实例输入流，后面再学
InputElementDesc[0].InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
InputElementDesc[0].InstanceDataStepRate = 0; // 实例数据步进率，目前我们没有用到实例化，填 0
InputElementDesc[1].SemanticName = "TEXCOORD"; // 要锚定的语义
InputElementDesc[1].SemanticIndex = 0; // 语义索引
InputElementDesc[1].Format = DXGI_FORMAT_R32G32_FLOAT; // 输入格式
InputElementDesc[1].InputSlot = 0; // 输入槽编号
// 在输入槽中的偏移，因为 position 与 texcoord 在同一输入槽(0号输入槽)
// position 是 float4，有 4 个 float ，每个 float 占 4 个字节，所以要偏移 4*4=16 个字节，这样才能确定 texcoord 参数的位置，不然装配的时候会覆盖原先 position 的数据
InputElementDesc[1].AlignedByteOffset = 16; // 在输入槽中的偏移
InputElementDesc[1].InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA; // 输入流类型
InputElementDesc[1].InstanceDataStepRate = 0; // 实例数据步进率
// 第 1 号输入槽: 输入模型矩阵 (因为 4x4 矩阵太大，需要分成 4 个 float4 向量传输)
// MATRIX0
// SemanticName 语义名: MATRIX (语义名后面不带数字)
// SemanticIndex 语义索引: 0
// InputSlot 输入槽: 第 1 号输入槽
// AlignedByteOffset 相对输入槽起始位置的偏移: 0
InputElementDesc[2].SemanticName = "MATRIX";
InputElementDesc[2].SemanticIndex = 0;
InputElementDesc[2].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
InputElementDesc[2].InputSlot = 1;
InputElementDesc[2].AlignedByteOffset = 0;
InputElementDesc[2].InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
InputElementDesc[2].InstanceDataStepRate = 0;
// MATRIX1
// SemanticName 语义名: MATRIX (语义名后面不带数字)
// SemanticIndex 语义索引: 1
// InputSlot 输入槽: 第 1 号输入槽
// AlignedByteOffset 相对输入槽起始位置的偏移: 0 + 4*4 = 16
InputElementDesc[3].SemanticName = "MATRIX";
InputElementDesc[3].SemanticIndex = 1;
InputElementDesc[3].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
InputElementDesc[3].InputSlot = 1;
InputElementDesc[3].AlignedByteOffset = 16;
InputElementDesc[3].InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
InputElementDesc[3].InstanceDataStepRate = 0;
// MATRIX2
// SemanticName 语义名: MATRIX (语义名后面不带数字)
// SemanticIndex 语义索引: 2
// InputSlot 输入槽: 第 1 号输入槽
// AlignedByteOffset 相对输入槽起始位置的偏移: 16 + 4*4 = 32
InputElementDesc[4].SemanticName = "MATRIX";
InputElementDesc[4].SemanticIndex = 2;
InputElementDesc[4].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
InputElementDesc[4].InputSlot = 1;
InputElementDesc[4].AlignedByteOffset = 32;
InputElementDesc[4].InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
InputElementDesc[4].InstanceDataStepRate = 0;
// MATRIX3
// SemanticName 语义名: MATRIX (语义名后面不带数字)
// SemanticIndex 语义索引: 3
// InputSlot 输入槽: 第 1 号输入槽
// AlignedByteOffset 相对输入槽起始位置的偏移: 32 + 4*4 = 48
InputElementDesc[5].SemanticName = "MATRIX";
InputElementDesc[5].SemanticIndex = 3;
InputElementDesc[5].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
InputElementDesc[5].InputSlot = 1;
InputElementDesc[5].AlignedByteOffset = 48;
InputElementDesc[5].InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
InputElementDesc[5].InstanceDataStepRate = 0;
InputLayoutDesc.NumElements = 6; // 输入元素个数
InputLayoutDesc.pInputElementDescs = InputElementDesc; // 输入元素结构体数组指针
}
创建不透明物体 PSO：CreateOpaquePSO
大部分方块都是 Opaque Model 完全不透明物体，我们需要先渲染这些物体，先创建 Opaque PSO：
// 创建不透明渲染管线状态对象 (Opaque Pipeline State Object, Opaque PSO)
void CreateOpaquePSO()
{
// Input Assembler 输入装配阶段
OpaquePSODesc.InputLayout = InputLayoutDesc; // 设置渲染管线 IA 阶段的输入布局
ComPtr<ID3DBlob> VertexShaderBlob; // 顶点着色器二进制字节码
ComPtr<ID3DBlob> PixelShaderBlob; // 像素着色器二进制字节码
ComPtr<ID3DBlob> ErrorBlob; // 错误字节码，根签名创建失败时用 OutputDebugStringA((const char*)ErrorBlob->GetBufferPointer()); 可以获取报错信息
// 编译顶点着色器 Vertex Shader
D3DCompileFromFile(L"OpaqueShader.hlsl", nullptr, nullptr, "VSMain", "vs_5_1", m_D3DShaderCompileFlag, NULL, &VertexShaderBlob, &ErrorBlob);
if (ErrorBlob) // 如果着色器编译出错，ErrorBlob 可以提供报错信息
{
OutputDebugStringA((const char*)ErrorBlob->GetBufferPointer());
OutputDebugStringA("
");
}
// 编译像素着色器 Pixel Shader
D3DCompileFromFile(L"OpaqueShader.hlsl", nullptr, nullptr, "PSMain", "ps_5_1", m_D3DShaderCompileFlag, NULL, &PixelShaderBlob, &ErrorBlob);
if (ErrorBlob) // 如果着色器编译出错，ErrorBlob 可以提供报错信息
{
OutputDebugStringA((const char*)ErrorBlob->GetBufferPointer());
OutputDebugStringA("
");
}
OpaquePSODesc.VS.pShaderBytecode = VertexShaderBlob->GetBufferPointer(); // VS 字节码数据指针
OpaquePSODesc.VS.BytecodeLength = VertexShaderBlob->GetBufferSize(); // VS 字节码数据长度
OpaquePSODesc.PS.pShaderBytecode = PixelShaderBlob->GetBufferPointer(); // PS 字节码数据指针
OpaquePSODesc.PS.BytecodeLength = PixelShaderBlob->GetBufferSize(); // PS 字节码数据长度
// Rasterizer 光栅化
OpaquePSODesc.RasterizerState.CullMode = D3D12_CULL_MODE_BACK; // 剔除模式，指定是否开启背面/正面/不剔除，这里选背面剔除
OpaquePSODesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID; // 填充模式，指定是否开启纯色/线框填充，这里选纯色填充
// 第一次设置根签名！本次设置是将根签名与 PSO 绑定，设置渲染管线的输入参数状态
OpaquePSODesc.pRootSignature = m_RootSignature.Get();
// 设置深度测试状态
OpaquePSODesc.DSVFormat = DSVFormat; // 设置深度缓冲的格式
OpaquePSODesc.DepthStencilState.DepthEnable = true; // 开启深度缓冲
OpaquePSODesc.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_LESS; // 深度缓冲的比较方式
OpaquePSODesc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL; // 深度缓冲的读写权限
// D3D12_DEPTH_WRITE_MASK_ALL 允许通过深度测试的像素写入深度缓冲 (深度缓冲可读写)
// D3D12_DEPTH_WRITE_MASK_ZERO 禁止对深度缓冲进行写操作，但仍可进行深度测试 (深度缓冲只读)
// 两者只能选一个，不可共存。指定 DepthWriteMask 可以控制深度数据的读写，实现某些特效
/*
深度测试比较像素深度的伪代码，符合条件就覆盖新像素，不符合就丢弃
NewPixel: 要写入的新像素
CurrentPixel: 当前在缓冲区的像素
DepthFunc: 比较方式 (实际上就是 C/C++ 的二元操作运算符)
if (NewPixel.Depth DepthFunc CurrentPixel.Depth)
{
Accept(NewPixel) // 新像素通过深度测试，下一步可以进行混合
WriteDepth(NewPixel.Depth) // 将新像素深度写入深度缓冲中
}
else
{
Reject(NewPixel) // 丢弃新像素
}
D3D12_COMPARISON_FUNC_LESS 相当于小于号 <
if (NewPixel.Depth < CurrentPixel.Depth)
{
Accept(NewPixel) // 如果新像素深度更小，说明距离摄像机更靠前，通过深度测试
WriteDepth(NewPixel.Depth) // 将新像素深度写入深度缓冲中
}
else
{
Reject(NewPixel) // 否则，这个新像素更靠后，被当前像素遮住了，丢弃新像素
}
*/
// 设置基本图元，这里我们设置三角形面
OpaquePSODesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
// 设置渲染目标数量，我们只有一副渲染目标 (颜色缓冲) 需要进行渲染，所以填 1
OpaquePSODesc.NumRenderTargets = 1;
// 设置渲染目标的格式，这里要和交换链指定窗口缓冲的格式一致，这里的 0 指的是渲染目标的索引
OpaquePSODesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
// 设置混合阶段 (输出合并阶段) 下 RGBA 颜色通道的开启和关闭，D3D12_COLOR_WRITE_ENABLE_ALL 表示 RGBA 四色通道全部开启
OpaquePSODesc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
// 设置采样次数，我们这里填 1 就行
OpaquePSODesc.SampleDesc.Count = 1;
// 设置采样掩码，这个是用于多重采样的，我们直接填全采样 (UINT_MAX，就是将 UINT 所有的比特位全部填充为 1) 就行
OpaquePSODesc.SampleMask = UINT_MAX;
// 最终创建 PSO 对象
m_D3D12Device->CreateGraphicsPipelineState(&OpaquePSODesc, IID_PPV_ARGS(&m_OpaquePSO));
}
创建透明物体 PSO：CreateTransparentPSO
门、床这些属于带透明像素的 Transparent Model 透明模型，需要用一套新的 TransparentPSO：
// 创建透明渲染管线状态对象 (Transparent Pipeline State Object, Transparent PSO)
void CreateTransparentPSO()
{
// 复用上文的 OpaquePSODesc 结构体
TransparentPSODesc = OpaquePSODesc;
ComPtr<ID3DBlob> VertexShaderBlob; // 顶点着色器二进制字节码
ComPtr<ID3DBlob> PixelShaderBlob; // 像素着色器二进制字节码
ComPtr<ID3DBlob> ErrorBlob; // 错误字节码，根签名创建失败时用 OutputDebugStringA((const char*)ErrorBlob->GetBufferPointer()); 可以获取报错信息
// 编译顶点着色器 Vertex Shader
D3DCompileFromFile(L"TransparentShader.hlsl", nullptr, nullptr, "VSMain", "vs_5_1", m_D3DShaderCompileFlag, NULL, &VertexShaderBlob, &ErrorBlob);
if (ErrorBlob) // 如果着色器编译出错，ErrorBlob 可以提供报错信息
{
OutputDebugStringA((const char*)ErrorBlob->GetBufferPointer());
OutputDebugStringA("
");
}
// 编译像素着色器 Pixel Shader
D3DCompileFromFile(L"TransparentShader.hlsl", nullptr, nullptr, "PSMain", "ps_5_1", m_D3DShaderCompileFlag, NULL, &PixelShaderBlob, &ErrorBlob);
if (ErrorBlob) // 如果着色器编译出错，ErrorBlob 可以提供报错信息
{
OutputDebugStringA((const char*)ErrorBlob->GetBufferPointer());
OutputDebugStringA("
");
}
TransparentPSODesc.VS.pShaderBytecode = VertexShaderBlob->GetBufferPointer(); // VS 字节码数据指针
TransparentPSODesc.VS.BytecodeLength = VertexShaderBlob->GetBufferSize(); // VS 字节码数据长度
TransparentPSODesc.PS.pShaderBytecode = PixelShaderBlob->GetBufferPointer(); // PS 字节码数据指针
TransparentPSODesc.PS.BytecodeLength = PixelShaderBlob->GetBufferSize(); // PS 字节码数据长度
// 关闭背面剔除
TransparentPSODesc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
// 最终创建 PSO 对象
m_D3D12Device->CreateGraphicsPipelineState(&TransparentPSODesc, IID_PPV_ARGS(&m_TransparentPSO));
}
注意这里要关闭背面剔除，否则看起来会很怪：
// 关闭背面剔除 TransparentPSODesc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
大家可以注意到，新管线用了一套不同的 TransparentShader.hlsl 文件，其实里面也只是改动了 Pixel Shader 像素着色器而已：
// Pixel Shader 像素着色器入口函数 (逐像素输入)，接收来自光栅化阶段经过插值后的每个片元，返回像素颜色
// 上一阶段：Rasterization 光栅化阶段
// 下一阶段：Output Merger 输出合并阶段
float4 PSMain(VSOutput input) : SV_Target // SV_Target 也是系统语义，通知输出合并阶段将 PS 阶段返回的颜色写入到渲染目标(颜色缓冲)上
{
float4 color = m_texure.Sample(m_sampler, input.texcoordUV); // 采样得到的像素颜色
clip(color.a - 0.1); // 如果像素 alpha 值减去 0.1 后是负值，说明是透明像素，丢弃此像素，后续不再处理
return color; // 如果不符合 clip 需要的条件，说明该像素不透明，返回颜色
}
这个 clip(value) 函数 (只能用于 Pixel Shader) 可以用来裁剪片元，当 value < 0 的时候，Pixel Shader 会直接丢弃该像素，后续阶段不再处理。而透明像素的 alpha 通道值一般都小于 0.1，我们可以利用这一特性，在 Pixel Shader 将透明像素裁剪，这样就实现了"透明"的效果。
创建半透明物体 PSO：CreateTranslucencePSO
然而像玻璃这样的 Translucence Model 半透明物体，它们的半透明像素还带有颜色，clip 函数是不能解决问题的，我们需要进行 Alpha Blend 透明混合。
透明混合本质上是一种颜色叠加，例如下图：
透明混合经常使用下文的公式，切记，仅限下层像素 (目标图) 是完全不透明像素 (Alpha 通道为 1) 时，该公式才可以使用：
控制颜色混合的因素我们称为 Blend Factor 混合因子，用 F s r c , F d s t m{F_{src}}, m{F_{dst}} Fsrc,Fdst 表示：
我们需要一个新的 TranslucencePSO 来开启混合，这样玻璃就能正确渲染了：
// 创建半透明渲染管线状态对象 (Translucence Pipeline State Object, Translucence PSO)
void CreateTranslucencePSO()
{
// 复用上文的 OpaquePSODesc 结构体
TranslucencePSODesc = OpaquePSODesc;
ComPtr<ID3DBlob> VertexShaderBlob; // 顶点着色器二进制字节码
ComPtr<ID3DBlob> PixelShaderBlob; // 像素着色器二进制字节码
ComPtr<ID3DBlob> ErrorBlob; // 错误字节码，根签名创建失败时用 OutputDebugStringA((const char*)ErrorBlob->GetBufferPointer()); 可以获取报错信息
// 编译顶点着色器 Vertex Shader
D3DCompileFromFile(L"TranslucenceShader.hlsl", nullptr, nullptr, "VSMain", "vs_5_1", m_D3DShaderCompileFlag, NULL, &VertexShaderBlob, &ErrorBlob);
if (ErrorBlob) // 如果着色器编译出错，ErrorBlob 可以提供报错信息
{
OutputDebugStringA((const char*)ErrorBlob->GetBufferPointer());
OutputDebugStringA("
");
}
// 编译像素着色器 Pixel Shader
D3DCompileFromFile(L"TranslucenceShader.hlsl", nullptr, nullptr, "PSMain", "ps_5_1", m_D3DShaderCompileFlag, NULL, &PixelShaderBlob, &ErrorBlob);
if (ErrorBlob) // 如果着色器编译出错，ErrorBlob 可以提供报错信息
{
OutputDebugStringA((const char*)ErrorBlob->GetBufferPointer());
OutputDebugStringA("
");
}
TranslucencePSODesc.VS.pShaderBytecode = VertexShaderBlob->GetBufferPointer(); // VS 字节码数据指针
TranslucencePSODesc.VS.BytecodeLength = VertexShaderBlob->GetBufferSize(); // VS 字节码数据长度
TranslucencePSODesc.PS.pShaderBytecode = PixelShaderBlob->GetBufferPointer(); // PS 字节码数据指针
TranslucencePSODesc.PS.BytecodeLength = PixelShaderBlob->GetBufferSize(); // PS 字节码数据长度
// 关闭背面裁剪
TranslucencePSODesc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
// 关闭深度写入，但仍然保留深度测试
TranslucencePSODesc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ZERO;
// 结果色彩 = 上层色彩 * 上层色彩 alpha + 下层色彩 * (1 - 上层色彩 alpha)，这套公式仅适用于下层是不透明物体的情况
// Src = 源色彩 = 上层色彩，Dest = 目标色彩 = 下层色彩
// Result = Src * SrcA + Dest * (1 - SrcA)
TranslucencePSODesc.BlendState.RenderTarget[0].BlendEnable = true; // 开启混合
// 下面三个选项控制 RGB 通道的混合，Alpha 通道与 RGB 通道的混合是分开的，这一点请留意！
// Result = Src * SrcA + Dest * (1 - SrcA)
// 让上层色彩乘上 alpha，Src * SrcA
TranslucencePSODesc.BlendState.RenderTarget[0].SrcBlend = D3D12_BLEND_SRC_ALPHA;
// 让下层色彩乘上 1 - alpha，Dest * (1 - SrcA)
TranslucencePSODesc.BlendState.RenderTarget[0].DestBlend = D3D12_BLEND_INV_SRC_ALPHA;
// 两种色彩相加，Src * SrcA + Dest * (1 - SrcA)
TranslucencePSODesc.BlendState.RenderTarget[0].BlendOp = D3D12_BLEND_OP_ADD;
// 下面的三个选项控制 Alpha 通道的混合，Alpha 通道与 RGB 通道的混合是分开的，这一点请留意！
// ResultA = SrcA * 1 + DstA * 0
// 让上层色彩透明度乘 1，表示使用 SrcA
TranslucencePSODesc.BlendState.RenderTarget[0].SrcBlendAlpha = D3D12_BLEND_ONE;
// 让下层色彩透明度乘 0，表示不使用 DstA
TranslucencePSODesc.BlendState.RenderTarget[0].DestBlendAlpha = D3D12_BLEND_ZERO;
// 最终要混合的色彩 alpha 是 ResultA
TranslucencePSODesc.BlendState.RenderTarget[0].BlendOpAlpha = D3D12_BLEND_OP_ADD;
// 最终创建 PSO 对象
m_D3D12Device->CreateGraphicsPipelineState(&TranslucencePSODesc, IID_PPV_ARGS(&m_TranslucencePSO));
}
注意这里！
// 关闭深度写入，但仍然保留深度测试 TranslucencePSODesc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ZERO;关闭深度信息写入，但保留深度测试，这是因为经过 Opaque、Transparent 渲染后，深度缓冲会剩下不透明像素的深度值，关闭深度写入，就能保留这些深度值，这样在不透明物体之后的像素会丢弃，之前的像素会进行混合。
示例用到的是无序混合，然而这种混合是有缺陷的，上方物体的深度决定了它的混合顺序，简单的无序混合在复杂情况下会渲染出很奇怪的图像。在现代图形 API，想要解决这个问题就要用到一系列的 Order-Independent Transparency (OIT) 顺序无关透明混合算法，笔者能力不行，在 DirectX 12 上尚未成功实现过任意一个 OIT 算法，如果有感兴趣的小伙伴可以参考以下文章尝试实现一下：
CPU无序透明 (Order Independent Transparency) -zxx43
vulkan_顺序无关的半透明混合(OIT) -沉默的舞台剧
图形学基础 - 着色 - 透明度混合-OIT -杨鼎超
修改渲染代码：Render
最后一步是修改渲染代码了，我们可以通过 SetPipelineState 设置渲染管线状态了。注意！CommandList 命令列表只负责记录命令，CommandQueue 才是执行命令的设备！
// 渲染
void Render()
{
// 每帧渲染开始前，调用 UpdateConstantBuffer() 更新常量缓冲区
UpdateConstantBuffer();
// 获取 RTV 堆首句柄
RTVHandle = m_RTVHeap->GetCPUDescriptorHandleForHeapStart();
// 获取当前渲染的后台缓冲序号
FrameIndex = m_DXGISwapChain->GetCurrentBackBufferIndex();
// 偏移 RTV 句柄，找到对应的 RTV 描述符
RTVHandle.ptr += FrameIndex * RTVDescriptorSize;
// 先重置命令分配器
m_CommandAllocator->Reset();
// 再重置命令列表，Close 关闭状态 -> Record 录制状态
m_CommandList->Reset(m_CommandAllocator.Get(), nullptr);
// 将起始转换屏障的资源指定为当前渲染目标
beg_barrier.Transition.pResource = m_RenderTarget[FrameIndex].Get();
// 调用资源屏障，将渲染目标由 Present 呈现(只读) 转换到 RenderTarget 渲染目标(只写)
m_CommandList->ResourceBarrier(1, &beg_barrier);
// 第二次设置根签名！本次设置将会检查 渲染管线绑定的根签名 与 这里的根签名 是否匹配
// 以及根签名指定的资源是否被正确绑定，检查完毕后会进行简单的映射
m_CommandList->SetGraphicsRootSignature(m_RootSignature.Get());
// 设置视口 (光栅化阶段)，用于光栅化里的屏幕映射
m_CommandList->RSSetViewports(1, &viewPort);
// 设置裁剪矩形 (光栅化阶段)
m_CommandList->RSSetScissorRects(1, &ScissorRect);
// 用 RTV 句柄设置渲染目标，同时用 DSV 句柄设置深度模板缓冲，开启深度测试
m_CommandList->OMSetRenderTargets(1, &RTVHandle, false, &DSVHandle);
// 清空后台的深度模板缓冲，将深度重置为初始值 1，记住上文创建深度缓冲资源的时候，要填 ClearValue
// 否则会报 D3D12 WARNING: The application did not pass any clear value to resource creation.
m_CommandList->ClearDepthStencilView(DSVHandle, D3D12_CLEAR_FLAG_DEPTH, 1, 0, 0, nullptr);
// 清空当前渲染目标的背景为天蓝色
m_CommandList->ClearRenderTargetView(RTVHandle, DirectX::Colors::SkyBlue, 0, nullptr);
// 用于设置描述符堆用的临时 ID3D12DescriptorHeap 数组
ID3D12DescriptorHeap* _temp_DescriptorHeaps[] = { m_SRVHeap.Get() };
// 设置描述符堆
m_CommandList->SetDescriptorHeaps(1, _temp_DescriptorHeaps);
// 设置常量缓冲 (第一个根参数)，我们复制完数据到 CBVResource 后，就可以让着色器读取、对顶点进行 MVP 变换了
m_CommandList->SetGraphicsRootConstantBufferView(0, m_CBVResource->GetGPUVirtualAddress());
// 设置图元拓扑 (输入装配阶段)，我们这里设置三角形列表
m_CommandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// 先设置 Opaque PSO，渲染不透明物体
m_CommandList->SetPipelineState(m_OpaquePSO.Get());
m_ModelManager.RenderOpaqueModel(m_CommandList);
// 再设置 Transparent PSO，渲染透明物体
m_CommandList->SetPipelineState(m_TransparentPSO.Get());
m_ModelManager.RenderTransparentModel(m_CommandList);
// 最后设置 Translucence PSO，渲染半透明物体
m_CommandList->SetPipelineState(m_TranslucencePSO.Get());
m_ModelManager.RenderTranslucenceModel(m_CommandList);
// 将终止转换屏障的资源指定为当前渲染目标
end_barrier.Transition.pResource = m_RenderTarget[FrameIndex].Get();
// 再通过一次资源屏障，将渲染目标由 RenderTarget 渲染目标(只写) 转换到 Present 呈现(只读)
m_CommandList->ResourceBarrier(1, &end_barrier);
// 关闭命令列表，Record 录制状态 -> Close 关闭状态，命令列表只有关闭才可以提交
m_CommandList->Close();
// 用于传递命令用的临时 ID3D12CommandList 数组
ID3D12CommandList* _temp_cmdlists[] = { m_CommandList.Get() };
// 执行上文的渲染命令！
m_CommandQueue->ExecuteCommandLists(1, _temp_cmdlists);
// 向命令队列发出交换缓冲的命令，此命令会加入到命令队列中，命令队列执行到该命令时，会通知交换链交换缓冲
m_DXGISwapChain->Present(1, NULL);
// 将围栏预定值设定为下一帧
FenceValue++;
// 在命令队列 (命令队列在 GPU 端) 设置围栏预定值，此命令会加入到命令队列中
// 命令队列执行到这里会修改围栏值，表示渲染已完成，"击中"围栏
m_CommandQueue->Signal(m_Fence.Get(), FenceValue);
// 设置围栏的预定事件，当渲染完成时，围栏被"击中"，激发预定事件，将事件由无信号状态转换成有信号状态
m_Fence->SetEventOnCompletion(FenceValue, RenderEvent);
}
第八节全代码
main.cpp
// (8) AlphaBlend：用 DirectX 12 绘制玻璃等有透明像素的物体，初步了解透明测试/混合与渲染顺序的关系
#includeOpaqueShader.hlsl
// (8) AlphaBlend：用 DirectX 12 绘制玻璃等有透明像素的物体，初步了解透明测试/混合与渲染顺序的关系
// OpaqueShader.hlsl 不透明物体使用的 shader
struct VSInput // VS 阶段输入顶点数据
{
float4 position : POSITION; // 输入顶点的位置，POSITION 语义对应 C++ 端输入布局中的 POSITION
float2 texcoordUV : TEXCOORD; // 输入顶点的纹理坐标，TEXCOORD 语义对应 C++ 端输入布局中的 TEXCOORD
// 如果我们需要向 IA 阶段传递矩阵，矩阵太大没法直接传，我们可以把矩阵分割成一个一个行向量，再到 VS 阶段重新组装
// MATRIX 是自定义语义，语义后面的数字表示同一个输入槽下，同语义名 (MATRIX) 的第 i 号数据
float4 Matrix_Row0 : MATRIX0;
float4 Matrix_Row1 : MATRIX1;
float4 Matrix_Row2 : MATRIX2;
float4 Matrix_Row3 : MATRIX3;
// 其实语义只是个标识东西的字符串...
};
struct VSOutput // VS 阶段输出顶点数据
{
float4 position : SV_Position; // 输出顶点的位置，SV_POSITION 是系统语义，指定顶点坐标已经位于齐次裁剪空间，通知光栅化阶段对顶点进行透视除法和屏幕映射
float2 texcoordUV : TEXCOORD; // 输出顶点纹理坐标时，仍然需要 TEXCOORD 语义
};
// Constant Buffer 常量缓冲，常量缓冲是预先分配的一段高速显存，存放每一帧都要变换的数据，例如我们这里的 MVP 变换矩阵
// 常量缓冲对所有着色器都是只读的，着色器不可以修改常量缓冲里面的内容
cbuffer GlobalData : register(b0, space0) // 常量缓冲，b 表示 buffer 缓冲，b0 表示 0 号 CBV 寄存器，space0 表示使用 b0 的 0 号空间
{
row_major float4x4 MVP; // MVP 矩阵，用于将顶点坐标从模型空间变换到齐次裁剪空间，HLSL 默认按列存储，row_major 表示数据按行存储
}
// Vertex Shader 顶点着色器入口函数 (逐顶点输入)，接收来自 IA 阶段输入的顶点数据，处理并返回齐次裁剪空间下的顶点坐标
// 上一阶段：Input Assembler 输入装配阶段
// 下一阶段：Rasterization 光栅化阶段
VSOutput VSMain(VSInput input)
{
float4x4 ModelMatrix; // VS 阶段要用到的模型矩阵
VSOutput output; // 输出给光栅化阶段的结构体变量
// 将 IA 阶段得到的行数据组装成矩阵
ModelMatrix[0] = input.Matrix_Row0;
ModelMatrix[1] = input.Matrix_Row1;
ModelMatrix[2] = input.Matrix_Row2;
ModelMatrix[3] = input.Matrix_Row3;
// 注意 cbuffer 常量缓冲对着色器是只读的！所以我们不能在这里对常量缓冲进行修改！
output.position = mul(input.position, ModelMatrix); // 先乘 模型矩阵
output.position = mul(output.position, MVP); // 再乘 观察矩阵 和 投影矩阵，注意 mul 左操作数是 output.position
output.texcoordUV = input.texcoordUV; // 纹理 UV 不用变化，照常输出即可
return output;
}
// register(*#，spaceN) *表示资源类型，#表示所用的寄存器编号，spaceN 表示使用的 N 号寄存器空间
Texture2D m_texure : register(t0, space0); // 纹理，t 表示 SRV 着色器资源，t0 表示 0 号 SRV 寄存器，space0 表示使用 t0 的 0 号空间
SamplerState m_sampler : register(s0, space0); // 纹理采样器，s 表示采样器，s0 表示 0 号 sampler 寄存器，space0 表示使用 s0 的 0 号空间
// Pixel Shader 像素着色器入口函数 (逐像素输入)，接收来自光栅化阶段经过插值后的每个片元，返回像素颜色
// 上一阶段：Rasterization 光栅化阶段
// 下一阶段：Output Merger 输出合并阶段
float4 PSMain(VSOutput input) : SV_Target // SV_Target 也是系统语义，通知输出合并阶段将 PS 阶段返回的颜色写入到渲染目标(颜色缓冲)上
{
return m_texure.Sample(m_sampler, input.texcoordUV); // 在像素着色器根据光栅化插值得到的 UV 坐标对纹理进行采样
}
TransparentShader.hlsl
// (8) AlphaBlend：用 DirectX 12 绘制玻璃等有透明像素的物体，初步了解透明测试/混合与渲染顺序的关系
// TransparentShader.hlsl 透明物体使用的 shader
struct VSInput // VS 阶段输入顶点数据
{
float4 position : POSITION; // 输入顶点的位置，POSITION 语义对应 C++ 端输入布局中的 POSITION
float2 texcoordUV : TEXCOORD; // 输入顶点的纹理坐标，TEXCOORD 语义对应 C++ 端输入布局中的 TEXCOORD
// 如果我们需要向 IA 阶段传递矩阵，矩阵太大没法直接传，我们可以把矩阵分割成一个一个行向量，再到 VS 阶段重新组装
// MATRIX 是自定义语义，语义后面的数字表示同一个输入槽下，同语义名 (MATRIX) 的第 i 号数据
float4 Matrix_Row0 : MATRIX0;
float4 Matrix_Row1 : MATRIX1;
float4 Matrix_Row2 : MATRIX2;
float4 Matrix_Row3 : MATRIX3;
// 其实语义只是个标识东西的字符串...
};
struct VSOutput // VS 阶段输出顶点数据
{
float4 position : SV_Position; // 输出顶点的位置，SV_POSITION 是系统语义，指定顶点坐标已经位于齐次裁剪空间，通知光栅化阶段对顶点进行透视除法和屏幕映射
float2 texcoordUV : TEXCOORD; // 输出顶点纹理坐标时，仍然需要 TEXCOORD 语义
};
// Constant Buffer 常量缓冲，常量缓冲是预先分配的一段高速显存，存放每一帧都要变换的数据，例如我们这里的 MVP 变换矩阵
// 常量缓冲对所有着色器都是只读的，着色器不可以修改常量缓冲里面的内容
cbuffer GlobalData : register(b0, space0) // 常量缓冲，b 表示 buffer 缓冲，b0 表示 0 号 CBV 寄存器，space0 表示使用 b0 的 0 号空间
{
row_major float4x4 MVP; // MVP 矩阵，用于将顶点坐标从模型空间变换到齐次裁剪空间，HLSL 默认按列存储，row_major 表示数据按行存储
}
// Vertex Shader 顶点着色器入口函数 (逐顶点输入)，接收来自 IA 阶段输入的顶点数据，处理并返回齐次裁剪空间下的顶点坐标
// 上一阶段：Input Assembler 输入装配阶段
// 下一阶段：Rasterization 光栅化阶段
VSOutput VSMain(VSInput input)
{
float4x4 ModelMatrix; // VS 阶段要用到的模型矩阵
VSOutput output; // 输出给光栅化阶段的结构体变量
// 将 IA 阶段得到的行数据组装成矩阵
ModelMatrix[0] = input.Matrix_Row0;
ModelMatrix[1] = input.Matrix_Row1;
ModelMatrix[2] = input.Matrix_Row2;
ModelMatrix[3] = input.Matrix_Row3;
// 注意 cbuffer 常量缓冲对着色器是只读的！所以我们不能在这里对常量缓冲进行修改！
output.position = mul(input.position, ModelMatrix); // 先乘 模型矩阵
output.position = mul(output.position, MVP); // 再乘 观察矩阵 和 投影矩阵，注意 mul 左操作数是 output.position
output.texcoordUV = input.texcoordUV; // 纹理 UV 不用变化，照常输出即可
return output;
}
// register(*#，spaceN) *表示资源类型，#表示所用的寄存器编号，spaceN 表示使用的 N 号寄存器空间
Texture2D m_texure : register(t0, space0); // 纹理，t 表示 SRV 着色器资源，t0 表示 0 号 SRV 寄存器，space0 表示使用 t0 的 0 号空间
SamplerState m_sampler : register(s0, space0); // 纹理采样器，s 表示采样器，s0 表示 0 号 sampler 寄存器，space0 表示使用 s0 的 0 号空间
// Pixel Shader 像素着色器入口函数 (逐像素输入)，接收来自光栅化阶段经过插值后的每个片元，返回像素颜色
// 上一阶段：Rasterization 光栅化阶段
// 下一阶段：Output Merger 输出合并阶段
float4 PSMain(VSOutput input) : SV_Target // SV_Target 也是系统语义，通知输出合并阶段将 PS 阶段返回的颜色写入到渲染目标(颜色缓冲)上
{
float4 color = m_texure.Sample(m_sampler, input.texcoordUV); // 采样得到的像素颜色
clip(color.a - 0.1); // 如果像素 alpha 值减去 0.1 后是负值，说明是透明像素，丢弃此像素，后续不再处理
return color; // 如果不符合 clip 需要的条件，说明该像素不透明，返回颜色
}
TranslucenceShader.hlsl
// (8) AlphaBlend：用 DirectX 12 绘制玻璃等有透明像素的物体，初步了解透明测试/混合与渲染顺序的关系
// TranslucenceShader.hlsl 半透明物体使用的 shader
struct VSInput // VS 阶段输入顶点数据
{
float4 position : POSITION; // 输入顶点的位置，POSITION 语义对应 C++ 端输入布局中的 POSITION
float2 texcoordUV : TEXCOORD; // 输入顶点的纹理坐标，TEXCOORD 语义对应 C++ 端输入布局中的 TEXCOORD
// 如果我们需要向 IA 阶段传递矩阵，矩阵太大没法直接传，我们可以把矩阵分割成一个一个行向量，再到 VS 阶段重新组装
// MATRIX 是自定义语义，语义后面的数字表示同一个输入槽下，同语义名 (MATRIX) 的第 i 号数据
float4 Matrix_Row0 : MATRIX0;
float4 Matrix_Row1 : MATRIX1;
float4 Matrix_Row2 : MATRIX2;
float4 Matrix_Row3 : MATRIX3;
// 其实语义只是个标识东西的字符串...
};
struct VSOutput // VS 阶段输出顶点数据
{
float4 position : SV_Position; // 输出顶点的位置，SV_POSITION 是系统语义，指定顶点坐标已经位于齐次裁剪空间，通知光栅化阶段对顶点进行透视除法和屏幕映射
float2 texcoordUV : TEXCOORD; // 输出顶点纹理坐标时，仍然需要 TEXCOORD 语义
};
// Constant Buffer 常量缓冲，常量缓冲是预先分配的一段高速显存，存放每一帧都要变换的数据，例如我们这里的 MVP 变换矩阵
// 常量缓冲对所有着色器都是只读的，着色器不可以修改常量缓冲里面的内容
cbuffer GlobalData : register(b0, space0) // 常量缓冲，b 表示 buffer 缓冲，b0 表示 0 号 CBV 寄存器，space0 表示使用 b0 的 0 号空间
{
row_major float4x4 MVP; // MVP 矩阵，用于将顶点坐标从模型空间变换到齐次裁剪空间，HLSL 默认按列存储，row_major 表示数据按行存储
}
// Vertex Shader 顶点着色器入口函数 (逐顶点输入)，接收来自 IA 阶段输入的顶点数据，处理并返回齐次裁剪空间下的顶点坐标
// 上一阶段：Input Assembler 输入装配阶段
// 下一阶段：Rasterization 光栅化阶段
VSOutput VSMain(VSInput input)
{
float4x4 ModelMatrix; // VS 阶段要用到的模型矩阵
VSOutput output; // 输出给光栅化阶段的结构体变量
// 将 IA 阶段得到的行数据组装成矩阵
ModelMatrix[0] = input.Matrix_Row0;
ModelMatrix[1] = input.Matrix_Row1;
ModelMatrix[2] = input.Matrix_Row2;
ModelMatrix[3] = input.Matrix_Row3;
// 注意 cbuffer 常量缓冲对着色器是只读的！所以我们不能在这里对常量缓冲进行修改！
output.position = mul(input.position, ModelMatrix); // 先乘 模型矩阵
output.position = mul(output.position, MVP); // 再乘 观察矩阵 和 投影矩阵，注意 mul 左操作数是 output.position
output.texcoordUV = input.texcoordUV; // 纹理 UV 不用变化，照常输出即可
return output;
}
// register(*#，spaceN) *表示资源类型，#表示所用的寄存器编号，spaceN 表示使用的 N 号寄存器空间
Texture2D m_texure : register(t0, space0); // 纹理，t 表示 SRV 着色器资源，t0 表示 0 号 SRV 寄存器，space0 表示使用 t0 的 0 号空间
SamplerState m_sampler : register(s0, space0); // 纹理采样器，s 表示采样器，s0 表示 0 号 sampler 寄存器，space0 表示使用 s0 的 0 号空间
// Pixel Shader 像素着色器入口函数 (逐像素输入)，接收来自光栅化阶段经过插值后的每个片元，返回像素颜色
// 上一阶段：Rasterization 光栅化阶段
// 下一阶段：Output Merger 输出合并阶段
float4 PSMain(VSOutput input) : SV_Target // SV_Target 也是系统语义，通知输出合并阶段将 PS 阶段返回的颜色写入到渲染目标(颜色缓冲)上
{
return m_texure.Sample(m_sampler, input.texcoordUV); // 在像素着色器根据光栅化插值得到的 UV 坐标对纹理进行采样
}
到这里，我们的主线教程就正式完结了。接下来，我们将学习各不相同的 Branch 支线，学习 DirectX 12 的真谛。
本文地址：https://www.vps345.com/9842.html
上一篇：Java数据结构——二叉树
