织梦CMS - 轻松建站从此开始！
高级搜索|网站地图|TAG标签RSS订阅[设为首页] [加入收藏]

罗索

搜索

热门标签:

当前位置: 主页>音视频技术>音视频播放>

OpenGL读取3DS模型(Qt版)

落鹤生 发布于 2012-06-07 09:49 点击:次 
对于3DS格式，相比OBJ的话，其多了光照、贴图、材质等信息，但如果是工业标准，并且对于贴图和材质没有特别的要求的话，使用代码给每个不同物体写上一个单一颜色就好了。这样速度很快，速度是很重要的因素啊。
TAG:

OpenGL一个重要应用就是能够读取外部的3D模型文件，比如OBJ,MD2,MD3,3DS等。在我之前的日志里已经写过一篇关于OpenGL读取Obj格式的类，详情可以看“Qt下学习OpenGL之OBJ模型”。而这次我要介绍的是3DS文件的读取。

接下来要贴出的代码已经在Qt4下成功运行，不过里面需要依赖一个CBMPLoader的类，这个可以从《OpenGL游戏编程》这本书里看到，也可以在我博客里找到对应的代码。

最后，还补充一下个人的看法。对于3DS格式，相比OBJ的话，其多了光照、贴图、材质等信息，但如果是工业标准，并且对于贴图和材质没有特别的要求的话，使用代码给每个不同物体写上一个单一颜色就好了。这样速度很快，速度是很重要的因素啊。

