第11章 三维内功心法——Direct3D编程基础

11.1 典型Direct3D 程序流程分析

我们其实不用把3D 编程想象得多么神秘，说白了， 3D 编程就像一只纸老虎。
正所谓万剑归宗，首先介绍一下Direct3D 应用程序的一般框架思路。我们来看一张典型的Direct3D 程序框架图。



从上面这幅框架图中我们可以发现， Direct3D 程序的基本结构是非常简单清晰的，主要可以分为下面5 个部分：

创建一个Windows 窗口。
Direct3D 的初始化。
消息循环。
渲染图形。
结束应用程序，清除在初始化阶段所创建的COM 对象，并退出程序。

我们知道， DirectX 的程序开发就是一个基于SDK 开发包的过程。Direct3D 程序创建过程大体上与普通Win32 窗口程序的创建过程没有太大的的区别，首先需要创建一个具有主窗口的应用程序，并且在显示和更新窗口之前初始化Direct3D ，然后在消息循环中不断对3D 场景进行绘制，机制也都是消息循环的那一套机制。

其中消息循环和Direct3D 的绘制过程是不断在进行的，如果程序中有消息需要处理的话，先处理消息，再进行Direct3D 绘制过程。如果没有消息要处理的话，我们的程序就会不停地渲染图形，直到退出Direct3D 程序。

我们可以简单地这样理解， Direct3D 程序就是在普通Win32 应用程序的基础上，加上了Direct3D 的初始化过程和Direct3D 的绘制过程。作者在配图过程中，专门把Direct3D 独有的部分用虚线和不同的配色与Win32 部分区分开来， 这样更便于理解。然后我们可以这样理解这幅Direct3D 程序流程图，虚线以外的部分为普通Win32 窗口所拥有的常规步骤，而虚线以内的部分为Direct3D 应用程序特有的步骤。

上面已经提到过， Direct3D 特有的部分分为Direct3D 初始化与Direct3D 的绘制，这一节我们着重介绍Direct3D 初始化，Direct3D 的绘制过程将在下文详细介绍。当然，还有光照、矩阵与视角变换等等额外的初始化过程，我们可以把它们都理解为在Direct3D

初始化阶段完成，在这里先不涉及，后文我们会各个击破。

11.2 对COM 接口对象的一些介绍

在第10 章中我们己经提到了COM 接口，我们知道C＋＋与COM 接口配DirectX，是目前Windows 平台下99%的大型游戏采用的开发方案。在这里希望通过这一小节的介绍，我们能对COM接口有一个更深刻的印象。
COM ( Component Object Model ，组件对象模型）是一项能够使DirectX 独立于编程语言并具备向下兼容的技术。我们常称COM 对象为接口，可将其视为一个C++类来使用。在以C++编程语言和COM 接口方式开发的DirectX 应用程序中，可以直接访问COM 接口和对象。
COM 接口对象是一组特定功能的抽象集合，应用程序不能直接访问COM 接口对象，而是必须通过COM 接口对象的接口（ interface ）的指针来执行COM 接口对象的功能。
COM 接口对象为我们定义了可供程序调用的一组函数（或者说是方法），而接口是包含了函数指针数组的内存结构，其中每一个数组元素包含的是一个由组件所实现的函数地址， 使用方法方面， 类似于C＋＋类的指针。

COM接口都具有前缀大写字母“I”，例如一个管理X文件的COM接口叫ID3DXFile。

另外，使用COM 接口的时候千万要遗忘C＋＋中使用指针的new 和delete 这一套，他们和COM接口是八竿子打不着边的， 因为COM 接口对象与C＋＋类的生命周期有着很大的区别。C＋＋类由new 和delete 运算符控制类对象的生命周期， 而COM 接口对象则通过控制对某对象的引用计数个数来决定其生命周期的。COM 接口对象的引用计数器会记录某对象当前被引用的个数。这样说大家也许会有点不太好理解，举个例子吧， 我们现在创建了一个COM 接口对象，比如就是这篇文章后面会介绍到的Direct3D
初始化四步曲的第一步里初始化IDirect3D9 接口对象的一段代码。

LPDIRECT3D9  pD3D = NULL; //Direct3D接口对象的创建
if( NULL == ( pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) ) //初始化Direct3D接口对象，并进行DirectX版本协商
return E_FAIL;

当一个COM 接口对象被创建时，其引用计数将为1，以后每当程序又创建了这个COM 接口的新对象时，其引用计数就会加1。当程序对该对象引用结束时，我们就需要调用该对象的Release方法释放这个接口，而引用计数将减1。我们需要注意的是，即使引用计数减了1，但是还是不为0 的话，这个对象所占用的内存还是没有被释放的（释放的只是这个COM 接口的对象的引用，而不是这个COM 接口本身。只有当该对象的引用计数减为0 的时候，也就是说所有该对象的引用都已经得到释放后，才会去释放接口的COM
接口对象所占用的内存。且这个内存的释放是COM接口对象自行经营的， COM 接口自有它自己的一套内存管理理念，比较智能，我们只需要自行释放COM 接口对象的引用，让其引用计数为0 即可（也就是养成好习惯用Release 就行了） , COM接口对象的内存释放细节并不要我们去插手。

所以，每当程序中创建或者获得某个COM 接口对象后，我们先开开心心地使用这个接口对象，不过在使用完成之后，我们需要在适当的位置调用它们的Release 方法来释放这个接口， 让引用计数器减1 直到为0，以便在程序退出时能够释放它们所占的内存。

下面这段代码就是与上面的代码段搭配使用的，用于释放COM 接口的一段代码。

#define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } }   //定义一个安全释放宏，便于后面COM接口指针的释放

理解上面介绍的这些COM 接口相关的知识，对付正确使用DirectX 已经完全足够了。

11.3 写一个DirectX 程序通用框架

大家应该记得， 在学习GDI 游戏编程的时候，我们就做过类似的工作。在4.4 节中，我们在3.10 节编写的GameCore 的基础上，新自定义3 个函数。它们分别为封装了资源初始化代码的Game_lnit（）函数，封装了所有绘制代码的Game_Paint（） 函数，以及用于清理资源的Game_CleanUp()函数。我们这次的做法也差不多，无论是GDI
还是Direct3D ，既然同是基于Win32 窗口程序框架，
肯定是差不多的。
本节将在3. 10 节编写的GameCore 的基础上，新自定义4 个函数。分别是用于Direct3D 初始化的Direct3D_lnit 函数，用于要绘制的物体的初始化的Objects_Init 函数，用于Direct3D 渲染代码的书写的Direct3D_Render 函数，以及清理COM 资源以及其他资源的Direct3D_CleanUp 函数，即如下这4 个函数：

HRESULT					Direct3D_Init(HWND hwnd);		 //在这个函数中进行Direct3D的初始化
HRESULT					Objects_Init(HWND hwnd); 		//在这个函数中进行要绘制的物体的资源初始化
VOID							Direct3D_Render(HWND hwnd); 	//在这个函数中进行Direct3D渲染代码的书写
VOID							Direct3D_CleanUp( );				//在这个函数中清理COM资源以及其他资源

因为是一个程序框架而己，目前并没有什么实际上的Direct3D 的代码，所以除了这四个自定义函数的添加， 以及消息循环为之前我们讲解的“游戏循环”体系， 其他基本上与3.10 节我们写的GameCore 一样。这个框架我们取名为D3DdernoCore.为了大家在学习Direct3D 时对示例程序理解更加透彻，下面贴出这个框架的全部代码，这是我们在学习Direct3D 的过程中，唯一一次贴出完整的程序源代码：

//-----------------------------------【程序说明】----------------------------------------------
//  程序名称:：D3DdemoCore
//	 2013年4月 Create by 浅墨
//  描述：Direct3D程序的核心框架
//------------------------------------------------------------------------------------------------

//-----------------------------------【头文件包含部分】---------------------------------------
//	描述：包含程序所依赖的头文件
//------------------------------------------------------------------------------------------------
#include <d3d9.h>

//-----------------------------------【库文件包含部分】---------------------------------------
//	描述：包含程序所依赖的库文件
//------------------------------------------------------------------------------------------------
#pragma comment(lib,"winmm.lib")  //调用PlaySound函数所需库文件

//-----------------------------------【宏定义部分】--------------------------------------------
//	描述：定义一些辅助宏
//------------------------------------------------------------------------------------------------
#define WINDOW_WIDTH	800							//为窗口宽度定义的宏，以方便在此处修改窗口宽度
#define WINDOW_HEIGHT	600							//为窗口高度定义的宏，以方便在此处修改窗口高度
#define WINDOW_TITLE	L"【致我们永不熄灭的游戏开发梦想】Direct3D程序的核心框架"	//为窗口标题定义的宏
#define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } }   //定义一个安全释放宏，便于后面COM接口指针的释放

//-----------------------------------【全局变量声明部分】-------------------------------------
//	描述：全局变量的声明
//------------------------------------------------------------------------------------------------

//-----------------------------------【全局函数声明部分】-------------------------------------
//	描述：全局函数声明，防止“未声明的标识”系列错误
//------------------------------------------------------------------------------------------------
LRESULT CALLBACK	WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );//窗口过程函数
HRESULT					Direct3D_Init(HWND hwnd);		 //在这个函数中进行Direct3D的初始化
HRESULT					Objects_Init(HWND hwnd); 		//在这个函数中进行要绘制的物体的资源初始化
VOID							Direct3D_Render(HWND hwnd); 	//在这个函数中进行Direct3D渲染代码的书写
VOID							Direct3D_CleanUp( );				//在这个函数中清理COM资源以及其他资源

