NeHe OpenGL教程 第三十一课：加载模型

转自【翻译】NeHe OpenGL 教程

前言

声明，此 NeHe OpenGL教程系列文章由51博客yarin翻译（2010-08-19），本博客为转载并稍加整理与修改。对NeHe的OpenGL管线教程的编写，以及yarn的翻译整理表示感谢。

NeHe OpenGL第三十一课：加载模型

模型加载:

你知道大名鼎鼎的Milkshape3D建模软件么，我们将加载它的模型，当然你可以加载任何你认为不错的模型。

 

这篇渲染模型的文章是由Brett Porter所写的。

这篇教程的代码是从PortaLib3D中提取出来的，PortaLib3D是一个可以读取3D文件实用库。

这篇教程的代码是以第六课为基础的，我们只讨论改变的部分。

这课中使用的模型是从Milkshape3D中提取出来的，Milkshape3D是一个非常好的建模软件，它包含了自己的文件格式，所以你能很容易去分析和理解。

但是文件格式并不能使你加载一个模型，你必须自己定义一个结构去保存数据，接着把数据读入那个结构，我们将告诉你如何定义这样一个结构。

模型的定义在model.h中，好吧我们开始吧：

 

// 顶点结构

struct Vertex

{

 char m_boneID; // 顶点所在的骨骼

 float m_location[3];

};

// 顶点的个数和数据

int m_numVertices;

Vertex *m_pVertices;

在这一课你，你可以忽略m_boneID，我们将在以后的教程中介绍骨骼动画。m_location定义顶点的位置。

下面是三角形结构

 

// 三角形结构

struct Triangle

{

 float m_vertexNormals[3][3];

 float m_s[3], m_t[3];

 int m_vertexIndices[3];

};

// 使用的三角形

int m_numTriangles;

Triangle *m_pTriangles;

3个顶点构成一个三角形，m_vertexIndices保存了三个顶点的索引。 m_s 和 m_t储存了三个顶点的纹理坐标。m_vertexNormals保存了三个顶点的法线。

下面我们定义网格结构

 

// 网格结构

struct Mesh

{

 int m_materialIndex;

 int m_numTriangles;

 int *m_pTriangleIndices;

};

// 使用的网格

int m_numMeshes;

Mesh *m_pMeshes;

m_pTriangleIndices指向包含在网格中三角形的数据，它是动态分配的。 m_materialIndex 指向了这个网格所用的材质。 

  

// 材质属性

struct Material

{

 float m_ambient[4], m_diffuse[4], m_specular[4], m_emissive[4];

 float m_shininess;

 GLuint m_texture;

 char *m_pTextureFilename;

};

// 使用的纹理

int m_numMaterials;

Material *m_pMaterials;

这里我们使用与OpenGL中相对的材质。

下面的代码用来载入模型，我们通过重载loadModelData函数来实现它。

我们创建了一个新类MilkshapeModel,它是从Model继承而来的。 

  

bool MilkshapeModel::loadModelData( const char *filename )

