用Direct3D实现三维漫游

用Direct3D实现三维漫游

成都理工学院 17# 岳朝伟

朋友，喜欢玩游戏吗？自从计算机诞生以来，人们对计算机游戏就充满了热情，以前对字符型的游戏就乐此不疲，随着时代的发展，人们的要求也越来越高，三维实时游戏和多媒体应用已经成为人们追求的热点。

而Microsoft公司推出的DirectX正是这样一个热点的集合。如果你想抓住时代的潮流，并喜欢迎接挑战的话，本文将是一个很好的去处。同时，本人将以此文讲述用Direct3D保留模式的各种编程技巧和应用，而对于有关基本的DirectX的介绍，请参阅相关的文章。

程序调试环境：Win98、Visual C++6.0，它们都内嵌了DirectX 5.0，同时，为了大家调试的方便和确保程序正常运行，我们将使用最低级的DirectX驱动程序。

一、Direct3DRM中的基本概念

1.0、Direct3D简介

Direct3D是Microsoft公司推出的DirectX的一部分，它又包括立即模式(Direct3DIM)和保留模式(Direct3DRM)。同时，即使是一个最基本的Direct3D例程也必须包含DirectDraw 对象，它们是紧密的结合在一起的，因此，你在编写Direct3D应用程序之前还应先对DirectDraw有一定的认识！Direct3D立即模式是一种较低级的三维模式，因而牵涉到各种复杂的三维图形学的知识，而保留模式是建立在一系列的类调用的基础之上，其中大量的底层操作和运算都被封装在这些类当中，因此适合快速的创建一个三维环境并希望能实时的操作它。本程序就是利用它建立了一个可以用方向键控制的三维漫游程序！

2.0、Direct3DRM中有关图形学的基本内容介绍

Direct3DRM中牵涉到很多三维图形学的东西，这里本人对程序当中将要涉及到的最重要的部分作一简单介绍，让大家对Direct3DRM尽快的有一个感性的认识。

照相机（camera）场景（scene）视点（viewport）框架（frame）的概念及它们之间的关系：（这些概念与一些三维图形软件中的概念相当一致，如3DS ,因此你要是有这方面软件、的使用经验的话，你会更容易的理解这些概念）

框架（frame）：它是将各种三维网格托住的支架，同时，它还将灯光，照相机，物体等都虚拟成现实世界中的东西，它们都需要放在某一特定的物理框架上才能被托住，不至于落下来。各个框架之间的关系也非常符合现实世界中的各物体的位置关系，即要想被看见，则它必须在照相机框架的前面，同理，物体要想被灯光照着也必须在灯光框架的前方。各个框架之间可以形成一个树结构，多个框架组合在一起就形成了场景。

场景（scene）：是一个根框架，场景中的所有其它框架都应建立在它的基础之上，它是所有其它框架的父框架，而它没有父框架，且一个视点只能有一个场景。

照相机：它是建立在视点当中的用于可视的框架，在现实世界中可以将它想象成人的眼睛。同时，可以任意设置场景中的任一框架为照相机，方法有两种，一种是在创建Viewport 时直接给定某一框架为Camera，二是用Viewport对象提供的SetCamera()设置，因此，当你需要改变不同的视角时就可以用SetCamera()来调整观察的相对视角，但在适时漫游当中无需这样做，用第一种方法就足够了。

视点：它是用于决定在场景中的什么位置可以看到物体，这里的物体实质上已经变成了框架，而框架当中往往又包含了某一可见的网格。而视点实质上是一个二维矩形区域，且只有沿X,Y的正方向上可见的区域才能被渲染，且所有可见的物体被着色时都将自动变换成照相机坐标，这一点与人眼的作用相对应。

某一框架（在场景当中，且能被Viewport所见）

框架当中的网格

Viewport（视点），Camera附属于Viewport，通过Camera

的坐标调整即实现三维漫游同时场景也是相对于

Viewport重合的（实质上比Viewport

大）

3.0、回调函数

下面介绍一下Direct3DRM当中经常用到的一类函数----回调函数（CallBackfunction），这种函数必须深入理解才能明白Direct3DRM当中的各个调用过程，以后才能自如的添加你自己的代码。回调函数的特殊性：

●回调函数的创建不是任意的，都应遵循某一特定的结构和参数列表，且必须以这样

的参数形式才能被其它函数正确调用。

●回调函数的调用是附属于某一特定的函数，而不能单独使用，且还不能通过跟踪父

函数来达到跟踪回调函数的目的，而这样做只能导致回调函数已经执行了。因此为

