工程GameProject1: main.h, main.cpp这两个文件用于创建游戏Stranded。
工程GameEngine:RenderInterface.h , D3DRenderer.h, D3DRenderer.cpp, engine.h, defines.h. D3DRenderer.h和D3DRenderer.cpp用于创建Direct3D渲染系统; RenderInterface.h文件是一个基类，D3DRenderer就是从该类派生出来的；engine.h和defines.h包含了游戏引擎中要用到的Define(定义)、Function Prototype(函数原型)、Enumeration(枚举)、Structure(结构)和Include(包含)等语句。
main.h
#ifndef _UGP_MAIN_H_
#define _UGP_MAIN_H_
#include"StrandedEngine/engine.h"
#pragma comment(lib, "lib/StrandedEngine.lib")
#define WINDOW_CLASS "StrandedGame"
#define WINDOW_NAME "Stranded"
#define WIN_WIDTH 800
#define WIN_HEIGHT 600
#define FULLSCREEN 1
// Function Prototypes...
bool InitializeEngine();
void ShutdownEngine();
// Main game functions.
bool GameInitialize();
void GameLoop();
void GameShutdown();
#endif
main.cpp
#include"main.h"
// Globals...
HWND g_hwnd;
CRenderInterface *g_Render = NULL;
LRESULT WINAPI MsgProc(HWND hd, UINT msg, WPARAM wp, LPARAM lp)
{
switch(msg)
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
break;
case WM_KEYUP:
if(wp == VK_ESCAPE) PostQuitMessage(0);
break;
}
return DefWindowProc(hd, msg, wp, lp);
}
int WINAPI WinMain(HINSTANCE h, HINSTANCE p, LPSTR cmd, int show)
{
// Register the window class
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc,
0L, 0L, GetModuleHandle(NULL), NULL, NULL,
NULL, NULL, WINDOW_CLASS, NULL };
RegisterClassEx(&wc);
// Create the application's window
if(FULLSCREEN)
{
g_hwnd = CreateWindowEx(NULL, WINDOW_CLASS, WINDOW_NAME,
WS_POPUP | WS_SYSMENU | WS_VISIBLE, 0, 0,
WIN_WIDTH, WIN_HEIGHT,
NULL, NULL, h, NULL);
}
else
{
g_hwnd = CreateWindowEx(NULL, WINDOW_CLASS, WINDOW_NAME,
WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0,
0, WIN_WIDTH, WIN_HEIGHT,
NULL, NULL, h, NULL);
}
if(g_hwnd)
{
// Show the window
ShowWindow(g_hwnd, SW_SHOWDEFAULT);
UpdateWindow(g_hwnd);
}
// Initialize the Stranded Engine.
if(InitializeEngine())
{
// Initialize Stranded game.
if(GameInitialize())
{
// Enter the message loop
MSG msg;
ZeroMemory(&msg, sizeof(msg));
SetCursorPos(0, 0);
while(msg.message != WM_QUIT)
{
if(PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
GameLoop();
}
}
}
// Release any and all resources.
GameShutdown();
ShutdownEngine();
UnregisterClass(WINDOW_CLASS, wc.hInstance);
return 0;
}
bool InitializeEngine()
{
if(!CreateD3DRenderer(&g_Render)) return false;
if(!g_Render->Initialize(WIN_WIDTH, WIN_HEIGHT,
g_hwnd, FULLSCREEN)) return false;
g_Render->SetClearCol(0, 0, 0);
return true;
}
void ShutdownEngine()
{
if(g_Render)
{
g_Render->Shutdown();
delete g_Render;
g_Render = NULL;
}
}
bool GameInitialize()
{
return true;
}
void GameLoop()
{
if(!g_Render) return;
g_Render->StartRender(1, 1, 0);
g_Render->EndRendering();
}
void GameShutdown()
{
}
InitializeEngine()函数调用CreateD3DRenderer()函数为渲染系统分配内存。该函数调用对象的Initialize()函数初始化渲染系统。它将清除色设为黑色。清除色就是在应用程序启动新帧时，清除后台缓存用的颜色。ShutdownEngine()函数只是简单地将所有系统使用的动态内存清除干净。到目前为止，只有一个基本的渲染系统，所以这就是要清除的全部内容。GameInitialize()和GameShutdown()这两个函数都是空的，因为在此还没有创建具体的游戏代码。GameLoop()函数和第1章的render()函数很类似。该函数只是完成渲染一个黑屏的基本功能。
defines.h
defines.h文件包含了游戏使用的大量的定义和枚举变量。defines.h头文件将包含游戏或引擎将用到的常用定义.
#ifndef _UGP_DEFINES_H_
#define _UGP_DEFINES_H_
#include<windows.h>
// Boolean values.
#define UGP_INVALID -1
#define UGP_OK 1
#define UGP_FAIL 0
// Window handle (need new way if porting to Mac and OpenGL).
#define WinHWND HWND
// Typedefs and enumerations.
typedef long VertexType;
enum PrimType
{
NULL_TYPE,
POINT_LIST,
TRIANGLE_LIST,
TRIANGLE_STRIP,
TRIANGLE_FAN,
LINE_LIST,
LINE_STRIP
};
// Color defines.
#define UGPCOLOR_ARGB(a,r,g,b) ((unsigned long)((((a)&0xff)<<24)|\
(((r)&0xff)<<16)|(((g)&0xff)<<8)|\
((b)&0xff)))
#endif
RenderInterface.h
RenderInterface.h头文件包含了渲染系统基类的声明。然后派生该类以创建游戏引擎使用的真实渲染系统。
渲染系统的基类所包含的成员变量有屏幕宽度和高度、一个是否渲染整个屏幕的标识符，Direct3D初始化函数所需要的窗口句柄，以及两个投影矩阵所需的近距离值和远距离值。将变量属性设为受保护的(protected)，意味着它们可以是派生类的成员变量，就如同是在那些类中声明的一样。
这些渲染系统的基类开始先是构造函数和析构函数。这些构造函数只是简单地设置成员变量的默认值，而析构函数什么也不做。析构函数的属性被设置为虚拟的(virtual)，因为这样可以确保所有的派生类在析构时可以调用正确的析构函数。如果不这样的话，读者可能就会遇到一些意外错误或是很难发现的内存泄漏问题。在创建基类时，要牢记一定要创建一个虚拟析构函数。
函数的其余部分直接明了。Initialize()函数用于设置Direct3D渲染系统。OneTimeInit()函数调用只需调用代码一次，这就像设置投影矩阵一样。一旦应用程序使用Shutdown()函数，它就会清除渲染系统。在Direct3D中可以释放那些在系统运行过程中用到的Direct3D对象。SetClearCol()函数用于将后台缓存颜色设置为指定的颜色。StartRender()和EndRendering()这两个函数用于启动新场景，结束场景，在渲染场景之前、之后或过程中清除场景。CalculateProjMatrix()和CalculateOrthoMatrix()这两个函数用于设置可以使用立体投影和正交投影的两个矩阵。CreateStaticBuffer()函数用于创建要绘制的静态顶点缓存，Render()函数用于将缓存内容显示在屏幕上。由于OpenGL中没有像Direct3D一样的顶点缓存，因此如果要移植到OpenGL中，就可以设置这些内容，只要用static buffer(静态缓存)类指定浮点数组即可。OpenGL版的Render()函数可以使用顶点数组或OpenGL顶点缓存对象(VBOs)渲染静态缓存内容。唯一的差异在于OpenGL并没有像Direct3D这样创建顶点缓存的结构，但这对于代码移植而言并不是问题。
#ifndef _UGP_RENDERINTERFACE_H_
#define _UGP_RENDERINTERFACE_H_
#include"defines.h"
class CRenderInterface
{
public:
CRenderInterface() : m_screenWidth(0),
m_screenHeight(0), m_near(0), m_far(0) { }
virtual ~CRenderInterface() {}
virtual bool Initialize(int w, int h,
WinHWND mainWin, bool fullScreen) = 0;
virtual void OneTimeInit() = 0;
virtual void Shutdown() = 0;
virtual void SetClearCol(float r, float g, float b) = 0;
virtual void StartRender(bool bColor, bool bDepth,
bool bStencil) = 0;
virtual void ClearBuffers(bool bColor, bool bDepth,
bool bStencil) = 0;
virtual void EndRendering() = 0;
virtual void CalculateProjMatrix(float fov, float n,
float f) = 0;
virtual void CalculateOrthoMatrix(float n, float f) = 0;
virtual int CreateStaticBuffer(VertexType, PrimType,
int totalVerts, int totalIndices,
int stride, void **data, unsigned int *indices,
int *staticId) = 0;
virtual int Render(int staticId) = 0;
protected:
int m_screenWidth;
int m_screenHeight;
bool m_fullscreen;
WinHWND m_mainHandle;
float m_near;
float m_far;
};
#endif
engine.h
engine.h文件包含了include语句，这样就可以在一个地方访问游戏引擎的不同内容。这里只包含了渲染系统。诚如所知道的一样，该文件的内容将随着游戏的开发进度而发生变动。
#ifndef _UGP_ENGINE_H_
#define _UGP_ENGINE_H_
#include"RenderInterface.h"
#include"D3DRenderer.h"
#endif
D3DRenderer.h
D3DRenderer.h头文件定义了本书一直要用到的派生渲染类。除了该类将用于实现具体的渲染功能之外，它的定义与基类没有任何区别。类还声明了几个具体的Direct3D成员变量。
首先，D3DRenderer.h头文件包含和绑定了具体的Direct3D头和库。接下来是Direct3D静态缓存的声明。该缓存用顶点缓存将静态几何图形(非动画的)绘制到屏幕上。静态缓存结构由顶点缓存、索引缓存(三角形索引)、对顶点和索引的计算、单个顶点尺寸的幅度值、Direct3D顶点FVF以及在渲染静态缓存时要用的图元类型。
D3D渲染系统为Direct3d9对象详细说明了成员变量、Direct3D设备对象、清除色、一个用于确认它是否位于当前正在渲染的场景中的标识符、保存所有静态缓存的数组链表、静态缓存数目的计数器以及正在使用的当前静态缓存变量。最后一个变量是为了避免设置已经设置过的静态缓存。当有必要在单独一帧中多次渲染相同的对象时，会多次出现这种情况。每次设置相同的静态缓存都要浪费处理时间，都会影响到程序性能。在和纹理图像打交道，尤其是和大纹理图像和对象的多个实例打交道时，更是值得注意。
文件结尾处声明的最后一个函数原型是CreateD3DRenderer()。实际上并不需要该函数，但是有了该函数，调用它就可以为渲染系统分配内存。当使用动态链接库(DLL)，也就是一个用于Direct3D，一个用于OpenGL时，它们会非常有用。如果在这两个动态链接库中都有CreateRenderer()函数，它就会起作用。这样在程序运行期间，就可以为渲染系统分配要用的动态链接库。就可以让程序和渲染系统使用的对象无关。程序并不知道使用的是哪个渲染系统，它只要知道无论它用哪个渲染系统，都要指定它所用的动态链接库。
#ifndef _D3D_RENDERER_H_
#define _D3D_RENDERER_H_
#include<windows.h>
#include<d3d9.h>
#include<d3dx9.h>
#include"RenderInterface.h"
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
struct stD3DStaticBuffer
{
stD3DStaticBuffer() : vbPtr(0), ibPtr(0), numVerts(0),
numIndices(0), stride(0), fvf(0),
primType(NULL_TYPE) {}
LPDIRECT3DVERTEXBUFFER9 vbPtr;
LPDIRECT3DINDEXBUFFER9 ibPtr;
int numVerts;
int numIndices;
int stride;
unsigned long fvf;
PrimType primType;
};
class CD3DRenderer : public CRenderInterface
{
public:
CD3DRenderer();
~CD3DRenderer();
bool Initialize(int w, int h, WinHWND mainWin,
bool fullScreen);
void Shutdown();
void SetClearCol(float r, float g, float b);
void StartRender(bool bColor, bool bDepth, bool bStencil);
void ClearBuffers(bool bColor, bool bDepth, bool bStencil);
void EndRendering();
void CalculateProjMatrix(float fov, float n, float f);
void CalculateOrthoMatrix(float n, float f);
int CreateStaticBuffer(VertexType, PrimType,
int totalVerts, int totalIndices,
int stride, void **data, unsigned int *indices,
int *staticId);
int Render(int staticId);
private:
void OneTimeInit();
private:
D3DCOLOR m_Color;
LPDIRECT3D9 m_Direct3D;
LPDIRECT3DDEVICE9 m_Device;
bool m_renderingScene;
stD3DStaticBuffer *m_staticBufferList;
int m_numStaticBuffers;
int m_activeStaticBuffer;
};
bool CreateD3DRenderer(CRenderInterface **pObj);
#endif
D3DRenderer.cpp
D3DRenderer.cpp源文件开始先声明了CreateD3DRenderer()函数和CD3DRenderer类的构造函数和析构函数。CreateD3DRenderer()函数简单地实现了内存分配，以创建一个新的渲染对象。然后新对象存储在发送给函数的基类指针中。这样游戏只要和基类对象打交道就可以了，而不需要知道该对象是OpenGL还是Direct3D生成的对象。构造函数初始化类成员变量，而析构函数调用Shutdown()函数以确保在销毁对象前系统被清理干净。程序清单2.8显示了前三个函数。
#include"D3DRenderer.h"
bool CreateD3DRenderer(CRenderInterface **pObj)
{
if(!*pObj) *pObj = new CD3DRenderer;
else return false;
return true;
}
unsigned long CreateD3DFVF(int flags)
{
unsigned long fvf = 0;
return fvf;
}
CD3DRenderer::CD3DRenderer()
{
m_Direct3D = NULL;
m_Device = NULL;
m_renderingScene = false;
m_numStaticBuffers = 0;
m_activeStaticBuffer = UGP_INVALID;
m_staticBufferList = NULL;
}
CD3DRenderer::~CD3DRenderer()
{
Shutdown();
}
bool CD3DRenderer::Initialize(int w, int h, WinHWND mainWin,
bool fullScreen)
{
Shutdown();
m_mainHandle = mainWin;
if(!m_mainHandle) return false;
m_fullscreen = fullScreen;
D3DDISPLAYMODE mode;
D3DCAPS9 caps;
D3DPRESENT_PARAMETERS Params;
ZeroMemory(&Params, sizeof(Params));
m_Direct3D = Direct3DCreate9(D3D_SDK_VERSION);
if(!m_Direct3D) return false;
if(FAILED(m_Direct3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,
&mode))) return false;
if(FAILED(m_Direct3D->GetDeviceCaps(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, &caps))) return false;
DWORD processing = 0;
if(caps.VertexProcessingCaps != 0)
processing = D3DCREATE_HARDWARE_VERTEXPROCESSING |
D3DCREATE_PUREDEVICE;
else
processing = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
if(m_fullscreen)
{
Params.FullScreen_RefreshRateInHz = mode.RefreshRate;
Params.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
}
else
Params.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
Params.Windowed = !m_fullscreen;
Params.BackBufferWidth = w;
Params.BackBufferHeight = h;
Params.hDeviceWindow = m_mainHandle;
Params.SwapEffect = D3DSWAPEFFECT_DISCARD;
Params.BackBufferFormat = mode.Format;
Params.BackBufferCount = 1;
Params.EnableAutoDepthStencil = TRUE;
Params.AutoDepthStencilFormat = D3DFMT_D16;
m_screenWidth = w;
m_screenHeight = h;
if(FAILED(m_Direct3D->CreateDevice(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, m_mainHandle, processing,
&Params, &m_Device))) return false;
if(m_Device == NULL) return false;
OneTimeInit();
return true;
}
void CD3DRenderer::OneTimeInit()
{
if(!m_Device) return;
m_Device->SetRenderState(D3DRS_LIGHTING, FALSE);
m_Device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
CalculateProjMatrix(D3DX_PI / 4, 0.1f, 1000);
}
void CD3DRenderer::Shutdown()
{
for(int s = 0; s < m_numStaticBuffers; s++)
{
if(m_staticBufferList[s].vbPtr)
{
m_staticBufferList[s].vbPtr->Release();
m_staticBufferList[s].vbPtr = NULL;
}
if(m_staticBufferList[s].ibPtr)
{
m_staticBufferList[s].ibPtr->Release();
m_staticBufferList[s].ibPtr = NULL;
}
}
m_numStaticBuffers = 0;
if(m_staticBufferList) delete[] m_staticBufferList;
m_staticBufferList = NULL;
if(m_Device) m_Device->Release();
if(m_Direct3D) m_Direct3D->Release();
m_Device = NULL;
m_Direct3D = NULL;
}
void CD3DRenderer::SetClearCol(float r, float g, float b)
{
m_Color = D3DCOLOR_COLORVALUE(r, g, b, 1.0f);
}
void CD3DRenderer::StartRender(bool bColor, bool bDepth,
bool bStencil)
{
if(!m_Device) return;
unsigned int buffers = 0;
if(bColor) buffers |= D3DCLEAR_TARGET;
if(bDepth) buffers |= D3DCLEAR_ZBUFFER;
if(bStencil) buffers |= D3DCLEAR_STENCIL;
if(FAILED(m_Device->Clear(0, NULL, buffers, m_Color, 1, 0)))
return;
if(FAILED(m_Device->BeginScene())) return;
m_renderingScene = true;
}
void CD3DRenderer::ClearBuffers(bool bColor, bool bDepth,
bool bStencil)
{
if(!m_Device) return;
unsigned int buffers = 0;
if(bColor) buffers |= D3DCLEAR_TARGET;
if(bDepth) buffers |= D3DCLEAR_ZBUFFER;
if(bStencil) buffers |= D3DCLEAR_STENCIL;
if(m_renderingScene) m_Device->EndScene();
if(FAILED(m_Device->Clear(0, NULL, buffers, m_Color, 1, 0)))
return;
if(m_renderingScene)
if(FAILED(m_Device->BeginScene())) return;
}
void CD3DRenderer::EndRendering()
{
if(!m_Device) return;
m_Device->EndScene();
m_Device->Present(NULL, NULL, NULL, NULL);
m_renderingScene = false;
}
void CD3DRenderer::CalculateProjMatrix(float fov, float n, float f)
{
if(!m_Device) return;
D3DXMATRIX projection;
D3DXMatrixPerspectiveFovLH(&projection, fov,
(float)m_screenWidth/(float)m_screenHeight, n, f);
m_Device->SetTransform(D3DTS_PROJECTION, &projection);
}
void CD3DRenderer::CalculateOrthoMatrix(float n, float f)
{
if(!m_Device) return;
D3DXMATRIX ortho;
D3DXMatrixOrthoLH(&ortho, (float)m_screenWidth,
(float)m_screenHeight, n, f);
m_Device->SetTransform(D3DTS_PROJECTION, &ortho);
}
int CD3DRenderer::CreateStaticBuffer(VertexType vType,
PrimType primType, int totalVerts,
int totalIndices, int stride, void **data,
unsigned int *indices, int *staticId)
{
void *ptr;
int index = m_numStaticBuffers;
if(!m_staticBufferList)
{
m_staticBufferList = new stD3DStaticBuffer[1];
if(!m_staticBufferList) return UGP_FAIL;
}
else
{
stD3DStaticBuffer *temp;
temp = new stD3DStaticBuffer[m_numStaticBuffers + 1];
memcpy(temp, m_staticBufferList,
sizeof(stD3DStaticBuffer) * m_numStaticBuffers);
delete[] m_staticBufferList;
m_staticBufferList = temp;
}
m_staticBufferList[index].numVerts = totalVerts;
m_staticBufferList[index].numIndices = totalIndices;
m_staticBufferList[index].primType = primType;
m_staticBufferList[index].stride = stride;
m_staticBufferList[index].fvf = CreateD3DFVF(vType);
if(totalIndices > 0)
{
if(FAILED(m_Device->CreateIndexBuffer(sizeof(unsigned int) *
totalIndices, D3DUSAGE_WRITEONLY, D3DFMT_INDEX16,
D3DPOOL_DEFAULT,
&m_staticBufferList[index].ibPtr,
NULL))) return UGP_FAIL;
if(FAILED(m_staticBufferList[index].ibPtr->Lock(0, 0,
(void**)&ptr, 0))) return UGP_FAIL;
memcpy(ptr, indices, sizeof(unsigned int) * totalIndices);
m_staticBufferList[index].ibPtr->Unlock();
}
else
{
m_staticBufferList[index].ibPtr = NULL;
}
if(FAILED(m_Device->CreateVertexBuffer(totalVerts * stride,
D3DUSAGE_WRITEONLY, m_staticBufferList[index].fvf,
D3DPOOL_DEFAULT, &m_staticBufferList[index].vbPtr,
NULL))) return UGP_FAIL;
if(FAILED(m_staticBufferList[index].vbPtr->Lock(0, 0,
(void**)&ptr, 0))) return UGP_FAIL;
memcpy(ptr, data, totalVerts * stride);
m_staticBufferList[index].vbPtr->Unlock();
*staticId = m_numStaticBuffers;
m_numStaticBuffers++;
return UGP_OK;
}
int CD3DRenderer::Render(int staticId)
{
if(staticId >= m_numStaticBuffers) return UGP_FAIL;
if(m_activeStaticBuffer != staticId)
{
if(m_staticBufferList[staticId].ibPtr != NULL)
m_Device->SetIndices(m_staticBufferList[staticId].ibPtr);
m_Device->SetStreamSource(0,
m_staticBufferList[staticId].vbPtr, 0,
m_staticBufferList[staticId].stride);
m_Device->SetFVF(m_staticBufferList[staticId].fvf);
m_activeStaticBuffer = staticId;
}
if(m_staticBufferList[staticId].ibPtr != NULL)
{
switch(m_staticBufferList[staticId].primType)
{
case POINT_LIST:
if(FAILED(m_Device->DrawPrimitive(D3DPT_POINTLIST,
0, m_staticBufferList[staticId].numVerts)))
return UGP_FAIL;
break;
case TRIANGLE_LIST:
if(FAILED(m_Device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0,
0, m_staticBufferList[staticId].numVerts / 3,
0, m_staticBufferList[staticId].numIndices)))
return UGP_FAIL;
break;
case TRIANGLE_STRIP:
if(FAILED(m_Device->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0,
0, m_staticBufferList[staticId].numVerts / 2,
0, m_staticBufferList[staticId].numIndices)))
return UGP_FAIL;
break;
case TRIANGLE_FAN:
if(FAILED(m_Device->DrawIndexedPrimitive(D3DPT_TRIANGLEFAN, 0,
0, m_staticBufferList[staticId].numVerts / 2,
0, m_staticBufferList[staticId].numIndices)))
return UGP_FAIL;
break;
case LINE_LIST:
if(FAILED(m_Device->DrawIndexedPrimitive(D3DPT_LINELIST, 0,
0, m_staticBufferList[staticId].numVerts / 2,
0, m_staticBufferList[staticId].numIndices)))
return UGP_FAIL;
break;
case LINE_STRIP:
if(FAILED(m_Device->DrawIndexedPrimitive(D3DPT_LINESTRIP, 0,
0, m_staticBufferList[staticId].numVerts,
0, m_staticBufferList[staticId].numIndices)))
return UGP_FAIL;
break;
default:
return UGP_FAIL;
}
}
else
{
switch(m_staticBufferList[staticId].primType)
{
case POINT_LIST:
if(FAILED(m_Device->DrawPrimitive(D3DPT_POINTLIST,
0, m_staticBufferList[staticId].numVerts)))
return UGP_FAIL;
break;
case TRIANGLE_LIST:
if(FAILED(m_Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0,
(int)(m_staticBufferList[staticId].numVerts / 3))))
return UGP_FAIL;
break;
case TRIANGLE_STRIP:
if(FAILED(m_Device->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0,
(int)(m_staticBufferList[staticId].numVerts / 2))))
return UGP_FAIL;
break;
case TRIANGLE_FAN:
if(FAILED(m_Device->DrawPrimitive(D3DPT_TRIANGLEFAN, 0,
(int)(m_staticBufferList[staticId].numVerts / 2))))
return UGP_FAIL;
break;
case LINE_LIST:
if(FAILED(m_Device->DrawPrimitive(D3DPT_LINELIST, 0,
m_staticBufferList[staticId].numVerts / 2)))
return UGP_FAIL;
break;
case LINE_STRIP:
if(FAILED(m_Device->DrawPrimitive(D3DPT_LINESTRIP, 0,
m_staticBufferList[staticId].numVerts)))
return UGP_FAIL;
break;
default:
return UGP_FAIL;
}
}
return UGP_OK;
}
Initialize()和OneTimeInit()两个函数。这两个函数就像本书第1章中的演示程序一样用于初始化Direct3D。Initialize()函数像前面一样以相同的方式设置Direct3D，所以该函数没有什么新的东西。该函数的最后部分调用OneTimeInit()函数，以完成附加的初始化工作。Initialize()函数以窗口宽度(w)、高度(h)和窗口句柄(mainWin)以及一个指向窗口是否以全屏形式显示的标识(fullScreen)为参数。OneTimeInit()函数在此设置默认的投影矩阵。
Shutdown()函数主要负责清理所有渲染系统用过的内存。该函数在此循环检查，并释放所有的静态缓存数据，清理静态缓存列表，释放特定的Direct3D对象。
接下来是SetClearCol()、StartRender()、ClearBuffers()和EndRendering()函数。SetClearCol()函数以清屏的红绿蓝三色的浮点值作为参数。StartRender()和ClearBuffers()函数使用三个布尔值指明系统是否清除颜色、深度和stencil缓存。最后一个参数对渲染没有任何作用。StartRender()函数用于启动一个新的场景，而ClearBuffers()用于清理已经启动的场景。EndRendering()函数没有任何参数，用于停止场景的渲染。
下来是CalculateProjMatrix()和CalculateOrthoMatrix()函数。CalculateProjMatrix()函数用于创建平行投影矩阵，它有三个参数：视场(fv)、近距离(n)和远距离值(f)。CalculateOrthoMatrix()函数和CalculateProjMatrix()函数的功能相同，不过它创建的是一个正交投影矩阵，而且他只有两个参数：近距离值(n)和远距离值(f)。
渲染系统中的倒数第二个函数是CreateStaticBuffer()。该函数的功能是设置静态缓存对象中的一个对象内容，并将其添加到静态缓存列表中。该函数的参数包括：正在使用的顶点类型(本书将在稍后的游戏开发项目中复习该参数)、渲染该几何图形(例如：三角形列表、顶点)的指令、几何图形中的顶点总数和指向新创建的将要保存的静态缓存ID的变量指针。最后一个参数用于保存静态缓存ID，这样就在绘制几何图形时可以将该值传递给Render()函数。 CreateStaticBuffer()函数设置一个静态缓存对象内容，并将其添加到静态缓存列表中。在将该静态缓存添加到列表后，就会创建索引和顶点缓存，并保存静态缓存ID，增加静态缓存总数。使用矩阵列表可以简化对象列表的创建。
// 设置静态缓存对象中的一个对象内容，并将其添加到静态缓存列表中
int CD3DRenderer::CreateStaticBuffer(
VertexType vType, // 正在使用的顶点类型
PrimType primType, // 渲染该几何图形(例如：三角形列表、顶点)的指令
int totalVerts, // 几何图形中的顶点总数
int totalIndices, // 几何图形中的索引总数
int stride, // 单个顶点尺寸的幅度值
void **data, // 保存顶点的数组
unsigned int *indices, //保存索引的数组
int *staticId // 保存静态缓存ID的指针
);
这里，渲染系统中的最后一个函数是Render()。这个篇幅很长的函数包含了一个参数：静态缓存ID，它会将与该ID相关的几何图形渲染到屏幕上。函数最前面的部分快速检查静态缓存ID以确保其有效。接下来，该函数检查静态缓存ID是否可用。如果可用，它就会调用DrawPrimitive()函数渲染图形。如果静态缓存不可用，它就会调用SetStreamSource()和SetFvF()两个函数。可以像绘制无索引几何图形一样，Render()函数也可以绘制索引几何图形(使用索引的几何图形)。