(完整版)基于OpenGL的飞机3D实时仿真_程序代码

#include "total.h"

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#define GLUT_DISABLE_ATEXIT_HACK

#define FILE_NAME "feiji.3DS" //指定对应的FILE NAME

#define SCREEN_WIDTH 800

#define SCREEN_HEIGHT 600

#define SCREEN_DEPTH 16

#define MAX_TEXTURES 100 // 最大的纹理数目

#define PRIMARY 0x4D4D// 基本块(Primary Chunk)，位于文件的开始// 主块(Main Chunks)

#define OBJECTINFO 0x3D3D // 网格对象的版本号

#define VERSION 0x0002 // .3ds文件的版本

#define EDITKEYFRAME 0xB000 // 所有关键帧信息的头部

// 对象的次级定义(包括对象的材质和对象）

#define MATERIAL 0xAFFF // 保存纹理信息

#define OBJECT 0x4000 // 保存对象的面、顶点等信息// 材质的次级定义

#define MATNAME 0xA000 // 保存材质名称

#define MATDIFFUSE 0xA020 // 对象/材质的颜色

#define MATMAP 0xA200 // 新材质的头部

#define MATMAPFILE 0xA300 // 保存纹理的文件名

#define OBJECT_MESH 0x4100 // 新的网格对象

// OBJECT_MESH的次级定义

#define OBJECT_VERTICES 0x4110 // 对象顶点

#define OBJECT_FACES 0x4120 // 对象的面

#define OBJECT_MATERIAL 0x4130 // 对象的材质

#define OBJECT_UV 0x4140 // 对象的UV纹理坐标

int g_ViewMode = GL_TRIANGLES;

bool g_bLighting = true;

float g_Rotatex = 0;

float g_Rotatey = 0;

float g_Rotatez = 0;

float g_x =0;

float g_y =0;

float g_z =0;

//。。。。。。。。。。。。。。。。。。。。定义需要导入的数据

float Rotatex ;

float Rotatey ;

float Rotatez ;

float x ;

float y ;

float z ;

double gl_x; double gl_y; double gl_z; double gl_pitch; double gl_roll; double gl_yaw; double gl_wcpitch;double gl_wcroll;double gl_wcyaw;

using namespace std;

UINT g_Texture[MAX_TEXTURES] = {0};

HWND g_hWnd;

RECT g_rRect;

HDC g_hDC;

HGLRC g_hRC;

HINSTANCE g_hInstance;

HINSTANCE hInstance;

MMRESULT idtimer_Opengl;

HWND CreateMyWindow(LPSTR strWindowName, int width, int height, DWORD dwStyle, HINSTANCE hInstance);// 生成用户窗口

LRESULT CALLBACK WinProc(HWND gl_hwnd, UINT message, WPARAM wParam, LPARAM lParam);//消息响应

void Init(HWND gl_hWnd);// 初始化整个程序

void InitializeOpenGL(int width, int height);// 初始化OpenGL

bool bSetupPixelFormat(HDC hdc);// 设置像素格式

void SizeOpenGLScreen(int width, int height);// 初始化投影变换

int MainLoop();//主循环

void RenderScene(double gl_x, double gl_y, double gl_z, double gl_roll, double gl_pitch, double gl_yaw) ;

void DeInit();// 释放程序占用的内存空间

void myDisplaycube();//绘制外框架

void glprintf();//输出文字

//----------------定义结构变量----------------------------------------------------------------------------- // 定义3D点的类，用于保存模型中的顶点

class CVector3

{

public:

float x, y, z;

};

// 定义2D点类，用于保存模型的UV纹理坐标

class CVector2

{

public:

float x, y;

};

// 面的结构定义

struct tFace

{

int vertIndex[3]; // 顶点索引

int coordIndex[3]; // 纹理坐标索引

};

// 材质信息结构体

struct tMaterialInfo