好了，贴代码了。
3DSLoader.h内容：

  1. #ifndef __3DSLOADER_H__ 
  2. #define __3DSLOADER_H__ 
  3.  
  4. #include "Stdafx.h" 
  5. #include "Vector.h" 
  6. #include "CBMPLoader.h" 
  7.  
  8. /* 下面是定义一些块的ID号 */ 
  9.  
  10. /*  基本块(Primary Chunk)，位于文件的开始 */ 
  11. #define PRIMARY       0x4D4D 
  12.  
  13. /*  主块(Main Chunks) */ 
  14. #define OBJECTINFO    0x3D3D        /* 网格对象的版本号 */ 
  15. #define VERSION       0x0002        /* .3ds文件的版本 */ 
  16. #define EDITKEYFRAME  0xB000        /* 所有关键帧信息的头部 */ 
  17.  
  18. /*  对象的次级定义 */ 
  19. #define MATERIAL      0xAFFF        /* 纹理信息 */ 
  20. #define OBJECT        0x4000        /* 对象的面、顶点等信息 */ 
  21.  
  22. /*  材质的次级定义 */ 
  23. #define MATNAME       0xA000        /* 材质名称 */ 
  24. #define MATDIFFUSE    0xA020        /* 对象/材质的颜色 */ 
  25. #define MATMAP        0xA200        /* 新材质的头部 */ 
  26. #define MATMAPFILE    0xA300        /* 保存纹理的文件名 */ 
  27. #define OBJ_MESH      0x4100            /* 新的网格对象 */ 
  28.  
  29. /* 网格对象的次级定义 */ 
  30. #define OBJ_VERTICES  0x4110        /* 对象顶点 */ 
  31. #define OBJ_FACES     0x4120        /* 对象的面 */ 
  32. #define OBJ_MATERIAL  0x4130        /* 对象的材质 */ 
  33. #define OBJ_UV        0x4140        /* 对象的UV纹理坐标 */ 
  34.  
  35. /* 面的结构定义 */ 
  36. struct tFace 
  37. { 
  38.         int vertIndex[3];       /* 顶点索引 */ 
  39.         int coordIndex[3];      /* 纹理坐标索引 */ 
  40. }; 
  41.  
  42. /* 材质信息结构体 */ 
  43. struct tMatInfo 
  44. { 
  45.         char  strName[255];     /* 纹理名称 */ 
  46.         char  strFile[255];     /* 纹理文件名称 */ 
  47.         unsigned char  color[3];    /* 对象的RGB颜色 */ 
  48.         int   texureId;         /* 纹理ID */ 
  49.         float uTile;            /* u 重复 */ 
  50.         float vTile;            /* v 重复 */ 
  51.         float uOffset;          /* u 纹理偏移 */ 
  52.         float vOffset;          /* v 纹理偏移 */ 
  53. } ; 
  54.  
  55. /* 对象信息结构体 */ 
  56. struct t3DObject 
  57. { 
  58.         int  numOfVerts;        /* 模型中顶点的数目 */ 
  59.         int  numOfFaces;        /* 模型中面的数目 */ 
  60.         int  numTexVertex;      /* 模型中纹理坐标的数目 */ 
  61.         int  materialID;        /* 纹理ID */ 
  62.         bool bHasTexture;       /* 是否具有纹理映射 */ 
  63.         char strName[255];      /* 对象的名称 */ 
  64.         Vector3  *pVerts;       /* 对象的顶点 */ 
  65.         Vector3  *pNormals;     /* 对象的法向量 */ 
  66.         Vector2  *pTexVerts;        /* 纹理UV坐标 */ 
  67.         tFace *pFaces;          /* 对象的面信息 */ 
  68. }; 
  69.  
  70. /* 模型信息结构体 */ 
  71. struct t3DModel 
  72. {   int numOfObjects;       /* 模型中对象的数目 */ 
  73.         int numOfMaterials;     /* 模型中材质的数目 */ 
  74.         QVectorpMaterials;  /* 材质链表信息 */ 
  75.         QVector pObject;    /* 模型中对象链表信息 */ 
  76. }; 
  77.  
  78. /* 块信息的结构 */ 
  79. struct tChunk 
  80. { 
  81.         unsigned short int ID;       /* 块的ID */ 
  82.         unsigned int length;         /* 块的长度 */ 
  83.         unsigned int bytesRead;      /* 需要读的块数据的字节数 */ 
  84. }; 
  85.  
  86. #define MAX_TEXTURES  100 
  87.  
  88. /* 3DS文件载入类 */ 
  89. class C3DSLoader 
  90. { 
  91. public: 
  92.         /* 构造函数 */ 
  93.         C3DSLoader(); 
  94.         virtual ~C3DSLoader(); 
  95.         void Draw();//显示3ds模型 
  96.         void Init(char *filename); 
  97.  
  98. private: 
  99.         /* 读一个字符串 */ 
  100.         int  GetString(char *); 
  101.  
  102.         /* 装载3ds文件到模型结构中 */ 
  103.         bool Import3DS(t3DModel *pModel, char *strFileName); 
  104.  
  105.         /*  从文件中创建纹理 */ 
  106.         void LoadTexture(char* filename, GLuint textureArray[], GLuint textureID); 
  107.  
  108.         /* 读取一个块 */ 
  109.         void ReadChunk(tChunk *); 
  110.  
  111.         /* 读取下一个块 */ 
  112.         void ReadNextChunk(t3DModel *pModel, tChunk *); 
  113.  
  114.         /* 读取下一个对象 */ 
  115.         void ReadNextObjChunk(t3DModel *pModel,t3DObject *pObject,tChunk *); 
  116.  
  117.         /* 读取下一个材质块 */ 
  118.         void ReadNextMatChunk(t3DModel *pModel, tChunk *); 
  119.  
  120.         /* 读取对象颜色的RGB值 */ 
  121.         void ReadColor(tMatInfo *pMaterial, tChunk *pChunk); 
  122.  
  123.         /* 读取对象的顶点信息 */ 
  124.         void ReadVertices(t3DObject *pObject, tChunk *); 
  125.  
  126.         /* 读取对象的面信息 */ 
  127.         void ReadVertexIndices(t3DObject *pObject,tChunk *); 
  128.  
  129.         /* 读取对象的纹理坐标 */ 
  130.         void ReadUVCoordinates(t3DObject *pObject,tChunk *); 
  131.  
  132.         /* 读取赋予对象的材质 */ 
  133.         void ReadObjMat(t3DModel *pModel,t3DObject *pObject,tChunk *pPreChunk); 
  134.  
  135.         /* 计算对象顶点的法向量 */ 
  136.         void ComputeNormals(t3DModel *pModel); 
  137.  
  138.         /* 释放内存,关闭文件 */ 
  139.         void CleanUp(); 
  140.  
  141.         FILE         *m_FilePointer;              /*< 文件指针 */ 
  142.         tChunk       *m_CurrentChunk;             /*< 读取过程中当前块 */ 
  143.         tChunk       *m_TempChunk;                /*< 临时块 */ 
  144.         GLuint       m_textures[MAX_TEXTURES];    /*< 纹理 */ 
  145.         t3DModel     m_3DModel;                   /*< 模型 */ 
  146.         CBMPLoader   m_BMPTexture;                /* 载入位图 */ 
  147.  
  148. }; 
  149.  
  150. #endif 

