tool/physicsFromModel/main.cpp

Go to the documentation of this file.

/*
 * main.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.
 *
 *
 * Program that creates triangle meshes from glut-models.  Mostly used for
 * physics models.
 */

// includes --------------------------------------------------------------------
#include <fstream>
#include <iostream>

#include "common/wave_ex.h"
#include "glut-model/glut-model.h"
#include "perf/perf.h"
#include "util/token_stream.h"



// statics and typedefs --------------------------------------------------------

class DummyRegistry : public glut::MaterialRegistry {
public:
        DummyRegistry(void) {
                        m_material = new glut::material_t;
                        ASSERT(m_material, "out of memory");
                }

        ~DummyRegistry(void) throw() { }

        virtual smart_ptr<glut::material_t> getMaterial(IN const char * id) {
                        ASSERT(id, "null");
                        DPRINTF("Ignoring request to load material '%s'", id);
                        return m_material;
                }

private:
        smart_ptr<glut::material_t>     m_material;
};



struct triangle_t {
        int     index[3];               // 3 vertex indices per triangle
};

typedef std::vector<triangle_t> vec_triangle_t;



//
//      static helper methods
//

static void
writeVertices
(
IO std::ostream& stream,
IN const glut::model_t& model
)
{
        stream << "# vertex count and listing\n";
        stream << "nVertices " << model.nVertices << "\n";
        for (int i = 0; i < model.nVertices; ++i) {
                const point3d_t& p = model.vertices[i];
                stream << "v\t" << p.x << "\t";
                stream << p.y << "\t";
                stream << p.z << "\n";
        }
        stream << "\n";
}



static void
writeTriangles
(
IO std::ostream& stream,
IN const glut::model_t& model
)
{
        // accumulate triangles first
        vec_triangle_t vec;
        for (int i = 0; i < model.nPolygons; ++i) {
                const glut::polygon_t& poly = model.polygons[i];
                int nTriangles = poly.nVertices - 2;

                // construct a triangle fan from given polygon
                for (int j = 0; j < nTriangles; ++j) {
                        triangle_t t;
                        t.index[0] = poly.indices[0];
                        t.index[1] = poly.indices[j + 1];
                        t.index[2] = poly.indices[j + 2];
                        vec.push_back(t);
                }
        }

        // now write
        stream << "# triangle count and listing\n";
        stream << "nTriangles " << vec.size() << "\n";
        for (int i = 0; i < (int) vec.size(); ++i) {
                const triangle_t& t = vec[i];
                stream << "t\t";
                stream << t.index[0] << "\t";
                stream << t.index[1] << "\t";
                stream << t.index[2] << "\n";
        }
        stream << "\n";
}



//
//      entry point
//

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc, "usage: physicsFromModel <model-file>");
        const char * filename = argv[1];

        int retval = 0;

        try {
                perf::Timer timer("overall timer");
                glut::lod_model_t lod_model;

                std::ifstream infile(filename);
                if (!infile.good()) {
                        WAVE_EX(wex);
                        wex << "Failed to open model file: " << filename;
                }
                expectToken(infile, "modelFormat");
                expectToken(infile, "model-0.1");
                expectToken(infile, "type");
                expectToken(infile, "lod-model");
//              expectToken(infile, "lodModel");

                DummyRegistry reg;
                glut::parseLodModel(&reg, infile, lod_model);
                DPRINTF("Loaded model from %s", filename);

                if (lod_model.nEntries < 1) {
                        WAVE_EX(wex);
                        wex << "level-of-detail model contains no models?";
                }

                glut::model_t& model = lod_model.entries[0].model;

                std::cout << "# Autogenerated triangle mesh.\n";
                std::cout << "\n";

                writeVertices(std::cout, model);
                writeTriangles(std::cout, model);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
                retval = 1;
        }

        // dump timers and leave
        perf::dumpTimingSummary(std::cerr);
        return retval;
}