{

 ifstream inputFile( filename, ios::in | ios::binary | ios::nocreate );

 if ( inputFile.fail())

  return false; // 不能打开文件，返回失败

以二进制的方式打开文件，如果失败则返回

inputFile.seekg( 0, ios::end );

 long fileSize = inputFile.tellg();

 inputFile.seekg( 0, ios::beg );

返回文件大小

byte *pBuffer = new byte[fileSize];

 inputFile.read( pBuffer, fileSize );

 inputFile.close();

分配一个内存，载入文件，并关闭文件

const byte *pPtr = pBuffer;

 MS3DHeader *pHeader = ( MS3DHeader* )pPtr;

 pPtr += sizeof( MS3DHeader );

if ( strncmp( pHeader->m_ID, "MS3D000000", 10 ) != 0 )

  return false; // 如果不是一个有效的MS3D文件则返回

if ( pHeader->m_version < 3 || pHeader->m_version > 4 )

  return false; // 如果不能支持这种版本的文件，则返回失败

  

上面的文件读取文件头

int nVertices = *( word* )pPtr;

 m_numVertices = nVertices;

 m_pVertices = new Vertex[nVertices];

 pPtr += sizeof( word );

int i;

 for ( i = 0; i < nVertices; i++ )

 {

  MS3DVertex *pVertex = ( MS3DVertex* )pPtr;

  m_pVertices[i].m_boneID = pVertex->m_boneID;

  memcpy( m_pVertices[i].m_location, pVertex->m_vertex, sizeof( float )*3 );

  pPtr += sizeof( MS3DVertex );

 }

上面的代码读取顶点数据

int nTriangles = *( word* )pPtr;

 m_numTriangles = nTriangles;

 m_pTriangles = new Triangle[nTriangles];

 pPtr += sizeof( word );

for ( i = 0; i < nTriangles; i++ )

 {

  MS3DTriangle *pTriangle = ( MS3DTriangle* )pPtr;

  int vertexIndices[3] = { pTriangle->m_vertexIndices[0],
pTriangle->m_vertexIndices[1], pTriangle->m_vertexIndices[2] };

  float t[3] = { 1.0f-pTriangle->m_t[0], 1.0f-pTriangle->m_t[1], 1.0f-pTriangle->m_t[2] };

  memcpy( m_pTriangles[i].m_vertexNormals, pTriangle->m_vertexNormals, sizeof( float )*3*3 );

  memcpy( m_pTriangles[i].m_s, pTriangle->m_s, sizeof( float )*3 );

  memcpy( m_pTriangles[i].m_t, t, sizeof( float )*3 );

  memcpy( m_pTriangles[i].m_vertexIndices, vertexIndices, sizeof( int )*3 );

  pPtr += sizeof( MS3DTriangle );

 }

上面的代码用来读取三角形信息，因为MS3D使用窗口坐标系而OpenGL使用笛卡儿坐标系，所以需要反转每个顶点Y方向的纹理坐标

int nGroups = *( word* )pPtr;

 m_numMeshes = nGroups;

 m_pMeshes = new Mesh[nGroups];

 pPtr += sizeof( word );

 for ( i = 0; i < nGroups; i++ )

 {

  pPtr += sizeof( byte ); 

  pPtr += 32;

word nTriangles = *( word* )pPtr;

  pPtr += sizeof( word );

  int *pTriangleIndices = new int[nTriangles];

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

  {

   pTriangleIndices[j] = *( word* )pPtr;

   pPtr += sizeof( word );

  }

char materialIndex = *( char* )pPtr;

  pPtr += sizeof( char );

m_pMeshes[i].m_materialIndex = materialIndex;

  m_pMeshes[i].m_numTriangles = nTriangles;

  m_pMeshes[i].m_pTriangleIndices = pTriangleIndices;

 }

上面的代码填充网格结构

int nMaterials = *( word* )pPtr;

 m_numMaterials = nMaterials;

 m_pMaterials = new Material[nMaterials];

 pPtr += sizeof( word );

 for ( i = 0; i < nMaterials; i++ )

 {

  MS3DMaterial *pMaterial = ( MS3DMaterial* )pPtr;

  memcpy( m_pMaterials[i].m_ambient, pMaterial->m_ambient, sizeof( float )*4 );

  memcpy( m_pMaterials[i].m_diffuse, pMaterial->m_diffuse, sizeof( float )*4 );

  memcpy( m_pMaterials[i].m_specular, pMaterial->m_specular, sizeof( float )*4 );

  memcpy( m_pMaterials[i].m_emissive, pMaterial->m_emissive, sizeof( float )*4 );

  m_pMaterials[i].m_shininess = pMaterial->m_shininess;

  m_pMaterials[i].m_pTextureFilename = new char[strlen( pMaterial->m_texture )+1];

  strcpy( m_pMaterials[i].m_pTextureFilename, pMaterial->m_texture );

  pPtr += sizeof( MS3DMaterial );

 }

reloadTextures();

上面的代码加载纹理数据 

  

 delete[] pBuffer;

return true;

}

