Qt版OpenGL读取3DS模型

最新推荐文章于 2024-05-13 16:39:21 发布
最新推荐文章于 2024-05-13 16:39:21 发布
阅读量1.7k 收藏 6
点赞数 2
分类专栏： QT OpenGL
QT 同时被 2 个专栏收录
67 篇文章 7 订阅
订阅专栏
OpenGL
14 篇文章 1 订阅
订阅专栏

OpenGL一个重要应用就是能够读取外部的3D模型文件，比如OBJ,MD2,MD3,3DS等。在我之前的日志里已经写过一篇关于OpenGL读取Obj格式的类，详情可以看“Qt下学习OpenGL之OBJ模型”。而这次我要介绍的是3DS文件的读取。
　　接下来要贴出的代码已经在Qt4下成功运行，不过里面需要依赖一个CBMPLoader的类，这个可以从《OpenGL游戏编程》这本书里看到，也可以在我博客里找到对应的代码。
　　最后，还补充一下个人的看法。对于3DS格式，相比OBJ的话，其多了光照、贴图、材质等信息，但如果是工业标准，并且对于贴图和材质没有特别的要求的话，使用代码给每个不同物体写上一个单一颜色就好了。这样速度很快，速度是很重要的因素啊。
　　好了，贴代码了。
==========================================================================================
3DSLoader.h内容：


#ifndef __3DSLOADER_H__
#define __3DSLOADER_H__


#include "Stdafx.h"
#include "Vector.h"
#include "CBMPLoader.h"


/* 下面是定义一些块的ID号 */


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


/*  主块(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 OBJ_MESH      0x4100            /* 新的网格对象 */


/* 网格对象的次级定义 */
#define OBJ_VERTICES  0x4110 /* 对象顶点 */
#define OBJ_FACES     0x4120 /* 对象的面 */
#define OBJ_MATERIAL  0x4130 /* 对象的材质 */
#define OBJ_UV        0x4140 /* 对象的UV纹理坐标 */


/* 面的结构定义 */
struct tFace
{
        int vertIndex[3]; /* 顶点索引 */
        int coordIndex[3]; /* 纹理坐标索引 */
};


/* 材质信息结构体 */
struct tMatInfo
{
        char  strName[255]; /* 纹理名称 */
        char  strFile[255]; /* 纹理文件名称 */
        unsigned char  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 */
        bool bHasTexture; /* 是否具有纹理映射 */
        char strName[255]; /* 对象的名称 */
        Vector3  *pVerts; /* 对象的顶点 */
        Vector3  *pNormals; /* 对象的法向量 */
        Vector2  *pTexVerts; /* 纹理UV坐标 */
        tFace *pFaces; /* 对象的面信息 */
};


/* 模型信息结构体 */
struct t3DModel
{ int numOfObjects; /* 模型中对象的数目 */
        int numOfMaterials; /* 模型中材质的数目 */
        QVectorpMaterials; /* 材质链表信息 */
        QVector pObject; /* 模型中对象链表信息 */
};


/* 块信息的结构 */
struct tChunk
{
        unsigned short int ID; /* 块的ID */
        unsigned int length; /* 块的长度 */
        unsigned int bytesRead; /* 需要读的块数据的字节数 */
};


#define MAX_TEXTURES  100


/* 3DS文件载入类 */
class C3DSLoader
{
public:
        /* 构造函数 */
        C3DSLoader();
        virtual ~C3DSLoader();
        void Draw();//显示3ds模型
        void Init(char *filename);


private:
        /* 读一个字符串 */
        int  GetString(char *);


        /* 装载3ds文件到模型结构中 */
        bool Import3DS(t3DModel *pModel, char *strFileName);


        /*  从文件中创建纹理 */
        void LoadTexture(char* filename, GLuint textureArray[], GLuint textureID);


        /* 读取一个块 */
        void ReadChunk(tChunk *);


        /* 读取下一个块 */
        void ReadNextChunk(t3DModel *pModel, tChunk *);


        /* 读取下一个对象 */
        void ReadNextObjChunk(t3DModel *pModel,t3DObject *pObject,tChunk *);


