obj-model.cpp

Go to the documentation of this file.

/*
 * obj-model.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Routines to parse and draw OBJ 3D models (see obj-model.h)
 */

// includes --------------------------------------------------------------------
#include "obj-model.h"          // always include our own header first

#include "obj-material.h"

#include "common/wave_ex.h"
#include "perf/perf.h"
#include "util/parsing.h"
#include "util/file.h"
#include "wave-glut/material.h"


namespace obj {


// interface destructors
Model::~Model(void) throw() { }


// constants and statics
static const eParseBehavior s_parseFlags                = eParse_Strip;


// texture u,v coordinates
struct uv_t {
        uv_t(void) throw() { }
        uv_t(IN float iu, IN float iv) : u(iu), v(iv) { }
        void clear(void) throw() {
                        u = v = 0.0;
                }

        // data fields
        float           u;
        float           v;
};



// this is the face as read from the file: list of indices to vertex arrays
struct face_idx_t {
        face_idx_t(void) throw() { }
        face_idx_t(IN long iv, IN long ivt, IN long ivn) throw() :
            v(iv), vt(ivt), vn(ivn) { }

        // data fields
        long            v;      // vertex index
        long            vt;     // vertex texture index
        long            vn;     // vertex normal index
};



// this is the raw face vertex data.
struct face_vtx_t {
        // data fields
        point3d_t       v;      // vertex
        point3d_t       n;      // normal
        uv_t            uv;     // texture u,v-coordinates
};



////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

char *
findChar
(
IN char * string,
IN char find
)
throw()
{
        ASSERT(string, "null");

        char * p = string;
        for (; *p && *p != find; ++p) { }
        return p;
}



static point3d_t
readPoint3d
(
IN const char * p
)
{
        point3d_t v(0, 0, 0);
        readFloatsFromString(p, 3, &v.x);
        // v.dump("just parsed");
        return v;
}



static uv_t
readUV
(
IN const char * p
)
{
        uv_t uv(0, 0);
        readFloatsFromString(p, 3, &uv.u);
        return uv;
}



////////////////////////////////////////////////////////////////////////////////
//
//      OBJModel -- class that implements the obj::Model interface for
//              Open Asset Import library aiScene objects.
//
////////////////////////////////////////////////////////////////////////////////

class OBJModel : public obj::Model {
public:
        // constructor, destructor ---------------------------------------------
        OBJModel(void) throw();
        ~OBJModel(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN nstream::Stream * stream,
                                IN float scale);

        // glut::Renderable class interface methods ----------------------------
        rect3d_t getBoundingBox(void) const throw() { return m_bounds; }
        void render(IN const glut::render_context_t& rc,
                                IN glut::RenderQueue * rq);

        // obj::Model class interface methods ----------------------------------

private:
        // private typedefs ----------------------------------------------------
        typedef std::vector<point3d_t> vec_point_t;
        typedef std::vector<uv_t> vec_uv_t;
        typedef std::vector<face_vtx_t> face_t;

        struct mesh_t {
                std::string     material;
                face_t          vertices;
        };

        typedef std::vector<smart_ptr<mesh_t> > vec_mesh_t;

        // private helper methods ----------------------------------------------
        void readFace(IN mesh_t * mesh,
                                IN const char * p);
        void readMaterialMaps(IN nstream::Stream * stream,
                                IN const char * p);

