三维模型obj文件的格式解析与读取-程序员宅基地

请先看这两个中文博客中对于obj的介绍：

读取Obj格式的模型文件(Dx10)

C++读入obj格式模型文件

更为详细的英文资料(用google或者aol搜索 "obj format"即可得到)：

http://en.wikipedia.org/wiki/Wavefront_.obj_file

Wavefront OBJ File Format Summary

最详细的资料 obj spec: http://www.martinreddy.net/gfx/3d/OBJ.spec

http://people.cs.clemson.edu/~dhouse/courses/405/docs/brief-obj-file-format.html

http://www.scratchapixel.com/lessons/3d-advanced-lessons/obj-file-format/obj-file-format/

 

看完以上随便一个内容，obj的格式可以说了解了。下面实现对obj文件的读取。

 

 .obj文件中，每一行都有表明该行意义的标志符。对obj的读取中，处理以下标志符

"v"--点的坐标，三维模型为x, y, z的顺序；程序中以

typedef struct ObjVector3
{
    ObjFloat x;
    ObjFloat y;
    ObjFloat z;
} ObjVector3;

结构存储。

"vt"--纹理坐标，程序中以

typedef struct ObjVector2
{
    ObjFloat x;
    ObjFloat y;
} ObjVector2;

结构存储

"vn"--法向量坐标，程序中与“v”的存储结构相同

"f"--面所用到的点坐标/纹理坐标/法向量坐标的索引，

"mtllib"--.obj文件用到的material库文件，“usemtl”标志符用到的material都是从material库文件中取出的

"g"--组group的名称，group里面的"f"可以使用0-N个"usemtl"对面的显示渲染进行控制，当使用了大于1个“usemtl”标志符，程序处理时对于已经读取的"f"很难控制；同时查看obj读取的源码，有的用到了这个标志符，有的没有使用该标志，有的使用了"usemtl"标志符对所读取的"f"面进行分割，本文的处理是使用"usemtl"标志符将"f"面分割为mesh，但是考虑到不同的group可以使用相同的"usemtl”标志（即不同的group都使用了 usemtl AAA），因此将"g"与"usemtl"结合起来，二者的名称作为mesh的名称

"usemtl"--参见"mtllib"，"g"。一旦使用了该标志符，则在该标志符后面的"f"全部受影响，直到遇到下一个"usemtl"

mesh结构，解析已经读取的“f”存储所面的点坐标/纹理坐标/法向量坐标，其结构为

struct Mesh
{
    string name;        // name
    ObjIntd mtl_idx;    // the index of material used by mesh 

    vector<ObjVector3> positions;    // "v" flag
    vector<ObjVector2> texcoords;    // "vt" flag
    vector<ObjVector3> normals;        // "vn" flag
    vector<ObjDword> indices;    // the indices of points of face in positions

    void reset()
    { 
        mtl_idx = -1;

        name.clear();
        positions.clear();
        texcoords.clear();
        normals.clear();
        indices.clear();
    }
};

结构中出现的

ObjFloat ObjIntd

是一组typedef，具体为

typedef int32_t ObjBool;
typedef uint8_t ObjByte;
typedef uint16_t ObjWord;
typedef uint32_t ObjDword;
typedef int8_t ObjIntb;
typedef int16_t ObjIntw;
typedef int32_t ObjIntd;

typedef float ObjFloat;
typedef double ObjDouble;

 对obj文件读取的主体程序如下

    ObjBool obj_file_load(const string& objname)
    {
        if (objname.empty())
            return LIBOBJ_FALSE;

        int mesh_count = 0;
        Mesh mesh_;
        string groupname;
        string usemtl;
        vector<ObjVector3> positions;
        vector<ObjVector3> normals;
        vector<ObjVector2> texcoords;
        vector<vector<ObjVertexIndex> > faces;
        map<string, ObjIntd> mtlMap;

        fstream obj_stream;    
        obj_stream.open(objname.c_str(), std::ios_base::in);
        if (!obj_stream.is_open())
            return LIBOBJ_FALSE;

        string obj_flag;
        while (obj_stream.good())
        {
            obj_stream >> obj_flag;

            if (obj_flag.empty() || (obj_flag[0] == '#'))
            {
                obj_stream.ignore(1024, '\n');            // skip line
                continue;
            }

            if (obj_flag == "v")            // position flag
                if (!obj_parse_vector3(obj_stream, positions))
                    return LIBOBJ_FALSE;
            else if (obj_flag == "vt")    // texture coordinate flag
                if (!obj_parse_vector2(obj_stream, texcoords))
                    return LIBOBJ_FALSE;
            else if (obj_flag == "vn")    // normal flag
                if (!obj_parse_vector3(obj_stream, normals))
                    return LIBOBJ_FALSE;
            else if (obj_flag == "g")        //group name
                if (!obj_parse_group(obj_stream, groupname))
                    return LIBOBJ_FALSE;
            else if (obj_flag == "f")        // face    flag
            {
                vector<ObjVertexIndex> face;

                obj_parse_face(obj_stream, face, positions, texcoords, normals);

                faces.push_back(face);
            }
            else if (obj_flag == "mtllib")    // Material library
            {
                vector<string> materialnames;

                obj_parse_mtllib(obj_stream, materialnames);

                for (unsigned i = 0; i < materialnames.size(); i++)
                    if (!mtl_file_load(get_file_path(objname) + '/' + materialnames[i]))
                        return LIBOBJ_FALSE;
            }
            else if (obj_flag == "usemtl")
            {
                if (obj_save_mesh(positions, texcoords, normals, faces, groupname+usemtl, mesh_))
                {
                    m_meshes.back().mtl_idx = mtl_index(usemtl);
                    
                    faces.clear();
                    mesh_.reset();
                }

                obj_parse_group(obj_stream, usemtl);
            }
            else
            {
                obj_stream.ignore(1024, '\n');            // skip line
            }
        }  

        if (!obj_stream.eof())
            return LIBOBJ_FALSE;

        //save mesh data
        if (obj_save_mesh(positions, texcoords, normals, faces, groupname+usemtl, mesh_))
        {
            m_meshes.back().mtl_idx = mtl_index(usemtl);

            faces.clear();
            mesh_.reset();
        }

        obj_stream.close();

        return LIBOBJ_TRUE;
    }

 