3DSLoader.cpp内容：

  1. #include "Stdafx.h" 
  2. #include "3DSLoader.h" 
  3.  
  4. /* 构造函数 */ 
  5. C3DSLoader::C3DSLoader() 
  6. { 
  7.     m_CurrentChunk = new tChunk;     /* 为当前块分配空间 */ 
  8.     m_TempChunk = new tChunk;        /* 为临时块分配空间 */ 
  9.     m_3DModel.numOfObjects = 0; 
  10.     m_3DModel.numOfMaterials = 0; 
  11.     for(int i=0;i0) 
  12. LoadTexture(m_3DModel.pMaterials[i].strFile,m_textures, i);/* 使用纹理文件名称来装入位图 */ 
  13. m_3DModel.pMaterials[i].texureId = i;/* 设置材质的纹理ID */ 
  14.     } 
  15. } 
  16.  
  17. /* 显示3ds模型 */ 
  18. void C3DSLoader::Draw() 
  19. { 
  20.     /*保存现有颜色属实性 */ 
  21.     glPushAttrib(GL_CURRENT_BIT); 
  22.     glDisable(GL_TEXTURE_2D); 
  23.     //glEnable(GL_LIGHT0); 
  24.  
  25.     /* 遍历模型中所有的对象 */ 
  26.     for(int i = 0; i < m_3DModel.numOfObjects; i++) 
  27.     { 
  28.         /* 如果对象的大小小于0，则退出 */ 
  29.         if(m_3DModel.pObject.size() <= 0)
  30.              break;         /* 获得当前显示的对象 */
  31.          t3DObject *pObject = &m_3DModel.pObject[i];
  32.          /* 判断该对象是否有纹理映射 */
  33.          if(pObject->bHasTexture) 
  34.         { 
  35.             glEnable(GL_TEXTURE_2D);/* 打开纹理映射 */ 
  36.             glBindTexture(GL_TEXTURE_2D, m_textures[pObject->materialID]); 
  37.         } 
  38.         else 
  39.             glDisable(GL_TEXTURE_2D);/* 关闭纹理映射 */ 
  40.  
  41.         glColor3ub(255, 255, 255); 
  42.  
  43.         /* 开始绘制 */ 
  44.  
  45.             glBegin(GL_TRIANGLES); 
  46.  
  47.         /* 遍历所有的面 */ 
  48.         for(int j = 0; j < pObject->numOfFaces; j++) 
  49.         { 
  50.             /* 遍历三角形的所有点 */ 
  51.             for(int tex = 0; tex < 3; tex++)
  52.              {
  53. /* 获得面对每个点的索引 */
  54. int index = pObject->pFaces[j].vertIndex[tex]; 
  55.  
  56. /* 给出法向量 */ 
  57. glNormal3f(pObject->pNormals[index].x,pObject->pNormals[index].y, 
  58. pObject->pNormals[index].z); 
  59.  
  60.                 /* 如果对象具有纹理 */ 
  61.                 if(pObject->bHasTexture) 
  62.                 { 
  63.                     /* 确定是否有UVW纹理坐标 */ 
  64.                     if(pObject->pTexVerts) 
  65. glTexCoord2f(pObject->pTexVerts[index].x,pObject->pTexVerts[index].y); 
  66.                 } 
  67.                 else 
  68.                 { 
  69.                     if(m_3DModel.pMaterials.size() && pObject->materialID>= 0) 
  70.                     { 
  71. unsigned char *pColor = m_3DModel.pMaterials[pObject->materialID].color; 
  72. glColor3ub(pColor[0],pColor[1],pColor[2]); 
  73.                     } 
  74.                 } 
  75. glVertex3f(pObject->pVerts[index].x,pObject->pVerts[index].y,pObject->pVerts[index].z); 
  76.             } 
  77.         } 
  78.         glEnd(); 
  79.         /* 绘制结束 */ 
  80.     } 
  81.  
  82.     //glDisable(GL_LIGHT0); 
  83.     glEnable(GL_TEXTURE_2D); 
  84.  
  85.     /* 恢复前一属性 */ 
  86.     glPopAttrib(); 
  87. } 
  88.  
  89. void C3DSLoader::LoadTexture(char* filename, GLuint textureArray[], GLuint textureID) 
  90. { 
  91.     if(!filename) 
  92.         return; 
  93.  
  94.     if(!this->m_BMPTexture.LoadBitmap(filename)) 
  95.     { 
  96. QMessageBox::warning(0,QObject::tr("Load Bitmap Error"),QObject::tr("Load Bitmap Error")); 
  97.         return; 
  98.     } 
  99.  
  100.     glGenTextures(1,&m_textures[textureID]); 
  101.  
  102.     glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 
  103.     glBindTexture(GL_TEXTURE_2D, m_textures[textureID]); 
  104.  
  105.     /* 控制滤波 */ 
  106.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR); 
  107.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR); 
  108.  
  109.     /* 创建纹理 */ 
  110.     gluBuild2DMipmaps(GL_TEXTURE_2D, 3, m_BMPTexture.imageWidth,m_BMPTexture.imageHeight
  111. , GL_RGB, GL_UNSIGNED_BYTE, this->m_BMPTexture.image); 
  112.  
  113. } 
  114.  
  115. /* 载入3DS文件到模型结构中 */ 
  116. bool C3DSLoader::Import3DS(t3DModel *pModel,char *strFileName) 
  117. { 
  118.     char strMessage[255] = {0}; 
  119.  
  120.     /* 打开一个3ds文件 */ 
  121.     m_FilePointer = fopen(strFileName, "rb"); 
  122.  
  123.     /* 检查文件指针 */ 
  124.     if(!m_FilePointer) 
  125.     { 
  126.         sprintf(strMessage, "Cann't find the file: %s!", strFileName); 
  127.         QMessageBox::information(NULL, 
  128.                                  "Error", 
  129.                                  strMessage, 
  130.                                  QMessageBox::Yes | QMessageBox::No, 
  131.                                  QMessageBox::Yes); 
  132.         return false; 
  133.     } 
  134.  
  135.     /* 将文件的第一块读出并判断是否是3ds文件 */ 
  136.     ReadChunk(m_CurrentChunk); 
  137.  
  138.     /* 确保是3ds文件 */ 
  139.     if (m_CurrentChunk->ID != PRIMARY) 
  140.     { 
  141.         QMessageBox::information(NULL, 
  142.                                  "Error", 
  143.                                  "Cann't Loading the Function", 
  144.                                  QMessageBox::Yes | QMessageBox::No, 
  145.                                  QMessageBox::Yes); 
  146.         return false; 
  147.     } 
  148.  
  149.     /* 递归读出对象数据 */ 
  150.     ReadNextChunk(pModel, m_CurrentChunk); 
  151.  
  152.     /* 计算顶点的法线 */ 
  153.     ComputeNormals(pModel); 
  154.  
  155.     /* 释放内存空间 */ 
  156.     CleanUp(); 
  157.  
  158.     return true; 
  159. } 
  160.  
  161. /*  读入一个字符串 */ 
  162. int C3DSLoader::GetString(char *pBuffer) 
  163. { 
  164.     int index = 0; 
  165.  
  166.     /* 读入一个字节的数据 */ 
  167.     fread(pBuffer, 1, 1, m_FilePointer); 
  168.  
  169.     /* 直到结束 */ 
  170.     while (*(pBuffer + index++) != 0) 
  171.     { 
  172.         /* 读入一个字符直到NULL */ 
  173.         fread(pBuffer + index, 1, 1, m_FilePointer); 
  174.     } 
  175.  
  176.     /* 返回字符串的长度 */ 
  177.     return strlen(pBuffer) + 1; 
  178. } 
  179.  
  180. /* 读入块的ID号和它的字节长度 */ 
  181. void C3DSLoader::ReadChunk(tChunk *pChunk) 
  182. { 
  183.     /* 读入块的ID号 */ 
  184.     pChunk->bytesRead = fread(&pChunk->ID, 1, 2, m_FilePointer); 
  185.  
  186.     /* 读入块占用的长度 */ 
  187.     pChunk->bytesRead += fread(&pChunk->length, 1, 4, m_FilePointer); 
  188.  
  189. } 
  190.  
  191. /* 读出3ds文件的主要部分 */ 
  192. void C3DSLoader::ReadNextChunk(t3DModel *pModel, tChunk *pPreChunk) 
  193. { 
  194.     t3DObject newObject = {0};                  /* 用来添加到对象链表 */ 
  195.     tMatInfo newTexture = {0};                  /* 用来添加到材质链表 */ 
  196.     unsigned int version = 0;                   /* 保存文件版本 */ 
  197.     int buffer[50000] = {0};                    /* 用来跳过不需要的数据 */ 
  198.     m_CurrentChunk = new tChunk;                /* 为新的块分配空间      */ 
  199.  
  200.     /* 继续读入子块 */ 
  201.     while (pPreChunk->bytesRead < pPreChunk->length) 
  202.     { 
  203.         /* 读入下一个块 */ 
  204.         ReadChunk(m_CurrentChunk); 
  205.  
  206.         /* 判断块的ID号 */ 
  207.         switch (m_CurrentChunk->ID) 
  208.         { 
  209.  
  210.             /* 文件版本号 */ 
  211.         case VERSION: 
  212.  
  213.             /* 读入文件的版本号 */ 
  214.             m_CurrentChunk->bytesRead += fread(&version
  215. , 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer); 
  216.  
  217.             /* 如果文件版本号大于3，给出一个警告信息 */ 
  218.             if (version > 0x03) 
  219.                 QMessageBox::information(NULL, 
  220.                                          "Warning", 
  221.                                          "The 3DS File Version is wrong", 
  222.                                          QMessageBox::Yes | QMessageBox::No, 
  223.                                          QMessageBox::Yes); 
  224.             break; 
  225.  
  226.             /* 网格版本信息 */ 
  227.         case OBJECTINFO: 
  228.  
  229.             /* 读入下一个块 */ 
  230.             ReadChunk(m_TempChunk); 
  231.  
  232.             /* 获得网格的版本号 */ 
  233.             m_TempChunk->bytesRead += fread(&version, 1
  234. , m_TempChunk->length - m_TempChunk->bytesRead, m_FilePointer); 
  235.  
  236.             /* 增加读入的字节数 */ 
  237.             m_CurrentChunk->bytesRead += m_TempChunk->bytesRead; 
  238.  
  239.             /* 进入下一个块 */ 
  240.             ReadNextChunk(pModel, m_CurrentChunk); 
  241.             break; 
  242.  
  243.             /* 材质信息 */ 
  244.         case MATERIAL: 
  245.  
  246.             /* 材质的数目递增 */ 
  247.             pModel->numOfMaterials++; 
  248.  
  249.             /* 在纹理链表中添加一个空白纹理结构 */ 
  250.             pModel->pMaterials.push_back(newTexture); 
  251.  
  252.             /* 进入材质装入函数 */ 
  253.             ReadNextMatChunk(pModel, m_CurrentChunk); 
  254.             break; 
  255.  
  256.             /* 对象名称 */ 
  257.         case OBJECT: 
  258.  
  259.             /* 对象数递增 */ 
  260.             pModel->numOfObjects++; 
  261.  
  262.             /* 添加一个新的tObject节点到对象链表中 */ 
  263.             pModel->pObject.push_back(newObject); 
  264.  
  265.             /* 初始化对象和它的所有数据成员 */ 
  266.             memset(&(pModel->pObject[pModel->numOfObjects - 1])
  267. , 0, sizeof(t3DObject)); 
  268.  
  269.             /* 获得并保存对象的名称，然后增加读入的字节数 */ 
  270.             m_CurrentChunk->bytesRead
  271.  += GetString(pModel->pObject[pModel->numOfObjects - 1].strName); 
  272.  
  273.             /* 进入其余的对象信息的读入 */ 
  274.             ReadNextObjChunk(pModel
  275. , &(pModel->pObject[pModel->numOfObjects - 1]), m_CurrentChunk); 
  276.             break; 
  277.  
  278.             /* 关键帧 */ 
  279.         case EDITKEYFRAME: 
  280.  
  281.             /* 跳过关键帧块的读入 */ 
  282.             m_CurrentChunk->bytesRead += fread(buffer, 1
  283. , m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer); 
  284.             break; 
  285.  
  286.         default: 
  287.             /*  跳过所有忽略的块的内容的读入 */ 
  288.             m_CurrentChunk->bytesRead += fread(buffer, 1
  289. , m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer); 
  290.             break; 
  291.         } 
  292.  
  293.         /* 增加从最后块读入的字节数 */ 
  294.         pPreChunk->bytesRead += m_CurrentChunk->bytesRead; 
  295.     } 
  296.  
  297.     /* 释放当前块的内存空间 */ 
  298.     delete m_CurrentChunk; 
  299.     m_CurrentChunk = pPreChunk; 
  300. } 
  301.  
  302. /* 处理所有的文件中对象的信息 */ 
  303. void C3DSLoader::ReadNextObjChunk(t3DModel *pModel
  304. , t3DObject *pObject, tChunk *pPreChunk) 
  305. { 
  306.     /* 用于读入不需要的数据 */ 
  307.     int buffer[50000] = {0}; 
  308.  
  309.     /* 对新的块分配存储空间 */ 
  310.     m_CurrentChunk = new tChunk; 
  311.  
  312.     /* 继续读入块的内容直至本子块结束 */ 
  313.     while (pPreChunk->bytesRead < pPreChunk->length) 
  314.     { 
  315.         /* 读入下一个块 */ 
  316.         ReadChunk(m_CurrentChunk); 
  317.  
  318.         /* 区别读入是哪种块 */ 
  319.         switch (m_CurrentChunk->ID) 
  320.         { 
  321.             /* 正读入的是一个新块 */ 
  322.         case OBJ_MESH: 
  323.             /* 使用递归函数调用，处理该新块 */ 
  324.             ReadNextObjChunk(pModel, pObject, m_CurrentChunk); 
  325.             break; 
  326.  
  327.             /* 读入是对象顶点 */ 
  328.         case OBJ_VERTICES: 
  329.             ReadVertices(pObject, m_CurrentChunk); 
  330.             break; 
  331.  
  332.             /* 读入的是对象的面 */ 
  333.         case OBJ_FACES: 
  334.             ReadVertexIndices(pObject, m_CurrentChunk); 
  335.             break; 
  336.  
  337.             /* 读入的是对象的材质名称 */ 
  338.         case OBJ_MATERIAL: 
  339.             /* 读入对象的材质名称 */ 
  340.             ReadObjMat(pModel, pObject, m_CurrentChunk); 
  341.             break; 
  342.  
  343.             /* 读入对象的UV纹理坐标 */ 
  344.         case OBJ_UV: 
  345.             /* 读入对象的UV纹理坐标 */ 
  346.             ReadUVCoordinates(pObject, m_CurrentChunk); 
  347.             break; 
  348.  
  349.         default: 
  350.             /* 略过不需要读入的块 */ 
  351.             m_CurrentChunk->bytesRead += fread(buffer, 1
  352. , m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer); 
  353.             break; 
  354.         } 
  355.         /* 添加从最后块中读入的字节数到前面的读入的字节中 */ 
  356.         pPreChunk->bytesRead += m_CurrentChunk->bytesRead; 
  357.     } 
  358.     /* 释放当前块的内存空间，并把当前块设置为前面块 */ 
  359.     delete m_CurrentChunk; 
  360.     m_CurrentChunk = pPreChunk; 
  361. } 
  362.  
  363. /* 处理所有的材质信息 */ 
  364. void C3DSLoader::ReadNextMatChunk(t3DModel *pModel, tChunk *pPreChunk) 
  365. { 
  366.     /* 用于读入不需要的数据 */ 
  367.     int buffer[50000] = {0}; 
  368.  
  369.     /* 给当前块分配存储空间 */ 
  370.     m_CurrentChunk = new tChunk; 
  371.  
  372.     /* 继续读入这些块 */ 
  373.     while (pPreChunk->bytesRead < pPreChunk->length) 
  374.     { 
  375.         /* 读入下一块 */ 
  376.         ReadChunk(m_CurrentChunk); 
  377.         /* 判断读入的是什么块 */ 
  378.         switch (m_CurrentChunk->ID) 
  379.         { 
  380.         case MATNAME:                           /* 材质的名称 */ 
  381.             /* 读入材质的名称 */ 
  382.             m_CurrentChunk->bytesRead
  383.  += fread(pModel->pMaterials[pModel->numOfMaterials - 1].strName, 1
  384. , m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer); 
  385.             break; 
  386.         case MATDIFFUSE:                        /* 对象的R G B颜色 */ 
  387.             ReadColor(&(pModel->pMaterials[pModel->numOfMaterials - 1]), m_CurrentChunk); 
  388.             break; 
  389.         case MATMAP:                            /* 纹理信息的头部 */ 
  390.             /* 下一个材质块信息 */ 
  391.             ReadNextMatChunk(pModel, m_CurrentChunk); 
  392.             break; 
  393.         case MATMAPFILE:                        /* 材质文件的名称 */ 
  394.             /* 读入材质的文件名称 */ 
  395.             m_CurrentChunk->bytesRead
  396.  += fread(pModel->pMaterials[pModel->numOfMaterials - 1].strFile, 1
  397. , m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer); 
  398.             break; 
  399.         default: 
  400.             /* 跳过不需要读入的块 */ 
  401.             m_CurrentChunk->bytesRead += fread(buffer, 1
  402. , m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer); 
  403.             break; 
  404.         } 
  405.         /* 添加从最后块中读入的字节数 */ 
  406.         pPreChunk->bytesRead += m_CurrentChunk->bytesRead; 
  407.     } 
  408.     /* 删除当前块，并将当前块设置为前面的块 */ 
  409.     delete m_CurrentChunk; 
  410.     m_CurrentChunk = pPreChunk; 
  411. } 
  412.  
  413. /* 读入RGB颜色 */ 
  414. void C3DSLoader::ReadColor(tMatInfo *pMaterial, tChunk *pChunk) 
  415. { 
  416.     /* 读入颜色块信息 */ 
  417.     ReadChunk(m_TempChunk); 
  418.     /* 读入RGB颜色 */ 
  419.     m_TempChunk->bytesRead += fread(pMaterial->color, 1
  420. , m_TempChunk->length - m_TempChunk->bytesRead, m_FilePointer); 
  421.     /* 增加读入的字节数 */ 
  422.     pChunk->bytesRead += m_TempChunk->bytesRead; 
  423. } 
  424.  
  425. /* 读入顶点索引 */ 
  426. void C3DSLoader::ReadVertexIndices(t3DObject *pObject, tChunk *pPreChunk) 
  427. { 
  428.     unsigned short index = 0;                   /* 用于读入当前面的索引 */ 
  429.     /* 读入该对象中面的数目 */ 
  430.     pPreChunk->bytesRead += fread(&pObject->numOfFaces, 1, 2, m_FilePointer); 
  431.     /* 分配所有面的存储空间，并初始化结构 */ 
  432.     pObject->pFaces = new tFace [pObject->numOfFaces]; 
  433.     memset(pObject->pFaces, 0, sizeof(tFace) * pObject->numOfFaces); 
  434.     /* 遍历对象中所有的面 */ 
  435.     for(int i = 0; i < pObject->numOfFaces; i++) 
  436.     {   for(int j = 0; j < 4; j++)
  437.          {
  438.              /* 读入当前面的第一个点  */
  439.              pPreChunk->bytesRead += fread(&index, 1, sizeof(index), m_FilePointer); 
  440.             if(j < 3)
  441.              {
  442.                  /* 将索引保存在面的结构中 */
  443.                  pObject->pFaces[i].vertIndex[j] = index; 
  444.             } 
  445.         } 
  446.     } 
  447. } 
  448.  
  449. /* 读入对象的UV坐标 */ 
  450. void C3DSLoader::ReadUVCoordinates(t3DObject *pObject, tChunk *pPreChunk) 
  451. { 
  452.     /* 读入UV坐标的数量 */ 
  453.     pPreChunk->bytesRead += fread(&pObject->numTexVertex, 1, 2, m_FilePointer); 
  454.  
  455.     /* 分配保存UV坐标的内存空间 */ 
  456.     pObject->pTexVerts = new Vector2[pObject->numTexVertex]; 
  457.  
  458.     /* 读入纹理坐标 */ 
  459.     pPreChunk->bytesRead += fread(pObject->pTexVerts, 1
  460. , pPreChunk->length - pPreChunk->bytesRead, m_FilePointer); 
  461. } 
  462.  
  463. /*  读入对象的顶点 */ 
  464. void C3DSLoader::ReadVertices(t3DObject *pObject, tChunk *pPreChunk) 
  465. { 
  466.     /* 读入顶点的数目 */ 
  467.     pPreChunk->bytesRead += fread(&(pObject->numOfVerts), 1, 2, m_FilePointer); 
  468.  
  469.     /* 分配顶点的存储空间，然后初始化结构体 */ 
  470.     pObject->pVerts = new Vector3 [pObject->numOfVerts]; 
  471.     memset(pObject->pVerts, 0, sizeof(Vector3) * pObject->numOfVerts); 
  472.  
  473.     /* 读入顶点序列 */ 
  474.     pPreChunk->bytesRead += fread(pObject->pVerts, 1
  475. , pPreChunk->length - pPreChunk->bytesRead, m_FilePointer); 
  476.  
  477.     /* 遍历所有的顶点将Y轴和Z轴交换，然后将Z轴反向 */ 
  478.     for(int i = 0; i < pObject->numOfVerts; i++) 
  479.     { 
  480.         /* 保存Y轴的值 */ 
  481.         float fTempY = pObject->pVerts[i].y; 
  482.         /* 设置Y轴的值等于Z轴的值 */ 
  483.         pObject->pVerts[i].y = pObject->pVerts[i].z; 
  484.         /* 设置Z轴的值等于-Y轴的值  */ 
  485.         pObject->pVerts[i].z = -fTempY; 
  486.     } 
  487. } 
  488.  
  489. /* 读入对象的材质名称 */ 
  490. void C3DSLoader::ReadObjMat(t3DModel *pModel, t3DObject *pObject, tChunk *pPreChunk) 
  491. { 
  492.     char strMaterial[255] = {0};            /* 用来保存对象的材质名称 */ 
  493.     int buffer[50000] = {0};                /* 用来读入不需要的数据 */ 
  494.  
  495.     /* 读入赋予当前对象的材质名称 */ 
  496.     pPreChunk->bytesRead += GetString(strMaterial); 
  497.  
  498.     /* 遍历所有的纹理 */ 
  499.     for(int i = 0; i < pModel->numOfMaterials; i++) 
  500.     { 
  501.         /* 如果读入的纹理与当前的纹理名称匹配 */ 
  502.         if(strcmp(strMaterial, pModel->pMaterials[i].strName) == 0) 
  503.         { 
  504.             /* 设置材质ID */ 
  505.             pObject->materialID = i; 
  506.  
  507.             /* 判断是否是纹理映射 */ 
  508.             if(strlen(pModel->pMaterials[i].strFile) > 0) { 
  509.  
  510.                 /* 设置对象的纹理映射标志 */ 
  511.                 pObject->bHasTexture = true; 
  512.             } 
  513.             break; 
  514.         } 
  515.         else 
  516.         { 
  517.             /* 如果该对象没有材质，则设置ID为-1 */ 
  518.             pObject->materialID = -1; 
  519.         } 
  520.     } 
  521.     pPreChunk->bytesRead += fread(buffer, 1
  522. , pPreChunk->length - pPreChunk->bytesRead, m_FilePointer); 
  523. } 
  524.  
  525. /* 计算对象的法向量 */ 
  526. void C3DSLoader::ComputeNormals(t3DModel *pModel) 
  527. { 
  528.     Vector3 vVector1, vVector2, vNormal, vPoly[3]; 
  529.  
  530.     /* 如果模型中没有对象，则返回 */ 
  531.     if(pModel->numOfObjects <= 0) 
  532.         return; 
  533.  
  534.     /* 遍历模型中所有的对象 */ 
  535.     for(int index = 0; index < pModel->numOfObjects; index++) 
  536.     { 
  537.         /* 获得当前的对象 */ 
  538.         t3DObject *pObject = &(pModel->pObject[index]); 
  539.  
  540.         /* 分配需要的存储空间 */ 
  541.         Vector3 *pNormals       = new Vector3 [pObject->numOfFaces]; 
  542.         Vector3 *pTempNormals   = new Vector3 [pObject->numOfFaces]; 
  543.         pObject->pNormals       = new Vector3 [pObject->numOfVerts]; 
  544.  
  545.         /* 遍历对象的所有面 */ 
  546.         for(int i=0; i < pObject->numOfFaces; i++) 
  547.         {   vPoly[0] = pObject->pVerts[pObject->pFaces[i].vertIndex[0]]; 
  548.             vPoly[1] = pObject->pVerts[pObject->pFaces[i].vertIndex[1]]; 
  549.             vPoly[2] = pObject->pVerts[pObject->pFaces[i].vertIndex[2]]; 
  550.  
  551.             /* 计算面的法向量 */ 
  552.             vVector1 = vPoly[0] - vPoly[2];             /* 获得多边形的矢量 */ 
  553.             vVector2 = vPoly[2] - vPoly[1];             /* 获得多边形的第二个矢量 */ 
  554.             vNormal  = vVector1.crossProduct(vVector2); /* 计算两个矢量的叉积 */ 
  555.             pTempNormals[i] = vNormal; 
  556.             vNormal  = vNormal.normalize();             /* 规一化叉积 */ 
  557.             pNormals[i] = vNormal;                      /* 将法向量添加到法向量列表中 */ 
  558.         } 
  559.  
  560.         /* 计算顶点法向量 */ 
  561.         Vector3 vSum(0.0,0.0,0.0); 
  562.         Vector3 vZero = vSum; 
  563.         int shared=0; 
  564.  
  565.         /* 遍历所有的顶点 */ 
  566.         for (int i = 0; i < pObject->numOfVerts; i++) 
  567.         {   for (int j = 0; j < pObject->numOfFaces; j++)   /* 遍历所有的三角形面 */ 
  568.             {                                               /* 判断该点是否与其它的面共享 */ 
  569.                 if (pObject->pFaces[j].vertIndex[0] == i || 
  570.                     pObject->pFaces[j].vertIndex[1] == i || 
  571.                     pObject->pFaces[j].vertIndex[2] == i) 
  572.                 { 
  573.                     vSum = vSum + pTempNormals[j]; 
  574.                     shared++; 
  575.                 } 
  576.             } 
  577.             pObject->pNormals[i] = vSum / float(-shared); 
  578.  
  579.             /* 规一化顶点法向 */ 
  580.             pObject->pNormals[i] = pObject->pNormals[i].normalize(); 
  581.             vSum = vZero; 
  582.             shared = 0; 
  583.         } 
  584.         /* 释放存储空间，开始下一个对象 */ 
  585.         delete [] pTempNormals; 
  586.         delete [] pNormals; 
  587.     } 
  588. } 

使用方法：

  1. //使用很简单，声明对象 
  2.   C3DSLoader m_3DS; 
  3. //初始化 
  4. m_3DS.Init("d:\plane.3ds"); 
  5. //绘制模型 
  6. m_3DS.Draw(); 

附上贴图：

 

(民警小刘)
本站文章除注明转载外，均为本站原创或编译欢迎任何形式的转载，但请务必注明出处，尊重他人劳动，同学习共成长。转载请注明：文章转载自：罗索实验室 [http://www.rosoo.net/a/201206/16070.html]
本文出处：liusir　作者：民警小刘 原文
顶一下
(5)
35.7%
踩一下
(9)
64.3%
------分隔线----------------------------
相关文章
发表评论
请自觉遵守互联网相关的政策法规，严禁发布色情、暴力、反动的言论。
评价:
表情:
用户名: 验证码:点击我更换图片
最新评论 进入详细评论页>>
栏目列表
将本文分享到微信
织梦二维码生成器
推荐内容
热点内容