代码功能：渲染一个绕中心轴自转的圆柱体。要求该圆柱体高度为3.0，半径为0.5。
#include <windows.h>
#include <d3d11.h>
#include <d3dx11.h>
#include <d3dcompiler.h>
#include <xnamath.h>
#include <cmath>
#include <random>
#include "resource.h"
using namespace std;
//自定义圆周率常量的近似值
const float pi = 3.1415926536;
//设置基本的参数（包括圆面的顶点数量 圆柱体高度和底面半径）
float TotalHeight = 3.0;
float radius = 0.5;
const int RoundPointNum = 50;
//通过结构体定义的方式来定义一个简单的顶点类型
struct SimpleVertex
{
XMFLOAT3 Pos; //通过一个三维向量表示顶点的三维坐标信息
XMFLOAT4 Color; //通过一个四维向量表示顶点的颜色信息（RGB和透明度）
};
//通过结构体的方式定义常量缓冲区的数据格式
struct ConstantBuffer
{
XMMATRIX mWorld; //存储世界矩阵，将顶点变换到世界空间
XMMATRIX mView; //存储观察矩阵，将顶点变换到观察空间
XMMATRIX mProjection; //存储投影矩阵，将顶点坐标变换到裁剪空间
};
//全局变量定义区
HINSTANCE g_hInst = NULL; //存储应用程序的实例句柄
HWND g_hWnd = NULL; //存储应用程序的主窗口句柄
D3D_DRIVER_TYPE g_driverType = D3D_DRIVER_TYPE_NULL; //存储Direct3D驱动类型
D3D_FEATURE_LEVEL g_featureLevel = D3D_FEATURE_LEVEL_11_0; //指定Direct3D特性级别
ID3D11Device* g_pd3dDevice = NULL; //指定Direct3D设备对象
ID3D11DeviceContext* g_pImmediateContext = NULL;
IDXGISwapChain* g_pSwapChain = NULL;
ID3D11RenderTargetView* g_pRenderTargetView = NULL;
ID3D11VertexShader* g_pVertexShader = NULL;
ID3D11PixelShader* g_pPixelShader = NULL;
ID3D11InputLayout* g_pVertexLayout = NULL;
ID3D11Buffer* g_pVertexBuffer = NULL;
ID3D11Buffer* g_pIndexBuffer = NULL;
ID3D11Buffer* g_pConstantBuffer = NULL;
XMMATRIX g_World;
XMMATRIX g_View;
XMMATRIX g_Projection;
//前向函数声明（用于后续的过程中）
HRESULT InitWindow(HINSTANCE hInstance, int nCmdShow);
HRESULT InitDevice();
void CleanupDevice();
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void Render();
//程序入口：进行了初始化并进入消息循环，在空闲时间内进行场景渲染
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow)
{
//消除未使用参数的编译警告
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
//对窗口进行初始化
if (FAILED(InitWindow(hInstance, nCmdShow)))
return 0;
//初始化Direct3D的设备和相关资源
if (FAILED(InitDevice()))
{
CleanupDevice();
return 0;
}
//处理窗口消息和渲染场景
MSG msg = { 0 };
//循环一直运行知道窗口关闭
while (WM_QUIT != msg.message)
{
//判断消息队列中是否还有消息没有处理
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
//将未处理的消息转换为合适的形式发送给窗口过程
TranslateMessage(&msg);
DispatchMessage(&msg);
}
//空闲时间则进行渲染
else
{
Render();
}
}
//清理所占用的资源
CleanupDevice();
//消息循环的退出代码
return (int)msg.wParam;
}
//初始化窗口并注册窗口类
HRESULT InitWindow(HINSTANCE hInstance, int nCmdShow)
{
//对窗口的相关属性进行设置
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_TUTORIAL1);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = L"TutorialWindowClass";
wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_TUTORIAL1);
//对窗口进行创建
if (!RegisterClassEx(&wcex))
return E_FAIL;
//完成创建窗口的过程
g_hInst = hInstance;
RECT rc = { 0, 0, 640, 480 };
AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
g_hWnd = CreateWindow(L"TutorialWindowClass", L"Direct3D 11 Tutorial 4: 3D Spaces", WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, hInstance,
NULL);
if (!g_hWnd)
return E_FAIL;
ShowWindow(g_hWnd, nCmdShow);
return S_OK;
}
//用于编译着色器的辅助函数
HRESULT CompileShaderFromFile(WCHAR* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut)
{
HRESULT hr = S_OK;
DWORD dwShaderFlags = D3DCOMPILE_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
// Set the D3DCOMPILE_DEBUG flag to embed debug information in the shaders.
// Setting this flag improves the shader debugging experience, but still allows
// the shaders to be optimized and to run exactly the way they will run in
// the release configuration of this program.
dwShaderFlags |= D3DCOMPILE_DEBUG;
#endif
ID3DBlob* pErrorBlob;
hr = D3DX11CompileFromFile(szFileName, NULL, NULL, szEntryPoint, szShaderModel,
dwShaderFlags, 0, NULL, ppBlobOut, &pErrorBlob, NULL);
if (FAILED(hr))
{
if (pErrorBlob != NULL)
OutputDebugStringA((char*)pErrorBlob->GetBufferPointer());
if (pErrorBlob) pErrorBlob->Release();
return hr;
}
if (pErrorBlob) pErrorBlob->Release();
return S_OK;
}
// 初始化和设置一些与图形渲染相关的对象和参数
HRESULT InitDevice(void)
{
//定义了一个名为hr的变量，类型为HRESULT，并将其初始化为S_OK
HRESULT hr = S_OK;
//定义了一个名为rc的变量，类型为RECT，用于存储窗口的矩形区域
RECT rc;
//调用GetClientRect函数，将窗口g_hWnd的客户区域的矩形信息存储到rc变量中
GetClientRect(g_hWnd, &rc);
//计算窗口宽度
UINT width = rc.right - rc.left;
//计算窗口高度
UINT height = rc.bottom - rc.top;
//存储创建Direct3D设备时的标志
UINT createDeviceFlags = 0;
//如果定义了_DEBUG宏，则执行#ifdef _DEBUG和#endif之间的代码块
#ifdef _DEBUG
//如果处于调试模式，将D3D11_CREATE_DEVICE_DEBUG标志位按位或运算（ |= ）到createDeviceFlags变量上
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
//定义了一个名为driverTypes的数组，包含了三种Direct3D驱动类型：硬件驱动、WARP驱动和参考驱动
D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_WARP,
D3D_DRIVER_TYPE_REFERENCE,
};
//计算driverTypes数组中驱动类型的数量
UINT numDriverTypes = ARRAYSIZE(driverTypes);
//定义了一个名为featureLevels的数组，包含了三种Direct3D功能级别：11.0、10.1和10.0
D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
};
//计算featureLevels数组中功能级别的数量
UINT numFeatureLevels = ARRAYSIZE(featureLevels);
//设置交换链的描述信息
//包括缓冲区数量、尺寸、像素格式、刷新率、使用方式、输出窗口、抗锯齿采样等
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = 1;
sd.BufferDesc.Width = width;
sd.BufferDesc.Height = height;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = g_hWnd;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
//使用一个循环来尝试不同的驱动类型，创建Direct3D设备和交换链
for (UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++)
{
g_driverType = driverTypes[driverTypeIndex];
hr = D3D11CreateDeviceAndSwapChain(NULL, g_driverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels,
D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext);
if (SUCCEEDED(hr))
break;
}
//如果设备和交换链创建失败则返回错误代码
if (FAILED(hr))
return hr;
//创建渲染目标视图
ID3D11Texture2D* pBackBuffer = NULL;
hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
if (FAILED(hr))
return hr;
hr = g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_pRenderTargetView);
pBackBuffer->Release();
if (FAILED(hr))
return hr;
//将渲染目标视图设置为当前的渲染目标，以便将渲染的图像输出到该渲染目标
g_pImmediateContext->OMSetRenderTargets(1, &g_pRenderTargetView, NULL);
//设置视口,定义了渲染目标上的可见区域
D3D11_VIEWPORT vp;
vp.Width = (FLOAT)width;
vp.Height = (FLOAT)height;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
g_pImmediateContext->RSSetViewports(1, &vp);
//编译顶点着色器
ID3DBlob* pVSBlob = NULL;
hr = CompileShaderFromFile(L"Cylinder Rendering.fx", "VS", "vs_4_0", &pVSBlob);
if (FAILED(hr))
{
MessageBox(NULL,
L"The FX file cannot be compiled. Please run this executable from the directory that contains the FX file.", L"Error", MB_OK);
return hr;
}
//创建顶点着色器
hr = g_pd3dDevice->CreateVertexShader(pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), NULL, &g_pVertexShader);
if (FAILED(hr))
{
pVSBlob->Release();
return hr;
}
// 定义输入布局,指定顶点数据的格式
D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = ARRAYSIZE(layout);
//创建输入布局，将输入布局元素与顶点着色器关联起来
hr = g_pd3dDevice->CreateInputLayout(layout, numElements, pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(), &g_pVertexLayout);
pVSBlob->Release();
if (FAILED(hr))
return hr;
//设置当前渲染管线中的输入布局
g_pImmediateContext->IASetInputLayout(g_pVertexLayout);
//编译像素着色器
ID3DBlob* pPSBlob = NULL;
hr = CompileShaderFromFile(L"Cylinder Rendering.fx", "PS", "ps_4_0", &pPSBlob);
if (FAILED(hr))
{
MessageBox(NULL,
L"The FX file cannot be compiled. Please run this executable from the directory that contains the FX file.", L"Error", MB_OK);
return hr;
}
//创建像素着色器
hr = g_pd3dDevice->CreatePixelShader(pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), NULL, &g_pPixelShader);
pPSBlob->Release();
if (FAILED(hr))
return hr;
//设置构成圆面的顶点的个数
const int PointNum = 2 * RoundPointNum + 2;
float angleUnit = 360.0 / RoundPointNum;
float halfHeight = TotalHeight / 2;
SimpleVertex vertices[PointNum];
random_device device;
mt19937 engine(device());
uniform_real_distribution<float> getRandom(0.0f, 1.0f);
//逐一为每一个顶点设置空间坐标和颜色
for (int i(0); i < RoundPointNum; ++i)
{
float x = radius * sin(i * angleUnit * pi / 180.0);
float z = radius * cos(i * angleUnit * pi / 180.0);
float R = getRandom(engine);
float G = getRandom(engine);
float B = getRandom(engine);
vertices[i] = { XMFLOAT3(x,-halfHeight,z) ,XMFLOAT4(R,G,B,1.0f)};
vertices[i + RoundPointNum] = { XMFLOAT3(x,halfHeight,z),XMFLOAT4(R,G,B,1.0f) };
}
float R1 = getRandom(engine);
float G1 = getRandom(engine);
float B1 = getRandom(engine);
float R2 = getRandom(engine);
float G2 = getRandom(engine);
float B2 = getRandom(engine);
vertices[2 * RoundPointNum] = { XMFLOAT3(0,halfHeight,0),XMFLOAT4(R1,G1,B1,1.0f) };
vertices[2 * RoundPointNum + 1] = { XMFLOAT3(0,halfHeight,0),XMFLOAT4(R2,G2,B2,1.0f) };
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
//设置缓冲区的使用方式为默认
bd.Usage = D3D11_USAGE_DEFAULT;
//设置缓冲区的字节宽度
bd.ByteWidth = sizeof(SimpleVertex) * PointNum;
//设置缓冲区的绑定标志为顶点缓冲区
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
//定义了一个D3D11_SUBRESOURCE_DATA结构体变量，并将其内存清零
bd.CPUAccessFlags = 0;
//将顶点数据数组的指针赋给InitData的pSysMem成员
D3D11_SUBRESOURCE_DATA InitData;
ZeroMemory(&InitData, sizeof(InitData));
InitData.pSysMem = vertices;
//创建顶点缓冲区
hr = g_pd3dDevice->CreateBuffer(&bd, &InitData, &g_pVertexBuffer);
//检查创建顶点缓冲区是否失败
if (FAILED(hr))
return hr;
//将顶点缓冲区绑定到输入装配阶段，使得图形渲染管线能够使用该顶点缓冲区中的数据进行渲染
UINT stride = sizeof(SimpleVertex);
UINT offset = 0;
g_pImmediateContext->IASetVertexBuffers(0, 1, &g_pVertexBuffer, &stride, &offset);
//创建一个索引数组
WORD indices[12 * RoundPointNum];
for (int i(0); i < RoundPointNum - 1; ++i)
{
//渲染下面的部分
indices[i * 12] = 2 * RoundPointNum;
indices[i * 12 + 1] = i;
indices[i * 12 + 2] = i + 1;
//渲染上面的部分
indices[i * 12 + 3] = 2 * RoundPointNum + 1;
indices[i * 12 + 4] = i + RoundPointNum;
indices[i * 12 + 5] = i + RoundPointNum + 1;
//渲染侧面的第一个三角形
indices[i * 12 + 6] = i;
indices[i * 12 + 7] = i + 1;
indices[i * 12 + 8] = i + RoundPointNum;
//渲染侧面的第二个三角形
indices[i * 12 + 9] = i + 1;
indices[i * 12 + 10] = i + RoundPointNum;
indices[i * 12 + 11] = i + RoundPointNum - 1;
}
//渲染边界的情况
int i(RoundPointNum - 1);
//渲染下面的部分
indices[i * 12] = 2 * RoundPointNum;
indices[i * 12 + 1] = 0;
indices[i * 12 + 2] = RoundPointNum - 1;
//渲染上面的部分
indices[i * 12 + 3] = 2 * RoundPointNum + 1;
indices[i * 12 + 4] = RoundPointNum;
indices[i * 12 + 5] = 2 * RoundPointNum - 1;
//渲染侧面的第一个三角形
indices[i * 12 + 6] = RoundPointNum - 1;
indices[i * 12 + 7] = 0;
indices[i * 12 + 8] = 2 * RoundPointNum - 1;
//渲染侧面的第二个三角形
indices[i * 12 + 9] = 0;
indices[i * 12 + 10] = RoundPointNum;
indices[i * 12 + 11] = 2 * RoundPointNum - 1;
//设置缓冲区的使用方式为默认
bd.Usage = D3D11_USAGE_DEFAULT;
//设置缓冲区的字节宽度，这里是每个索引的字节大小乘以索引数量（36个索引）
bd.ByteWidth = sizeof(WORD) * (12 * RoundPointNum);
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
InitData.pSysMem = indices;
hr = g_pd3dDevice->CreateBuffer(&bd, &InitData, &g_pIndexBuffer);
if (FAILED(hr))
return hr;
//设置索引缓冲区
g_pImmediateContext->IASetIndexBuffer(g_pIndexBuffer, DXGI_FORMAT_R16_UINT, 0);
//设置图元拓扑,表示要绘制的图元拓扑类型为三角形列表
g_pImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
//创建常量缓冲区
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(ConstantBuffer);
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.CPUAccessFlags = 0;
hr = g_pd3dDevice->CreateBuffer(&bd, NULL, &g_pConstantBuffer);
if (FAILED(hr))
return hr;
//初始化世界矩阵
g_World = XMMatrixIdentity();
//初始化视图矩阵
XMVECTOR Eye = XMVectorSet(0.0f, 1.0f, -5.0f, 0.0f);
XMVECTOR At = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
XMVECTOR Up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
g_View = XMMatrixLookAtLH(Eye, At, Up);
//初始化投影矩阵
g_Projection = XMMatrixPerspectiveFovLH(XM_PIDIV2, width / (FLOAT)height, 0.01f, 100.0f);
return S_OK;
}
//释放创建的对象的函数
void CleanupDevice()
{
if (g_pImmediateContext) g_pImmediateContext->ClearState();
if (g_pConstantBuffer) g_pConstantBuffer->Release();
if (g_pVertexBuffer) g_pVertexBuffer->Release();
if (g_pIndexBuffer) g_pIndexBuffer->Release();
if (g_pVertexLayout) g_pVertexLayout->Release();
if (g_pVertexShader) g_pVertexShader->Release();
if (g_pPixelShader) g_pPixelShader->Release();
if (g_pRenderTargetView) g_pRenderTargetView->Release();
if (g_pSwapChain) g_pSwapChain->Release();
if (g_pImmediateContext) g_pImmediateContext->Release();
if (g_pd3dDevice) g_pd3dDevice->Release();
}
//窗口过程函数，用于处理程序接收到的消息
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
//用于渲染一帧的函数
void Render(void)
{
//记录时间流逝的变量
static float t = 0.0f;
//检查当前的驱动类型是否为参考驱动类型
if (g_driverType == D3D_DRIVER_TYPE_REFERENCE)
{
//如果使用参考驱动类型，将t增加一个固定的增量用于模拟动画效果。
t += (float)XM_PI * 0.0125f;
}
//如果不是参考驱动类型，执行以下代码块
else
{
//记录程序开始运行的时间
static DWORD dwTimeStart = 0;
//获取当前的系统时间
DWORD dwTimeCur = GetTickCount();
//如果dwTimeStart为0，表示是第一次执行Render函数，则将dwTimeStart设置为当前时间
if (dwTimeStart == 0)
dwTimeStart = dwTimeCur;
//计算从程序开始运行到当前时间的经过的秒数
t = (dwTimeCur - dwTimeStart) / 1000.0f;
}
//根据时间计算旋转矩阵用于物体的旋转变换
g_World = XMMatrixRotationY(t);
//定义一个清除元素数组（包含RGBA分量的值）
float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f };
//使用清除颜色清除后备缓冲区，准备渲染新的帧
g_pImmediateContext->ClearRenderTargetView(g_pRenderTargetView, ClearColor);
//定义一个名为cb的常量缓冲区结构
ConstantBuffer cb;
//将g_World矩阵转置后赋值给cb结构的mWorld成员
cb.mWorld = XMMatrixTranspose(g_World);
//将g_View矩阵转置后赋值给cb结构的mView成员
cb.mView = XMMatrixTranspose(g_View);
//将g_Projection矩阵转置后赋值给cb结构的mProjection成员
cb.mProjection = XMMatrixTranspose(g_Projection);
//将cb结构的数据更新到常量缓冲区g_pConstantBuffer中
g_pImmediateContext->UpdateSubresource(g_pConstantBuffer, 0, NULL, &cb, 0, 0);
//设置顶点着色器为g_pVertexShader
g_pImmediateContext->VSSetShader(g_pVertexShader, NULL, 0);
//将常量缓冲区g_pConstantBuffer绑定到顶点着色器的指定槽位
g_pImmediateContext->VSSetConstantBuffers(0, 1, &g_pConstantBuffer);
//设置像素着色器为g_pPixelShader
g_pImmediateContext->PSSetShader(g_pPixelShader, NULL, 0);
//使用索引缓冲区进行绘制
//绘制36个顶点，形成12个三角形。这是一个绘制立方体的操作
g_pImmediateContext->DrawIndexed(12*RoundPointNum, 0, 0);
//将后备缓冲区的内容呈现到屏幕上，显示渲染结果
g_pSwapChain->Present(0, 0);
}