上面的代码设置好了一切参数，但纹理还没有载入内存，下面的代码完成这个功能。 

  

void Model::reloadTextures()

{

 for ( int i = 0; i < m_numMaterials; i++ )

  if ( strlen( m_pMaterials[i].m_pTextureFilename ) > 0 )

   m_pMaterials[i].m_texture = LoadGLTexture( m_pMaterials[i].m_pTextureFilename );

  else

   m_pMaterials[i].m_texture = 0;

}

有了数据，就可以写出绘制函数了，下面的函数根据模型的信息，按网格分组，分别绘制每一组的数据。 

  

void Model::draw()

{

 GLboolean texEnabled = glIsEnabled( GL_TEXTURE_2D );

// 按网格分组绘制

 for ( int i = 0; i < m_numMeshes; i++ )

 {

int materialIndex = m_pMeshes[i].m_materialIndex;

  if ( materialIndex >= 0 )

  {

   glMaterialfv( GL_FRONT, GL_AMBIENT, m_pMaterials[materialIndex].m_ambient );

   glMaterialfv( GL_FRONT, GL_DIFFUSE, m_pMaterials[materialIndex].m_diffuse );

   glMaterialfv( GL_FRONT, GL_SPECULAR, m_pMaterials[materialIndex].m_specular );

   glMaterialfv( GL_FRONT, GL_EMISSION, m_pMaterials[materialIndex].m_emissive );

   glMaterialf( GL_FRONT, GL_SHININESS, m_pMaterials[materialIndex].m_shininess );

if ( m_pMaterials[materialIndex].m_texture > 0 )

   {

    glBindTexture( GL_TEXTURE_2D, m_pMaterials[materialIndex].m_texture );

    glEnable( GL_TEXTURE_2D );

   }

   else

    glDisable( GL_TEXTURE_2D );

  }

  else

  {

   glDisable( GL_TEXTURE_2D );

  }

glBegin( GL_TRIANGLES );

  {

   for ( int j = 0; j < m_pMeshes[i].m_numTriangles; j++ )

   {

    int triangleIndex = m_pMeshes[i].m_pTriangleIndices[j];

    const Triangle* pTri = &m_pTriangles[triangleIndex];

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

    {

     int index = pTri->m_vertexIndices[k];

glNormal3fv( pTri->m_vertexNormals[k] );

     glTexCoord2f( pTri->m_s[k], pTri->m_t[k] );

     glVertex3fv( m_pVertices[index].m_location );

    }

   }

  }

  glEnd();

 }

if ( texEnabled )

  glEnable( GL_TEXTURE_2D );

 else

  glDisable( GL_TEXTURE_2D );

}

有了上面的函数，我们来看看如何使用它们。首先，我们定义一个MilkshapeModel类。

Model *pModel = NULL; // 定义一个指向模型类的指针

接着加载模型文件

pModel = new MilkshapeModel();

 if ( pModel->loadModelData( "data/model.ms3d" ) == false )

 {

  MessageBox( NULL, "不能加载data/model.ms3d文件", "加载错误", MB_OK | MB_ICONERROR );

  return 0;         // 返回失败

 }

接着载入纹理

pModel->reloadTextures();

完成了初始化操作，我们来实际绘制我们的模型 

  

int DrawGLScene(GLvoid)

{

 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // 情况缓存

 glLoadIdentity();    

 gluLookAt( 75, 75, 75, 0, 0, 0, 0, 1, 0 );

glRotatef(yrot,0.0f,1.0f,0.0f);

//绘制模型

 pModel->draw();

yrot+=1.0f;

 return TRUE;      //成功返回

}

原文及其个版本源代码下载：

http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=31