//-----------------------------------【WinMain( )函数】--------------------------------------
//	描述：Windows应用程序的入口函数，我们的程序从这里开始
//------------------------------------------------------------------------------------------------
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,LPSTR lpCmdLine, int nShowCmd)
{
//【1】窗口创建四步曲之一：开始设计一个完整的窗口类
WNDCLASSEX wndClass = { 0 };							//用WINDCLASSEX定义了一个窗口类
wndClass.cbSize = sizeof( WNDCLASSEX ) ;			//设置结构体的字节数大小
wndClass.style = CS_HREDRAW | CS_VREDRAW;	//设置窗口的样式
wndClass.lpfnWndProc = WndProc;					//设置指向窗口过程函数的指针
wndClass.cbClsExtra		= 0;								//窗口类的附加内存，取0就可以了
wndClass.cbWndExtra		= 0;							//窗口的附加内存，依然取0就行了
wndClass.hInstance = hInstance;						//指定包含窗口过程的程序的实例句柄。
wndClass.hIcon=(HICON)::LoadImage(NULL,L"icon.ico",IMAGE_ICON,0,0,LR_DEFAULTSIZE|LR_LOADFROMFILE);  //本地加载自定义ico图标
wndClass.hCursor = LoadCursor( NULL, IDC_ARROW );    //指定窗口类的光标句柄。
wndClass.hbrBackground=(HBRUSH)GetStockObject(GRAY_BRUSH);  //为hbrBackground成员指定一个白色画刷句柄
wndClass.lpszMenuName = NULL;						//用一个以空终止的字符串，指定菜单资源的名字。
wndClass.lpszClassName = L"ForTheDreamOfGameDevelop";		//用一个以空终止的字符串，指定窗口类的名字。

//【2】窗口创建四步曲之二：注册窗口类
if( !RegisterClassEx( &wndClass ) )				//设计完窗口后，需要对窗口类进行注册，这样才能创建该类型的窗口
return -1;

//【3】窗口创建四步曲之三：正式创建窗口
HWND hwnd = CreateWindow( L"ForTheDreamOfGameDevelop",WINDOW_TITLE,				//喜闻乐见的创建窗口函数CreateWindow
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, WINDOW_WIDTH,
WINDOW_HEIGHT, NULL, NULL, hInstance, NULL );

//Direct3D资源的初始化
Direct3D_Init (hwnd);

//【4】窗口创建四步曲之四：窗口的移动、显示与更新
MoveWindow(hwnd,250,80,WINDOW_WIDTH,WINDOW_HEIGHT,true);		//调整窗口显示时的位置，使窗口左上角位于（250,80）处
ShowWindow( hwnd, nShowCmd );    //调用ShowWindow函数来显示窗口
UpdateWindow(hwnd);						//对窗口进行更新，就像我们买了新房子要装修一样

PlaySound(L"War3XMainScreen.wav", NULL, SND_FILENAME | SND_ASYNC|SND_LOOP); //循环播放背景音乐
MessageBox(hwnd, L"DirectX，等着瞧吧，我们来降服你了~!", L"浅墨的消息窗口", 0); //使用MessageBox函数，显示一个消息窗口

//【5】消息循环过程
MSG msg = { 0 };  //初始化msg
while( msg.message != WM_QUIT )			//使用while循环
{
if( PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) )   //查看应用程序消息队列，有消息时将队列中的消息派发出去。
{
TranslateMessage( &msg );		//将虚拟键消息转换为字符消息
DispatchMessage( &msg );		//该函数分发一个消息给窗口程序。
}
else
{
Direct3D_Render(hwnd);   //进行渲染
}
}
//【6】窗口类的注销
UnregisterClass(L"ForTheDreamOfGameDevelop", wndClass.hInstance);  //程序准备结束，注销窗口类
return 0;
}

//-----------------------------------【WndProc( )函数】--------------------------------------
//	描述：窗口过程函数WndProc,对窗口消息进行处理
//------------------------------------------------------------------------------------------------
LRESULT CALLBACK WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
{
switch( message )						//switch语句开始
{
case WM_PAINT:						// 若是客户区重绘消息
Direct3D_Render(hwnd);                 //调用Direct3D渲染函数
ValidateRect(hwnd, NULL);		// 更新客户区的显示
break;									//跳出该switch语句

case WM_KEYDOWN:					// 若是键盘按下消息
if (wParam == VK_ESCAPE)    // 如果被按下的键是ESC
DestroyWindow(hwnd);		// 销毁窗口, 并发送一条WM_DESTROY消息
break;									//跳出该switch语句

case WM_DESTROY:					//若是窗口销毁消息
Direct3D_CleanUp();			//调用自定义的资源清理函数Game_CleanUp（）进行退出前的资源清理
PostQuitMessage( 0 );			//向系统表明有个线程有终止请求。用来响应WM_DESTROY消息
break;									//跳出该switch语句

default:										//若上述case条件都不符合，则执行该default语句
return DefWindowProc( hwnd, message, wParam, lParam );		//调用缺省的窗口过程
}

return 0;									//正常退出
}

//-----------------------------------【Direct3D_Init( )函数】--------------------------------------
//	描述：Direct3D初始化函数，进行Direct3D的初始化
//------------------------------------------------------------------------------------------------
HRESULT Direct3D_Init(HWND hwnd)
{
if(!(S_OK==Objects_Init(hwnd))) return E_FAIL;     //调用一次Objects_Init，进行渲染资源的初始化
return S_OK;
}

//-----------------------------------【Object_Init( )函数】--------------------------------------
//	描述：渲染资源初始化函数，在此函数中进行要被渲染的物体的资源的初始化
//--------------------------------------------------------------------------------------------------
HRESULT Objects_Init(HWND hwnd)
{
return S_OK;
}

//-----------------------------------【Direct3D_Render( )函数】--------------------------------------
//	描述：使用Direct3D进行渲染
//--------------------------------------------------------------------------------------------------
void Direct3D_Render(HWND hwnd)
{
//暂时为空，且听下回分解
}

//-----------------------------------【Direct3D_CleanUp( )函数】--------------------------------
//	描述：资源清理函数，在此函数中进行程序退出前资源的清理工作
//---------------------------------------------------------------------------------------------------
void Direct3D_CleanUp()
{
//暂时为空，且听下回分解
}

我们在Direct3D_ Init 函数内部调用的Objects_Init 函数，这表示我们之后的DirectX 程序都会是先初始化Direct3D，再接着初始化游戏资源，而我们只需在WinMain 函数中调用一次Direct3D_lnit 函数就可以了。

另外， 大家需要注意，为了演示DirectX 各项功能的方便性，与代码的易读性，目前我们并没有以类为载体，因为类说实话不适合进行教学，如果我们一上来就用类的方式来写示例程序， 大家很可能都会云里雾里，无形中给大家增添了学习的烦恼。我们的想法是，当后面需要构建功能复杂的游戏程序的时候，再转向面向对象的思想。而我们接下来书写关于Direct3D 的程序，简单点说，

只需做如下这四步就可以了：

 在Direct3D_lnit（） 函数里完成Direct3D 的相关初始化。
 在Objects_lnit（） 函数里完成将要绘制的绘制资源的初始化．
 在Direct3D_Render（） 函数里完成渲染。
 在Direct3D_CleanUp（） 函数里完成资源的清理。

11.4 化腐朽为神奇——Direct3D 初始化四步曲

想要使用Direct3D 来开发游戏程序，首先要做的就是进行Direct3D初始化，这是Direct3D 程序的根本。这一节里，我们通过四步曲的方式，来教大家如何轻而易举地掌握Direct3D 初始化的方法。
作者在这里自己总结，并引入了“ 四步曲”的理念， 这样我们在对Ditect3D 的初始化就有章可循，理解和记忆起来就很容易了。下面我们正式开始。

11.4.1 Direct3D 初始化四步曲概述

首先介绍一下Direct3D 初始化四步曲的组成：

 Direct3D 初始化四步曲之一： 创建Direct3D 接口对象（简称： 创接口）。
 Direct3D 初始化四步曲之二： 获取设备硬件信息（简称：取信息） 。
 Direct3D 初始化四步曲之三： 填充D3DPRESENT_PARAMETERS 结构体（简称： 填内容） 。
 Direct3D 初始化四步曲之四： 创建Direct3D 设备接口（简称： 创设备)．

所以， Direct3D 初始化四步曲，也就简明扼要1 2 个字：创接口， 取信息， 填内容，创设备。

11.4.2 Direct3D 初始化四步曲之一：创接口

Direct3D 初始化四步曲之一，简称创接口，也就是创建Direct3D 接口对象。

首先需要注意， Direct3D 接口对象和Direct3D 设备接口不是一个概念， 大家不耍弄混了。

因为我们咬定了采用C＋＋配合COM 接口的方式来进行游戏开发， 所以初始化的第一步就开门见山，与COM 接口相关。

在四步曲的第一步里我们创建一个lDirect3D 接口对象，这步操作主要是为后面的初始化四步曲的第二、三、四步做铺垫， 因为Direct3D 接口对象在手，才能以此作为媒介，完成第二步的设备硬件信息的获取，以及第四步的Direct3D 设备接口的创建。

下面就开始看这一步的具体思路， 首先我们定义一个LPDIRECT3D9 类型的指针pD3D:

LPDIRECT3D9  pD3D = NULL; //Direct3D接口对象的创建