{

char strName[255]; // 纹理名称

char strFile[255]; // 如果存在纹理映射，则表示纹理文件名称

BYTE color[3]; // 对象的RGB颜色

int texureId; // 纹理ID

float uTile; // u 重复

float vTile; // v 重复

float uOffset; // u 纹理偏移

float vOffset; // v 纹理偏移

} ;

// 对象信息结构体

struct t3DObject

{

int numOfVerts; // 模型中顶点的数目

int numOfFaces; // 模型中面的数目

int numTexVertex; // 模型中纹理坐标的数目

int materialID; // 纹理ID

char strName[255]; // 对象的名称

CVector3 *pVerts; // 对象的顶点

CVector3 *pNormals; // 对象的法向量

CVector2 *pTexVerts; // 纹理UV坐标

tFace *pFaces; // 对象的面信息

};

// 模型信息结构体

struct t3DModel

{

int numOfObjects; // 模型中对象的数目

int numOfMaterials; // 模型中材质的数目

vector pMaterials; // 材质链表信息

vector pObject; // 模型中对象链表信息

};

struct tIndices

{

unsigned short a, b, c, bVisible;

};

// 保存块信息的结构

struct tChunk

{

unsigned short int ID; // 块的ID

unsigned int length; // 块的长度

unsigned int bytesRead; // 需要读的块数据的字节数

};

// CLoad3DS类处理所有的装入代码

class CLoad3DS

{

public://可以被该类中的函数、子类的函数、其友元函数访问,也可以由该类的对象访问

CLoad3DS(); // 初始化数据成员

// 装入3ds文件到模型结构中

bool Import3DS(t3DModel *pModel, char *strFileName);

//只能由该类中的函数、其友元函数访问,不能被任何其他访问，该类的对象也不能访问// 读一个字符串

int GetString(char *);

// 读下一个块

void ReadChunk(tChunk *);

// 读下一个块

void ProcessNextChunk(t3DModel *pModel, tChunk *);

// 读下一个对象块

void ProcessNextObjectChunk(t3DModel *pModel, t3DObject *pObject, tChunk *);

// 读下一个材质块

void ProcessNextMaterialChunk(t3DModel *pModel, tChunk *);

// 读对象颜色的RGB值

void ReadColorChunk(tMaterialInfo *pMaterial, tChunk *pChunk);

// 读对象的顶点

void ReadVertices(t3DObject *pObject, tChunk *);

// 读对象的面信息

void ReadVertexIndices(t3DObject *pObject, tChunk *);

// 读对象的纹理坐标

void ReadUVCoordinates(t3DObject *pObject, tChunk *);

// 读赋予对象的材质名称

void ReadObjectMaterial(t3DModel *pModel, t3DObject *pObject, tChunk *pPreviousChunk);

// 计算对象顶点的法向量

void ComputeNormals(t3DModel *pModel);

// 关闭文件，释放内存空间

void CleanUp();

// 文件指针

FILE *m_FilePointer;

tChunk *m_CurrentChunk;//当前块

tChunk *m_TempChunk;//下一个块

};

CLoad3DS g_Load3ds;

t3DModel g_3DModel;

//.........................程序函数............................................................................

int OpenGL_Main()//入口程序

{

gl_hWnd=CreateMyWindow("飞机动态飞行模拟", SCREEN_WIDTH, SCREEN_HEIGHT, 0, hInstance);

if(gl_hWnd == NULL) return true;

Init(gl_hWnd);// 初始化整个程序

MainLoop();

return 0;}

//创建窗口

HWND CreateMyWindow(LPSTR strWindowName, int width, int height, DWORD dwStyle, HINSTANCE hInstance)

{

HWND gl_hWnd;

WNDCLASS wndclass;/*wndclass用来保存我们的窗口类的结构。窗口类结构中保存着我们的窗口信息。

通过改变类的不同字段我们可以改变窗口的外观和行为。

每个窗口都属于一个窗口类。当您创建窗口时，您必须为窗口注册类。*/

memset(&wndclass, 0, sizeof(WNDCLASS));

wndclass.style = CS_HREDRAW | CS_VREDRAW;//设置窗口风格

wndclass.lpfnWndProc = WinProc; // WndProc处理消息其实就是键盘响应

wndclass.hInstance = hInstance; // 设置实例

wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);// 装入缺省图标要使用windows预定义的图标,这时hInstance必须设置成NULL

