Directx11学习笔记【八】 龙书D3DApp的实现

原文:Directx11学习笔记【八】 龙书D3DApp的实现

directx11龙书中的初始化程序D3DApp跟我们上次写的初始化程序大体一致，只是包含了计时器的内容，而且使用了深度模板缓冲。

D3DUtil类，定义了一些工具和宏，目前只定义了两个宏，以后还会添加

#ifndef D3DUTIL_H

#define D3DUTIL_H

#include <d3dx11.h>

#include <xnamath.h>

#include <dxerr.h>

#include <cassert>

//-------------------------------

//方便检测d3d errors

//-------------------------------

#if defined(DEBUG) | defined(_DEBUG)

#ifndef HR

#define HR(x)                                              \

    {                                                          \

    HRESULT hr = (x);                                      \

if (FAILED(hr))                                         \

        {                                                      \

        DXTrace(__FILE__, (DWORD)__LINE__, hr, L#x, true); \

        }                                                      \

    }

#endif

#else

#ifndef HR

#define HR(x) (x)

#endif

#endif

//------------------------------

//方便删除COM objects

//------------------------------

#define ReleaseCOM(x) { if(x){ x->Release(); x = 0; } }

#endif//D3DUTIL_H

基类D3DApp的实现

.h文件

 #ifndef D3DAPP_H

 #define D3DAPP_H

 #include <windows.h>

 #include <string>

 #include "D3DUtil.h"

 #include "GameTimer.h"

 class D3DApp

 {

 public:

     D3DApp(HINSTANCE hInstance);

     virtual ~D3DApp();

     HINSTANCE AppInst() const;

     HWND MainWnd() const;

     float AspectRatio() const;

     int Run();

     virtual bool Init();

     virtual void OnResize();

     virtual void UpdateScene(float dt) = ;

     virtual void DrawScene();

     virtual LRESULT MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

     //鼠标事件

     virtual void OnMouseDown(WPARAM btnState, int x, int y){}

     virtual void OnMouseUp(WPARAM btnState, int x, int y){}

     virtual void OnMouseMove(WPARAM btnState, int x, int y){}

 protected:

     bool InitMainWindow();

     bool InitDirect3D();

     //计算FPS

     void CalculateFrameStats();

 protected:

     HINSTANCE m_hAppInst;                            //实例句柄

     HWND m_hMainWnd;                                //主窗口句柄

     bool m_isAppPaused;

     bool m_isMinimized;

     bool m_isMaximized;

     bool m_isResizing;

     UINT m_4xMsaaQuality;                            //4重采样质量

     GameTimer m_timer;                                //计时器

     D3D_DRIVER_TYPE m_d3dDriverType;                //驱动类型

     ID3D11Device *m_pD3dDevice;                        //设备

     ID3D11DeviceContext *m_pImmediateContext;        //设备上下文

     IDXGISwapChain *m_pSwapChain;                    //交换链

     ID3D11Texture2D *m_pDepthStencilBuffer;            //深度模板缓冲

     ID3D11RenderTargetView *m_pRenderTargetView;    //渲染目标视图

     ID3D11DepthStencilView *m_pDepthStencilView;    //深度模板缓冲视图

     D3D11_VIEWPORT m_screenViewPort;                //视口

     std::wstring m_mainWndCaption;                    //窗口标题

     int m_clientWidth;

     int m_clientHeight;

     bool m_isEnable4xMsaa;                            //是否支持4重采样

 };

 #endif    //D3DAPP_H

.cpp

 #include <windowsx.h>//包含大量可用的宏和各种方便的工具

 #include <sstream>

 #include "D3DApp.h"

 namespace

 {

     D3DApp *g_d3dApp = NULL;

 }

 LRESULT CALLBACK MainWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)

 {

     return g_d3dApp->MsgProc(hWnd,msg,wParam,lParam);

 }

 D3DApp::D3DApp(HINSTANCE hInstance) :

 m_hAppInst(hInstance),

 m_mainWndCaption(L"D3D11 Application"),

 m_d3dDriverType(D3D_DRIVER_TYPE_HARDWARE),

 m_clientHeight(),

 m_clientWidth(),

 m_isEnable4xMsaa(false),

 m_hMainWnd(NULL),

 m_isAppPaused(false),

 m_isMaximized(false),

 m_isMinimized(false),

 m_isResizing(false),

 m_4xMsaaQuality(),

 m_pD3dDevice(NULL),

 m_pImmediateContext(NULL),

 m_pSwapChain(NULL),

 m_pRenderTargetView(NULL),

 m_pDepthStencilBuffer(NULL)

 {

     ZeroMemory(&m_screenViewPort, sizeof(D3D11_VIEWPORT));

     g_d3dApp = this;

 }

 D3DApp::~D3DApp()

 {

     ReleaseCOM(m_pRenderTargetView);

     ReleaseCOM(m_pDepthStencilBuffer);

     ReleaseCOM(m_pSwapChain);

     ReleaseCOM(m_pDepthStencilView);

     if (m_pImmediateContext)

         m_pImmediateContext->ClearState();

     ReleaseCOM(m_pImmediateContext);

     ReleaseCOM(m_pD3dDevice);

 }

 HINSTANCE D3DApp::AppInst() const

 {

     return m_hAppInst;

 }

 HWND D3DApp::MainWnd() const

 {

     return m_hMainWnd;

 }

 float D3DApp::AspectRatio() const

 {

     return static_cast<float>(m_clientWidth / m_clientHeight);

 }

 int D3DApp::Run()

 {

     MSG msg;

     ZeroMemory(&msg, sizeof(MSG));

     m_timer.Reset();

     while (msg.message != WM_QUIT)

     {

         if (PeekMessage(&msg, NULL, , , PM_REMOVE))

         {

             TranslateMessage(&msg);

             DispatchMessage(&msg);

         }

         else

         {

             m_timer.Tick();

             if (!m_isAppPaused)

             {

                 CalculateFrameStats();

                 UpdateScene(m_timer.DeltaTime());

                 DrawScene();

             }

             else

             {

                 Sleep();

             }

         }

     }

     return static_cast<int>(msg.wParam);

 }

 bool D3DApp::Init()

 {

     if (!InitMainWindow())

         return false;

     if (!InitDirect3D())

         return false;

     return true;

 }

 void D3DApp::OnResize()

 {

     assert(m_pImmediateContext);

     assert(m_pD3dDevice);

     assert(m_pSwapChain);

     //release old views

     ReleaseCOM(m_pRenderTargetView);

     ReleaseCOM(m_pDepthStencilView);

     ReleaseCOM(m_pDepthStencilBuffer);

     HR(m_pSwapChain->ResizeBuffers(, m_clientWidth, m_clientHeight, DXGI_FORMAT_R8G8B8A8_UNORM, ));

     ID3D11Texture2D *backBuffer;

     HR(m_pSwapChain->GetBuffer(, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&backBuffer)));

     HR(m_pD3dDevice->CreateRenderTargetView(backBuffer, , &m_pRenderTargetView));

     ReleaseCOM(backBuffer);

     //create depth/stencil buffer and view

     D3D11_TEXTURE2D_DESC depthStencilDecs;

     depthStencilDecs.Width = m_clientWidth;

     depthStencilDecs.Height = m_clientHeight;

     depthStencilDecs.MipLevels = ;

     depthStencilDecs.ArraySize = ;

     depthStencilDecs.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;

     //是否使用4重采样

     if (m_isEnable4xMsaa)

     {

         depthStencilDecs.SampleDesc.Count = ;

         depthStencilDecs.SampleDesc.Quality = m_4xMsaaQuality - ;

     }

     else

     {

         depthStencilDecs.SampleDesc.Count = ;

         depthStencilDecs.SampleDesc.Quality = ;

     }

     depthStencilDecs.Usage = D3D11_USAGE_DEFAULT;

     depthStencilDecs.BindFlags = D3D11_BIND_DEPTH_STENCIL;

     depthStencilDecs.CPUAccessFlags = ;

     depthStencilDecs.MiscFlags = ;

     HR(m_pD3dDevice->CreateTexture2D(&depthStencilDecs, , &m_pDepthStencilBuffer));

     HR(m_pD3dDevice->CreateDepthStencilView(m_pDepthStencilBuffer, , &m_pDepthStencilView));

     //绑定新的render target view 和 depth/stencil view到管线

     m_pImmediateContext->OMSetRenderTargets(, &m_pRenderTargetView, m_pDepthStencilView);

     //设置viewport

     m_screenViewPort.TopLeftX = ;

     m_screenViewPort.TopLeftY = ;

     m_screenViewPort.Width = m_clientWidth;

     m_screenViewPort.Height = m_clientHeight;

     m_screenViewPort.MaxDepth = 1.0f;

     m_screenViewPort.MinDepth = 0.0f;

     m_pImmediateContext->RSSetViewports(, &m_screenViewPort);

 }

 LRESULT D3DApp::MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)

 {

     switch (msg)

     {

         //当一个窗口被激活或失去激活状态

     case WM_ACTIVATE:

         if (LOWORD(wParam) == WA_INACTIVE)

         {

             m_isAppPaused = true;

             m_timer.Stop();

         }

         else

         {

             m_isAppPaused = false;

             m_timer.Start();

         }

         return ;

         //当用户重绘窗口时

     case WM_SIZE:

         m_clientWidth = LOWORD(lParam);

         m_clientHeight = HIWORD(lParam);

         if (m_pD3dDevice)

         {

             if (wParam == SIZE_MINIMIZED)//窗口最小化

             {

                 m_isAppPaused = true;

                 m_isMinimized = true;

                 m_isMaximized = true;

             }

             else if (wParam == SIZE_MAXIMIZED)//窗口最大化

             {

                 m_isAppPaused = false;

                 m_isMinimized = false;

                 m_isMaximized = true;

                 OnResize();

             }

             else if (wParam == SIZE_RESTORED)//窗口大小改变既不是最大化也不是最小化

             {

                 if (m_isMinimized)

                 {

                     m_isAppPaused = false;

                     m_isMinimized = false;

                     OnResize();

                 }

                 else if (m_isMaximized)

                 {

                     m_isAppPaused = false;

                     m_isMaximized = false;

                     OnResize();

                 }

                 //当用户正在改变窗口大小时不调用OnResize(),当改变完成后再

                 //调用

                 else if (m_isResizing)

                 {

                 }

                 else

                 {

                     OnResize();

                 }

             }

         }

         return ;

     //用户开始拖拽改变窗口大小

     case WM_ENTERSIZEMOVE:

         m_isAppPaused = true;

         m_isResizing = true;

         m_timer.Stop();

         return ;

     //用户改变窗口大小完毕

     case WM_EXITSIZEMOVE:

         m_isAppPaused = false;

         m_isResizing = false;

         m_timer.Start();

         OnResize();

         return  ;

     //窗口销毁

     case WM_DESTROY:

         PostQuitMessage();

         return ;

     //The WM_MENUCHAR message is sent when a menu is active and the user presses

     // a key that does not correspond to any mnemonic or accelerator key.

     case WM_MENUCHAR:

         return MAKELRESULT(, MNC_CLOSE);

     //防止窗口变得太小

     case WM_GETMINMAXINFO:

         ((MINMAXINFO*)lParam)->ptMinTrackSize.x = ;

         ((MINMAXINFO*)lParam)->ptMinTrackSize.y = ;

         return ;

     case WM_LBUTTONDOWN:

     case WM_MBUTTONDOWN:

     case WM_RBUTTONDOWN:

         OnMouseDown(wParam, GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam));

         return ;

     case WM_LBUTTONUP:

     case WM_MBUTTONUP:

     case WM_RBUTTONUP:

         OnMouseUp(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));

         return ;

     case WM_MOUSEMOVE:

         OnMouseMove(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));

         return ;

     }

     return DefWindowProc(hWnd, msg, wParam, lParam);

 }

 bool D3DApp::InitMainWindow()

 {

     WNDCLASS wc;

     wc.cbClsExtra = ;

     wc.cbWndExtra = ;

     wc.hbrBackground = static_cast<HBRUSH>(GetStockObject(NULL_BRUSH));

     wc.hCursor = LoadCursor(, IDC_ARROW);

     wc.hIcon = LoadIcon(, IDI_APPLICATION);

     wc.hInstance = m_hAppInst;

     wc.lpfnWndProc = MainWndProc;

     wc.lpszClassName = L"D3DWndClassName";

     wc.lpszMenuName = NULL;

     wc.style = CS_HREDRAW | CS_VREDRAW;

     if (!RegisterClass(&wc))

     {

         MessageBox(, L"RegisterClass Failed", , );

         return false;

     }

     RECT rect{ , , m_clientWidth, m_clientHeight };

     AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, false);

     int width = rect.right - rect.left;

     int height = rect.bottom - rect.top;

     m_hMainWnd = CreateWindow(L"D3DWndClassName", m_mainWndCaption.c_str(), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,

         width, height, NULL, NULL, m_hAppInst, );

     if (!m_hMainWnd)

     {

         MessageBox(, L"CreateWindow Failed", , );

         return ;

     }

     ShowWindow(m_hMainWnd,SW_SHOW);

     UpdateWindow(m_hMainWnd);

     return true;

 }

 bool D3DApp::InitDirect3D()

 {

     UINT createDeviceFlags = ;

 #if defined(DEBUG) || defined(_DEBUG)

     createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;

 #endif

     D3D_FEATURE_LEVEL featureLevel;

     HRESULT hr = D3D11CreateDevice(

         ,//默认的adapter

         m_d3dDriverType,

         ,

         createDeviceFlags,

         , ,

         D3D11_SDK_VERSION,

         &m_pD3dDevice,

         &featureLevel,

         &m_pImmediateContext

         );

     if (FAILED(hr))

     {

         MessageBox(, L"D3D11CreateDevice Failed", , );

         return hr;

     }

     if (featureLevel != D3D_FEATURE_LEVEL_11_0)

     {

         MessageBox(, L"Direct3D Feature Level 11 unsupported!", , );

         return false;

     }

     //check 4x msaa quality support

     HR(m_pD3dDevice->CheckMultisampleQualityLevels(DXGI_FORMAT_R8G8B8A8_UNORM, , &m_4xMsaaQuality));

     assert(m_4xMsaaQuality > );

     //填充交换链描述

     DXGI_SWAP_CHAIN_DESC sd;

     sd.BufferDesc.Width = m_clientWidth;

     sd.BufferDesc.Height = m_clientHeight;

     sd.BufferDesc.RefreshRate.Numerator = ;

     sd.BufferDesc.RefreshRate.Denominator = ;

     sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;

     sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;

     sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;

     //是否用4重采样

     if (m_isEnable4xMsaa)

     {

         sd.SampleDesc.Count = ;

         sd.SampleDesc.Quality = m_4xMsaaQuality - ;

     }

     else

     {

         sd.SampleDesc.Count = ;

         sd.SampleDesc.Quality = ;

     }

     sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;

     sd.BufferCount = ;

     sd.OutputWindow = m_hMainWnd;

     sd.Windowed = true;

     sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;

     sd.Flags = ;

     //要创建交换链必须得到IDXGIFactory

     IDXGIDevice *pDxgiDevice = ;

     HR(m_pD3dDevice->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&pDxgiDevice)));

     IDXGIAdapter *pDxgiAdapter = ;

     HR(pDxgiDevice->GetParent(__uuidof(IDXGIAdapter), reinterpret_cast<void**>(&pDxgiAdapter)));

     IDXGIFactory *pDxgiFactory = ;

     HR(pDxgiAdapter->GetParent(__uuidof(IDXGIFactory), reinterpret_cast<void**>(&pDxgiFactory)));

     HR(pDxgiFactory->CreateSwapChain(m_pD3dDevice, &sd, &m_pSwapChain));

     ReleaseCOM(pDxgiDevice);

     ReleaseCOM(pDxgiAdapter);

     ReleaseCOM(pDxgiFactory);

     OnResize();

     return true;

 }

 void D3DApp::CalculateFrameStats()

 {

     //计算fps，每一帧调用

     static int frameCnt = ;

     static float timeElapsed = 0.0f;

     frameCnt++;

     if ((m_timer.TotalTime() - timeElapsed) >= 1.0f)

     {

         float fps = static_cast<float>(frameCnt);

         float mspf = .f / fps;

         std::wostringstream outs;

         outs.precision();//浮点数显示6位

         outs << m_mainWndCaption << L"    " << L"FPS:" << fps << L"    "

             << L"Frame Time:" << mspf << L" (ms) ";

         SetWindowText(m_hMainWnd, outs.str().c_str());

         frameCnt = ;

         timeElapsed += 1.0f;

     }

 }

 void D3DApp::DrawScene()

 {

 }

