obj-material.cpp

Go to the documentation of this file.

/*
 * obj-material.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.
 *
 *
 * Material handling for OBJ objects.  See obj-material.h
 */

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

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


namespace obj {


static const eParseBehavior s_parseFlags                = eParse_Strip;



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


static void
setMaterial
(
IN int flag,
IN const glut::fcolor_t& c
)
throw()
{
        float val[] = { c.red, c.green, c.blue, c.alpha };
        glMaterialfv(GL_FRONT_AND_BACK, flag, val);
}



static glut::fcolor_t
parseColor
(
IN const char * p
)
{
        ASSERT(p, "null");

        const char * orig = p;
        glut::fcolor_t c;
        int n = readFloatsFromString(p, 3, &c.red);
        ASSERT_THROW(3 == n, "Incomplete color: " << orig);

        return c;
}



////////////////////////////////////////////////////////////////////////////////
//
//      OBJMaterial: object that implements the glut::Material interface for
//              Open Asset Import library materials.
//
////////////////////////////////////////////////////////////////////////////////

class OBJMaterial : public glut::Material {
public:
        // constructor, destructor ---------------------------------------------
        OBJMaterial(void) throw(); 
        ~OBJMaterial(void) throw() { }

        // public class methods ------------------------------------------------
        void parseLine(IN const char * keyword,
                                IN const char * line);

        // glut::Material class interface methods ------------------------------
        bool hasTexture(void) const throw() { return (0 != m_textureId); }
        void prepare(void);
        void cleanup(void) throw();

private:
        // private typedefs ----------------------------------------------------

        // private data members ------------------------------------------------
        int                     m_textureId;
        int                     m_twosided;
        glut::fcolor_t          m_colorDiffuse;
        glut::fcolor_t          m_colorAmbient;
        glut::fcolor_t          m_colorSpecular;
        glut::fcolor_t          m_colorEmissive;
        float                   m_shininess;
        int                     m_oldPolyMode[2];
        int                     m_oldCull;
};



OBJMaterial::OBJMaterial
(
void
)
throw()
{
        m_textureId = 0;
        m_twosided = 0;
        m_shininess = 10.0;
}



void
OBJMaterial::parseLine
(
IN const char * keyword,        // first token on this line in mtl file
IN const char * line            // actually, the remainder of the line
)
{
        ASSERT(keyword, "null");
        ASSERT(line, "null");

        // switch based on keyword--most common first!
        if (!strcmp("Kd", keyword)) {
                m_colorDiffuse = parseColor(line);
        } else {
                DPRINTF("Ignoring unknown material keyword: '%s'", keyword);
                DPRINTF("  %s %s", keyword, line);
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      OBJMaterial -- glut::Material class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
OBJMaterial::prepare
(
void
)
{
        // set all the colors
//      setMaterial(GL_AMBIENT, m_colorAmbient);
        setMaterial(GL_DIFFUSE, m_colorDiffuse);
//      setMaterial(GL_SPECULAR, m_colorSpecular);
//      setMaterial(GL_EMISSION, m_colorEmissive);

        // set shininess
        glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, m_shininess);

        // bind texture
        if (m_textureId) {
                glEnable(GL_TEXTURE_2D);
                glBindTexture(GL_TEXTURE_2D, m_textureId);
        }

        // turn off culling?
        if (m_twosided) {
                // save current polygon mode
                glGetIntegerv(GL_POLYGON_MODE, m_oldPolyMode);
                glPolygonMode(GL_BACK, m_oldPolyMode[0]);       // set back == front
                glGetIntegerv(GL_CULL_FACE, &m_oldCull);
                glDisable(GL_CULL_FACE);
        }
}



void
OBJMaterial::cleanup
(
void
)
throw()
{
        if (m_textureId) {
                glDisable(GL_TEXTURE_2D);
        }
        if (m_twosided) {
                glPolygonMode(GL_FRONT, m_oldPolyMode[0]);
                glPolygonMode(GL_BACK, m_oldPolyMode[1]);
                if (m_oldCull) {
                        glEnable(GL_CULL_FACE);
                }
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      OBJMaterial -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////



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

map_mtl_t
parseOBJMaterials
(
IN nstream::Stream * stream
)
{
        ASSERT_THROW(stream->good(), "Bad stream?");

        map_mtl_t materials;

        // parse materials!
        std::string line, keyword;
        smart_ptr<OBJMaterial> curr;    // current material
        while (!stream->eof()) {
                line = getNextLineFromStream(*stream, s_parseFlags);

                const char * p = line.c_str();

                p = getNextTokenFromString(p, keyword, s_parseFlags);
                if ("" == keyword) {
                        continue;       // skip empty lines
                }

                // check keyword
                if ("newmtl" == keyword) {
                        std::string name;
                        getNextTokenFromString(p, name, s_parseFlags);
                        ASSERT_THROW("" != name, "Bad material name in file!");

                        curr = new OBJMaterial;
                        ASSERT(curr, "out of memory");

                        materials[name] = curr;
                } else {
                        // unknown keyword!  Pass on to material
                        if (!curr) {
                                WAVE_EX(wex);
                                wex << "Encountered keyword before newmtl?  ";
                                wex << "line: " << line;
                        }
                        curr->parseLine(keyword.c_str(), p);
                }
        }

        // all done!
        return materials;
}



};      // obj namespace