wndclass.hCursor = LoadCursor(NULL, IDC_ARROW); // 装入鼠标指针

wndclass.hbrBackground = (HBRUSH) (COLOR_WINDOW+1);//设置opengl的背景色wndclass.lpszClassName = "opengl"; //只是设定一个类型名

RegisterClass(&wndclass);//注册窗口的

if(!dwStyle)

dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;//拓展窗口风格的

/*WS_CLIPCHILDREN裁剪子窗口。。。就是不绘制与子窗口重合的父窗口部分子窗口间相互裁减。

当两个窗口相互重叠时，设置了WS_CLIPSIBLINGS样式的子窗口重绘时不能绘制被重叠的部分。

WS_OVERLAPPEDWINDOW可以创建一个拥有各种窗口风格的窗体，包括标题，系统菜单，边框，最小化和最大化按钮等*/

g_hInstance = hInstance;

RECT rWindow;// 取得矩形的左上角和右下角的坐标值

rWindow.left = 0; //将Left 设为0

rWindow.right = width; // 宽度

rWindow.top = 0;

rWindow.bottom = height;//高度

AdjustWindowRect( &rWindow, dwStyle, false);//该函数依据所需计算需要的窗口矩形的大小随后传递给CreateWindow函数，用于创建一个客户区所需大小的窗口。

gl_hWnd = CreateWindow("opengl", strWindowName, dwStyle, 0, 0,

rWindow.right - rWindow.left, rWindow.bottom - rWindow.top,

NULL, // 无父窗口

NULL,//无菜单

hInstance,//实例

NULL);//不向WM_CREATE传递信息

if(!gl_hWnd) return NULL ;

ShowWindow(gl_hWnd, SW_SHOWNORMAL); //该函数设置指定窗口的显示状态SW_SHOWNORMAL运行时正常大小显示

UpdateWindow(gl_hWnd);//指定客户区

SetFocus(gl_hWnd);//设置键盘焦点

return gl_hWnd;

}

LRESULT CALLBACK WinProc(HWND gl_hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)//窗口响应

{

static int cxClient,cyClient;

LONG lRet = 0;

switch (uMsg)

{

case WM_SIZE://用于控制窗口的形状变化

cxClient = LOWORD(lParam);

cyClient = HIWORD(lParam);

return 0;

case WM_CLOSE: //关闭窗口的响应

ShowWindow(gl_hWnd,SW_HIDE) ; //隐藏窗口

break;

default:

lRet = DefWindowProc (gl_hWnd, uMsg, wParam, lParam); //处理无关消息

break;

}

return lRet;

}

void Init(HWND gl_hWnd)//初始化整个窗口

{

g_hWnd = gl_hWnd;

GetClientRect(g_hWnd, &g_rRect);//该函数获取窗口客户区的坐标。

InitializeOpenGL(g_rRect.right, g_rRect.bottom);//以hWnd代表的客户区的矩形的宽和高为变量初始化opengl

g_Load3ds.Import3DS(&g_3DModel, FILE_NAME); // 将3ds文件装入到模型结构体中

glEnable(GL_LIGHT0); // 使用默认的0号灯

glEnable(GL_LIGHTING); // 使用灯光

glEnable(GL_COLOR_MA TERIAL); // 使用颜色材质

}

void InitializeOpenGL(int width, int height) // 初始化OpenGL

{

g_hDC = GetDC(g_hWnd);

if (!bSetupPixelFormat(g_hDC))

PostQuitMessage (0);

g_hRC = wglCreateContext(g_hDC); //函数建立一个适合在指定hdc上绘制的RC，RC 与DC有相同的像素格式

wglMakeCurrent(g_hDC, g_hRC);

glEnable(GL_TEXTURE_2D);//开启2D纹理贴图功能

glEnable(GL_DEPTH_TEST); //开启深度测试

SizeOpenGLScreen(width, height);

}