然后将该对象初始化，这时我们会用到一个叫做Direct3DCreate9 的函数，下面先介绍一下这个函数：

我们可以在DirectX SDK 中查到Direct3DCreate9 函数的原型是这样声明的：

IDirect3D9 * Direct3DCreate9(
UINT SDKVersion
);

这个函数作用是返回指向IDirect3D9 接口的指针，并进行DirectX 的版本协商。它有一个唯一的参数，UINT 类型的SDKVersion ， 表示当前使用的DirectX SDK 的版本，用于确保我们的应用程序所包含的所有头文件在编译时能够与DirectX 运行时的DLL 相匹配。

如果Direct3DCreate9 函数执行失败的话，就会返回NULL，表示在程序中包含的头文件的版本与运行时的DLL 版本不匹配。

所以， Direct3D 初始化四步曲的第一步整体来看，我们就可以这样写：

	//--------------------------------------------------------------------------------------
// 【Direct3D初始化四步曲之一，创接口】：创建Direct3D接口对象, 以便用该Direct3D对象创建Direct3D设备对象
//--------------------------------------------------------------------------------------
LPDIRECT3D9  pD3D = NULL; //Direct3D接口对象的创建
if( NULL == ( pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) ) //初始化Direct3D接口对象，并进行DirectX版本协商
return E_FAIL;

11.4.3 Direct3D 初始化四步曲之二：取信息

Direct3D 初始化四步曲之二，简称取信息，也就是获取设备的硬件信息。
获取硬件设备信息包括取得系统中所有可用的显卡的性能、显示模式、格式以及其他相关信息。

我们平常比较关心的是我们的显卡是否支持硬件顶点运算，因为这种方式运行起来比较高效。相比而言，软件顶点运算方式就只能自叹不如了。

在DirectX 9 中， IDirect3D9 接口为我们提供了GetDeviceCaps 方法，获取指定设备的性能参数，这个方法会把所获取的硬件设备的信息保存到一个叫D3DCAPS9 的预设好的结构体当中。下面我们就来看看这个GetDeviceCaps 的具体使用方法，可以在DirectX SDK 中查到GetDeviceCaps方法的声明如下：

HRESULT GetDeviceCaps(
[in]   UINT Adapter,
[in]   D3DDEVTYPE DeviceType,
[out]  D3DCAPS9 *pCaps
);

· 第一个参数， UINT 类型的Adapter，表示使用的显卡的序号，通常我们都使用其默认值D3DADAPTER_DEFAULT ，表示当前使用的显卡。

· 第二个参数， D3DDEVTYPE 类型的DeviceType ， 表示设备的类型， 取值为D3DDEVTYPE结构体的某一成员， D3DDEVTYPE 结构体声明如下：

typedef enum D3DDEVTYPE {
D3DDEVTYPE_HAL           = 1,
D3DDEVTYPE_NULLREF       = 4,
D3DDEVTYPE_REF           = 2,
D3DDEVTYPE_SW            = 3,
D3DDEVTYPE_FORCE_DWORD   = 0xffffffff
} D3DDEVTYPE, *LPD3DDEVTYPE;

一般我们只会涉及到硬件设备类型D3DDEVTYPE_HAL 与软件设备类型D3DDEVTYPE_REF ，了解这两个一般就足够了。

· 第三个参数， D3DCAPS9 类型的*pCaps ，我们可以看到它为一个指针，指向一个前面提到过的用于接收包含设备信息的D3DCAPS9 结构体的指针。

我们知道， 顶点是3D 图形学中的基本元素， 而Direct3D 可以有两种不同的顶点运算方式，也就是前面提到过的硬件顶点运算与软件顶点运算。其中， 硬件顶点运算得到了显卡的支持，可以使用硬件专有的加速功能，其执行速度将远远快于软件顶点运算方式。

所以我们在编写Direct3D 的游戏程序的时候， 始终应该优先考虑使用“高富帅”硬件顶点运算方式。但是，或许某些老掉牙的显卡并不支持硬件顶点运算，所以， 我们就需要在Direct3D 初始化过程中，通过GetDeviceCaps 方法检查显卡支持的顶点运算模式。

所以，Direct3D 初始化四步曲的第二步整体来看， 我们就可以这样写：

//--------------------------------------------------------------------------------------
// 【Direct3D初始化四步曲之二,取信息】：获取硬件设备信息
//--------------------------------------------------------------------------------------
D3DCAPS9 caps; int vp = 0;
if( FAILED( pD3D->GetDeviceCaps( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps ) ) )
{
return E_FAIL;
}
if( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT )
vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;   //支持硬件顶点运算，我们就采用硬件顶点运算，妥妥的
else
vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING; //不支持硬件顶点运算，无奈只好采用软件顶点运算

其中D3DDEVCAPS_HWTRANSFORMANDLIGHT 宏表示显卡可以硬件支持变换和光照。

关于D3DCAPS9 结构体， 用于描述显卡的所有性能参数，由于里面的内容太多了， 而且没有过多介绍的必要性。在这里就不多做说明了，需要的时候，我们可以在DirectX SDK 中进行查阅。

11.4.4 Direct3D 初始化四步曲之三：填内容

Direct3D 初始化四步曲之三，简称填内容，也就是在填充D3DPRESENT_PARAMETERS 结构体。

这一步非常好理解， 其实就是做一个填空题， 填充D3DPRESENT_PARAMETERS 结构体，完全就是为后面的第四步创建Direct3D 设备接口做准备的。但是为了便于我们的记忆与理解，在这里专门作为一个步骤列举出来。

这个结构体可谓非常地重要，使用Direct3D 一般都需要进行这个结构体的填充工作，希望大家仔细理解。其实各成员的功能看一下它的变量名就可以知道， 顾名思义，比如BackBufferWidth,按字面意思理解，就是后台缓冲区（ BackBuffer ）的宽度（ Width ） 。

我们可以在DirectX SDK 中查到D3DPRESENT_PARAMETERS 的原型声明：

typedef struct D3DPRESENT_PARAMETERS {
UINT                BackBufferWidth;
UINT                BackBufferHeight;
D3DFORMAT           BackBufferFormat;
UINT                BackBufferCount;
D3DMULTISAMPLE_TYPE MultiSampleType;
DWORD               MultiSampleQuality;
D3DSWAPEFFECT       SwapEffect;
HWND                hDeviceWindow;
BOOL                Windowed;
BOOL                EnableAutoDepthStencil;
D3DFORMAT           AutoDepthStencilFormat;
DWORD               Flags;
UINT                FullScreen_RefreshRateInHz;
UINT                PresentationInterval;
} D3DPRESENT_PARAMETERS, *LPD3DPRESENT_PARAMETERS;

下面我们开始无脑地对成员分别进行介绍：

 UINT 类型的BackBufferWidth ， 指定后台缓冲区的宽度。
 UINT 类型的BackBufferHeigh ， 指定后台缓冲区的高度。
 D3DFORMAT 类型的BackBufferF ormat ， 指定后台缓冲区的保存像素格式， 可以用D3DFORMAT 枚举定义。可以用GetDisplayMode 获取当前像素格式。
 UlNT 类型的BackBufferCount，指定后台缓冲区的宽度。
 D3DMUL TIS AMPLE_ TYPE 类型的MultiSampleType，表示多重采样的类型。通常我们将MultiSample Type 设为
D3DMULTISAMPLE_ NONE,
 DWORD 类型的MultiSampleQuality，表示多重采样的格式。通常我们将其设为0 ,
 D3DSW APEFFECT 类型的SwapEffect，用于指定Direct3D 如何将后台缓冲区的内容复制到前台的缓存中，通常我们都将其设为D3DSWAPEFFECT_DISCARD.
 HWND 类型的hDeviceWindow ，很显然， 就是我们熟知的窗口句柄，这里指定我们需要在哪个窗口上进行绘制。这个参数也可以设为NULL，这时就表示对当前被激活的窗口进行绘制。
 BOOL 类型的Windowed 表示绘制窗体的显示模式，为TRUE 使表示使用窗口模式，为FALSE 则表示使用全屏模式。
 BOOL 类型的EnableAutoDepthStencil，表示Direct3D 是否为应用程序自动管理深度缓存，这个成员为TRUE 的话，表示需要自动管理深度缓存，这时候就需要对下一个成员A utoDepthStencilFormat 进行相关像素格式的设直。关于深度缓存，后面我们有专门的章节进行介绍.
 D3DFORMAT 类型的AutoDepthStencilForrnat 上面刚介绍这如果我们把EnableAutoDepthStencil 成员设为TRUE 的话，在这里就需要指定AutoDepthStenciIFormat 的深度缓冲的像素格式，具体格式可以在结构体D3DFORMAT 中进行选取，后面我们有专门的章节进行介绍。
 DWORD 类型的Flags ，表示附加属性，通常都设为0 。
 UINT 类型的FuUScreen RefreshRatelnHz，表示在全屏模式时指定的屏幕的刷新率，在全屏模式时在EnumAdapterModes 枚举类型中进行取值，我们在全屏模式时将其设为默认值D3DPRESENT_RATE_DEFAULT，窗口模式时这个成员没有意义，我们把它就设为0 了。
 UINT 类型的Presentationlnterval ，用于指定指定后台缓冲区与前台缓冲区的最大交换频率，可在D3DPRESENT 中进行取值。

好了，终于把这个重要的结构体介绍完了。下面我们来整体看一下如何整体填充这个结构体，也就是我们Direct3D 初始化四步曲的第三步所需代码：

