DirectX9完全面向对象框架

 #pragma once
 #define UNICODE
 //Direct3D lib
 #include<d3d9.h>
 #include<d3dx9.h>
 #pragma comment(lib, "d3d9.lib")
 #pragma comment(lib, "d3dx9.lib")

 //Default lib
 #include<wchar.h>
 #include<tchar.h>
 #include<assert.h>
 #pragma comment(lib, "winmm.lib")

 namespace Clear
 {
     template<typename T>
     void SafeRelease(T t)
     {
         if (t)
         {
             t->Release();
             t = nullptr;
         }
     }
     template<typename T>
     void SafeDelete(T t)
     {
         if (t)
         {
             delete t;
             t = nullptr;
         }
     }
 }
 class DXApp
 {
 public:

     DXApp(HINSTANCE hInstance = nullptr);
     virtual ~DXApp();

     bool InitDXApp(const WCHAR* title, UINT width, UINT height, bool fullscreen);

     bool InitWindow(const WCHAR* title, UINT width, UINT height, bool fullscreen);
     bool InitDirect3D_9();

     virtual LRESULT MsgProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam);
     virtual int Run();
     void RenderShell();
     virtual void Render() = ;
     virtual void Update() = ;
     virtual void OnLostDevice() = ;
     virtual void OnResetDevice() = ;

 protected:

     HINSTANCE m_AppInstance;
     HWND m_hWindowedHWND;
     WCHAR m_strAppTitle[];
     UINT m_windowWidth;
     UINT m_windowHeight;

     bool m_bFullScreen;
     bool m_bLostDevice;

     //Direct3D_9 properties
     IDirect3D9* m_pD3D;
     D3DPRESENT_PARAMETERS m_PresentParamenters;
     IDirect3DDevice9* m_pD3Ddevice;

 };

