model-parsing.cpp

Go to the documentation of this file.

/*
 * model-parsing.cpp
 *
 * Copyright (C) 2008,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/load GLUT 3D models.
 */

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

#include <fstream>

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


namespace glut {


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


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

static void
getDictionaryFromNextLine
(
IO std::istream& stream,
IN const char * debug_info,
OUT dictionary_t& d
)
{
        ASSERT(stream.good(), "bad?");
        ASSERT(debug_info, "null");
        d.clear();

        eParseBehavior behavior = (eParseBehavior)
            (eParse_StripComments | eParse_StripBogus);

        std::string line = getNextLineFromStream(stream, behavior);
        getDictionaryFromString(line.c_str(), debug_info, d);
}



static byte_t
getOptionalByte
(
IN const dictionary_t& d,
IN const char * key
)
{
        int i = atoi(getOptionalValue(d, key, "0"));
        if (i < 0 || i > 255) {
                WAVE_EX(wex);
                wex << "Bad byte value (" << key << " = " << i << ")";
        }
        return (byte_t) i;
}



static void
writePoint3dToStream
(
IO std::ostream& stream,
IN const point3d_t& p
)
{
        ASSERT(stream.good(), "bad?");
        stream << "x " << p.x << " y " << p.y << " z " << p.z;
}



/*
static void
writeNonzeroByte
(
IO std::ostream& stream,
IN const char * key,
IN byte_t val
)
{
        ASSERT(stream.good(), "bad?");
        ASSERT(key, "null");

        if (!val)
                return;

        stream << key << " " << (int) val << "\t";
}



static void
writeColorToStream
(
IO std::ostream& stream,
IN const glut::color_t& color
)
{
        writeNonzeroByte(stream, "r", color.red);
        writeNonzeroByte(stream, "g", color.green);
        writeNonzeroByte(stream, "b", color.blue);
        writeNonzeroByte(stream, "a", color.alpha);
}
*/


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

void
parseColor
(
IO std::istream& stream,
OUT img_color_t& color
)
{
        ASSERT(stream.good(), "bad?");
        color.clear();

        dictionary_t d;
        getDictionaryFromNextLine(stream, "polygon color", d);

        color.red = getOptionalByte(d, "r");
        color.green = getOptionalByte(d, "g");
        color.blue = getOptionalByte(d, "b");
        color.alpha = getOptionalByte(d, "a");
}



void
parseMaterial
(
IO std::istream& stream,
IN const char * parentDir,
OUT material_t& material
)
{
        perf::Timer timer("parseMaterial");
        ASSERT(stream.good(), "bad?");
        ASSERT(parentDir, "null");
        material.clear();

        expectToken(stream, "{");

        std::string token;
        for (;;) {
                getNextToken(stream, token);
                if ("}" == token) {
                        break;          // end of material
                } else if ("isTransparent" == token) {
                        getNextToken(stream, token);
                        if ("1" == token ||
                            !strcasecmp("true", token.c_str()) ||
                            !strcasecmp("t", token.c_str())) {
                                // true!
                                material.isTransparent = true;
                        }
                } else if ("texture" == token) {
                        getNextToken(stream, token);

                        // create filesystem manager
                        smart_ptr<nstream::Manager> mgr =
                            nstream::getFilesystemManager(parentDir);
                        ASSERT_THROW(mgr, "failed to create filesystem mgr: "
                            << parentDir);
                        media::image_t image;
                        ASSERT_THROW(
                            media::loadImage(mgr, token.c_str(), image),
                            "Failed to load image: " << token);

                        material.texture_id = createTextureFromImage(image);
                } else {
                        WAVE_EX(wex);
                        wex << "Unknown keyword in texture file: " << token;
                }
        }
}



void
parsePolygon
(
IN MaterialRegistry * mreg,
IO std::istream& stream,
OUT polygon_t& polygon
)
{
        ASSERT(mreg, "null");
        ASSERT(stream.good(), "bad?");
        polygon.clear();

        // open polygon
        expectToken(stream, "{");
        std::string token;

        // read vertex count
        expectToken(stream, "nVertices");
        polygon.nVertices = readInteger(stream, token);
        if (polygon.nVertices < 3) {
                WAVE_EX(wex);
                wex << "Too few vertices in polygon: " << polygon.nVertices;
        }

        // allocate arrays
        polygon.indices = new int[polygon.nVertices];
        polygon.u = new float[polygon.nVertices];
        polygon.v = new float[polygon.nVertices];
        ASSERT(polygon.indices && polygon.u && polygon.v, "out of memory");

        // read vertex information
        expectToken(stream, "vertices");
        expectToken(stream, "{");
        for (int i = 0; i < polygon.nVertices; ++i) {
                // polygon vertex line should begin with "pv" token
                expectToken(stream, "pv");

                // grab the rest of the line, parse into dictionary
                std::string line = getNextLineFromStream(stream, eParse_Strip);
                dictionary_t d;
                getDictionaryFromString(line.c_str(), "polygon vertex", d);

                // pull important values out of dictionary
                polygon.indices[i] = atoi(getRequiredValue(d, "i"));
                polygon.u[i] = atof(getOptionalValue(d, "u", "0"));
                polygon.v[i] = atof(getOptionalValue(d, "v", "0"));
        }
        expectToken(stream, "}");

        // read normal
        expectToken(stream, "normal");
        parsePoint3d(stream, polygon.normal);

        // read material ID
        expectToken(stream, "material");
        getNextToken(stream, token);
        DPRINTF("material = '%s'", token.c_str());
        polygon.material = mreg->getMaterial(token.c_str());
        if (!polygon.material) {
                WAVE_EX(wex);
                wex << "Failed to load material for polygon: " << token;
        }

        // all done!
        expectToken(stream, "}");
}



void
parseModel
(
IN MaterialRegistry * mreg,
IO std::istream& stream,
OUT model_t& model
)
{
        perf::Timer timer("parseModel");
        ASSERT(mreg, "null");
        ASSERT(stream.good(), "bad?");
        model.clear();

        // open model
        expectToken(stream, "{");
        std::string token;

        // read vertex count
        expectToken(stream, "nVertices");
        model.nVertices = readInteger(stream, token);
        if (model.nVertices < 3) {
                WAVE_EX(wex);
                wex << "Too few vertices in model: " << model.nVertices;
        }
        model.vertices = new point3d_t[model.nVertices];
        ASSERT(model.vertices, "out of memory");

        // read vertices
        expectToken(stream, "vertices");
        expectToken(stream, "{");
        for (int i = 0; i < model.nVertices; ++i) {
                expectToken(stream, "vertex");
                parsePoint3d(stream, model.vertices[i]);
                if (!i) {
                        model.boundingBox.setToPoint(model.vertices[0]);
                } else {
                        model.boundingBox.includePoint(model.vertices[i]);
                }
        }
        expectToken(stream, "}");
        model.boundingBox.dump("bounding box");

        // read polygon count
        expectToken(stream, "nPolygons");
        model.nPolygons = readInteger(stream, token);
        if (model.nPolygons < 1) {
                WAVE_EX(wex);
                wex << "Too few polygons in model: " << model.nPolygons;
        }
        model.polygons = new polygon_t[model.nPolygons];
        ASSERT(model.polygons, "out of memory");

        // read polygons
        expectToken(stream, "polygons");
        expectToken(stream, "{");
        for (int i = 0; i < model.nPolygons; ++i) {
                expectToken(stream, "polygon");
                parsePolygon(mreg, stream, model.polygons[i]);
        }
        expectToken(stream, "}");
}



void
parseLodEntry
(
IN MaterialRegistry * mreg,
IO std::istream& stream,
OUT lod_entry_t& entry
)
{
        ASSERT(mreg, "null");
        ASSERT(stream.good(), "bad?");
        entry.clear();

        // open LOD entry
        expectToken(stream, "{");
        std::string token;

        // read distance
        expectToken(stream, "distance");
        entry.distance = readFloat(stream, token);
        if (entry.distance <= 0.0) {
                WAVE_EX(wex);
                wex << "Bad level-of-detail distance: " << entry.distance;
        }

        // read model
        expectToken(stream, "model");
        parseModel(mreg, stream, entry.model);
}



void
parseLodModel
(
IN MaterialRegistry * mreg,
IO std::istream& stream,
OUT lod_model_t& model
)
{
        perf::Timer timer("parseLodModel");
        ASSERT(mreg, "null");
        ASSERT(stream.good(), "bad?");
        model.clear();

        // read header and opening tags
        std::string token;
        expectToken(stream, "lodModel");
        expectToken(stream, "{");

        // how many entries?
        expectToken(stream, "nEntries");
        int nEntries = readInteger(stream, token);
        if (nEntries < 1) {
                WAVE_EX(wex);
                wex << "Bad count of lod entries: " << nEntries;
        }
        model.entries = new lod_entry_t[nEntries];
        ASSERT(model.entries, "out of memory");

        // read lod entries
        for (int i = 0; i < nEntries; ++i) {
                expectToken(stream, "lodEntry");
                parseLodEntry(mreg, stream, model.entries[i]);

                // ensure our bounding box encloses all child models
                model_t& child = model.entries[i].model;
                if (!i) {
                        model.boundingBox = child.getBoundingBox();
                } else {
                        model.boundingBox.expand(child.getBoundingBox());
                }
        }

        // finished parsing!
        model.nEntries = nEntries;
}



void
writeModelToStream
(
IO std::ostream& stream,
IN const model_t& model
)
{
        perf::Timer timer("writeModelToStream");
        ASSERT(stream.good(), "bad?");

        // write opening bracket
        stream << " {\n";

        // write vertex count
        stream << "nVertices " << model.nVertices << "\n";

        // write out vertices
        stream << "vertices {\n";
        for (int i = 0; i < model.nVertices; ++i) {
                stream << "\tvertex\t";
                writePoint3dToStream(stream, model.vertices[i]);
                stream << "\n";
        }
        stream << "}\n";

        // write polygon count
        stream << "nPolygons " << model.nPolygons << "\n";

        // write polygons
        stream << "polygons {\n";
        for (int i = 0; i < model.nPolygons; ++i) {
                const polygon_t& poly = model.polygons[i];

                // open polygon entry
                stream << "\tpolygon {\n";

                // write polygon vertex count
                stream << "\t\tnVertices " << poly.nVertices << "\n";

                // write polygon vertices
                stream << "\t\tvertices {\n";
                for (int j = 0; j < poly.nVertices; ++j) {
                        stream << "\t\t\tpv\t";
                        stream << "i " << poly.indices[j] << "\t";
                        stream << "u " << ((poly.u) ? poly.u[j] : 0.0) << "\t";
                        stream << "v " << ((poly.v) ? poly.v[j] : 0.0) << "\n";
                }
                stream << "\t\t}\n";

                // write normal
                stream << "\t\tnormal\t";
                writePoint3dToStream(stream, poly.normal);
                stream << "\n";

                // write material ID
                stream << "\t\tmaterial\t";
                stream << "BOGUS_ID";
                stream << "\n";

                // close polygon
                stream << "\t}\n";
        }
        stream << "}\n";        // end of polygon list

        // write closing bracket for model
        stream << "}\n";
}



smart_ptr<Renderable>
loadModel
(
IN const char * filename,
IN MaterialRegistry * reg
)
{
        ASSERT(filename, "null");
        ASSERT(reg, "null");

        std::ifstream infile(filename);
        if (!infile.good()) {
                WAVE_EX(wex);
                wex << "Failed to open wavepacket glut model file: ";
                wex << filename;
        }

        smart_ptr<lod_model_t> r = new lod_model_t;
        ASSERT(r, "out of memory");

        parseLodModel(reg, infile, *r);

        return r;
}



};      // glut namespace