//--------------------------------------------------------------------------------------
// 【Direct3D初始化四步曲之三，填内容】：填充D3DPRESENT_PARAMETERS结构体
//--------------------------------------------------------------------------------------
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.BackBufferWidth            = WINDOW_WIDTH;
d3dpp.BackBufferHeight           = WINDOW_HEIGHT;
d3dpp.BackBufferFormat           = D3DFMT_A8R8G8B8;
d3dpp.BackBufferCount            = 1;
d3dpp.MultiSampleType            = D3DMULTISAMPLE_NONE;
d3dpp.MultiSampleQuality         = 0;
d3dpp.SwapEffect                 = D3DSWAPEFFECT_DISCARD;
d3dpp.hDeviceWindow              = hwnd;
d3dpp.Windowed                   = true;
d3dpp.EnableAutoDepthStencil     = true;
d3dpp.AutoDepthStencilFormat     = D3DFMT_D24S8;
d3dpp.Flags                      = 0;
d3dpp.FullScreen_RefreshRateInHz = 0;
d3dpp.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE;

11.4.5 Direct3D 初始化四步曲之四：创设备

Direct3D 初始化四步曲之四，简称创设备，也就是Direct3D 设备接口的正式创建。

其实就是利用第一步创建的Direct3D 接口对象调用一下IDirect3D9::CreateDevice 方法， 非常简单。下面我们就来介绍一下这个也非常重要的IDirect3D9::CreateDevice 方法。

我们可以在DirectX SDK 中查到这个方法的原型如下：

HRESULT CreateDevice(
[in]           UINT Adapter,
[in]           D3DDEVTYPE DeviceType,
[in]           HWND hFocusWindow,
[in]           DWORD BehaviorFlags,
[in, out]      D3DPRESENT_PARAMETERS *pPresentationParameters,
[out, retval]  IDirect3DDevice9 **ppReturnedDeviceInterface
);

接下来按顺序分别讲解每个成员的具体含义和使用方法。

 UINT 类型的Adapter，表示将创建的IDirect3D Device9 接口对象所代表的显卡序号，通常我们使用D3DADAPTER DEFAULT，或者取α 表示默认的显卡，因为在d3d9.h头文件中定义了这个宏：
1. #define D3DADAPTER_DEFAULT 0
 D3DDEVTYPE 类型的DeviceType ，指定Direct3D 的设备类型，前面第二步中讲到过，我们可以在D3DDEVTYPE 枚举类型中取值，我们一般取D3DDEVTYPE_HAL,表示硬件设备类型。
 HWND 类型的hFocusWindow ， 一个窗口句柄，指定当Direct3D 程序从前台交换到后台时的提示窗口。在全屏模式运行时，这个窗口必须是最上层显示的窗口，当窗口模式运行时，这个成员可为NULL。为了达到正确的显示效果，我们一般把这个窗口设为和Direct3D 初始化四步曲的第二步里面D3DPRESENT_PARAMETERS 结构体唯一的窗口句柄成员hDeviceWindow 一致。
 DWORD 类型的BehaviorFlags ， 表示设备行为标识，我们只要知道这个参数可以取D3DCREATE_HARDWARE_VERTEXPROCESSING （硬件顶点运算）或者
D3DCREATE_SOFTWARE_ VERTEXPROCESSING （软件顶点运算）就可以了。
 D3DPRESENT_PARAMETERS 类型的*pPresentationParameters ， 在这里填一个已经完成初始化的
D3DPRESENT_PARMMETERS 类型的结构体，不用多介绍了吧，第二步填充的结构体就是在现在使用的。
 IDirect3DDevice9 类型的*ppRetumedDev icelnterface, 即指定我们创建的Direct3D 设备接口的指针， 可以这样说，调用CreateDevice 函数，就是为了得到这个Direct3D设备接口的指针，以完成之后的绘制过程。

介绍完这个非常重要的函数的各个参数，下面我们就来看看到底这个函数在实际情况下应该如何书写，这段代码也就是Direct3D 初始化四步曲最后一步的完整代码，其实非常地简短：

if(FAILED(pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
hwnd, vp, &d3dpp, &g_pd3dDevice)))
return E_FAIL;

在这里我们进行了错误处理，用返回值来判断函数是否调用成功了。因为CreateDevice 方法返回一个HRESULT 类型的返回值，我们可以通过SUCCESSED 和FAIL 宏来判断这个函数的执行结果。

11.4.6 Direct3D 初始化四步曲代码赏析

通过以上四个步骤的分别介绍，相信大家已经对如何初始化Di.rect3D 有了一个深刻的认识，也就是四步曲，简明扼要，也就是十二个字： 创接口，取信息，填内容，创设备。

然后我们贴出Direct3D 初始化四步曲的全部代码，也就是Direct3D_lnit（）函数的实现。大家只要理解并消化了下面这段代码了，就能拍拍胸脯对自己说， 我已经掌握Direct3D 初始化的方法了。

//-----------------------------------【Direct3D_Init( )函数】--------------------------------------
//	描述：Direct3D初始化函数，进行Direct3D的初始化
//------------------------------------------------------------------------------------------------
HRESULT Direct3D_Init(HWND hwnd)
{
//--------------------------------------------------------------------------------------
// 【Direct3D初始化四步曲之一，创接口】：创建Direct3D接口对象, 以便用该Direct3D对象创建Direct3D设备对象
//--------------------------------------------------------------------------------------
LPDIRECT3D9  pD3D = NULL; //Direct3D接口对象的创建
if( NULL == ( pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) ) //初始化Direct3D接口对象，并进行DirectX版本协商
return E_FAIL;

//--------------------------------------------------------------------------------------
// 【Direct3D初始化四步曲之二,取信息】：获取硬件设备信息
//--------------------------------------------------------------------------------------
D3DCAPS9 caps; int vp = 0;
if( FAILED( pD3D->GetDeviceCaps( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps ) ) )
{
return E_FAIL;
}
if( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT )
vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;   //支持硬件顶点运算，我们就采用硬件顶点运算，妥妥的
else
vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING; //不支持硬件顶点运算，无奈只好采用软件顶点运算

//--------------------------------------------------------------------------------------
// 【Direct3D初始化四步曲之三，填内容】：填充D3DPRESENT_PARAMETERS结构体
//--------------------------------------------------------------------------------------
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.BackBufferWidth            = WINDOW_WIDTH;
d3dpp.BackBufferHeight           = WINDOW_HEIGHT;
d3dpp.BackBufferFormat           = D3DFMT_A8R8G8B8;
d3dpp.BackBufferCount            = 1;
d3dpp.MultiSampleType            = D3DMULTISAMPLE_NONE;
d3dpp.MultiSampleQuality         = 0;
d3dpp.SwapEffect                 = D3DSWAPEFFECT_DISCARD;
d3dpp.hDeviceWindow              = hwnd;
d3dpp.Windowed                   = true;
d3dpp.EnableAutoDepthStencil     = true;
d3dpp.AutoDepthStencilFormat     = D3DFMT_D24S8;
d3dpp.Flags                      = 0;
d3dpp.FullScreen_RefreshRateInHz = 0;
d3dpp.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE;

//--------------------------------------------------------------------------------------
// 【Direct3D初始化四步曲之四，创设备】：创建Direct3D设备接口
//--------------------------------------------------------------------------------------
if(FAILED(pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
hwnd, vp, &d3dpp, &g_pd3dDevice)))
return E_FAIL;

SAFE_RELEASE(pD3D) //LPDIRECT3D9接口对象的使命完成，我们将其释放掉

if(!(S_OK==Objects_Init(hwnd))) return E_FAIL;     //调用一次Objects_Init，进行渲染资源的初始化
return S_OK;
}

11.4.7 示例程序D3Ddemo1

这个示例程序中， 我们在之前写的DirectX 程序框架D3DdemoCore 的基础上，加入了Direct3D初始化四步曲的相关代码。

主要是Direct3D_InitQii1数的实现代码，我们在l 1.4 . 6 节己经贴出了，这里就不再浪费篇幅重复贴出。然后我们用代码加入了两个库文件， 主要是方便DirectX 开发环境没有配置完全、lib 库文件没有添加真正成功的朋友们依然能够顺利编译源代码井运行成功。不然很可能就有“未解析的夕阳但命令”系列诡异的错误来困扰着这些朋友们。即如下两句代码增加了我们程序的生命力：

//-----------------------------------【库文件包含部分】---------------------------------------
//	描述：包含程序所依赖的库文件
//------------------------------------------------------------------------------------------------
#pragma comment(lib,"winmm.lib")  //调用PlaySound函数所需库文件
#pragma comment(lib,"d3d9.lib")
#pragma comment(lib,"d3dx9.lib")

其中，为了演示的方便，我们把Direct3D 的初始化放在了显示和更新窗口之后，井且采用if·· ·else 语句配合MessageBox 函数， Direct3D 调用成功或者失败，都会弹出相应的消息，下面就是这段内容的实现代码：

//Direct3D资源的初始化，成功或者失败都用messagebox予以显示
if (S_OK==Direct3D_Init (hwnd))
{
MessageBox(hwnd, L"Direct3D初始化完成~！", L"浅墨的消息窗口", 0); //使用MessageBox函数，创建一个消息窗口
}
else
{
MessageBox(hwnd, L"Direct3D初始化失败~！", L"浅墨的消息窗口", 0); //使用MessageBox函数，创建一个消息窗口
}

其余的代码就基本上和我们上文中已经详细贴出的DirectX 程序框架D3DdemoCore 的源代码相同，这里就不浪费篇幅重复贴出了。