了调试或检验回调函数体的代码，必须采用调试窗口当中的Run to Cursor的方法

来调试，这样才能让调试器跟踪进入回调函数体。

●回调函数的深入理解：（只针对设备的查找用到的回调函数），因它是一种自动查找

函数，故在其父函数找到某一特定的设备或驱动程序后它就会自动调用给定的回调

函数，这样就形成一个循环，：父函数查找设备—回调函数检验设备—回调函

数返回—再由父函数查找。其中当回调函数返回D3DENUMRET_OK则让父函

数继续查找形成循环，返回D3DENUMRET_CANCEL则停止查找父函数结束。

●其它形式的回调函数：最常用于Direct3DRM当中的是Movecallback function()，它

于设备查找回调函数的明显区别在于设备查找回调函数只跟随父函数执行一次，而

Movecallback()会在接口IDirect3DRMViewport:::Move()调用的美一次都要执行各

个框架的Movecallback()，这样可以统一管理各个框架的动作，且一个回调函数可

以应用于多个框架，同时，它在Direct3DRM当中对动画的应用起着相当重要的作

用，即在插值动画与一般的动画当中都必须使用回调函数来逐帧的渲染你设定的每

一个动作。

小结：这里讲述的回调函数只能让你有一个感性的认识，具体认识到具体的程序当中才能体会。接下来我们将进入代码的添加阶段，并给出详细的注释，你可得仔细看好了。

4.0、窗口框架的生成

我们将利用MFC和DirectX SDK进行建造，这样做的好处是可以结合了它们各自的优点。同时，大多数的Win32例子均采用SDK编写—晦涩难懂，但代码高效，而MFC却一目了然。还有我们为了调试的方便，将建立窗口形式的Direct3D应用程序。这里我们将借助MFC提供的对话框模板加以改进就能实现MFC和DirectX SDK的无缝联接。具体表现为在对话框

类中的InitInstance()中将自己创建的窗口类变为主窗口，则以后对系统的操作将完全转化为对这个自定义窗口的操作，也就任由你摆布了。具体代码添加过程如下。

初始化基本窗口类模板步骤：

●首先启动VC++6.0，从File下选择New，选择Project下MFCAPPWizard（exe），

命名为D3Dtest，除向导第二项全部不选外，接受其它所有缺省值。

●去掉对话框资源，在FileView处去掉D3DtestDlg.cpp和D3DtestDlg.h。在

ResourceView处去掉Dialog栏。

●打开主菜单下Insert，从NewClass下Name栏输入d3dwnd在Base Class栏选

generic CWnd 作为基类。OK

●打开d3dwnd.cpp文件，在View主菜单下选ClassVizard，class name选d3dwnd

类，Message分别双击选WM_PAINT、WM_DESTROY、WM_MOVE、WM_SIZE、

WM_KEYDOWN默认消息处理函数名，OK。

●打开d3dwnd.cpp创建自定义函数(具体方法是在ClassView列表中d3dwnd处单击

右键选add Member Function)名为：

void SetFreshRegion(HWND win);// 窗口更新

void ShowInfo(); // 将渲染结果放到前台

HRESULT D3DGetSurfDesc(LPDDSURFACEDESC lpDDSurfDesc,

LPDIRECTDRAWSURFACE lpDDSurf);

void ClearBuffer(LPDIRECTDRAWSURFACE lpbuffer);// 初始化面对象

BOOL Createfaces(int w,int h); // 创建面对象

void CleanUp();// 释放各个对象

BOOL MyScene();// 初始化场景内容

BOOL CreateDevAndView(LPDIRECTDRAWCLIPPER lpclipper,

int driver, int width, int height);

BOOL EnumDrivers();// 查询驱动设备

BOOL RenderLoop();// 着色循环

BOOL InitD3D(HWND win);// 初始化D3DRM

BOOL Create3DWnd();// 创建3D窗口

●打开D3Dtest.cpp文件，在View主菜单下选ClassVizard，class name选CD3DtestApp

类Message栏分别双击InitInstance、ExitInstance、OnIdle然后OK即可。这里重载这些函数是进行渲染的需要。

以上建立了基本类模板和主窗口的基本消息处理函数，下面是在各个文件中添加的代码：

为了能够正确的编译并连接，我们将作如下的准备：

工程项目设置：在Project主菜单下选Settings，在link栏的object/library modules处加入如下的.lib文件才能保证程序的正确连接：dinput.lib ddraw.lib d3dxof.lib d3drm.lib dxguid.lib winmm.lib

网格准备：这里用DirectX SDK提供的sphere3.x和triplane.x