初始化程序

InitDirect3DApp.h

 #ifndef INITDIRECT3DAPP_H

 #define INITDIRECT3DAPP_H

 #include "D3DApp.h"

 class InitDirect3DApp : public D3DApp

 {

 public:

     InitDirect3DApp(HINSTANCE hInstance);

     ~InitDirect3DApp();

     bool Init();

     void OnResize();

     void UpdateScene(float dt);

     void DrawScene();

 };

 #endif//INITDIRECT3DAPP_H

InitDirect3DApp.cpp

 #include "InitDirect3DApp.h"

 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)

 {

 #if defined(DEBUG) | defined(_DEBUG)

     _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

 #endif

     InitDirect3DApp theApp(hInstance);

     if (!theApp.Init())

         return  ;

     return theApp.Run();

 }

 InitDirect3DApp::InitDirect3DApp(HINSTANCE hInstance) : D3DApp(hInstance)

 {

 }

 InitDirect3DApp::~InitDirect3DApp()

 {

 }

 bool InitDirect3DApp::Init()

 {

     if (!D3DApp::Init())

         return false;

     return true;

 }

 void InitDirect3DApp::OnResize()

 {

     D3DApp::OnResize();

 }

 void InitDirect3DApp::UpdateScene(float dt)

 {

 }

 void InitDirect3DApp::DrawScene()

 {

     assert(m_pImmediateContext);

     assert(m_pSwapChain);

     float ClearColor[] = { 0.0f, 0.0f, 1.0f, 1.0f };

     m_pImmediateContext->ClearRenderTargetView(m_pRenderTargetView, ClearColor);

     m_pImmediateContext->ClearDepthStencilView(m_pDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, );

     HR(m_pSwapChain->Present(, ));

 }