bool bSetupPixelFormat(HDC hdc) //设置设置像素格式

{

PIXELFORMATDESCRIPTOR pfd;

int pixelformat;

pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);

pfd.nVersion = 1;

pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;

pfd.dwLayerMask = PFD_MAIN_PLANE;

pfd.iPixelType = PFD_TYPE_RGBA;

https://www.360docs.net/doc/b811181716.html,olorBits = SCREEN_DEPTH;

pfd.cDepthBits = SCREEN_DEPTH;

pfd.cAccumBits = 0;

pfd.cStencilBits = 0;

if ( (pixelformat = ChoosePixelFormat(hdc, &pfd)) == FALSE ) //获取opengl最佳像素

{

return FALSE;

}

if (SetPixelFormat(hdc, pixelformat, &pfd) == FALSE) //设置像素格式

{

return FALSE;

}

return TRUE;

}

void SizeOpenGLScreen(int width, int height)//初始化投影变换

{

if (height==0)

{

height=1;

}

glViewport(0,0,width,height);// 设置实际图像映射的像素矩形

glMatrixMode(GL_PROJECTION);//指定当前矩阵

glLoadIdentity();//变成单位矩阵

gluPerspective(45.0f,////角度

(GLfloat)width/(GLfloat)height,//视景体的宽高比

.5f ,//沿z轴方向的两裁面之间的距离的近处

150.0f//沿z轴方向的两裁面之间的距离的远处

);//设置透视投影矩阵

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

}

int MainLoop()//主循环

{

MSG msg;

while(1)

{

if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) //该函数为一个消息检查线程消息队列，并将该消息（如果存在）放于指定的结构。

//PM_REMOVE：PeekMessage处理后，消息从队列里除掉

{

if(msg.message == WM_CLOSE)

break;

TranslateMessage(&msg); //键盘码的转化

DispatchMessage(&msg); //分发消息到回调函数，系统通过调用回调函数实现在窗体中实现对应操作

}

else

{

glprintf();//输出状态文字

gl_x=0;gl_y=0;gl_z=0;

gl_wcpitch=wc.pitch;gl_wcroll=wc.roll;gl_wcyaw=wc.yaw;

gl_pitch=gl_wcpitch;gl_roll=gl_wcroll;gl_yaw=gl_wcyaw;

RenderScene(gl_x,gl_y,gl_z,gl_roll,gl_pitch,gl_yaw);//控制飞机的姿态和观察角度并且对应的在opengl中绘制3ds模型

}

}

for(int i = 0; i < g_3DModel.numOfObjects; i++)//清空图形的相关变量

{

// 删除所有的变量

delete [] g_3DModel.pObject[i].pFaces;//对象的面

delete [] g_3DModel.pObject[i].pNormals;// 给出法向量

delete [] g_3DModel.pObject[i].pVerts; // 对象的顶点

delete [] g_3DModel.pObject[i].pTexVerts;// 纹理UV坐标

}

DeInit(); // 释放程序占用的内存空间

return(msg.wParam);

}

void DeInit()// 释放程序占用的内存空间

{

if (g_hRC)

{

wglMakeCurrent(NULL, NULL); //用于释放opengl里面的上下文环境-------------------- 渲染上下文句柄为null时才有这个功能

wglDeleteContext(g_hRC);//删除渲染内容的句柄

}

if (g_hDC)

ReleaseDC(g_hWnd, g_hDC);//函数释放设备上下文环境（DC）供其他应用程序使用

UnregisterClass("opengl", g_hInstance); //该函数注销一个窗口类，一类释放所需的内存

PostQuitMessage (0);

}

//文字显示

void glprintf()