DXApp.cpp

 #include "DXApp.h"

 //Store DXApp global pointer
 namespace Global
 {
     DXApp* g_pDxapp = nullptr;
 }
 LRESULT CALLBACK MainProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam)
 {
     if (Global::g_pDxapp)
     {
         return Global::g_pDxapp->MsgProc(hWnd, Message, wParam, lParam);
     }
     else
     {
         return DefWindowProc(hWnd, Message, wParam, lParam);
     }
 }

 DXApp::DXApp(HINSTANCE hInstance)
 {
     m_AppInstance = hInstance;
     m_hWindowedHWND = nullptr;
     Global::g_pDxapp = this;

 }

 DXApp::~DXApp()
 {
     Clear::SafeRelease(m_pD3D);
     Clear::SafeRelease(m_pD3Ddevice);
 }

 bool DXApp::InitDXApp(const WCHAR* title, UINT width, UINT height, bool fullscreen)
 {
     if(!InitWindow(title, width, height, fullscreen))
         return false;
     if (!InitDirect3D_9())
         return false;

     return true;
 }

 bool DXApp::InitWindow(const WCHAR* title, UINT width, UINT height, bool fullscreen)
 {
     // Initialize window's properties
     wsprintfW(m_strAppTitle, title);
     m_windowWidth = width;
     m_windowHeight = height;
     m_bFullScreen = fullscreen;
     m_bLostDevice = false;

     const WCHAR* CLASSNAME = L"DEMOCLASS";
     WNDCLASSEX wcex;
     ZeroMemory(&wcex, sizeof(wcex));
     wcex.style = CS_VREDRAW | CS_HREDRAW;
     wcex.cbClsExtra = ;
     wcex.cbSize = sizeof(wcex);
     wcex.cbWndExtra = ;
     wcex.hbrBackground = nullptr;
     wcex.hCursor = LoadCursor(m_AppInstance, IDC_ARROW);
     wcex.hIcon = LoadIcon(m_AppInstance, IDI_APPLICATION);
     wcex.hIconSm = LoadIcon(m_AppInstance, IDI_APPLICATION);
     wcex.hInstance = m_AppInstance;
     wcex.lpfnWndProc = MainProc;
     wcex.lpszClassName = CLASSNAME;
     wcex.lpszMenuName = nullptr;
     if (!RegisterClassEx(&wcex))
     {
         OutputDebugString(L"DXApp::InitWindow: RegisterClassEx()failed!");
         return false;
     }

     // adjust window size
     RECT adjR;
     SetRect(&adjR, , , m_windowWidth, m_windowHeight);
     AdjustWindowRect(&adjR, WS_OVERLAPPEDWINDOW, false);
     UINT w = adjR.right - adjR.left;
     UINT h = adjR.bottom - adjR.top;
     UINT x = GetSystemMetrics(SM_CXSCREEN) /  - w / ;
     UINT y = GetSystemMetrics(SM_CYSCREEN) /  - h / ;
     m_hWindowedHWND = CreateWindow(CLASSNAME, m_strAppTitle, WS_OVERLAPPEDWINDOW, x, y, w, h, nullptr, nullptr, m_AppInstance, nullptr);
     if (!m_hWindowedHWND)
     {
         OutputDebugString(L"DXApp::InitWindow: CreateWindow()failed!");
         return false;
     }

     ShowWindow(m_hWindowedHWND, SW_SHOWDEFAULT);

     return true;
 }

 bool DXApp::InitDirect3D_9()
 {
     m_pD3D = Direct3DCreate9(D3D_SDK_VERSION);

     D3DCAPS9 d3dcaps;
     int vertex_proc = ;
     m_pD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3dcaps);
     if (d3dcaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
     {
         vertex_proc = D3DCREATE_HARDWARE_VERTEXPROCESSING;
     }
     else
     {
         vertex_proc = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
     }

     ZeroMemory(&m_PresentParamenters, sizeof(m_PresentParamenters));
     m_PresentParamenters.BackBufferCount = ;
     m_PresentParamenters.BackBufferWidth = m_windowWidth;
     m_PresentParamenters.BackBufferHeight = m_windowHeight;
     m_PresentParamenters.BackBufferFormat = D3DFMT_A8R8G8B8;
     m_PresentParamenters.EnableAutoDepthStencil = true;
     m_PresentParamenters.AutoDepthStencilFormat = D3DFMT_D24S8;
     m_PresentParamenters.hDeviceWindow = m_hWindowedHWND;
     m_PresentParamenters.Flags = ;
     m_PresentParamenters.SwapEffect = D3DSWAPEFFECT_DISCARD;
     m_PresentParamenters.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
     m_PresentParamenters.MultiSampleQuality = ;
     m_PresentParamenters.MultiSampleType = D3DMULTISAMPLE_NONE;
     m_PresentParamenters.Windowed = true;
     m_PresentParamenters.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

     // create device
     if (FAILED(m_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hWindowedHWND, vertex_proc, &m_PresentParamenters, &m_pD3Ddevice)))
     {
         OutputDebugString(L"DXApp::InitDirect3D_9: CreateDevice()failed!");
         return false;
     }

     return true;
 }

 LRESULT DXApp::MsgProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam)
 {
     switch (Message)
     {
     case WM_KEYDOWN:
         if (wParam == VK_ESCAPE)
             DestroyWindow(hWnd);
         return ;
     case WM_DESTROY:
         PostQuitMessage();
         return ;
     }

     return DefWindowProc(hWnd, Message, wParam, lParam);
 }

 int DXApp::Run()
 {
     MSG msg;
     ZeroMemory(&msg, sizeof(msg));
     while (msg.message != WM_QUIT)
     {
         if (PeekMessage(&msg, nullptr, , , PM_REMOVE))
         {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
         else
         {
             RenderShell();
         }
     }

     return (int)msg.wParam;
 }

 void DXApp::RenderShell()
 {
     if (m_bLostDevice)
     {
         HRESULT hr = m_pD3Ddevice->TestCooperativeLevel();
         if (hr == D3DERR_DEVICELOST)
         {
             OnLostDevice();
             return;
         }
         if (hr == D3DERR_DEVICENOTRESET)
         {
             m_pD3Ddevice->Reset(&m_PresentParamenters);
             OnResetDevice();
             return;
         }

         m_bLostDevice = false;
     }
     m_pD3Ddevice->Clear(, nullptr, D3DCLEAR_TARGET | D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(, , ), .f, 0L);
     m_pD3Ddevice->BeginScene();
     Update();
     Render();
     m_pD3Ddevice->EndScene();
     HRESULT hr = m_pD3Ddevice->Present(, , , );
     if (hr == D3DERR_DEVICELOST)
         m_bLostDevice = true;
 }