图片准备：背景用DirectX SDK提供的lake.bmp,球体帖图用它提供的tutor.bmp（长宽均满足2的整数次幂）

●首先创建一个名为D3Daid.h的头文件，并加入当前工程当中。这个文件主要记录程序

当中用到的各种自定义结构，这里为了方便将它们综合在一个文件当中。添加代码如下：

struct Aid_Value

{

CRect client_rect;//自己建立的窗口客户矩形区域

POINT startpoint;//窗口客户区的起点(相对整个屏幕)

LPDIRECT3DRMDEVICE dev;//D3D保留模式设备对象指针

LPDIRECTDRAW lpddraw;//DDraw对象指针

LPDIRECTDRAWSURFACE lpprimary;//主面对象(大小为800X600)

LPDIRECTDRAWSURFACE lpback;//后台面对象(大小与窗口一样)

LPDIRECT3DRMVIEWPORT view;//保留模式视点对象指针

LPDIRECT3DRMFRAME scene;//场景框架

LPDIRECT3DRMFRAME camera;//照相机框架

GUID DriverGUID[5];//可能找到的全局统一标识符结构

char DriverName[5][50];//可能找到的三维驱动设备名称

D3DV ALUE dx,dy,dz;//照相机的漫游坐标

D3DV ALUE Rotate_rad;//旋转弧度

int NumDrivers;//可能找到的驱动设备数目

int CurrDriver;//当前使用的驱动设备

BOOL bRotate;//旋转标志(在三维漫游当中使用)

BOOL bMove;//移动标志(通上)

BOOL bQuit;//程序结束标志

BOOL bInitialized;//程序被初始化标志

BOOL bMinimized;//程序最小化标志

int BPP;//当前系统使用的颜色位数

};

●打开D3Dtest.h添加代码如下：

#include "d3dwnd.h"

class CD3DtestApp : public CWinApp

{

public:

d3dwnd * p3Dwnd;//自定义的窗口对象指针

int failcount;//渲染失败数目

}；

●打开d3dwnd.h添加代码如下：

#define INITGUID//预定义COM构件的全局统一标识符

#include "d3drmwin.h"//D3D保留模式

#include "D3Daid.h"//自定义结构

●打开D3Dtest.cpp添加代码如下：这里不用系统产生的InitInstance()函数

BOOL CD3DtestApp::InitInstance()

{

p3Dwnd=new d3dwnd;//分配空间

p3Dwnd->Create3DWnd();//创建窗口并初始化D3DRM

m_pMainWnd=p3Dwnd;//让自定义窗口设为当前线程的主窗口

m_pMainWnd->ShowWindow(SW_SHOW);//显示窗口

m_pMainWnd->UpdateWindow();//更新窗口

failcount=0;//初始化渲染失败次数

return TRUE;

}

BOOL CD3DtestApp::OnIdle(LONG lCount)

{

// TODO: Add your specialized code here and/or call the base class

i f(!p3Dwnd->RenderLoop())//当没有消息处理时就进行渲染

++failcount;

i f(failcount>2)

p3Dwnd->CleanUp();//如果失败三次则退出程序

r eturn TRUE;// 这里不执行系统的空闲函数CWinApp::OnIdle(lCount);

}

int CD3DtestApp::ExitInstance()

{

// TODO: Add your specialized code here and/or call the base class

d elet

e p3Dwnd;//退出程序时去掉窗口指针

r eturn CWinApp::ExitInstance();

}

●打开d3dwnd.cpp添加代码如下：

#include "math.h"

#define MAX_DRIVERS 5//最大驱动器数目

#define PI2 6.28318f//圆周

#define Rotate_step PI2/100.0f//旋转步长

#define Move_step 0.5f//移动步长

#define SAFE_RELEASE(x) if (x != NULL) {x->Release(); x = NULL;}

#define MSG(str) MessageBox(str, "Application Message", MB_OK )

//预定义两个常用的宏

HWND hwnd=NULL;//初始化主窗口句柄

LPDIRECT3DRM lpD3DRM=NULL;//初始化D3D保留模式对象指针

LPDIRECTDRAWCLIPPER lpDDClipper=NULL;//初始化裁剪对象指针Aid_Value myvalue;//自定义结构对象

DWORD BppToDDbd(int bpp)//进行颜色位数匹配

{

switch(bpp)

{

case 1:

return DDBD_1;

case 2:

return DDBD_1;

case 4:

return DDBD_4;

case 8:

return DDBD_8;

case 16:

return DDBD_16;

case 24:

return DDBD_24;

case 32:

return DDBD_32;

default:

return 0;

}

}