{

char str0[100];

sprintf(str0, "%-08.3lf", wc.pitch);

char str_pitch[] = "俯仰角度：";

strcat(str_pitch, str0);

SetBkColor(g_hDC,NULL);

TextOut(g_hDC,5,5,str_pitch,strlen(str_pitch));

SetTextColor(g_hDC,RGB(0,200,0));

char str1[100];

sprintf(str1, "%-08.3lf", wc.roll);

char str_roll[] = "滚转角度：";

strcat(str_roll, str1);

SetBkColor(g_hDC,NULL);

TextOut(g_hDC,5,20,str_roll,strlen(str_roll));

SetTextColor(g_hDC,RGB(0,200,0));

char str2[100];

sprintf(str2, "%-08.3lf", wc.yaw);

char str_yaw[] = "偏航角度：";

strcat(str_yaw, str2);

SetBkColor(g_hDC,NULL);

TextOut(g_hDC,5,35,str_yaw,strlen(str_yaw));

SetTextColor(g_hDC,RGB(0,200,0));

char str3[100];

sprintf(str3, "%-08.3lf", x);

char str_x[] = "X轴位移：";

strcat(str_x, str3);

SetBkColor(g_hDC,NULL);

TextOut(g_hDC,5,60,str_x,strlen(str_x));

SetTextColor(g_hDC,RGB(0,200,0));

char str4[100];

sprintf(str4, "%-08.3lf", y);

char str_y[] = "Y轴位移：";

strcat(str_y, str4);

SetBkColor(g_hDC,NULL);

TextOut(g_hDC,5,75,str_y,strlen(str_y));

SetTextColor(g_hDC,RGB(0,200,0));

char str5[100];

sprintf(str5, "%-08.3lf", z);

char str_z[] = "Z轴位移：";

strcat(str_z, str5);

SetBkColor(g_hDC,NULL);

TextOut(g_hDC,5,90,str_z,strlen(str_z));

SetTextColor(g_hDC,RGB(0,200,0));

}

void RenderScene(double gl_x, double gl_y, double gl_z, double gl_roll, double gl_pitch, double gl_yaw)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除颜色缓冲以及深度缓冲

glLoadIdentity();//设置为单位矩阵

gluLookAt(1.2,1.2,-1.2, 0, 0, 0, -1,-1,-1);//设置观察坐标，视点坐标，视线朝向

glPushMatrix(); myDisplaycube();glPopMatrix();//绘制外部正方体框架

g_x=gl_x; g_y=gl_y; g_z=gl_z;

g_Rotatex=gl_roll;g_Rotatey= gl_pitch;g_Rotatez=gl_yaw;

glTranslatef(g_x,g_y,g_z);//机翼是y方向从机头前方看右侧有正，机身前后方向是x机头方向为正方向，机身垂直是z向下为正方向

glRotatef(g_Rotatex,1.0f, 0, 0);//是飞机roll的角度

glRotatef(g_Rotatey, 0, 1.0f, 0);//pitch的角度

glRotatef(g_Rotatez, 0, 0,1.0f);//yaw的角度

glPushMatrix(); //将当前变换矩阵(单位阵)压入堆栈

glPopMatrix();

// 遍历模型中所有的对象（将显示列表里的信息显示出来）

for(int i = 0; i < g_3DModel.numOfObjects; i++)

{

// 如果模型中没有对应的对象，则退出

if(g_3DModel.pObject.size() <= 0) break;

// 获得当前显示的对象

t3DObject *pObject = &g_3DModel.pObject[i];

glBegin(g_ViewMode);// 开始以g_ViewMode模式绘制

// 遍历所有的面

for(int j = 0; j < pObject->numOfFaces; j++)

{

// 遍历三角形的所有点

for(int whichVertex = 0; whichVertex < 3; whichVertex++)

{

// 获得面对每个点的索引

int index = pObject->pFaces[j].vertIndex[whichVertex];

// 给出法向量

glNormal3f(pObject->pNormals[ index ].x, pObject->pNormals[ index ].y, pObject->pNormals[ index ].z);

glVertex3f(pObject->pVerts[ index ].x, pObject->pVerts[ index ].y, pObject->pVerts[ index ].z);

}

}

glEnd(); // 绘制结束

}

