TriangleMesh.cpp

/***************************************************************************
 *   This file is part of OpenCAL: Open Computer Animation Library         *
 *   I created OpenCAL as my master's thesis Computer Science (multimedia) *
 *   at the tUL university in Diepenbeek, Belgium                          *
 *                                                                         *
 *   Copyright (C) 2003-2004 by Jeroen Dierckx                             *
 *   jeroen.dierckx@student.luc.ac.be                                      *
 *                                                                         *
 ***************************************************************************/

// Includes
#include "TriangleMesh.h"
#include <OpenCAL/Vertex.h>
#include <OpenCAL/Triangle.h>
#include <OpenCAL/MeshLoader.h>
using namespace OpenCAL;

#include <OpenCAL/Material.h>
#include <OpenCAL/Texture.h>
using namespace OpenCAL::Utils;

using namespace std;


/******************************
* Constructors and destructor *
******************************/

TriangleMesh::TriangleMesh(bool rigid)
: m_texture(0), m_rigid(rigid), m_drawNormals(false)
{
}

TriangleMesh::TriangleMesh(const string &filename, bool rigid)
: m_texture(0), m_rigid(rigid), m_drawNormals(false)
{
    MeshLoader::loadMesh(this, filename);
}

TriangleMesh::~TriangleMesh()
{
    clear();
}


/************************
* Get and set functions *
************************/


/****************
* Add functions *
****************/

Vertex *TriangleMesh::addVertex(const Vertex &vertex)
{
    m_vertices.push_back(new Vertex(vertex));
    return m_vertices.back();
}

Triangle *TriangleMesh::addTriangle(const Triangle &triangle)
{
    m_triangles.push_back(new Triangle(triangle));
    return m_triangles.back();
}

Material *TriangleMesh::addMaterial()
{
    m_materials.push_back(new Material());
    return m_materials.back();
}

Material *TriangleMesh::addMaterial(const Material &material)
{
    m_materials.push_back(new Material(material));
    return m_materials.back();
}

/*
Texture *TriangleMesh::addTexture()
{
    m_textures.push_back(new Texture());
    return m_textures.back();
}

Texture *TriangleMesh::addTexture(const Texture &texture)
{
    m_textures.push_back(new Texture(texture));
    return m_textures.back();
}
*/


/******************
* Other functions *
******************/

void TriangleMesh::clear()
{
    TriangleList::iterator triangle;
    for(triangle = m_triangles.begin(); triangle != m_triangles.end(); ++triangle)
        delete *triangle;
    m_triangles.clear();

    VertexList::iterator vertex;
    for(vertex = m_vertices.begin(); vertex != m_vertices.end(); ++vertex)
        delete *vertex;
    m_vertices.clear();

    MaterialList::iterator material;
    for(material = m_materials.begin(); material != m_materials.end(); ++material)
        delete *material;
    m_materials.clear();

/*
    TextureList::iterator texture;
    for(texture = m_textures.begin(); texture != m_textures.end(); ++texture)
        delete *texture;
    m_textures.clear();
*/
}

void TriangleMesh::invalidateTriangleNormals()
{
    TriangleList::iterator triangle;
    for(triangle = m_triangles.begin(); triangle != m_triangles.end(); ++triangle)
        (*triangle)->invalidateNormal();
}

void TriangleMesh::calculateVertexNormals()
{
    TriangleList::iterator triangle;
    for(triangle = m_triangles.begin(); triangle != m_triangles.end(); ++triangle)
    {
        (*triangle)->getVertex(0)->addNormal((*triangle)->getNormal());
        (*triangle)->getVertex(1)->addNormal((*triangle)->getNormal());
        (*triangle)->getVertex(2)->addNormal((*triangle)->getNormal());
    }

    VertexList::iterator vertex;
    for(vertex = m_vertices.begin(); vertex != m_vertices.end(); ++vertex)
        (*vertex)->getNormalP()->normalize();
}

void TriangleMesh::loadFromFile(const string &filename)
{
    MeshLoader::loadMesh(this, filename);
}

//void TriangleMesh::initialize()
//{
    //if(m_texture)
    //  m_texture->initialize();
/*
    TextureList::iterator texture;
    for(texture = m_textures.begin(); texture != m_textures.end(); ++texture)
        (*texture)->initialize();
*/
//}

/*
#ifdef USE_OPENGL
void TriangleMesh::drawGL()
{
    invalidateTriangleNormals();
    calculateVertexNormals();

    glLineWidth(1.0f);

    if(m_texture)
    {
        glEnable(GL_TEXTURE_2D);
        m_texture->bindGL();
    }
    else
        glDisable(GL_TEXTURE_2D);

    glBegin(GL_TRIANGLES);

    TriangleList::iterator it;
    for(it = m_triangles.begin(); it != m_triangles.end(); ++it)
    {
        Triangle *t = *it;

        // Material
        if(t->hasMaterial())
            t->getMaterial()->applyGL();

        // Vertices
        if(m_texture)
            glTexCoord2f(t->getVertex(0)->getTextureU(), t->getVertex(0)->getTextureV());
        if(m_useNormals)
            glNormal3fv(t->getVertex(0)->getNormal());
        glVertex3fv(t->getVertex(0)->getPosition());

        if(m_texture)
            glTexCoord2f(t->getVertex(1)->getTextureU(), t->getVertex(1)->getTextureV());
        if(m_useNormals)
            glNormal3fv(t->getVertex(1)->getNormal());
        glVertex3fv(t->getVertex(1)->getPosition());

        if(m_texture)
            glTexCoord2f(t->getVertex(2)->getTextureU(), t->getVertex(2)->getTextureV());
        if(m_useNormals)
            glNormal3fv(t->getVertex(2)->getNormal());
        glVertex3fv(t->getVertex(2)->getPosition());
    }

    glEnd();

    if(m_texture)
        m_texture->unbindGL();


    if(m_drawNormals)
    {
        glBegin(GL_LINES);

        VertexList::iterator it2;
        for(it2 = m_vertices.begin(); it2 != m_vertices.end(); ++it2)
        {
            glVertex3fv((*it2)->getPosition());
            glVertex3fv((*it2)->getPosition() + (*it2)->getNormal());
        }

        glEnd();
    }
}
#endif // USE_OPENGL
*/


/**********************
* Protected functions *
**********************/

---