trimesh.cpp

Go to the documentation of this file.

/*
 * trimesh.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.
 *
 * Support for triangle meshes.  See trimesh.h
 */

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

#include <fstream>

#include "common/wave_ex.h"
#include "perf/perf.h"
#include "util/token_stream.h"


namespace trimesh {

/// \ingroup trimesh
/*@{*/


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



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


////////////////////////////////////////////////////////////////////////////////
//
//      Mesh -- class that implements the Trimesh interface
//
////////////////////////////////////////////////////////////////////////////////

class Mesh : public Trimesh {
public:
        // constructor, destructor ---------------------------------------------
        Mesh(void) throw();
        ~Mesh(void) throw();

        // public class methods ------------------------------------------------
        void initialize(IN const char * filename);

        // trimesh::Trimesh class interface methods ----------------------------
        int getVertexCount(void) const throw() { return m_nVertices; }
        int getTriangleCount(void) const throw() { return m_nTriangles; }
        const point3d_t * getVertexArray(void) const throw() { return m_vertices; }
        const int * getTriangleArray(void) const throw() { return m_triangles; }
        void dump(IN const char * title) const throw();

private:
        // private member data -------------------------------------------------
        int             m_nVertices;
        int             m_nTriangles;
        point3d_t *     m_vertices;
        int *           m_triangles;
};



Mesh::Mesh(void)
throw()
{
        m_nVertices = m_nTriangles = 0;
        m_vertices = NULL;
        m_triangles = NULL;
}


Mesh::~Mesh(void)
throw()
{
        if (m_vertices) {
                delete[] m_vertices;
        }
        if (m_triangles) {
                delete[] m_triangles;
        }
}



void
Mesh::initialize
(
IN const char * filename
)
{
        ASSERT(filename, "null");

        // open file
        std::ifstream infile(filename);
        if (!infile.good()) {
                WAVE_EX(wex);
                wex << "Could not open triangle mesh file: " << filename;
        }
        std::string token;

        // get vertex count and allocate memory
        expectToken(infile, "nVertices");
        m_nVertices = readInteger(infile, token);
        if (m_nVertices < 0) {
                WAVE_EX(wex);
                wex << "Invalid vertex count (" << m_nVertices << ") in ";
                wex << filename;
        }

        m_vertices = new point3d_t[m_nVertices];
        ASSERT(m_vertices, "out of memory");

        // read vertices
        for (int i = 0; i < m_nVertices; ++i) {
                expectToken(infile, "v");
                point3d_t& p = m_vertices[i];

                // read x,y,z coordinates for this vertex
                p.x = readFloat(infile, token);
                p.y = readFloat(infile, token);
                p.z = readFloat(infile, token);
        }

        // get triangle count and allocate memory
        expectToken(infile, "nTriangles");
        m_nTriangles = readInteger(infile, token);
        if (m_nTriangles < 0) {
                WAVE_EX(wex);
                wex << "Invalid triangle count (" << m_nTriangles << ") in ";
                wex << filename;
        }
        m_triangles = new int[3 * m_nTriangles];
        ASSERT(m_triangles, "out of memory");

        // read triangles
        for (int i = 0; i < m_nTriangles; ++i) {
                expectToken(infile, "t");
                int * index = m_triangles + (3 * i);

                // read the 3 vertex indices for this triangle
                index[0] = readInteger(infile, token);
                index[1] = readInteger(infile, token);
                index[2] = readInteger(infile, token);
        }
}



void
Mesh::dump
(
IN const char * title
)
const
throw()
{
        ASSERT(title, "null");

        DPRINTF("Triangle mesh: %s", title);
        DPRINTF("  vertex count:   %4d", m_nVertices);
        DPRINTF("  triangle count: %4d", m_nTriangles);
}



////////////////////////////////////////////////////////////////////////////////
//
//      Public APIs
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Trimesh>
Trimesh::load
(
IN const char * filename
)
{
        perf::Timer timer("TriangleMesh::load");
        ASSERT(filename, "null");

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

        local->initialize(filename);

        return local;
}



};      // trimesh namespace