Sleep(60);//为了降低opengl的cpu占用率，降低刷新频率

SwapBuffers(g_hDC); // 交换缓冲区

}

void myDisplaycube()//绘制矩形边框

{

glColor3f(1.0f, 1.0f, 1.0f);

static const GLfloat vertex_list[][3] = {

-0.41f, -0.39f, -0.52f,

0.41f, -0.39f, -0.52f,

-0.41f, 0.39f, -0.52f,

0.41f, 0.39f, -0.52f,

-0.41f, -0.39f, 0.52f,

0.41f, -0.39f, 0.52f,

-0.41f, 0.39f, 0.52f,

0.41f, 0.39f, 0.52f,};

glBegin(GL_LINE_LOOP);

glVertex3fv(vertex_list[0]);

glVertex3fv(vertex_list[2]);

glVertex3fv(vertex_list[3]);

glVertex3fv(vertex_list[1]);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3fv(vertex_list[0]);

glVertex3fv(vertex_list[4]);

glVertex3fv(vertex_list[5]);

glVertex3fv(vertex_list[1]);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3fv(vertex_list[0]);

glVertex3fv(vertex_list[4]);

glVertex3fv(vertex_list[6]);

glVertex3fv(vertex_list[2]);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3fv(vertex_list[2]);

glVertex3fv(vertex_list[6]);

glVertex3fv(vertex_list[7]);

glVertex3fv(vertex_list[3]);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3fv(vertex_list[3]);

glVertex3fv(vertex_list[7]);

glVertex3fv(vertex_list[5]);

glVertex3fv(vertex_list[1]);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3fv(vertex_list[5]);

glVertex3fv(vertex_list[7]);

glVertex3fv(vertex_list[6]);

glVertex3fv(vertex_list[4]);

glEnd();

glPointSize(5.0f);

glFlush();

}

//导入3ds文件部分，生成显示列表部分

// 构造函数的功能是初始化tChunk数据，分配内存空间

CLoad3DS::CLoad3DS()