obj文件用到了.mtl格式的material，在对“mtllib”标志符解析时开始读取该.mtl文件，

对于.mtl文件的介绍，请阅读

obj + mtl 格式

mtl文件格式

MTL文件格式分析

mtl文件的简要说明

更为详细的英文资料：

http://www.fileformat.info/format/material/

http://people.cs.clemson.edu/~dhouse/courses/405/docs/brief-mtl-file-format.html

本程序中存储mtl文件的结构较为简单，只使用了mtl文件中的几个结构而没有全部处理

struct ObjMaterial
{
    string name;
    
    ObjRgb ambient;
    ObjRgb diffuse;
    ObjRgb specular;

    ObjWord shininess;
    ObjByte illumination_model;
    ObjFloat transparency;

    string ambient_texture;
    string diffuse_texture;
    string specular_texture;
};

对mtl文件的解析代码：

    ObjBool mtl_file_load(const string& mtlname)
    {
        if (mtlname.empty())        // if obj has no material
            return LIBOBJ_FALSE;

        ObjMaterial* pmaterial = NULL;

        fstream mtlstream;
        mtlstream.open(mtlname.c_str(), std::ios_base::in);    //open strFileName file
        if (!mtlstream.is_open())
            return LIBOBJ_FALSE;
        
        string mtlflag;
        while (mtlstream.good())
        {
            mtlstream >> mtlflag;

            if (mtlflag == "newmtl")
            {
                string materialname;
                mtlstream >> materialname;
                if (mtl_index(materialname) != -1)
                    continue;

                pmaterial = new ObjMaterial;
                pmaterial->name = materialname;
                m_materials.push_back(pmaterial);
            }
            else if (mtlflag == "Ka")        //Ambient color
                if (!mtl_parse_color(mtlstream, pmaterial->ambient))
                    return LIBOBJ_FALSE;
            else if (mtlflag == "Kd")        //Diffuse color
                if (!mtl_parse_color(mtlstream, pmaterial->diffuse))
                    return LIBOBJ_FALSE;
            else if (mtlflag == "Ks")        //Specular color
                if (!mtl_parse_color(mtlstream, pmaterial->specular))
                    return LIBOBJ_FALSE;
            else if (mtlflag == "Tr"/*"d"*/)        // Alpha, that is transparent
                if (!mtl_parse_light(mtlstream, pmaterial->transparency))
                    return LIBOBJ_FALSE;
            else if (mtlflag == "Ns")        //Shininess
                if (!mtl_parse_light(mtlstream, pmaterial->shininess))
                    return LIBOBJ_FALSE;
            else if (mtlflag == "illum")        //Illumination type
                if (!mtl_parse_light(mtlstream, pmaterial->illumination_model))
                    return LIBOBJ_FALSE;
            else if (mtlflag == "map_Ka")    //ambient Texture
                if (!mtl_parse_texture(mtlstream, pmaterial->ambient_texture))
                    return LIBOBJ_FALSE;
            else if (mtlflag == "map_Kd")    //diffuse Texture
                if (!mtl_parse_texture(mtlstream, pmaterial->diffuse_texture))
                    return LIBOBJ_FALSE;
            else if (mtlflag == "map_Ks")    //specular Texture
                if (!mtl_parse_texture(mtlstream, pmaterial->specular_texture))
                    return LIBOBJ_FALSE;
            else
                mtlstream.ignore(1024, '\n');    // ignore this line, on the assumption that the max characters at this line is 1024.                
        }

        if (!mtlstream.eof())
            return LIBOBJ_FALSE;

        mtlstream.close();
        return LIBOBJ_TRUE;
    }

完整的代码放在了https://github.com/priseup/obj_load

ps: 手上没有数据，还没有进行测试