        /* 读取下一个材质块 */
        void ReadNextMatChunk(t3DModel *pModel, tChunk *);


        /* 读取对象颜色的RGB值 */
        void ReadColor(tMatInfo *pMaterial, tChunk *pChunk);


        /* 读取对象的顶点信息 */
        void ReadVertices(t3DObject *pObject, tChunk *);


        /* 读取对象的面信息 */
        void ReadVertexIndices(t3DObject *pObject,tChunk *);


        /* 读取对象的纹理坐标 */
        void ReadUVCoordinates(t3DObject *pObject,tChunk *);


        /* 读取赋予对象的材质 */
        void ReadObjMat(t3DModel *pModel,t3DObject *pObject,tChunk *pPreChunk);


        /* 计算对象顶点的法向量 */
        void ComputeNormals(t3DModel *pModel);


        /* 释放内存,关闭文件 */
        void CleanUp();


        FILE     *m_FilePointer;          /*< 文件指针 */
        tChunk     *m_CurrentChunk;             /*< 读取过程中当前块 */
        tChunk     *m_TempChunk;                /*< 临时块 */
        GLuint       m_textures[MAX_TEXTURES];    /*< 纹理 */
        t3DModel     m_3DModel;                   /*< 模型 */
        CBMPLoader   m_BMPTexture;                /* 载入位图 */


};


#endif






==========================================================================================
3DSLoader.cpp内容：
#include "Stdafx.h"
#include "3DSLoader.h"


/* 构造函数 */
C3DSLoader::C3DSLoader()
{
    m_CurrentChunk = new tChunk; /* 为当前块分配空间 */
    m_TempChunk = new tChunk;        /* 为临时块分配空间 */
    m_3DModel.numOfObjects = 0;
    m_3DModel.numOfMaterials = 0;
    for(int i=0;i0)
            LoadTexture(m_3DModel.pMaterials[i].strFile,m_textures, i);/* 使用纹理文件名称来装入位图 */
        m_3DModel.pMaterials[i].texureId = i;/* 设置材质的纹理ID */
    }
}


/* 显示3ds模型 */
void C3DSLoader::Draw()
{
    /*保存现有颜色属实性 */
    glPushAttrib(GL_CURRENT_BIT);
    glDisable(GL_TEXTURE_2D);
    //glEnable(GL_LIGHT0);


    /* 遍历模型中所有的对象 */
    for(int i = 0; i < m_3DModel.numOfObjects; i++)
    {
        /* 如果对象的大小小于0，则退出 */
        if(m_3DModel.pObject.size() <= 0)             break;         /* 获得当前显示的对象 */         t3DObject *pObject = &m_3DModel.pObject[i];         /* 判断该对象是否有纹理映射 */         if(pObject->bHasTexture)
        {
            glEnable(GL_TEXTURE_2D);/* 打开纹理映射 */
            glBindTexture(GL_TEXTURE_2D, m_textures[pObject->materialID]);
        }
        else
            glDisable(GL_TEXTURE_2D);/* 关闭纹理映射 */


        glColor3ub(255, 255, 255);


        /* 开始绘制 */


            glBegin(GL_TRIANGLES);


        /* 遍历所有的面 */
        for(int j = 0; j < pObject->numOfFaces; j++)
        {
            /* 遍历三角形的所有点 */
            for(int tex = 0; tex < 3; tex++)             {                 /* 获得面对每个点的索引 */                 int index = pObject->pFaces[j].vertIndex[tex];


                /* 给出法向量 */
                glNormal3f(pObject->pNormals[index].x,pObject->pNormals[index].y,
                           pObject->pNormals[index].z);


                /* 如果对象具有纹理 */
                if(pObject->bHasTexture)
                {
                    /* 确定是否有UVW纹理坐标 */
                    if(pObject->pTexVerts)
                        glTexCoord2f(pObject->pTexVerts[index].x,pObject->pTexVerts[index].y);
                }
                else
                {
                    if(m_3DModel.pMaterials.size() && pObject->materialID>= 0)
                    {
                        unsigned char *pColor = m_3DModel.pMaterials[pObject->materialID].color;
                        glColor3ub(pColor[0],pColor[1],pColor[2]);
                    }
                }
                glVertex3f(pObject->pVerts[index].x,pObject->pVerts[index].y,pObject->pVerts[index].z);
            }
        }
        glEnd();
        /* 绘制结束 */
    }


    //glDisable(GL_LIGHT0);
    glEnable(GL_TEXTURE_2D);


    /* 恢复前一属性 */
    glPopAttrib();
}