这个示例程序的运行截图如下：



我们可以看到弹出的提示信息框“ Direct3D 初始化完成～ ！ ”，说明我们的Direct3D 是初始化成功了的。

11.5 深入理解Direct3D 动画显示技术——交换链

Direct3D 的工作模式与电影的播放原理类似。当播放电影图像时， 影片图像以每秒24 帧的速度连续地闪动，由于这些图像之间的差别很小，以及人眼的滞留作用，所以实际看到的就好像是连续的动作画面。

Direct3D 中，使用了一种称作交换链（ Pape Flipping ）的技术， 来让画面能够平滑的过渡。交换链由两个或者两个以上的表面组成， 而每个表面都是存储着2D 图形的一个线性数组， 其中每个元素都表示着屏幕上的一个像素。

上面讲到的只是2D 图形， 而对于三维物体呢，我们还需要一个称作深度的信息， Direct3D 使用深度缓冲区为最终绘制的图像的每个像素都存储一个深度信息，深度缓冲区只包含特定像素的深度信息，而不包含图像数据的表面信息（表面信息上面讲过， 由表面信息来存储，就是一个存储着2D 图形的线性数组〉。

前台缓冲区和后台缓冲区是位于系统内存或显存里的内存块，对应于将要显示的二维显示区域。前台缓冲区是显示在显示屏上的、我们可以看到的内容。而后台缓冲区则主要用于图形绘制的准备工作，属于我们熟知的“幕后”（想要上演一出完美而杰出的表演，幕后准备工作肯定是要准备充分的〕。这样我们的图像在经过在后台缓冲区中的处理后， 变得光鲜和毫无瑕疵， 在后台缓冲区处理完成后，也就是后台缓冲区中的内容准备好之后， 就可以和前台缓冲区进行一个交换操作，这就是我们所说的交换链页面翻转。通过前台缓冲区和后台缓冲区的配合，
运用交换链技术，就可以流畅而高效地绘制出漂亮无瑕的动画图像来。

下面我们通过一幅图来看看这神奇的交换链翻转操作到底是怎样完成的。



对这幅多后台缓冲区编码翻转演示图，我们可以这样理解： 在Direct3D 中，通常是通过在一系列后台缓冲区中生成动画帧（也就是一幅图像） ， 然后再将他们通过交换链技术， 逐个提交到前台来显示，实现华丽的动画效果。其中，这一系列的后台缓冲区被组织成交换链。所以我们可以这样说， 交换链就是按顺序逐个提交到前台来显示的多个后台缓冲区的集合。

在Direct3D 中创建的每一个渲染设备至少要有一个交换链，在我们的Direct3D 初始化四步曲中的第三步里面，我们填充了
D3DPRESENT_PARAMETERS 结构体， 其中我们设置的BackBufferCount 成员会告诉Direct3D 我们创建的Direct3D 设备对象的交换链中，有多少个后台缓冲区，图中表示有两个后台缓冲区，就是这段代码：

D3DPRESENT_PARAMETERS d3dpp;
d3dpp.BackBufferCount = 2;

需要注意的是，上面这两句只是告诉了Direct3D 相关的信息， 没有真正的去创建， 而交换链正式的创建， 是在四步曲的第四步里面，调用IDirect3D9::CreateDevice（） 方法的时候。IDirect3 D9: : Create Device（）方法完成了Direct3D 设备对象和相应交换链的创建。

创建完成后，我们自然需要“驱动” 交换链进行翻转操作，而交换链的翻转操作就是本节主要讲解的Direct3D 渲染五步曲里的最后一步“翻转显示”之中，也就是调用IDirect3DDevice9:: Present()函数，进行页面的翻转和显示。接下来会讲解这个函数的具体用法，这里我们知道它用于页面翻转操作的就够了。

我们可以总结一下，交换链其实就是在进行一个风水轮流转的过程，按部就班，万年不变地进行着一次又一次的轮回。他们的轮回生命由IDirect3D9: :CreateDevice（）方法来赋予。演员个数由D3DPRESENT_PARAMETERS 结构体中的BackBufferCount 成员指定，而驱动这个轮回的，就是我们的IDirect3DDevice9: :Present（）函数。

最后，我们需要知道的是， 在调用IDirect3DDevice9::Present() 函数，请求并进行页面翻转时，是指向前台缓冲区和后台缓冲区表面内存的指针在进行着调换操作。也就是说，页面翻转是经过交换指向表面内存的指针来实现的，而不是通过复制表面的内容实的。我们都知道， 指针这个东西，使用起来方便、环保、资源占用小。

交换链技术利用这样的指针交换操作， 实现了高效而流畅的动画绘制。

11.6 对固定功能渲染流水线体系的理解

其实固定渲染流水线和我们将要学习的可编程渲染流水线体系有很多异曲同工之处。Direct3D中，先学习固定功能渲染流水线系，再学可编程渲染流水线体系，是最合适的路线， 可以循序渐进，步步为营地掌握好DirectX 。

空间中的物体需要使用三维坐标来描述，而我们的显示器显示的是二维的，所以在屏幕上渲染一个三维场景时，首先需要将物体描述空间物体的三维坐标变换为二维坐标（也就是世界坐标到屏幕坐标〉，这在Direct3D 中称为顶点坐标变换。顶点坐标变换通常通过矩阵来完成。我们之前的几个demo 中，演示的是如何显示一个二维的平面图形，它的顶点是以屏幕坐标系的二维值表示的，也是经过顶点坐标变换之后的顶点坐标数据，可以把顶点坐标变换想象成摄像的过程， 三维世界的景物通过摄像机拍摄显示在二维的相片之上，有所不同的是把相片换成了屏幕。

在固定功能渲染流水线这套体系中，大体分为两个阶段，第一阶段我们将它称为坐标变换和光照处理阶段（ Transforming &Lighting ，简称T&L 阶段） 。在这个阶段中，每个对象的顶点从一个抽象的、浮点坐标变换到基于像素的屏幕空间当中。这里需要注意是，坐标变换不仅包含物体顶点位置，它还可能包括顶点的法线、纹理坐标等等。并根据场景中光源和物体表面的材质对物体顶点应用不同类型的光照效果。还有其他一些比较重要的任务，比如视口的设置和裁剪也是在第一阶段进行的。
我们再来看看第二阶段，第二阶段称为光栅化处理阶段。顶点在经过第一阶段也就是变换与光照阶段的“洗礼”之后，已经略有雏形，在第二阶段， Direct3D 将这些己经完成变换和光照阶段的顶点组织为以点、线、面为基础的图元，应用纹理贴图和物体顶点的颜色属性，并根据相关渲染状态的设置（ 比如着色模式等）决定每个像素最终的颜色值， 并且在屏幕上显示出来。
为了大家更宏观和更深入地理解，依然是配了一幅图。通过下面这幅图，大家可以对固定功能渲染流水线的结构脉络做到一目然。



需要注意的是，渲染流水线中的步骤并不一定都要有，根据实际情况可以省略一些。比如之前我们给出的几个demo ，都是省略了变换和光照阶段，直接将顶点作为屏幕坐标输出显示。因为我们在定义顶点的属性的时候，给我们的顶点定的“标签”是
D3DFVF_XYZRHW ， 表示包含经过坐标变换的顶点坐标值， 这样Direct3D 就知道这些顶点坐标不需要再经过顶点坐标变换了，他们的坐标值就是最终显示屏幕上的坐标值了。

目前我们重点介绍坐标变换和光照处理阶段（ Transforming &Lighting ，简称T&L 阶段） 。在这个阶段中，未经过变换和光照的顶点从一端进入，在流水线内部这些顶点将完成几个连续的操作，这几个操作按顺序分别为世界变换，取景变换，光照处理，投影变换以及视口变换。经过这些处理之后的顶点从另一端出来，表示己经完成坐标变换和光照处理了。我们的应用程序是通过指定几个

矩阵、视口以及所使用的光线来建立T&L 流水线的，然后应用程序将顶点送入流水线，并对这些顶点在流水线中进行坐标变换、照明以及裁剪，将其投影到屏幕空间当中，并根据视口的规定对其进行缩放。顶点在T&L 流水线中进过“涅架”之后，就到了
第二阶段——光栅化处理阶段去完成新的试炼了。

关于变换和光照渲染流水线阶段，也就是丁＆L 阶段，也配了一幅图，方便大家的记忆与理解，如下图所示。

11. 7 Direct3D 中的“绘制金钥匙”——Direct3D 设备接口

其实，使用Direct3D 绘制3D 图形和我们之前使用的GDI 绘制2D 图形的方法是异曲同工的，毕竟都是微软那些强人们写出来的，风格或多或少会有一定的相似之处。

看完这本书的前面小半部分GDI 游戏编程的朋友们应该都知道。在GDI 编程中，有一把金钥匙叫hdc ，也就是传说中的设备描述表的句柄，不过我们在编程中因为命名规范的关系，把它写成了g hdc ， 表示他是一个全局变量。我们要在屏幕上采用GDI 绘制图形，都是在与hdc 这个家伙打交道。我们进行各种透明处理， 弄什么双缓冲甚至多缓冲的最终目的，都是想要把流畅的动画绘制到hdc 之中。在GDI 游戏实现代码中，大家肯定对这个句子非常的熟悉：

hdc = GetDC (hwnd) ;

就是这个语句让我们用CreateWindow 创建出来的窗口句柄hwnd 与hdc 有了剪不断理还乱的联系。就是它，成就了hdc 这把GDI 中绘制的金钥匙。

我们再来看看Direct3D 这边。