//设备查找回调函数

//回调函数将找到的一个匹配的设备驱动器后，进行填充并退出设备查找//匹配准则是：与当前的系统的颜色位数一致，一般都使用硬件抽象层HRESULT WINAPI enumDeviceFunc(GUID* lpGuid,

LPSTR lpDeviceDescription,LPSTR lpDeviceName,

LPD3DDEVICEDESC lpHWDesc,LPD3DDEVICEDESC lpHELDesc,

LPVOID lpContext)

{

LPD3DDEVICEDESC lpdesc;//D3D设备描述结构

int *lpStartDriver=(int *)lpContext;

lpdesc=lpHWDesc->dcmColorModel?lpHWDesc:lpHELDesc;

if(!lpdesc->dwDeviceRenderBitDepth&BppToDDbd(myvalue.BPP))

return D3DENUMRET_OK;

memcpy(&myvalue.DriverGUID[myvalue.NumDrivers],lpGuid,sizeof(GUID)); lstrcpy(&myvalue.DriverName[myvalue.NumDrivers][0],lpDeviceName);

if(lpdesc==lpHWDesc&&lpdesc->dcmColorModel!=D3DCOLOR_MONO) *lpStartDriver=myvalue.NumDrivers ;

myvalue.NumDrivers++;

if(myvalue.NumDrivers==5)

return (D3DENUMRET_CANCEL);

return D3DENUMRET_OK;

void UserControl(LPDIRECT3DRMFRAME frame, void* arg, D3DV ALUE delta) {

LPDIRECT3DRMFRAME scene;

frame->GetScene(&scene);

if(myvalue.bMove)

{

frame->AddTranslation(D3DRMCOMBINE_AFTER,

myvalue.dx,myvalue.dy,myvalue.dz);

frame->SetPosition(scene,myvalue.dx,myvalue.dy,myvalue.dz);

myvalue.bMove = FALSE;

}

if(myvalue.bRotate)

{

frame->AddRotation(D3DRMCOMBINE_REPLACE,

0,1,0,myvalue.Rotate_rad);

frame->SetPosition(scene,myvalue.dx,myvalue.dy,myvalue.dz);

myvalue.bRotate = FALSE;

}

SAFE_RELEASE(scene);

}

//以上是全局函数和变量的声名，应把它们放在d3dwnd::d3dwnd()构造函数之前//以下是自定义函数的实体和各个消息响应函数

//创建窗口并初始化D3D的各种对象

BOOL d3dwnd::Create3DWnd()

{

LPCTSTR m_name=AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW, AfxGetApp()->LoadCursor(IDC_ARROW),//光标

(HBRUSH)GetStockObject(BLACK_BRUSH),//窗口背景

AfxGetApp()->LoadIcon(IDR_MAINFRAME)//图标

);//窗口注册

BOOL bret = CreateEx(WS_EX_APPWINDOW,m_name,"Direct3DRM Example", WS_VISIBLE|WS_OVERLAPPEDWINDOW,//定义窗口属性

CW_USEDEFAULT,CW_USEDEFAULT,400,400,//窗口大小和起始位置

NULL,NULL,NULL);//创建窗口

if(!bret)

return FALSE;

hwnd=GetSafeHwnd();

if(!InitD3D(hwnd))//初始化D3D

{

MSG("InitDirect3D Failed!");

OnDestroy();

return FALSE;

return TRUE;

}

BOOL d3dwnd::InitD3D(HWND win)

{

LPDIRECT3DRMTEXTURE lptex=NULL;//背景文理帖图

//注意：D3D中的文理帖图的长宽都必须是2的整数次幂

HDC hdc;

ZeroMemory(&myvalue,sizeof(myvalue));//初始化自定义结构对象

hdc=::GetDC(win);//取得当前窗口的设备句柄

myvalue.BPP=::GetDeviceCaps(hdc,BITSPIXEL);//取得系统的当前颜色位数

::ReleaseDC(win,hdc);

SetFreshRegion(win);//更新窗口位置

if(!EnumDrivers())//查找匹配的驱动设备

return FALSE;

myvalue.lpddraw->SetCooperativeLevel(win,DDSCL_NORMAL);

//设置协作等级(这里是窗口协作等级)

if(!Createfaces(myvalue.client_rect.Width(),myvalue.client_rect.Height()))

return FALSE; //根据窗口的大小来建立各种要用到的面对象

::Direct3DRMCreate(&lpD3DRM);//创建D3D保留模式对象

lpD3DRM->CreateFrame(NULL,&myvalue.scene );//创建场景根框架

lpD3DRM->CreateFrame(myvalue.scene,&myvalue.camera);//创建场景中照相机框架if(myvalue.scene->SetOrientation(NULL,D3DV AL(0.0),D3DV AL(0.0),D3DV AL(1.0), D3DV AL(0.0),D3DV AL(-1.0),D3DV AL(0.0))!=D3DRM_OK)

//设置场景的方向(默认的方向)

return FALSE;

lpD3DRM->LoadTexture("lake.bmp",&lptex);//创建背景纹理帖图

myvalue.scene->SetSceneBackgroundImage(lptex);//设置背景帖图

/*myvalue.scene->SetSceneBackgroundRGB(0.5f,0.6f,0.7f);

//背景用一纯色

*/

//根据窗口的大小创建渲染设备和渲染视点

if(!CreateDevAndView(lpDDClipper,myvalue.CurrDriver,

myvalue.client_rect.right,myvalue.client_rect.bottom))

return FALSE;

if(!MyScene())//创建好场景中使用的各种物体和帖图

return FALSE;

myvalue.bInitialized=TRUE;//D3DRM被初始化

SAFE_RELEASE(lptex);//去掉临时对象

return TRUE;

}

BOOL d3dwnd::RenderLoop()

{

if(myvalue.bMinimized||!myvalue.bInitialized)

return TRUE;

//Frame的move()函数使场景中所有与场景框架有层次关系的子框架以一定的速度轮流改变

//它们轮流改变的速度由函数的参数决定，此处为0.25

//并且这些子框架改变的依据是同这些子框架自身的运动状态联系在一起的。

//也就是说，各个子框架都可以具有自身独立的运动，而这些运动将在Move()作用后体现出来

//可见这个Move()函数的作用实在是太大了。并且它还能给你很多的启示!!!!!

if(myvalue.scene->Move(D3DV AL(0.25))!=D3DRM_OK)

return FALSE;

if(myvalue.view->Clear()!=D3DRM_OK)

return FALSE;

//这里渲染的场景将包括属于它的各个子框架也会被渲染

//并且这些框架被渲染后并不会立即被放到显示设备上显示出来，

//而这一步是分配给显示设备处理的

if(myvalue.view->Render(myvalue.scene)!=D3DRM_OK)

return FALSE;

if(myvalue.dev->Update()!=D3DRM_OK)

return FALSE;

//注意：这里的对场景的渲染、更新都是在后台面对象上进行，这是由于

//我们在创建渲染设备时所决定的，请仔细看渲染设备的创建代码就会清楚

//而我们的最终目的是在主面对象上显示，故用到下面的自定义函数

ShowInfo();

return TRUE;

}

BOOL d3dwnd::EnumDrivers()

{

HRESULT rval;

LPDIRECT3D lpd3d;

::DirectDrawCreate(NULL,&myvalue.lpddraw ,NULL);//创建DDraw对象

rval=myvalue.lpddraw->QueryInterface(IID_IDirect3D,(void**)&lpd3d);

//查询并创建D3D即时模式对象(因D3DRM当中没有定义驱动设备查找函数)

if(rval!=DD_OK)

{

myvalue.lpddraw->Release();

return FALSE;

}

myvalue.CurrDriver =-1;

lpd3d->EnumDevices(enumDeviceFunc,&myvalue.CurrDriver);//驱动设备查找

if(myvalue.NumDrivers ==0)

return FALSE;

lpd3d->Release();

return TRUE;

}

BOOL d3dwnd::CreateDevAndView(LPDIRECTDRAWCLIPPER lpclipper, int driver, int width, int height)

{

HRESULT rval;

rval=lpD3DRM->CreateDeviceFromSurface(&myvalue.DriverGUID[driver],

myvalue.lpddraw,myvalue.lpback,&myvalue.dev);

//用后台面对象创建渲染设备，这样可以方便的向前台面对象写入信息而不会

//发生闪烁的现象

width=myvalue.dev->GetWidth();

height=myvalue.dev->GetHeight();

//取得设备的高宽，当设备未创建成功程序会在这里崩溃

rval=lpD3DRM->CreateViewport(myvalue.dev,myvalue.camera,

0,0,width,height,&myvalue.view);//创建场景中的视点对象if(rval!=D3DRM_OK)

{

myvalue.dev->Release();

return FALSE;

}

//myvalue.view->SetField(0.5f );

//The screen Clip area is a rect(-0.5,-0.5)---(0.5,0.5);

//屏幕尺寸是(-0.5,-0.5)---(0.5,0.5),这是个系统默认值。

//可由SetField()调整

rval=myvalue.view->SetBack(D3DV AL(1000.0));

//设置可见的camera锥体区域,一般front默认为距离camera为1个单位

//并且只有在front和back之间的锥体区域才能被viewport渲染

if(rval!=D3DRM_OK)

{

myvalue.dev->Release();

myvalue.view->Release();

return FALSE;

}

//设置设备的渲染质量

rval=myvalue.dev->SetBufferCount(1);

rval=myvalue.dev->SetQuality(D3DRMLIGHT_ON|D3DRMFILL_SOLID|D3DRMSHAD E_GOURAUD );

if(rval!=D3DRM_OK)

return FALSE;

return TRUE;

}

BOOL d3dwnd::MyScene()

{

LPDIRECT3DRMFRAME lplightframe1=NULL;//灯光框架

LPDIRECT3DRMFRAME lpsphere3_frame=NULL;//球体框架

LPDIRECT3DRMFRAME lpplane_frame=NULL;//飞机框架

LPDIRECT3DRMLIGHT lplight1=NULL;//灯光对象

LPDIRECT3DRMLIGHT lplight2=NULL;

LPDIRECT3DRMTEXTURE lptex=NULL;//用于球体的帖图

LPDIRECT3DRMWRAP lpwrap =NULL;//用于计算球体的帖图坐标对象

LPDIRECT3DRMMESHBUILDER lpsphere3_builder=NULL;//球体网格

lpD3DRM->CreateFrame(myvalue.scene,&lplightframe1);//创建灯光框架

lpD3DRM->CreateFrame(myvalue.scene,&lpsphere3_frame);//创建球体框架

lpD3DRM->CreateFrame(myvalue.scene,&lpplane_frame);

lpD3DRM->CreateLightRGB(D3DRMLIGHT_POINT,D3DV AL(0.8),

D3DV AL(0.8),D3DV AL(0.8),&lplight1);//创建点光源

lplightframe1->AddLight(lplight1);//将灯对象加入灯光框架

lpD3DRM->CreateLightRGB(D3DRMLIGHT_AMBIENT,D3DV AL(0.5),

D3DV AL(0.5),D3DV AL(0.5),&lplight2);//创建大气灯光

//因环境光是只属于场景的故它不需要另外设置框架,直接将其加入场景即可

myvalue.scene->AddLight(lplight2);

//设置灯光、照相机、飞机和球体框架的位置

lplightframe1->SetPosition(myvalue.scene,0.0f,0.0f,1.0f);

myvalue.camera->SetPosition(myvalue.scene,0.0f,0.0f,0.0f ) ;

lpsphere3_frame->SetPosition(myvalue.scene,0.0f,0.0f,20.0f);

lpplane_frame->SetPosition(myvalue.scene, 0.0f,1.0f,12.0f);

//飞机框架直接从文件中调用

lpplane_frame->Load("triplane.x",NULL,D3DRMLOAD_FROMFILE,NULL,NULL);

lpsphere3_frame->SetOrientation(myvalue.scene,D3DV AL(0.0),D3DV AL(0.0),D3DV AL(1.0 ),

D3DV AL(0.0),D3DV AL(1.0),D3DV AL(0.0));

//为球体框架赋一旋转动画

lpsphere3_frame->SetRotation(myvalue.scene,D3DV AL(0.0),D3DV AL(0.1),

D3DV AL(0.0),D3DV AL(0.05));

lpD3DRM->CreateMeshBuilder(&lpsphere3_builder);

lpsphere3_builder->Load("sphere3.x",NULL,D3DRMLOAD_FROMFILE,NULL,NULL);

lpsphere3_builder->Scale(D3DV AL(2),D3DV AL(2),D3DV AL(2));//放大2倍

lpsphere3_builder->SetColorRGB(D3DV AL(1),D3DV AL(1),D3DV AL(1));

D3DV ALUE miny,maxy,height;

D3DRMBOX box;

lpsphere3_builder->GetBox(&box);

maxy=box.max.y;

miny=box.min.y;

height=maxy-miny;

lpD3DRM->CreateWrap(D3DRMWRAP_CYLINDER,NULL ,

D3DV AL(0.0),D3DV AL(0.0),D3DV AL(0.0),

D3DV AL(0.0),D3DV AL(1.0),D3DV AL(0.0),

D3DV AL(0.0),D3DV AL(0.0),D3DV AL(1.0),

D3DV AL(0.0),D3DDivide(miny,height),

D3DV AL(1.0),D3DDivide(D3DV AL(1.0),height),&lpwrap);

//创建一求形帖图坐标，并赋给球体对象

lpwrap->Apply((LPDIRECT3DRMOBJECT)lpsphere3_builder);

//create the texture from the .bmp file and give the sphere3

mesh(LPDIRECT3DRMVISUAL)lpsphere3_builder

lpD3DRM->LoadTexture("tutor.bmp",&lptex);

lpsphere3_builder->SetTexture(lptex);

lpsphere3_frame->AddVisual((LPDIRECT3DRMVISUAL)lpsphere3_builder);

//球体框架加入可视对象

//lpplane_frame->AddVisual((LPDIRECT3DRMVISUAL)lpplane_builder);

myvalue.camera->AddChild(lplightframe1);

//让点光源跟随照相机移动,为以后的三维漫游作好准备

myvalue.camera->AddMoveCallback(UserControl,NULL);

lplightframe1->Release();

lpsphere3_frame->Release();

lpplane_frame->Release();

lpsphere3_builder->Release();

lplight1->Release();

lplight2->Release();

lptex->Release();

lpwrap->Release();//以上是释放临时对象

return TRUE;

}

void d3dwnd::CleanUp()

{

SAFE_RELEASE(myvalue.lpprimary);

SAFE_RELEASE(myvalue.lpback);

SAFE_RELEASE(lpDDClipper);

myvalue.bInitialized =FALSE;

SAFE_RELEASE(myvalue.scene);

SAFE_RELEASE(myvalue.camera);

SAFE_RELEASE(myvalue.view);

SAFE_RELEASE(myvalue.dev);

SAFE_RELEASE(lpD3DRM);

SAFE_RELEASE(myvalue.lpddraw);

myvalue.bQuit=TRUE;

}

BOOL d3dwnd::Createfaces(int w, int h)

{

DDSURFACEDESC ddsd;

HWND win;

HRESULT aa;

win=GetSafeHwnd();

memset(&ddsd,0,sizeof(DDSURFACEDESC));

ddsd.dwSize = sizeof( ddsd );

ddsd.dwFlags = DDSD_CAPS ;

ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;

aa= myvalue.lpddraw->CreateSurface(&ddsd,&myvalue.lpprimary,NULL);

//创建主面对象(系统默认为全屏)

if(aa!=DD_OK)

return FALSE;

ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;

ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |DDSCAPS_VIDEOMEMORY|

DDSCAPS_3DDEVICE;

ddsd.dwWidth =w;

ddsd.dwHeight =h;

aa= myvalue.lpddraw->CreateSurface(&ddsd, &myvalue.lpback, NULL);

//创建后台面对象

if(aa!=DD_OK)

return FALSE;

myvalue.lpddraw->CreateClipper(0,&lpDDClipper,NULL);

//创建裁剪对象

lpDDClipper->SetHWnd(0,win);//将裁剪对象赋给窗口

myvalue.lpprimary->SetClipper(lpDDClipper);

//也将此裁剪对象赋给主面对象

ClearBuffer(myvalue.lpprimary);//初始化面对象表面

ClearBuffer(myvalue.lpback);

return TRUE;

}

void d3dwnd::ClearBuffer(LPDIRECTDRAWSURFACE lpbuffer)

{

DDSURFACEDESC ddsd;

RECT dst;

DDBLTFX ddbltfx;

if(!lpbuffer)

return;

D3DGetSurfDesc(&ddsd, lpbuffer);

memset(&ddbltfx, 10, sizeof(ddbltfx));

ddbltfx.dwSize = sizeof(DDBLTFX);

SetRect(&dst, 0, 0, ddsd.dwWidth, ddsd.dwHeight);

lpbuffer->Blt(&dst, NULL, NULL,

DDBLT_COLORFILL|DDBLT_WAIT,&ddbltfx);

}

HRESULT d3dwnd::D3DGetSurfDesc(LPDDSURFACEDESC lpDDSurfDesc, LPDIRECTDRAWSURFACE lpDDSurf)

{

HRESULT result;

memset(lpDDSurfDesc, 0, sizeof(DDSURFACEDESC));

lpDDSurfDesc->dwSize = sizeof(DDSURFACEDESC);

result = lpDDSurf->GetSurfaceDesc(lpDDSurfDesc);

return result;

}

//响应毁灭消息

void d3dwnd::OnDestroy()

{

CleanUp();

CWnd::OnDestroy();

// TODO: Add your message handler code here

}

//响应窗口重画消息，这里让D3D保留模式接管这个消息

void d3dwnd::OnPaint()

{

LPDIRECT3DRMWINDEVICE lpd3drmwindev;

CRect re;

PAINTSTRUCT ps;

HWND h_win;

HDC hdc;

h_win=GetSafeHwnd();

if(!myvalue.bInitialized||!myvalue.dev)

return;

if(::GetUpdateRect(h_win,&re,FALSE))

{

hdc=::BeginPaint(h_win,&ps);

myvalue.dev->QueryInterface(IID_IDirect3DRMWinDevice,

(void**)&lpd3drmwindev);

lpd3drmwindev->HandlePaint(ps.hdc);

lpd3drmwindev->Release();

::EndPaint(h_win,&ps);

}

RenderLoop();

}

//只要窗口的大小发生改变则重新创建渲染设备和视点对象

void d3dwnd::OnSize(UINT nType, int cx, int cy)

{

int width =cx;

int height =cy;

if(width && height &&myvalue.view &&myvalue.dev)

{

int view_width = myvalue.view->GetWidth();

int view_height = myvalue.view->GetHeight();

int dev_width = myvalue.dev->GetWidth();

int dev_height = myvalue.dev->GetHeight();

if(view_width==width&&view_height==height&&!myvalue.bMinimized)

return;

myvalue.bInitialized = FALSE;

SAFE_RELEASE(myvalue.view);

SAFE_RELEASE(myvalue.dev);

SAFE_RELEASE(myvalue.lpprimary);

SAFE_RELEASE(myvalue.lpback);

SAFE_RELEASE(lpDDClipper);

SetFreshRegion(hwnd);

Createfaces(width,height);

if(!CreateDevAndView(lpDDClipper,myvalue.CurrDriver,width,height))

{

myvalue.CurrDriver = 0;

MSG("Failed to create the D3DRM device.\n" );

d3dwnd::OnDestroy();

return;

}

myvalue.bInitialized = TRUE;

myvalue.bMinimized = FALSE;

}

else

{

myvalue.bMinimized = TRUE;

}

}

//当设备在后台面对象上渲染结束后，将渲染结果从后台面对象拷贝到前台主面对象void d3dwnd::ShowInfo()

{

CRect re;

re.left=myvalue.startpoint.x;

re.top=myvalue.startpoint.y;

re.right=myvalue.client_rect.Width()+re.left;

re.bottom=myvalue.client_rect.Height()+re.top;

//更新区域

myvalue.lpprimary->Blt(&re,myvalue.lpback,&myvalue.client_rect,DDBLT_WAIT,NULL);/ /|DDBLT_KEYSRC

}

void d3dwnd::SetFreshRegion(HWND win)

{

myvalue.startpoint.x=myvalue.startpoint.y=0;

//这里必须将此设置为0,否则下面的函数将上次的结果与当前结果相加

::ClientToScreen(win, &myvalue.startpoint);

::GetClientRect(win,&myvalue.client_rect);

}

//当窗口移动时作的的消息响应

void d3dwnd::OnMove(int x, int y)

{

myvalue.startpoint.x=x;

myvalue.startpoint.y=y;

// TODO: Add your message handler code here

}

void d3dwnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)