{

m_CurrentChunk = new tChunk; // 初始化并为当前的块分配空间

m_TempChunk = new tChunk; // 初始化一个临时块并分配空间}

// 打开一个3ds文件，读出其中的内容，并释放内存

bool CLoad3DS::Import3DS(t3DModel *pModel, char *strFileName)

{

char strMessage[255] = {0};

m_FilePointer = fopen(strFileName, "rb");// 打开一个3ds文件

ReadChunk(m_CurrentChunk);//读出块的id和块的size

ProcessNextChunk(pModel, m_CurrentChunk);// 现在开始读入数据，ProcessNextChunk()是一个递归函数通过调用下面的递归函数，将对象读出

ComputeNormals(pModel);// 在读完整个3ds文件之后，计算顶点的法线

CleanUp(); // 释放内存空间

return true;

}

void CLoad3DS::CleanUp()// 下面的函数释放所有的内存空间，并关闭文件

{

fclose(m_FilePointer); // 关闭当前的文件指针

delete m_CurrentChunk; // 释放当前块

delete m_TempChunk; // 释放临时块

}

/*fread函数的功能是从一个文件流中读数据,读取count个元素,每个元素size字节.如果调用成功返回count.如果调用成功则实际读取size*count字节*/

// 下面的函数读出3ds文件的主要部分

void CLoad3DS::ProcessNextChunk(t3DModel *pModel, tChunk *pPreviousChunk)

{

t3DObject newObject = {0}; // 用来添加到对象链表

unsigned int version = 0; // 保存文件版本

int buffer[50000] = {0}; // 用来跳过不需要的数据

m_CurrentChunk = new tChunk; // 为新的块分配空间

while (pPreviousChunk->bytesRead < pPreviousChunk->length)

{

// 读入下一个块

ReadChunk(m_CurrentChunk);

// 判断块的ID号

switch (m_CurrentChunk->ID)

{

case VERSION:

// 读入文件的版本号，并将字节数添加到bytesRead变量中

m_CurrentChunk->bytesRead += fread(&version, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);

if (version > 0x03)// 如果文件版本号大于3，给出一个警告信息

MessageBox(NULL, "This 3DS file is over version 3 so it may load incorrectly", "Warning", MB_OK);

break;

case OBJECTINFO: //网格对象的信息

ReadChunk(m_TempChunk);

m_TempChunk->bytesRead += fread(&version, 1, m_TempChunk->length - m_TempChunk->bytesRead, m_FilePointer);

m_CurrentChunk->bytesRead += m_TempChunk->bytesRead;

ProcessNextChunk(pModel, m_CurrentChunk);

break;

case OBJECT: // 对象的名称

// 该块是对象信息块的头部，保存了对象了名称

// 对象数递增

pModel->numOfObjects++;

// 添加一个新的tObject节点到对象链表中

pModel->pObject.push_back(newObject);

// 初始化对象和它的所有数据成员

memset(&(pModel->pObject[pModel->numOfObjects - 1]), 0, sizeof(t3DObject));

// 获得并保存对象的名称，然后增加读入的字节数

m_CurrentChunk->bytesRead += GetString(pModel->pObject[pModel->numOfObjects - 1].strName);

// 进入其余的对象信息的读入

ProcessNextObjectChunk(pModel, &(pModel->pObject[pModel->numOfObjects - 1]), m_CurrentChunk);

break;

case EDITKEYFRAME:

// 跳过关键帧块的读入，增加需要读入的字节数

m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);

break;

default:

// 跳过所有忽略的块的内容的读入，增加需要读入的字节数

m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);

break;

}

// 增加从最后块读入的字节数

pPreviousChunk->bytesRead += m_CurrentChunk->bytesRead;

}

// 释放当前块的内存空间

delete m_CurrentChunk;

m_CurrentChunk = pPreviousChunk;

}

// 下面的函数处理所有的文件中对象的信息

void CLoad3DS::ProcessNextObjectChunk(t3DModel *pModel, t3DObject *pObject, tChunk *pPreviousChunk)

{

int buffer[50000] = {0}; // 用于读入不需要的数据

// 对新的块分配存储空间

m_CurrentChunk = new tChunk;

// 继续读入块的内容直至本子块结束

while (pPreviousChunk->bytesRead < pPreviousChunk->length)

{

// 读入下一个块

ReadChunk(m_CurrentChunk);

// 区别读入是哪种块

switch (m_CurrentChunk->ID)

{

case OBJECT_MESH: // 正读入的是一个新块

// 使用递归函数调用，处理该新块

ProcessNextObjectChunk(pModel, pObject, m_CurrentChunk);

break;

case OBJECT_VERTICES: // 读入是对象顶点

ReadVertices(pObject, m_CurrentChunk);

break;

case OBJECT_FACES: // 读入的是对象的面

ReadVertexIndices(pObject, m_CurrentChunk);

break;

case OBJECT_UV: // 读入对象的UV纹理坐标

// 读入对象的UV纹理坐标

ReadUVCoordinates(pObject, m_CurrentChunk);

break;

default:

// 略过不需要读入的块

m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);

break;

}

// 添加从最后块中读入的字节数到前面的读入的字节中

pPreviousChunk->bytesRead += m_CurrentChunk->bytesRead;

}

// 释放当前块的内存空间，并把当前块设置为前面块

delete m_CurrentChunk;

m_CurrentChunk = pPreviousChunk;

}

// 下面函数读入块的ID号和它的字节长度

void CLoad3DS::ReadChunk(tChunk *pChunk)