void C3DSLoader::LoadTexture(char* filename, GLuint textureArray[], GLuint textureID)
{
    if(!filename)
        return;


    if(!this->m_BMPTexture.LoadBitmap(filename))
    {
        QMessageBox::warning(0,QObject::tr("Load Bitmap Error"),QObject::tr("Load Bitmap Error"));
        return;
    }


    glGenTextures(1,&m_textures[textureID]);


    glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
    glBindTexture(GL_TEXTURE_2D, m_textures[textureID]);


    /* 控制滤波 */
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR);


    /* 创建纹理 */
    gluBuild2DMipmaps(GL_TEXTURE_2D, 3, m_BMPTexture.imageWidth,m_BMPTexture.imageHeight, GL_RGB,
                      GL_UNSIGNED_BYTE, this->m_BMPTexture.image);


}


/* 载入3DS文件到模型结构中 */
bool C3DSLoader::Import3DS(t3DModel *pModel,char *strFileName)
{
    char strMessage[255] = {0};


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


    /* 检查文件指针 */
    if(!m_FilePointer)
    {
        sprintf(strMessage, "Cann't find the file: %s!", strFileName);
        QMessageBox::information(NULL,
                                 "Error",
                                 strMessage,
                                 QMessageBox::Yes | QMessageBox::No,
                                 QMessageBox::Yes);
        return false;
    }


    /* 将文件的第一块读出并判断是否是3ds文件 */
    ReadChunk(m_CurrentChunk);


    /* 确保是3ds文件 */
    if (m_CurrentChunk->ID != PRIMARY)
    {
        QMessageBox::information(NULL,
                                 "Error",
                                 "Cann't Loading the Function",
                                 QMessageBox::Yes | QMessageBox::No,
                                 QMessageBox::Yes);
        return false;
    }


    /* 递归读出对象数据 */
    ReadNextChunk(pModel, m_CurrentChunk);


    /* 计算顶点的法线 */
    ComputeNormals(pModel);


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


    return true;
}


/*  读入一个字符串 */
int C3DSLoader::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;
}


/* 读入块的ID号和它的字节长度 */
void C3DSLoader::ReadChunk(tChunk *pChunk)
{
    /* 读入块的ID号 */
    pChunk->bytesRead = fread(&pChunk->ID, 1, 2, m_FilePointer);


    /* 读入块占用的长度 */
    pChunk->bytesRead += fread(&pChunk->length, 1, 4, m_FilePointer);


}