{

switch(nChar)

{

case VK_UP:

myvalue.dx+=Move_step*(D3DV ALUE)sin((double)myvalue.Rotate_rad);

myvalue.dz+=Move_step*(D3DV ALUE)cos((double)myvalue.Rotate_rad);

myvalue.bMove = TRUE;

break;

case VK_DOWN:

myvalue.dx-=Move_step*(D3DV ALUE)sin((double)myvalue.Rotate_rad);

myvalue.dz-=Move_step*(D3DV ALUE)cos((double)myvalue.Rotate_rad);

myvalue.bMove = TRUE;

break;

case VK_LEFT:

myvalue.Rotate_rad-=Rotate_step;

if(myvalue.Rotate_rad<=(-PI2))

myvalue.Rotate_rad+=PI2;

myvalue.bRotate = TRUE;

break;

case VK_RIGHT:

myvalue.Rotate_rad+=Rotate_step;

if(myvalue.Rotate_rad>=PI2)

myvalue.Rotate_rad-=PI2;

myvalue.bRotate = TRUE;

break;

}

//CWnd::OnKeyDown(nChar, nRepCnt, nFlags);

}

小结：以上程序编译并执行后，可以看到一个地球仪在一个美丽的背景当中不停的旋转，一架飞机停在空中，同时你还可以通过方向键进行三维漫游进行多角度观察。并且你还可以象处理Windows一般窗口那样进行拖动、放大、缩小、最小化、最大化等操作。这里再提醒一下，在运行或编译前一定要把前面准备步骤当中的东西备齐才能看到预想的结果。