        // private member data -------------------------------------------------
        rect3d_t                        m_bounds;
        std::string                     m_timerName;
        vec_point_t                     m_vertices;
        vec_point_t                     m_vertexNormals;
        vec_uv_t                        m_vertexTexCoords;
        vec_mesh_t                      m_meshes;
        map_mtl_t                       m_materials;
        float                           m_scale;
        long                            m_faceCount;    // faces read from file
        long                            m_triangleCount;// triangles found
};



OBJModel::OBJModel
(
void
)
throw()
{
        m_faceCount = 0;
        m_triangleCount = 0;
        m_scale = 1.0;
}



void
OBJModel::initialize
(
IN nstream::Stream * stream,
IN float scale
)
{
        perf::Timer timer("OBJ format parse");
        ASSERT(stream, "null");
        ASSERT(scale > 0, "Bad scale");

        // save scale
        m_scale = scale;

        // get the timer name
        m_timerName = "render:";
        smart_ptr<nstream::File> file = stream->getFile();
        if (file) {
                m_timerName += GetFilename(file->getName());
        }

        // parse line by line
        eParseBehavior flags = s_parseFlags;
        std::string line, keyword, token;
        smart_ptr<mesh_t> currMesh;             // current mesh
        while (!stream->eof()) {
                line = getNextLineFromStream(*stream, flags);

                // now parse this line
                const char * p = line.c_str();

                // get the first token (keyword)
                p = getNextTokenFromString(p, keyword, flags);

                // skip empty lines
                if ("" == keyword)
                        continue;

                // what do we do?
                // REMEMBER: it is more efficient to put most common first!
                if ("v" == keyword) {
                        point3d_t v = readPoint3d(p);   // read vertex
                        if (!m_vertices.size()) {
                                // first vertex!
                                m_bounds.setToPoint(v);
                        } else {
                                m_bounds.includePoint(v);
                        }
                        m_vertices.push_back(v);
                } else if ("vn" == keyword) {
                        m_vertexNormals.push_back(readPoint3d(p));
                } else if ("vt" == keyword) {
                        m_vertexTexCoords.push_back(readUV(p));
                } else if ("f" == keyword) {
                        ASSERT_THROW(currMesh,
                            "faces specified without material?");
                        this->readFace(currMesh, p);
                } else if ("usemtl" == keyword) {
                        currMesh = new mesh_t;
                        ASSERT(currMesh, "out of memory");
                        getNextTokenFromString(p, currMesh->material,
                            s_parseFlags);
                        ASSERT_THROW(
                            m_materials.end() != m_materials.find(currMesh->material),
                            "Unknown material: " << p);
                        DPRINTF("Reading new mesh with material: '%s'", 
                            currMesh->material.c_str());
                        m_meshes.push_back(currMesh);
                } else if ("mtllib" == keyword) {
                        this->readMaterialMaps(stream, p);
                } else {
                        DPRINTF("Skipping unrecognized OBJ keyword: %s",
                            line.c_str());
                }
        }

        // report
        DPRINTF("Read %d vertices", (int) m_vertices.size());
        DPRINTF("Read %d vertex normals", (int) m_vertexNormals.size());
        DPRINTF("Read %d vertex texture coordinates", (int) m_vertexTexCoords.size());
        DPRINTF("Read %d meshes", (int) m_meshes.size());
        DPRINTF("Read %d materials", (int) m_materials.size());
        DPRINTF("Converted %ld faces into %ld triangles", m_faceCount,
            m_triangleCount);
        m_bounds.dump("Bounding box");

        // free memory!  all of this has been copied to vertex structs
        m_vertices.clear();
        m_vertexNormals.clear();
        m_vertexTexCoords.clear();
}



void
OBJModel::render
(
IN const glut::render_context_t& rc,
IN glut::RenderQueue * rq
)
{
        perf::Timer timer(m_timerName.c_str());
        ASSERT(rq, "null");

        // scale
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glScalef(m_scale, m_scale, m_scale);

        // first, we'll get the vertex and vertex normal arrays into OpenGL
        glEnableClientState(GL_VERTEX_ARRAY);
        glEnableClientState(GL_NORMAL_ARRAY);

        // render each mesh
        for (vec_mesh_t::iterator i = m_meshes.begin(); i != m_meshes.end();
             ++i) {
                mesh_t * mesh = *i;
                ASSERT(mesh, "null");

                // look up the material
                map_mtl_t::iterator mtl = m_materials.find(mesh->material);
                if (m_materials.end() == mtl) {
                        DPRINTF("WARNING: cannot find material: %s",
                            mesh->material.c_str());
                        continue;       // skip mesh altogether
                }
                smart_ptr<glut::Material>& material = mtl->second;
                ASSERT(material, "null");

                // set up material (and make sure it is cleaned up after)
                glut::MaterialContext mc(material);

                // we know the mesh is a triangle mesh, with vertices and
                //      normals already provided to OpenGL above.
                int nVertices = (int) mesh->vertices.size();

                const int coordinatesPerVertex = 3;
                const int type = GL_FLOAT;
                const int stride = sizeof(face_vtx_t);

                // get a reference to the first face vertex struct
                face_vtx_t& fv0 = mesh->vertices[0];

                // set vertex and normal arrays
                glVertexPointer(coordinatesPerVertex, type, stride, &fv0.v.x);
                glNormalPointer(type, stride, &fv0.n.x);

                // now blast through all triangles
                const int mode = GL_TRIANGLES;
                const int startIndex = 0;
                glDrawArrays(mode, startIndex, nVertices);
        }

        // all done!
        glDisableClientState(GL_VERTEX_ARRAY);
        glDisableClientState(GL_NORMAL_ARRAY);
        glPopMatrix();
}



////////////////////////////////////////////////////////////////////////////////
//
//      OBJModel -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

void
OBJModel::readFace
(
IN mesh_t * mesh,
IN const char * p
)
{
        ASSERT(mesh, "null");
        ASSERT(p, "null");

        // initialize face
        smart_ptr<face_t> face = new face_t;
        ASSERT(face, "out of memory");

        // keep reading triplets
        const int s_maxSize = 31;       // should be big enough for 3 ints
        const int s_bufsize = s_maxSize + 1;
        char buffer[s_bufsize];

        // store parsed faces here
        const int s_maxFaceVertices = 12;
        face_idx_t face_indices[s_maxFaceVertices];
        int nVertices = 0;
        while (*p) {
                int nChars;
                p = getNextTokenFromString(p, buffer, s_bufsize, eParse_None,
                      nChars);
                ASSERT_THROW(nChars < s_bufsize,
                    "entry in face vertex list is too large!");

                // buffer now contains a string of the form X/Y/Z
                // (Y may or may not be empty)
                char * firstSlash = findChar(buffer, '/');
                char * secondSlash = findChar(firstSlash + 1, '/');

                ASSERT_THROW(*firstSlash && *secondSlash,
                    "Badly formatted face string: " << buffer);

                // replace with nulls
                *firstSlash = 0;
                *secondSlash = 0;
                char * secondInt = firstSlash + 1;
                char * thirdInt = secondSlash + 1;

                // okay, get values
                ASSERT_THROW(nVertices < s_maxFaceVertices,
                    "OBJ file contains face with " << nVertices
                    << " or more vertices!");

                // get a reference to the appropriate face
                face_idx_t& f = face_indices[nVertices];
                nVertices++;

                // populate indices based on what we just parsed
                f.v = atol(buffer);
                f.vt = atol(secondInt);
                f.vn = atol(thirdInt);

                // obj format is 1-based, we want 0-based
                f.v--;
                f.vt--;
                f.vn--;

                // validate
                ASSERT_THROW(f.v >= 0 && f.v < (long) m_vertices.size(),
                    "Invalid face vertex index: " << f.v);
                ASSERT_THROW(f.vt >= -1 && f.vt < (long) m_vertexTexCoords.size(),
                    "Invalid face vertex texture coordinate index: " << f.vt);
                ASSERT_THROW(f.vn >= -1 && f.vn < (long) m_vertexNormals.size(),
                    "Invalid face vertex normal index: " << f.vn);
        }
//      DPRINTF("Face polygon contained %d vertices", nVertices);
        m_faceCount++;

        // convert this polygon into triangles
        int nTriangles = nVertices - 2;
//      DPRINTF("  I'll convert this into %d triangles", nTriangles);
        for (int i = 0; i < nTriangles; ++i) {

                // use a simple fan algorithm, pivoting on first vertex
                face_idx_t v[3];
                v[0] = face_indices[0];
                v[1] = face_indices[i + 1];
                v[2] = face_indices[i + 2];

                // construct denormalized (non-indexed) face vertex struct
                for (int j = 0; j < 3; ++j) {
                        face_vtx_t fv;
                        fv.v = m_vertices[v[j].v];
                        long idx = v[j].vn;
                        if (idx > -1) {
                                fv.n = m_vertexNormals[idx];
                        } else {
                                fv.n.clear();
                        }
                        idx = v[j].vt;
                        if (idx > -1) {
                                fv.uv = m_vertexTexCoords[idx];
                        } else {
                                fv.uv.clear();
                        }

                        // save this denormalized face vertex
                        mesh->vertices.push_back(fv);
                }
        }
        m_triangleCount += nTriangles;
}



void
OBJModel::readMaterialMaps
(
IN nstream::Stream * stream,
IN const char * p
)
{
        ASSERT(stream, "null");
        ASSERT(p, "null");

        // get the stream File
        smart_ptr<nstream::File> file = stream->getFile();
        ASSERT_THROW(file, "stream does not have valid file?");
        const char * filename = file->getName();
        //DPRINTF("Stream is from file: %s", filename);
        smart_ptr<nstream::Manager> mgr = file->getManager();
        ASSERT_THROW(mgr, "file does not have valid stream Manager? " <<
            filename);

        // the mtllib line can contain multiple files--iterate
        std::string relPath;
        while (*p) {
                p = getNextTokenFromString(p, relPath, s_parseFlags);

                std::string path = getPathRelativeTo(filename, relPath.c_str());
                //DPRINTF("Looking for relative path: %s", relPath.c_str());
                //DPRINTF("  --> absolute path: %s", path.c_str());

                smart_ptr<nstream::File> file = mgr->getEntry(path.c_str());
                if (!file) {
                        DPRINTF("WARNING--could not load material file: %s",
                            path.c_str());
                        DPRINTF("This is often due to bad .obj files with "
                            "absolute instead of relative paths to .mtl files");
                        DPRINTF("(absolute paths are nonportable--your OBJ "
                            "files will break if copied to another path, even "
                            "if the MTL files go with them)");
                        DPRINTF("I'll try to load the mtl file as a peer to the"
                            " obj file...");

                        path = getPathRelativeTo(filename,
                            GetFilename(relPath.c_str()));
                        DPRINTF("Trying path: %s", path.c_str());
                        file = mgr->getEntry(path.c_str());

                        if (!file) {
                                DPRINTF("That didn't work either!");
                                DPRINTF("As a last-ditch attempt I'll try the "
                                    "absolute path.");
                                DPRINTF("This is completely nonportable "
                                    "(definitely won't work if people copy "
                                    "files around) but it's the last thing I "
                                    "can try...");
                                DPRINTF("Trying path: %s", relPath.c_str());
                                file = mgr->getEntry(relPath.c_str());

                                if (!file) {
                                        DPRINTF("ERROR--failed to load material"
                                            "file: %s", relPath.c_str());
                                        DPRINTF("Usually this is an error in "
                                            "the application writing the .OBJ "
                                            "file to begin with.");
                                        continue;       // skip material
                                }
                        }
                }

                smart_ptr<nstream::Stream> stream = file->openStream();
                ASSERT_THROW(stream, "could not open stream: " << path);

                // okay, parse all the materials in that stream
                map_mtl_t map;
                try {
                        map = parseOBJMaterials(stream);
                } catch (std::exception& e) {
                        WAVE_EX(wex);
                        wex << "Failed to parse material file: " << path;
                        wex << "\n" << e.what();
                }
                DPRINTF("Found %d materials in file", (int) map.size());
                for (map_mtl_t::iterator i = map.begin(); i != map.end(); ++i) {
                        const char * mtlName = i->first.c_str();
                        smart_ptr<glut::Material> mtl = i->second;
                        ASSERT(mtl, "null");

                        // the policy is that the first map wins
                        // so don't allow duplicate inserts
                        map_mtl_t::iterator j = m_materials.find(mtlName);
                        if (m_materials.end() != j) {
                                DPRINTF("WARNING--material already exists: %s",
                                    mtlName);
                                DPRINTF("  Ignoring second specification");
                                continue;
                        }

                        // okay, add it!
                        m_materials[mtlName] = mtl;
                }
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Model>
Model::create
(
IN nstream::Stream * stream,
IN float scale
)
{
        ASSERT(stream, "null");
        ASSERT(scale > 0, "Bad scale: %f", scale);

        smart_ptr<OBJModel> local = new OBJModel;
        ASSERT(local, "out of memory");

        try {
                local->initialize(stream, scale);
        } catch (std::exception& e) {
                WAVE_EX(wex);
                wex << "Failed to parse OBJ file: ";
                stream->writeDiagnostics(wex);
                wex << "\n" << e.what();
        }

        return local;
}



};      // obj namespace