在上一节， Direct3D 初始化四步曲中我们讲到了初始化Direct3D 的第三步是填内容， 也就是填充D3DPRESENT_PARAMETERS 结构体。D3DPRESENT_PARAMETERS 结构体的第八个参数， HWND 类型的hDeviceWindow ，很显然，就是我们熟知的窗口句柄，这里指定我们需要在哪个窗口上进行绘制，我们通常都填hwnd 。也就是这样写：

D3DPRESENT_PARAMETERS d3dpp;
d3dpp.hDeviceWindow = hwnd;

然后在初始化Direct3D 的第四步是创设备填内容中，我们这样写：

pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd, vp, &d3dpp, &g_pd3dDevice);

CreateDevice 函数的倒数第二个参数，我们指定的就是D3DPRESENT_PARAMETERS 的实例d3dpp 。最后一个参数， IDirect3DDevice9 类型的**ppReturnedDevicelnterface 就是我们指向Direct3D设备接口的句柄。
这样我们就间接地把hwnd 和Direct3D 设备联系起来了，这就是通过CreateDevice 方法创建出来的Direct3D 设备能趾高气扬地作为Direct3D 中“绘制金钥匙”的资本。

举个具体例子，在这一节稍后的示例程序demo 之中， g_pd3dDevice 就是这个绘制金钥匙，后面的绘制操作就是通过它来完成的，比如拿起g_pd3dDevice 指一下Present ，也就是渲染五步曲的最终步骤：

g_pd3dDevice- >Present(NULL, NULL , NULL, NULL);  //翻转与显示

这个函数将在后面重点讲解，这里只是提一下。

所以如果我们想要在Direct3D 中进行绘制，拿起Direct3D 中的金钥匙——“ Direct3D 设备”，用箭头“→”调用一下相应的方法就了。

11.8 Direct3D 中二维文本的绘制

在Direct3D 中， ID3DXFont 接口负责着Direct3D 应用程序中创建字体以及实现二维文本的绘制，该接口封装了Windows 字体和Direct3D 设备指针。其实， ID3DXFont 内部实际上还是借用的GDI 实现了文本的绘制。

11.8.1 D3DXCreateFont 函数

首先我们来看一下将要使用到的、Direct3D 中用于创建字体的一个函数， 它很憨厚老实，人如其名，就叫D3DXCreateFont。我们可以在DirectX SDK 中查到这个D3DXCreateFont 函数的声明：

HRESULT  D3DXCreateFont(
__in   LPDIRECT3DDEVICE9 pDevice,
__in   INT Height,
__in   UINT Width,
__in   UINT Weight,
__in   UINT MipLevels,
__in   BOOL Italic,
__in   DWORD CharSet,
__in   DWORD OutputPrecision,
__in   DWORD Quality,
__in   DWORD PitchAndFamily,
__in   LPCTSTR pFacename,
__out  LPD3DXFONT *ppFont
);

然后依次是每个变量的介绍：
 第一个参数， LPDIRECT3DDEVICE9 类型的pDevice ，也就是我们的Direct3D 绘制金钥匙——Direct3D 设备的指针。
 第二个参数， INT 类型的Height，表示字体的高度。
 第三个参数， UINT 类型的Width ， 表示字体的宽度。
 第四个参数， UINT 类型的Weight，表示字体的权重值。
 第五个参数， UINT 类型的MipLevels，表示字体的过滤属性。
 第六个参数， BOOL 类型的Italic，表示是否为斜体， TRUE 表示是斜体， FLASE 表示不是斜体。
 第七个参数， DWORD 类型的CharSet ， 表示字体所使用的字符集， 通常我们设为默认值DEFAULT CHARS ET ， 表示使用默认字符集。
 第八个参数， DWORD 类型的OutputPrecision，表示输出文本的精度，通常设为默认值OUT_DEFAULT_PREClS。
 第九个参数， DWORD 类型的Quality ，表示指定字符的输出质量， 通常也设为DEFAULT_QUALITY。
 第十个参数， DWORD 类型的PitchAndFamily ，用于指定字体的索引号， 通常都设为0 。
 第十一个参数， LPCTSTR 类型的pFacename ， 指定我们想要创建的字体名称，比如“微软雅黑”等等
 第十二个参数， LPD3DXFONT 类型的*ppFont ， 用于存储我们新储存的字体指针。它也是一把钥匙，我们要进行字体绘制相关的操作，全都靠它了。

设置起来非常简单，也就是做填空题， 按部就班， 一个一个填，而且有章可循， 非常好写。

11.8.2 DrawText 函数

完成了字体的创建，下面就是要调用绘制文本的函数了。也就是ID3 DXFont::DrawText 的调用，

下面看一下这个函数的原型：

INT DrawText(
[in]  LPD3DXSPRITE pSprite,
[in]  LPCTSTR pString,
[in]  INT Count,
[in]  LPRECT pRect,
[in]  DWORD Format,
[in]  D3DCOLOR Color
);

第一个参数， LPD3DXSPRITE 类型的pSprite ，指定字符串所属的ID3DXSprite 对象接口，我们可以把它设为0 ， 表示在当前窗口绘制字符串。
 第二个参数， LPCTSTR 类型的pString， 指定我们将要绘制的字符串内容。
 第三个参数， INT 类型的Count ，指定绘制字符的个数，如果取－ 1 的话，就表示函数会自动绘制到字符串结束为止。
 第四个参数， LPRECT 类型的pRect ， 表示用于绘制字符串的矩形区域位置。
 第五个参数， DWORD 类型的Format ， 指定字符串在上面设置的这个参数， pRect 矩形区域中的摆放属性。比较常用的属性打在了下面这张表上面了，他们之间用“｜” 符号联合起来使用，比如DT_ CENTER I OT_ VCENTER 。



第六个参数， D3DCOLOR 类型的Color ， 显而易见，它是用于指定我们字符串显示的颜色值的，属于我们之前讲过的D3DCOLOR 结构体， 可以随意从中挑选并设置。

使用这两个函数，我们就可以在Direct3D 程序中随心所欲地显示中文和英文了。任何颜色，任何字体， 任何字体大小， 任何位置的文字显示，这两个函数都能很好胜任。

所以，概括地来说，在Direct3D 应用程序中输出文字就两步：

调用D3DXCreateFont 创建字体。
拿起创建的字体，调用ID3DXFont: :DrawText 进行文本的绘制。

当然，在Direct3D 中绘制2D 文本的方式并不只这一种，但是这种方式用起来最舒服。

另外告诉大家一点， 关于Direct3D11 中汉字的显示，在Direct3D11 中，不知道微软出于什么考虑，把Direct3D9 中这么好用的ID3DXFont 接口和D3DXCreateFont 全部都移除了。所以在Direct3D11 中，如果不使用第三方库、资源和软件，想输出中文文字是有点难的。这就是为什么Direct3D11 在国内很难普及的又一个原因吧。

11.9 起承转合的艺术： Direct3D 渲染五步曲

11.9.1 Direct30 渲染五步曲概述

在之前的示例程序D3DdemoCore 中，我们自定义了一个Direct3D_ Render()函数，这个函数我们说是用于书写Direct3D 渲染与绘制相关代码的。我们准备在这个Direct3D_ Render（）函数中，简单干净地完成这渲染五步曲操作， 不多做一点赘余的操作，消息循环中代码是这样写的：

//【5】消息循环过程
MSG msg = { 0 };  //初始化msg
while( msg.message != WM_QUIT )			//使用while循环
{
if( PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) )   //查看应用程序消息队列，有消息时将队列中的消息派发出去。
{
TranslateMessage( &msg );		//将虚拟键消息转换为字符消息
DispatchMessage( &msg );		//该函数分发一个消息给窗口程序。
}
else
{
Direct3D_Render(hwnd);   //进行渲染
}
}

这表示我们时时刻刻地在调用Direct3D_Render（） 函数，每秒钟调用成千上万次都是可能的。所以为了写出执行效率高的游戏程序，我们一定要保证Direct3D_Render（） 函数代码的干净整洁。

下面我们就来看看， Direct3D_Render（）函数需要的渲染五步曲， 是哪五步：

渲染五步曲之一：清屏操作。
渲染五步曲之二：开始场景。
渲染五步曲之三：正式绘制。
 渲染五步曲之四； 结束场景。
 渲染五步曲之五：翻转显示。

所以，渲染五步曲连起来说， 也就是简单的20 个字： 清屏操作， 开始场景， 正式绘制，结束场景，翻转显示。
这五步非常地好理解， 有点像写文章里“起承转合”的味道。
值得提出的是，渲染五步曲都有一个统一的指挥棒，那就是Direct3D 中的“绘制金钥匙”——Direct3D 设备接口，我们稍后可以到，这五步曲里的每一步里面都是拿着个IDirect3DDevice9接口的指针对象g_pd3dDevice 指一下某某函数。

接下来我们对着五步曲进行各个击破，分别进行细讲。首先来看下第一步。

11.9.2 五步曲之一：清屏操作

每当绘制画面之前呢，我们都需要通过IDirect3DDevice9 接口的Clear 方法将后台缓冲区中的内容进行清空， 并设置我们喜欢的表面填充颜色等。

我们可以在DirectX SDK 中查到。Direct3D 渲染五步曲的第一步中的主角IDirect3DDevice9: :Clear 的原型声明是这样的：

HRESULT Clear(
[in]  DWORD Count,
[in]  const D3DRECT *pRects,
[in]  DWORD Flags,
[in]  D3DCOLOR Color,
[in]  float Z,
[in]  DWORD Stencil
);