{

// 读入块的ID号，占用了2个字节。块的ID号象OBJECT或MATERIAL一样，说明了在块中所包含的内容

pChunk->bytesRead = fread(&pChunk->ID, 1, 2, m_FilePointer);

// 然后读入块占用的长度，包含了四个字节

pChunk->bytesRead += fread(&pChunk->length, 1, 4, m_FilePointer);

}

// 下面的函数读入一个字符串

int CLoad3DS::GetString(char *pBuffer)

{

int index = 0;

// 读入一个字节的数据

fread(pBuffer, 1, 1, m_FilePointer);

// 直到结束

while (*(pBuffer + index++) != 0) {

// 读入一个字符直到NULL

fread(pBuffer + index, 1, 1, m_FilePointer);

}

// 返回字符串的长度

return strlen(pBuffer) + 1;

}

// 下面的函数读入RGB颜色

void CLoad3DS::ReadColorChunk(tMaterialInfo *pMaterial, tChunk *pChunk)

{

// 读入颜色块信息

ReadChunk(m_TempChunk);

// 读入RGB颜色

m_TempChunk->bytesRead += fread(pMaterial->color, 1, m_TempChunk->length - m_TempChunk->bytesRead, m_FilePointer);

// 增加读入的字节数

pChunk->bytesRead += m_TempChunk->bytesRead;

}

// 下面的函数读入顶点索引

void CLoad3DS::ReadVertexIndices(t3DObject *pObject, tChunk *pPreviousChunk)

{

unsigned short index = 0; // 用于读入当前面的索引

// 读入该对象中面的数目

pPreviousChunk->bytesRead += fread(&pObject->numOfFaces, 1, 2, m_FilePointer);

// 分配所有面的存储空间，并初始化结构

pObject->pFaces = new tFace [pObject->numOfFaces];

memset(pObject->pFaces, 0, sizeof(tFace) * pObject->numOfFaces);

// 遍历对象中所有的面

for(int i = 0; i < pObject->numOfFaces; i++)

{

for(int j = 0; j < 4; j++)

{

// 读入当前面的第一个点

pPreviousChunk->bytesRead += fread(&index, 1, sizeof(index), m_FilePointer);

if(j < 3)

{

// 将索引保存在面的结构中

pObject->pFaces[i].vertIndex[j] = index;

}

}

}

}

// 下面的函数读入对象的UV坐标

void CLoad3DS::ReadUVCoordinates(t3DObject *pObject, tChunk *pPreviousChunk)

{

// 为了读入对象的UV坐标，首先需要读入UV坐标的数量，然后才读入具体的数据

// 读入UV坐标的数量

pPreviousChunk->bytesRead += fread(&pObject->numTexVertex, 1, 2, m_FilePointer);

// 分配保存UV坐标的内存空间

pObject->pTexVerts = new CVector2 [pObject->numTexVertex];

// 读入纹理坐标

pPreviousChunk->bytesRead += fread(pObject->pTexVerts, 1, pPreviousChunk->length - pPreviousChunk->bytesRead, m_FilePointer);

}

// 读入对象的顶点

void CLoad3DS::ReadVertices(t3DObject *pObject, tChunk *pPreviousChunk)

{

// 在读入实际的顶点之前，首先必须确定需要读入多少个顶点。

// 读入顶点的数目

pPreviousChunk->bytesRead += fread(&(pObject->numOfVerts), 1, 2, m_FilePointer);

// 分配顶点的存储空间，然后初始化结构体

pObject->pVerts = new CVector3 [pObject->numOfVerts];

memset(pObject->pVerts, 0, sizeof(CVector3) * pObject->numOfVerts);

// 读入顶点序列

pPreviousChunk->bytesRead += fread(pObject->pVerts, 1, pPreviousChunk->length - pPreviousChunk->bytesRead, m_FilePointer);

/* 现在已经读入了所有的顶点。

因为3D Studio Max的模型的Z轴是指向上的，因此需要将y轴和z轴翻转过来。

具体的做法是将Y轴和Z轴交换，然后将Z轴反向。*/

// 遍历所有的顶点