主菜终于来了。这个d3dclass主要做的工作是dx11图形程序的初始化工作，它将创建显示表面交换链，d3d设备，d3d设备上下文，渲染目标表面，深度模板缓存；设置视口，生成投影矩阵。
- D3D设备：可以看成是一个接口，获得这个接口后就能创建各种d3d对象
- D3D设备上下文：应该也可以看成是渲染环境的接口吧，使用它就能定制各种渲染环境，对绘制环境进行配置
- 显示表面交换链：显示表面的集合，显示表面是什么？是当前屏幕内容的内存映射，这或许应该说是主显示表面，与主显示表面同在交换链里的是副显示表面。它们的出现是为了实现平滑的绘制效果
- 渲染目标表面：就是交换链当前处于后台的表面（副表面）
- 深度模板缓存：一个存储当前绘制了的像素对应的Z值的数据块，通过这个缓存块可以决定我们是否能看到模型。就像我们把两张纸放在我们的眼前，我们只能看到离我们近的那张，离我们远的那张被离的近的挡住了，这个远近的量化就是Z值。
- 视口：显示图形的矩形，如果是全屏，那么视口就是当前屏幕
- 投影矩阵：3d渲染管线中一个重要的矩阵，他能将相机看到的内容投影到视口上
代码：
d3dclass.h
#pragma once #include <d3d11.h>
#include <d3dcompiler.h>
#include <D3DX11.h>
#include <xnamath.h> #pragma comment(lib,"d3dx11.lib")
#pragma comment(lib,"d3d11.lib")
#pragma comment(lib,"d3dcompiler.lib") class d3dclass
{
public:
d3dclass();
~d3dclass(); private:
ID3D11Device *m_d3ddevice;
ID3D11DeviceContext *m_d3dcontext;
IDXGISwapChain *m_d3dswapchain;
ID3D11RenderTargetView *m_d3dtargetview;
ID3D11Texture2D* m_d3ddepthStencil;
ID3D11DepthStencilView* m_d3ddepthStencilView;
XMMATRIX m_pro; public:
bool Initialize(HWND hwnd);
void Shutdown();
void Getdevice(ID3D11Device*& device);
void Getcontext(ID3D11DeviceContext*& context);
void Beginrender(float r, float g, float b, float a);
void Endrender();
void Getpromtrx(XMMATRIX& pro);
};
m_d3ddevice:d3d设备对象
m_d3dcontext:d3d设备上下文
m_d3dswapchain:d3d交换链
m_d3dtargetview:渲染目标表面
m_d3ddepthStencil:深度缓存
m_d3ddepthStencilView:深度缓存表面
m_pro:投影矩阵
公有方法作用：
Initialize()：初始化directx的各种对象
Shutdown()：释放各种对象
Getdevice()：获取设备指针以供使用
Getcontext()：获取设备上下文指针以供使用
Beginrender()：在模型渲染前调用
Endrender()：在模型渲染后调用
Getpromatrx()：获取投影矩阵以供使用
d3dclass.cpp
#include "d3dclass.h" d3dclass::d3dclass()
{
} d3dclass::~d3dclass()
{
} bool d3dclass::Initialize(HWND hwnd)
{
HRESULT hr = S_OK;
D3D_DRIVER_TYPE drivertype;
D3D_FEATURE_LEVEL featurelevel; RECT rc;
GetClientRect(hwnd, &rc);
int width = rc.right - rc.left;
int height = rc.bottom - rc.top; UINT createDeviceFlags = ;
#ifdef _DEBUG
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_WARP,
D3D_DRIVER_TYPE_REFERENCE,
};
UINT numDriverTypes = ARRAYSIZE(driverTypes); D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
};
UINT numFeatureLevels = ARRAYSIZE(featureLevels); DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = ;///////////////
sd.BufferDesc.Width = width;
sd.BufferDesc.Height = height;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = ;
sd.BufferDesc.RefreshRate.Denominator = ;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = hwnd;
sd.SampleDesc.Count = ;//////////////
sd.SampleDesc.Quality = ;/////////////
sd.Windowed = TRUE; for (UINT driverTypeIndex = ; driverTypeIndex < numDriverTypes; driverTypeIndex++)
{
drivertype = driverTypes[driverTypeIndex];
hr=D3D11CreateDeviceAndSwapChain(NULL, drivertype, NULL, createDeviceFlags, featureLevels, numFeatureLevels,
D3D11_SDK_VERSION, &sd, &m_d3dswapchain, &m_d3ddevice, &featurelevel, &m_d3dcontext);
if (SUCCEEDED(hr))
{
break;
}
}
if (FAILED(hr))
{
return false;
} ID3D11Texture2D* pBackBuffer = NULL;
hr = m_d3dswapchain->GetBuffer(, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
if (FAILED(hr))
{
return false;
} hr = m_d3ddevice->CreateRenderTargetView(pBackBuffer, NULL, &m_d3dtargetview); pBackBuffer->Release();
if (FAILED(hr))
{
return false;
} D3D11_TEXTURE2D_DESC descDepth;
ZeroMemory(&descDepth, sizeof(descDepth));
descDepth.Width = width;
descDepth.Height = height;
descDepth.MipLevels = ;
descDepth.ArraySize = ;
descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
descDepth.SampleDesc.Count = ;
descDepth.SampleDesc.Quality = ;
descDepth.Usage = D3D11_USAGE_DEFAULT;
descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL;
descDepth.CPUAccessFlags = ;
descDepth.MiscFlags = ;
hr = m_d3ddevice->CreateTexture2D(&descDepth, NULL, &m_d3ddepthStencil);
if (FAILED(hr))
{
return false;
} D3D11_DEPTH_STENCIL_VIEW_DESC descDSV;
ZeroMemory(&descDSV, sizeof(descDSV));
descDSV.Format = descDepth.Format;
descDSV.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
descDSV.Texture2D.MipSlice = ;
hr = m_d3ddevice->CreateDepthStencilView(m_d3ddepthStencil, &descDSV, &m_d3ddepthStencilView);
if (FAILED(hr))
{
return false;
} m_d3dcontext->OMSetRenderTargets(, &m_d3dtargetview, m_d3ddepthStencilView); D3D11_VIEWPORT vp;
vp.Width = (FLOAT)width;
vp.Height = (FLOAT)height;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = ;
vp.TopLeftY = ;
m_d3dcontext->RSSetViewports(, &vp); m_pro = XMMatrixPerspectiveFovLH(XM_PIDIV2, (float)width / (float)height, 0.01f, 1000.0f); return true;
} void d3dclass::Shutdown()
{
if (m_d3dtargetview)
{
m_d3dtargetview->Release();
}
if (m_d3ddepthStencilView)
{
m_d3ddepthStencilView->Release();
}
if (m_d3ddepthStencil)
{
m_d3ddepthStencil->Release();
}
if (m_d3dswapchain)
{
m_d3dswapchain->Release();
}
if (m_d3dcontext)
{
m_d3dcontext->Release();
}
if (m_d3ddevice)
{
m_d3ddevice->Release();
}
} void d3dclass::Getdevice(ID3D11Device*& device)
{
device = m_d3ddevice;
} void d3dclass::Getcontext(ID3D11DeviceContext*& context)
{
context = m_d3dcontext;
} void d3dclass::Beginrender(float r,float g,float b,float a)
{
float color[] = { r, g, b, a };
m_d3dcontext->ClearRenderTargetView(m_d3dtargetview,color);
m_d3dcontext->ClearDepthStencilView(m_d3ddepthStencilView, D3D11_CLEAR_DEPTH, 1.0f, );
} void d3dclass::Endrender()
{
m_d3dswapchain->Present(, );
} void d3dclass::Getpromtrx(XMMATRIX& pro)
{
pro = m_pro;
}
具体来看这几个方法。
Initialize()：
- 先罗列设备类型与特征层级，填充交换链描述数据结构，然后for循环测试使用哪个设备类型与特征层级，创建交换链，设备，设备上下文；
- 再获取一个二维内存，创建渲染目标表面；
- 再填充一个二维内存描述数据结构，创建一个二维内存，填充一个深度模板缓存描述数据结构，创建深度模板缓存，并设置之；
- 创建视口数据结构，填充各个字段，并设置；
- 最后生成投影矩阵
至于各个描述数据结构的各个字段含义，大家可以去查阅dx11的文档
（本函数没有进行设备性能检测，所以是不安全的代码，大家如果要深入学习，还是要多参考其他资料）
Shutdown()：依前是释放对象时做扫尾工作
Beginrender()：用指定颜色清理渲染目标表面，并清理深度缓存
Endrender()：交换交换链的显示表面