/* 读出3ds文件的主要部分 */
void C3DSLoader::ReadNextChunk(t3DModel *pModel, tChunk *pPreChunk)
{
    t3DObject newObject = {0}; /* 用来添加到对象链表 */
    tMatInfo newTexture = {0};    /* 用来添加到材质链表 */
    unsigned int version = 0; /* 保存文件版本 */
    int buffer[50000] = {0}; /* 用来跳过不需要的数据 */
    m_CurrentChunk = new tChunk; /* 为新的块分配空间 */


    /* 继续读入子块 */
    while (pPreChunk->bytesRead < pPreChunk->length)
    {
        /* 读入下一个块 */
        ReadChunk(m_CurrentChunk);


        /* 判断块的ID号 */
        switch (m_CurrentChunk->ID)
        {


            /* 文件版本号 */
        case VERSION:


            /* 读入文件的版本号 */
            m_CurrentChunk->bytesRead += fread(&version, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);


            /* 如果文件版本号大于3，给出一个警告信息 */
            if (version > 0x03)
                QMessageBox::information(NULL,
                                         "Warning",
                                         "The 3DS File Version is wrong",
                                         QMessageBox::Yes | QMessageBox::No,
                                         QMessageBox::Yes);
            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;


            /* 进入下一个块 */
            ReadNextChunk(pModel, m_CurrentChunk);
            break;


            /* 材质信息 */
        case MATERIAL:


            /* 材质的数目递增 */
            pModel->numOfMaterials++;


            /* 在纹理链表中添加一个空白纹理结构 */
            pModel->pMaterials.push_back(newTexture);


            /* 进入材质装入函数 */
            ReadNextMatChunk(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);


            /* 进入其余的对象信息的读入 */
            ReadNextObjChunk(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;
        }


        /* 增加从最后块读入的字节数 */
        pPreChunk->bytesRead += m_CurrentChunk->bytesRead;
    }


    /* 释放当前块的内存空间 */
    delete m_CurrentChunk;
    m_CurrentChunk = pPreChunk;
}


/* 处理所有的文件中对象的信息 */
void C3DSLoader::ReadNextObjChunk(t3DModel *pModel, t3DObject *pObject, tChunk *pPreChunk)
{
    /* 用于读入不需要的数据 */
    int buffer[50000] = {0};


    /* 对新的块分配存储空间 */
    m_CurrentChunk = new tChunk;


    /* 继续读入块的内容直至本子块结束 */
    while (pPreChunk->bytesRead < pPreChunk->length)
    {
        /* 读入下一个块 */
        ReadChunk(m_CurrentChunk);


        /* 区别读入是哪种块 */
        switch (m_CurrentChunk->ID)
        {
            /* 正读入的是一个新块 */
        case OBJ_MESH:
            /* 使用递归函数调用，处理该新块 */
            ReadNextObjChunk(pModel, pObject, m_CurrentChunk);
            break;


            /* 读入是对象顶点 */
        case OBJ_VERTICES:
            ReadVertices(pObject, m_CurrentChunk);
            break;


            /* 读入的是对象的面 */
        case OBJ_FACES:
            ReadVertexIndices(pObject, m_CurrentChunk);
            break;


            /* 读入的是对象的材质名称 */
        case OBJ_MATERIAL:
            /* 读入对象的材质名称 */
            ReadObjMat(pModel, pObject, m_CurrentChunk);
            break;


            /* 读入对象的UV纹理坐标 */
        case OBJ_UV:
            /* 读入对象的UV纹理坐标 */
            ReadUVCoordinates(pObject, m_CurrentChunk);
            break;


        default:
            /* 略过不需要读入的块 */
            m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
            break;
        }
        /* 添加从最后块中读入的字节数到前面的读入的字节中 */
        pPreChunk->bytesRead += m_CurrentChunk->bytesRead;
    }
    /* 释放当前块的内存空间，并把当前块设置为前面块 */
    delete m_CurrentChunk;
    m_CurrentChunk = pPreChunk;
}


/* 处理所有的材质信息 */
void C3DSLoader::ReadNextMatChunk(t3DModel *pModel, tChunk *pPreChunk)
{
    /* 用于读入不需要的数据 */
    int buffer[50000] = {0};


    /* 给当前块分配存储空间 */
    m_CurrentChunk = new tChunk;


    /* 继续读入这些块 */
    while (pPreChunk->bytesRead < pPreChunk->length)
    {
        /* 读入下一块 */
        ReadChunk(m_CurrentChunk);
        /* 判断读入的是什么块 */
        switch (m_CurrentChunk->ID)
        {
        case MATNAME: /* 材质的名称 */
            /* 读入材质的名称 */
            m_CurrentChunk->bytesRead += fread(pModel->pMaterials[pModel->numOfMaterials - 1].strName, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
            break;
        case MATDIFFUSE: /* 对象的R G B颜色 */
            ReadColor(&(pModel->pMaterials[pModel->numOfMaterials - 1]), m_CurrentChunk);
            break;
        case MATMAP: /* 纹理信息的头部 */
            /* 下一个材质块信息 */
            ReadNextMatChunk(pModel, m_CurrentChunk);
            break;
        case MATMAPFILE: /* 材质文件的名称 */
            /* 读入材质的文件名称 */
            m_CurrentChunk->bytesRead += fread(pModel->pMaterials[pModel->numOfMaterials - 1].strFile, 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;
        }
        /* 添加从最后块中读入的字节数 */
        pPreChunk->bytesRead += m_CurrentChunk->bytesRead;
    }
    /* 删除当前块，并将当前块设置为前面的块 */
    delete m_CurrentChunk;
    m_CurrentChunk = pPreChunk;
}


/* 读入RGB颜色 */
void C3DSLoader::ReadColor(tMatInfo *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 C3DSLoader::ReadVertexIndices(t3DObject *pObject, tChunk *pPreChunk)
{
    unsigned short index = 0; /* 用于读入当前面的索引 */
    /* 读入该对象中面的数目 */
    pPreChunk->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++)         {             /* 读入当前面的第一个点  */             pPreChunk->bytesRead += fread(&index, 1, sizeof(index), m_FilePointer);
            if(j < 3)             {                 /* 将索引保存在面的结构中 */                 pObject->pFaces[i].vertIndex[j] = index;
            }
        }
    }
}


/* 读入对象的UV坐标 */
void C3DSLoader::ReadUVCoordinates(t3DObject *pObject, tChunk *pPreChunk)
{
    /* 读入UV坐标的数量 */
    pPreChunk->bytesRead += fread(&pObject->numTexVertex, 1, 2, m_FilePointer);


    /* 分配保存UV坐标的内存空间 */
    pObject->pTexVerts = new Vector2[pObject->numTexVertex];


    /* 读入纹理坐标 */
    pPreChunk->bytesRead += fread(pObject->pTexVerts, 1, pPreChunk->length - pPreChunk->bytesRead, m_FilePointer);
}


/*  读入对象的顶点 */
void C3DSLoader::ReadVertices(t3DObject *pObject, tChunk *pPreChunk)
{
    /* 读入顶点的数目 */
    pPreChunk->bytesRead += fread(&(pObject->numOfVerts), 1, 2, m_FilePointer);


    /* 分配顶点的存储空间，然后初始化结构体 */
    pObject->pVerts = new Vector3 [pObject->numOfVerts];
    memset(pObject->pVerts, 0, sizeof(Vector3) * pObject->numOfVerts);


    /* 读入顶点序列 */
    pPreChunk->bytesRead += fread(pObject->pVerts, 1, pPreChunk->length - pPreChunk->bytesRead, m_FilePointer);


    /* 遍历所有的顶点将Y轴和Z轴交换，然后将Z轴反向 */
    for(int i = 0; i < pObject->numOfVerts; i++)
    {
        /* 保存Y轴的值 */
        float fTempY = pObject->pVerts[i].y;
        /* 设置Y轴的值等于Z轴的值 */
        pObject->pVerts[i].y = pObject->pVerts[i].z;
        /* 设置Z轴的值等于-Y轴的值  */
        pObject->pVerts[i].z = -fTempY;
    }
}


/* 读入对象的材质名称 */
void C3DSLoader::ReadObjMat(t3DModel *pModel, t3DObject *pObject, tChunk *pPreChunk)
{
    char strMaterial[255] = {0}; /* 用来保存对象的材质名称 */
    int buffer[50000] = {0}; /* 用来读入不需要的数据 */


    /* 读入赋予当前对象的材质名称 */
    pPreChunk->bytesRead += GetString(strMaterial);


    /* 遍历所有的纹理 */
    for(int i = 0; i < pModel->numOfMaterials; i++)
    {
        /* 如果读入的纹理与当前的纹理名称匹配 */
        if(strcmp(strMaterial, pModel->pMaterials[i].strName) == 0)
        {
            /* 设置材质ID */
            pObject->materialID = i;


            /* 判断是否是纹理映射 */
            if(strlen(pModel->pMaterials[i].strFile) > 0) {


                /* 设置对象的纹理映射标志 */
                pObject->bHasTexture = true;
            }
            break;
        }
        else
        {
            /* 如果该对象没有材质，则设置ID为-1 */
            pObject->materialID = -1;
        }
    }
    pPreChunk->bytesRead += fread(buffer, 1, pPreChunk->length - pPreChunk->bytesRead, m_FilePointer);
}


/* 计算对象的法向量 */
void C3DSLoader::ComputeNormals(t3DModel *pModel)
{
    Vector3 vVector1, vVector2, vNormal, vPoly[3];


    /* 如果模型中没有对象，则返回 */
    if(pModel->numOfObjects <= 0)
        return;


    /* 遍历模型中所有的对象 */
    for(int index = 0; index < pModel->numOfObjects; index++)
    {
        /* 获得当前的对象 */
        t3DObject *pObject = &(pModel->pObject[index]);


        /* 分配需要的存储空间 */
        Vector3 *pNormals = new Vector3 [pObject->numOfFaces];
        Vector3 *pTempNormals = new Vector3 [pObject->numOfFaces];
        pObject->pNormals = new Vector3 [pObject->numOfVerts];


        /* 遍历对象的所有面 */
        for(int i=0; i < pObject->numOfFaces; i++)
        { vPoly[0] = pObject->pVerts[pObject->pFaces[i].vertIndex[0]];
            vPoly[1] = pObject->pVerts[pObject->pFaces[i].vertIndex[1]];
            vPoly[2] = pObject->pVerts[pObject->pFaces[i].vertIndex[2]];


            /* 计算面的法向量 */
            vVector1 = vPoly[0] - vPoly[2];        /* 获得多边形的矢量 */
            vVector2 = vPoly[2] - vPoly[1];        /* 获得多边形的第二个矢量 */
            vNormal  = vVector1.crossProduct(vVector2); /* 计算两个矢量的叉积 */
            pTempNormals[i] = vNormal;
            vNormal  = vNormal.normalize(); /* 规一化叉积 */
            pNormals[i] = vNormal; /* 将法向量添加到法向量列表中 */
        }


        /* 计算顶点法向量 */
        Vector3 vSum(0.0,0.0,0.0);
        Vector3 vZero = vSum;
        int shared=0;


        /* 遍历所有的顶点 */
        for (int i = 0; i < pObject->numOfVerts; i++)
        { for (int j = 0; j < pObject->numOfFaces; j++) /* 遍历所有的三角形面 */
            { /* 判断该点是否与其它的面共享 */
                if (pObject->pFaces[j].vertIndex[0] == i ||
                    pObject->pFaces[j].vertIndex[1] == i ||
                    pObject->pFaces[j].vertIndex[2] == i)
                {
                    vSum = vSum + pTempNormals[j];
                    shared++;
                }
            }
            pObject->pNormals[i] = vSum / float(-shared);


            /* 规一化顶点法向 */
            pObject->pNormals[i] = pObject->pNormals[i].normalize();
            vSum = vZero;
            shared = 0;
        }
        /* 释放存储空间，开始下一个对象 */
        delete [] pTempNormals;
        delete [] pNormals;
    }
}






==========================================================================================
使用方法：
//使用很简单，声明对象
  C3DSLoader m_3DS;
//初始化
m_3DS.Init("d:\plane.3ds");
//绘制模型

m_3DS.Draw();

wang13342322203
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Qt 3D的研究（三）：显示3D模型
开发游戏，辉煌全中国
02-27 3万+
上一篇文章介绍了如何使用最少的代码创建一个Qt 3D的应用。和大家最初接触的glut一样，对于3D应用来说，需要做的准备工作还真不少，不过呢，Qt 3D把一些窗口相关的琐碎事情解决了，剩下的，该由我们完成重要的渲染部分了，可以说，带来了某种程度的方便。
qt加载obj格式的3D模型
weixin_35749545的博客
12-30 2661
在 Qt 中加载 obj 格式的 3D 模型可以使用 Qt 3D 模块。 首先，你需要在你的工程文件中包含 Qt 3D 模块，方法是在工程文件的顶部添加以下行： QT += 3dcore 3drender 3dinput 3dlogic 3dextras 然后，在你的代码中包含 Qt 3D 的头文件： #include <Qt3DCore/QEntity> #include <...
LearnOpenGL（十四）之模型加载
最新发布
ckg3824278的博客
05-13 144
LearnOpenGL（十四）之模型
Qt3D的简单应用之一：加载外部3D模型
热门推荐
04-10 1万+
之前项目工作中需要实现一个功能：在控制软件中通过3D的方式显示我们的设备，使其能够更随设备位置的变化而变化。由于控制软件我使用的Qt进行的开发，那么自然就可以使用Qt3D来实现这个功能。我使用的开发环境为Qt Creator，Qt版本为Qt5.10.1。 首先看看Qt官方有没有什么合适的例子吧，在Qt的示例代码中搜索“3D”，就可以看到这样一个工程"Qt 3D: Basic Shapes C++...
Qt5.11 Qt 3D入门（二）
UCRE的专栏
08-03 9218
前面我们使用Qt 3D框架创建了一个最基本的3D程序，蓝色的背景，里面什么也没有。 现在，我们要在此基础上把3D模型放进去。3D建模的工具有很多，Auto CAD, 3DS Max，Rhino, Blender等等，有收费，有免费，不一而足，总有一款你会喜欢。 在学校不同的专业学的软件可能不同，笔者是电子专业的，十几年前在学校只学过工程制图，使用的是AutoCAD。但没关系，我们要做的是编写3D...
Qt OpenGL加载OBJ模型
qq_38105943的博客
01-18 9655
在加载OBJ模型文件之前首先要对OBJ文件的内容有所了解，在3d模型网站https://free3d.com/3d-models/3d-printable-obj 随便找了一个模型 它的OBJ文件内容为： # File exported by ZBrush version 4.4 # www.zbrush.com #Vertex Count 20545 #UV Vertex Count ...
OpenGL实现3DS文件中的模型自由旋转
07-03
OpenGL实现3DS文件中的模型自由旋转
OpenGL读取3DS模型
06-12
本程序用C++编写，可以使用OpenGL工具读取并显示3DS模型。
Qt5版NeHe OpenGL教程6-10
05-17
这个Qt5版的NeHe OpenGL教程6-10将深入探讨如何在Qt5框架下利用OpenGL进行图形渲染。 第六课主要讲解了颜色索引纹理映射。颜色索引是一种早期的纹理映射技术，通过颜色表来查找对应的颜色值。在这一课中，我们将...
Qt openGL加载三维模型
09-21
可以支持obj格式模型，采用qt的框架讲模型显示出来。。。
在OPENGL中读取3DS模型文件
10-17
本文将详细介绍如何在 OpenGL 中读取 3DS 模型文件，包括 3DS 文件的存储格式、 OpenGL 与 3DS 的接口编程、读取 3DS 文件的实现等。 3DS 文件格式简介 3DS 文件由许多块组成，每个块首先描述其信息类别，即该块是...
Qt窗口中实现的3DS文件读取程序
12-31
我用的是Qt5.5实现的读取3DS文件的程序，如果用不了可以把里面的核心代码一直到你的程序里
Qt3D 加载obj不显示的问题
浅暖的博客
06-27 1752
Qt3D 加载obj不显示的问题
Qt和OpenGL：使用Open Asset Import Library（ASSIMP）加载3D模型
江达小记
12-15 2049
Qt和OpenGL：使用Open Asset Import Library（ASSIMP）加载3D模型 翻译自：https://www.ics.com/blog/qt-and-opengl-loading-3d-model-open-asset-import-library-assimp By Eric Stone Wednesday, May 21, 2014 Twitter LinkedIn ...
Qt opengl 图片实现3D效果
weixin_45571586的博客
03-26 4348
首先清楚OpenGL中的常用几个函数作用： （1）initializeGL() 初始化OpenGL函数 （2）resizeGL(int w, int h)调整窗口大小函数 （3）paintGL()绘制图像函数 1、paintGL()函数作调整 先定义模型、观察、投影3个矩阵。 //1、定义的4*4的矩阵 模型 观察 投影矩阵 QMatrix4x4 model; QMatrix4x4 view; QMatrix4x4 projection; /*----------按照
三维绘图之OpenGL和Qt的结合
hbyzl的专栏
11-09 3578
原文                  http://blog.csdn.net/bcs_01/article/details/8922115 主题QtOpenGL正则表达式         OpenGL是绘制三维图形的标准API。Qt应用程序可以使用QtOpenGL模块绘制三维图形，该模块依赖于系统的OpenGL库。Qt OpenGL模块提供QGLWidget类，可以通过对它子类
实现图形Qt学习：三维绘图之OpenGL和Qt的结合
weixin_33795093的博客
05-13 831
任务之余抽点时间出来写写博文，希望对新接触的朋友有帮助。今天在这里和大家一起学习一下实现图形             OpenGL是绘制三维图形的标准API。Qt应用程序可以应用QtOpenGL模块绘制三维图形，该模块依赖于系统的OpenGL库。Qt OpenGL模块供给QGLWidget类，可以通过对它子类化，并应用OpenGL命令开发出自己的窗口部件。对许多三维应用程序来讲，这就足够了。  ...
Qt实现读取显示obj文件——读取数据
Sean的专栏
03-16 1万+
前一篇写了关于实现的一些说明Qt实现读取显示obj文件——说明,这一篇说一说数据的读取~说明在头文件中我们建立一个OBJ文件的数据模型类；记录一些模型的结构与之后可能会使用的数据结构；(之后会在Github上上传所有的源码，但是数据不会上传~)class _GLModel { public: QString path;//obj文件路径 QString mtllibName;//材质文
QT的OpenGL进行模型的3D展示
weixin_46636063的博客
06-03 1835
QT的OpenGL进行模型的3D展示 由于项目需要，我需要实现一个模型3D展示的功能。这里采用的是QT的OpenGL进行实现（无材质！！！）。 由于本人也是第一次接触这方面知识，所以这里就将自己的学习历程记录一下。 主要内容 1.QT的OpenGL相关知识；这里包括QT的OpenGL类继承，着色器，材质，光照，桌标变换等知识； 2.模型文件在QT中的加载； 3.移植到虚拟机linux，Cent-OS7遇到的多个问题； 最终成果 在虚拟机下实现如下功能：（模型文件是我在SolidWork中自行画的并保存为ST
qt中使用opengl加载外部3ds模型
09-10
在Qt中使用OpenGL加载外部3DS模型，首先要进行以下步骤： 1. 引入必要的头文件和库文件：在代码中引入QtOpenGL和QGLWidget的头文件，并链接OpenGL库。 2. 创建一个继承自QGLWidget的自定义OpenGL窗口类：重写其initializeGL、resizeGL和paintGL方法。 3. 初始化OpenGL环境：在initializeGL方法中，设置OpenGL的一些初始参数，例如背景色、深度测试等。 4. 加载3DS模型文件：在自定义类中定义一个加载3DS模型文件的方法。可以使用第三方库如Assimp来加载3DS文件，并获取模型的顶点数据、面索引数据等。 5. 在paintGL方法中绘制3D场景：将加载的3DS模型的顶点数据和面索引数据传递给OpenGL，使用glBegin和glEnd函数绘制模型。 6. 设置相机视角和投影矩阵：在reshapeGL方法中设置相机的视角和OpenGL的投影矩阵，以呈现合适的视图效果。 7. 在主窗口中使用自定义OpenGL窗口类：在Qt的主窗口中创建自定义OpenGL窗口类的实例，将其添加到主窗口中显示。 8. 运行程序并查看效果：编译并运行程序，即可在主窗口中显示加载的外部3DS模型。 需要注意的是，由于3DS文件格式的复杂性，加载和渲染大型3DS模型可能会导致性能问题。因此，在加载和渲染过程中，可以对模型进行优化，例如使用顶点缓冲对象(VBO)、索引缓冲对象(IBO)等手段来提高渲染效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值