下面我们对各个成员分别进行讲解。

第一个参数， DWORD 类型的Count ，指定了接下来的一个参数pRect 指向的矩形数组中矩形的数量。我们可以这样说， Count 和pRects 是一对好基友。如果pRects 我们将其设为NULL的话， 这参数必须设为0 。而如果pRects 为有效的矩形数组的指针的话，这个Count 必须就为一个非零值了。
第二个参数， const D3DRECT 类型的*pRects ，指向一个D3DRECT 结构体的数组指针，表明我们需要清空的目标矩形区域。
第三个参数， DWORD 类型的Flags ，指定我们需要清空的缓冲区。它为D3DCLEAR_STENCIL 、D3DCLEAR_TARGET 、D3DCLEAR_ZBUFFER 的任意组合，分别表示模板缓冲区、颜色缓冲区、深度缓冲区，用“｜ ” 连接。
第四个参数， D3DCOLOR 类型的Color，用于指定我们在清空颜色缓冲区之后每个像素对应的颜色值，这里的颜色用D3DCOLOR 宏表示，即这样写D3DCOLOR_XRGB(R, G, B），其中的RGB 为我们设定的红绿蓝三原色的值， 都在0 到255 之间取值，比如D3DCOLOR_XRGB(123 , 76, 228);

关于Direct3D 中的颜色表示。除了上面介绍的D3DCOLOR＿XRGB 宏以外,还可以用D3DCOLOR＿ARGB(a,r,g,b)宏，
D3DCOLOR＿RGBA(r,g,b,a)宏,D3DXCOLORVALUE结构体、D3DXCOLOR 结构体来定义颜色值。
我们继续来讲解Clear 方法的后两个参数：

· 第五个参数， float 类型的Z ，用于指定清空深度缓冲区后每个像素对应的深度值。
· 第六个参数， DWORD 类型的Stencil ， 用于指定清空模板缓冲区之后模板缓冲区中每个像素对应的模板值。

所以， 渲染五步曲的第一步就是用一下这个Clear 方法：

//其中g_pd3dDevice 表示我们创建的有效的Direct3D 绘制”金钥匙”—Direct3D 设备对象
g_pd3dDevice- >Clear (0 , NULL , D3DCLEAR_TARGET , D3DCOLOR _ XRGB (0, 0, 0）, 1.0f, 0）；

11.9.3 五步曲之二：开始绘制

其实过程非常简单，就是简单地写一句:

／／其中g_pd3dDevice 表示我们创建的有效的Direct3D 绘制”金钥匙”一Direct3D 设备对象
g_pd3dDevice->BeginScene();

其中IDirect3DDevice9: :BeginScene（）没有参数，如果调用成功，返回值就为HRESULT 。需要重点注意的是，
这个IDirect3DDevice9:: BeginScene（）和IDirect3DDevice9::EndScene（）是一对好基友，形影不离。要么都不出现，要么肯定是成对出现的.

11.9.4 五步曲之三：正式绘制

“正式绘制”的就像BeginScene（）和EndScene（）这对好基友的电灯泡一样，总是乐此不疲地出现在他们两者中间，而且通常是大段大段的代码，正式绘制这一步并没有确切的固定代码，我们想绘制什么内容，就写什么样的句子。这也是我们编写游戏程序的重点所在， 通过写出不同的句子来绘制不同的游戏画面。如果是按我们这节的配套程序来分析的话，这里编写的是如下的代码：

//--------------------------------------------------------------------------------------
// 【Direct3D渲染五步曲之三】：正式绘制，在这里我们写了四段文字
//--------------------------------------------------------------------------------------
//在窗口右上角处，显示每秒帧数
int charCount = swprintf_s(g_strFPS, 20, _T("FPS:%0.3f"), Get_FPS() );
g_pFont->DrawText(NULL, g_strFPS, charCount , &formatRect, DT_TOP | DT_RIGHT, D3DCOLOR_XRGB(255,39,136));

//在纵坐标100处，写第一段文字
formatRect.top = 100;//指定文字的纵坐标
g_pFont->DrawText(0, _T("【致我们永不熄灭的游戏开发梦想】"), -1, &formatRect, DT_CENTER,
D3DCOLOR_XRGB(68,139,256));

//在纵坐标250处，写第二段文字
formatRect.top = 250;
g_pFont->DrawText(0, _T("游戏开发的世界，我们来降服你了~！"), -1, &formatRect,
DT_CENTER, D3DCOLOR_XRGB(255,255,255));

//在纵坐标400处，写第三段文字
formatRect.top = 400;
g_pFont->DrawText(0, _T("闪闪惹人爱"), -1, &formatRect, DT_CENTER,
D3DCOLOR_XRGB(rand() % 256, rand() % 256, rand() % 256));//采用随机RGB值，做出“闪闪惹人爱”的特效

11.9.5 五步曲之四：结束绘制

写完需要绘制内容的相关代码， 接下来这一步是非常非常简单，就是调用一下“ Direct3 D 绘制双人组”之一的EndScene（）方法。向Direct3D 表示，我们的绘制完成了。所以这一步也就是这样写：

//其中g_pd3dDevice表示我们创建的有效的Direct3D 绘制”金钥匙”一Direct3D 设备对象
g_pd3dDevice->EndScene () ; // 结束绘制

11.9.6 五步曲之五：翻转显示

只是绘制完成了还不够， 如果不进行翻转显示操作， 我们是看不到绘制的结果的。因为我们绘制的内容是在幕后完成的， 我们需要把幕后的内容翻转到前台， 就要用到我们在上文讲交换链时候提到的那个非常重要的函数Present（）， 我们来看一下这个函数在Direct3D SDK 中的原型：

HRESULT Present(
[in]  const RECT *pSourceRect,
[in]  const RECT *pDestRect,
[in]  HWND hDestWindowOverride,
[in]  const RGNDATA *pDirtyRegion
);

接着我们看一下这个主持着交换链的Present 方法的具体参数构成：

 第一个参数， const RECT 类型的*pSourceRect ， 表示指向复制源矩形区域的指针。显然一般我们都将其设为NULL。

 第二个参数， const RECT 类型的*pDestRect ， 表示指向复制目标矩形区域的指针。显然一般我们也将其设为NULL。 

 第三个参数， HWND 类型的hDestWindowOverride ， 表示指向当前绘制的窗口句柄。如果我们设为0 或NULL 就表示取我们之前初始化四步曲里面第三步填充的D3DPRESENT_PARAMETERS 结构体中的hDeviceWindows 的值。显然一般我们依然将其设NULL 

 第四个参数， const RGNDATA 类型的*pDirtyRegion ， 表示指向最小更新区域的指针。显然一般我们依然将其设为NULL 。

g_pd3dDevice->Present(NULL, NULL, NULL, NULL); // 翻转与显示

11.9.7 Direct3D 渲染五步曲代码整体赏析

学完上面五部分的内容，我们可以发现Direct3D 渲染五步曲其实非常地简单，只要记住20 个字就可以了：清屏操作，开始绘制，正式绘制，结束绘制，翻转显示。

具体实现代码也非常简单（先忽略掉正式绘制实现代码），有点起承转合的味道，但基本上千篇一律，也就是：

g_pd3dDevice->Clear(O , NULL , D3DCLEAR_TARGET , D3DCOLOR XRGB(O , 0, 0) , l.Of, 0); // 五步曲之一，清屏操作
g_pd3dDevice->BeginScene (); // 五步曲之二， 开始绘制
／*五步曲之三，正式绘制；一千个人眼中有一千个哈姆雷特，在这里按喜好填入相关代码，进行正式绘制操作*／
g_pd3dDevice->EndScene (); // 五步曲之四，结束绘制
g_pd3dDevice- >Present (NULL, NULL , NULL, NULL) ; // 五步曲之五， 翻转与显示

在后面我们学习熟练了就会发现，很多时候， 一、二、四、五这四步的代码基本上不用变，因为它们其实就是Direct3D 中绘制过程约定俗成的套路，我们只是简单地遵守这个套路，要得出不同的绘制图形，可以把第三步正式绘制的代码改改就好了。

11.9.8 示例程序D3Ddemo2

1 . 获取每秒帧数（ FPS ）函数的写法

看到FPS ，大家可能就激动了，这里的FPS 可不是游戏里的第一人称射击类游戏FPS( First-Person Shooter Game ） ，如穿越火线CF 、反恐精英cs 、使命召唤Call of the Duty 等等游戏的简称，而是Frame Per Second ，每秒帧速率。

为了之后我们的Direct3D 程序能更清晰地在运行时实时看到帧率， 来评估我们的程序的绘制效率，这里我们来手动写一个测帧率的函数Get_FPS（）函数。为了达到显示帧速率的效果，在D3Ddemol 的基础上， 主要有三处地方需要添加实现代码。

( I ）添加两个全局变量

首先我们定义两个全局变量：

float	 g_FPS = 0.0f;       //一个浮点型的变量，代表帧速率
wchar_t	 g_strFPS[50];    //包含帧速率的字符数组

( 2) Get_ FPS （）函数的具体实现

我们先看一下实现的代码：

//-----------------------------------【Get_FPS( )函数】------------------------------------------
//	描述：用于计算每秒帧速率的一个函数
//--------------------------------------------------------------------------------------------------
float Get_FPS()
{
//定义四个静态变量
static float  fps = 0; //我们需要计算的FPS值
static int     frameCount = 0;//帧数
static float  currentTime =0.0f;//当前时间
static float  lastTime = 0.0f;//持续时间

frameCount++;//每调用一次Get_FPS()函数，帧数自增1
currentTime = timeGetTime()*0.001f;//获取系统时间，其中timeGetTime函数返回的是以毫秒为单位的系统时间，所以需要乘以0.001，得到单位为秒的时间

//如果当前时间减去持续时间大于了1秒钟，就进行一次FPS的计算和持续时间的更新，并将帧数值清零
if(currentTime - lastTime > 1.0f) //将时间控制在1秒钟
{
fps = (float)frameCount /(currentTime - lastTime);//计算这1秒钟的FPS值
lastTime = currentTime; //将当前时间currentTime赋给持续时间lastTime，作为下一秒的基准时间
frameCount    = 0;//将本次帧数frameCount值清零
}

return fps;
}

静态变量的性质复习。静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的。静态变量都在全局数据区分配内存。
(3 ）在Direct3D_ Render（）函数中调用Get_FPS（）函数并进行文本的显示

//在窗口右上角处，显示每秒帧数
int charCount = swprintf_s(g_strFPS, 20, _T("FPS:%0.3f"), Get_FPS() );
g_pFont->DrawText(NULL, g_strFPS, charCount , &formatRect, DT_TOP | DT_RIGHT, D3DCOLOR_XRGB(255,39,136));

其中swprintf_s 函数的第二个参数中的0.3 表示保留3 位有效数字。

这样在Direct3D_ Render（）函数每秒钟成千上万次地被调用的过程中，也就让Get_FPS（）被成千上万次调用，也让这段显示FPS 的文字也成千上万次被调用了。

2 例程的新增代码分析

这次的渲染五步曲例程代码中，我们首先是新包含了2 个头文件：

#include <d3dx9.h>
#include <tchar.h>

这里的d3dx9.h 表示D3DX 库的头文件。这个D3DX 库提供了一些函数、类和接口，极大地简化了3 D 图形相关的运行，例如数学运算、纹理和图像运算、网格运算等等。以D3DX 开头的众多函数都是来自这个D3DX 库，比如我们这里要用到的字体创建函数D3DXCreateFont ，比如以后我们读取并创建纹理时经常用到的D3DXCreateTextureFile 。

然后tchar.h 大家应该就很熟悉了，调用swprintf_s 函数所需的头文件。
接着我们用代码手动添加了D3DX 库文件，来让我们的Direct3D 程序对运行环境的要求降低，避免“未解析的外部命令”系列错误。

#pragma comment(lib,"d3dx9.lib")

然后就是核心代码的书写了：

//-----------------------------------【全局变量声明部分】-------------------------------------
//	描述：全局变量的声明
//------------------------------------------------------------------------------------------------
LPDIRECT3DDEVICE9       g_pd3dDevice = NULL; //Direct3D设备对象
ID3DXFont*		g_pFont=NULL;    //字体COM接口
float			g_FPS = 0.0f;       //一个浮点型的变量，代表帧速率
wchar_t			g_strFPS[50];    //包含帧速率的字符数组

//-----------------------------------【Object_Init( )函数】--------------------------------------
//	描述：渲染资源初始化函数，在此函数中进行要被渲染的物体的资源的初始化
//--------------------------------------------------------------------------------------------------
HRESULT Objects_Init(HWND hwnd)
{
//创建字体
if(FAILED(D3DXCreateFont(g_pd3dDevice, 36, 0, 0, 1, false, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, 0, _T("微软雅黑"), &g_pFont)))
return E_FAIL;
srand(timeGetTime());      //用系统时间初始化随机种子
return S_OK;
}

//-----------------------------------【Direct3D_Render( )函数】-------------------------------
//	描述：使用Direct3D进行渲染
//--------------------------------------------------------------------------------------------------
void Direct3D_Render(HWND hwnd)
{
//--------------------------------------------------------------------------------------
// 【Direct3D渲染五步曲之一】：清屏操作
//--------------------------------------------------------------------------------------
g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);

//定义一个矩形，用于获取主窗口矩形
RECT formatRect;
GetClientRect(hwnd, &formatRect);

//--------------------------------------------------------------------------------------
// 【Direct3D渲染五步曲之二】：开始绘制
//--------------------------------------------------------------------------------------
g_pd3dDevice->BeginScene();                     // 开始绘制
//--------------------------------------------------------------------------------------
// 【Direct3D渲染五步曲之三】：正式绘制，在这里我们写了四段文字
//--------------------------------------------------------------------------------------
//在窗口右上角处，显示每秒帧数
int charCount = swprintf_s(g_strFPS, 20, _T("FPS:%0.3f"), Get_FPS() );
g_pFont->DrawText(NULL, g_strFPS, charCount , &formatRect, DT_TOP | DT_RIGHT, D3DCOLOR_XRGB(255,39,136));

//在纵坐标100处，写第一段文字
formatRect.top = 100;//指定文字的纵坐标
g_pFont->DrawText(0, _T("【致我们永不熄灭的游戏开发梦想】"), -1, &formatRect, DT_CENTER,
D3DCOLOR_XRGB(68,139,256));

//在纵坐标250处，写第二段文字
formatRect.top = 250;
g_pFont->DrawText(0, _T("游戏开发的世界，我们来降服你了~！"), -1, &formatRect,
DT_CENTER, D3DCOLOR_XRGB(255,255,255));

//在纵坐标400处，写第三段文字
formatRect.top = 400;
g_pFont->DrawText(0, _T("闪闪惹人爱"), -1, &formatRect, DT_CENTER,
D3DCOLOR_XRGB(rand() % 256, rand() % 256, rand() % 256));//采用随机RGB值，做出“闪闪惹人爱”的特效

//--------------------------------------------------------------------------------------
// 【Direct3D渲染五步曲之四】：结束绘制
//--------------------------------------------------------------------------------------
g_pd3dDevice->EndScene();                       // 结束绘制
//--------------------------------------------------------------------------------------
// 【Direct3D渲染五步曲之五】：显示翻转
//--------------------------------------------------------------------------------------
g_pd3dDevice->Present(NULL, NULL, NULL, NULL);  // 翻转与显示
}

//-----------------------------------【Get_FPS( )函数】------------------------------------------
//	描述：用于计算每秒帧速率的一个函数
//--------------------------------------------------------------------------------------------------
float Get_FPS()
{
//定义四个静态变量
static float  fps = 0; //我们需要计算的FPS值
static int     frameCount = 0;//帧数
static float  currentTime =0.0f;//当前时间
static float  lastTime = 0.0f;//持续时间

frameCount++;//每调用一次Get_FPS()函数，帧数自增1
currentTime = timeGetTime()*0.001f;//获取系统时间，其中timeGetTime函数返回的是以毫秒为单位的系统时间，所以需要乘以0.001，得到单位为秒的时间

//如果当前时间减去持续时间大于了1秒钟，就进行一次FPS的计算和持续时间的更新，并将帧数值清零
if(currentTime - lastTime > 1.0f) //将时间控制在1秒钟
{
fps = (float)frameCount /(currentTime - lastTime);//计算这1秒钟的FPS值
lastTime = currentTime; //将当前时间currentTime赋给持续时间lastTime，作为下一秒的基准时间
frameCount    = 0;//将本次帧数frameCount值清零
}

return fps;
}

//-----------------------------------【Direct3D_CleanUp( )函数】--------------------------------
//	描述：资源清理函数，在此函数中进行程序退出前资源的清理工作
//---------------------------------------------------------------------------------------------------
void Direct3D_CleanUp()
{
//释放COM接口对象
SAFE_RELEASE(g_pFont)
SAFE_RELEASE(g_pd3dDevice)
}

我们在Objects_lnit 函数中初始化了字体，并用系统时间初始化随机种子。在Direct3D_ Render()函数中进行了渲染五步曲代码的书写，且最关键的第三步我们用一系列的DrawText，在屏幕中绘制了几段文字以及在右上角绘制出了帧数FPS 的值。最后我们在Direct3D_ Clean Up 方法中， 用我们自定义的SAFE_RELEASE 方法释放了g_pFont 和g_pd3dDevice这两个COM 接口。

另外，大家也许会纳闷＿T（”【致我们永不熄灭的游戏开发梦想】”）这句中＿T（””）的用法，这里我们也来做一下解释。

我们通过对_T 进行【转到定义F12） 】，可以发现tchar.h 中有如下的宏定义。

#define _T(x)       __T(x)
#define _TEXT(x)    __T(x)

即＿T(x）、__T(x）、___T(x）这三者等价（注意下划线的长度）。而这三种＿T 宏可以把一个引号引起来的字符串根据我们的编译环境设置的字符集方式（Unicode 还是ANSI) ，智能进行选择。

比如我们工程的字符集使用的是Unicode ，那么T 宏会智能地把字符串前面加一个L。
这时_T（”【致我们永不熄灭的游戏开发梦想】”）相当于L” 【致我们永不熄灭的游戏开发梦想】”，这是宽字符串。

而如果我们工程的字符集使用的是多字节字符集的话，那么T 宏便不会在字符串前面加那个L ，
这时候_T（“【致我们永不熄灭的游戏开发梦想】”）相当于“【致我们永不熄灭的游戏开发梦想】”。

我们在写字符串常量时加上这个宏，工程可以方便地在Unicode 字符集和多字节字符集之间进行转换。

最后看一下程序的运行截图：

11.10 章节小憩

嗯， 在掌握Direct3D 的道路上我们已经迈出了最坚实的一步了， 三维游戏世界的大门已经缓缓开启，你准备好继续了吗？