glmesh.cpp

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Sheep is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "glmesh.h" // include first
#include "common/math/real.h"
#include "material.h"

#include <algorithm>
#include <cassert>

using namespace sheep;
using namespace std;

GLMesh::SubMesh::SubMesh() :
    m_material(0),
    m_list_name(0)  // 0 is not a valid display list index
{
    SetupRendering(IMMEDIATE_MODE);
}

GLMesh::SubMesh::~SubMesh() {
    if(m_list_name != 0)
        glDeleteLists(m_list_name, 1);
}

void GLMesh::SubMesh::SetMaterial(Material *m) {
    assert(m);
    m_material = m;
}

void GLMesh::SubMesh::SetupRendering(RenderingMode mode) {
    m_rendering_mode = mode;

    if(m_rendering_mode == DISPLAY_LIST) {
        if(m_list_name == 0)
            m_list_name = glGenLists(1);

        glNewList(m_list_name, GL_COMPILE);
        do_rendering();
        glEndList();
    }
}

void GLMesh::SubMesh::Render() const {
    switch(m_rendering_mode) {
    case IMMEDIATE_MODE:
        do_rendering();
        break;
    case DISPLAY_LIST:
        glCallList(m_list_name);
        break;
    }
}

void GLMesh::SubMesh::DisplayNormals() const {
    glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_LINE_BIT);

    glDisable(GL_LIGHTING);
    glDisable(GL_TEXTURE_2D);

    glLineWidth(1.0f);
    glColor3f(1.0f, 0.0f, 0.0f);

    //!\todo Make normals independant of the model scale.
    const Real NORMAL_LENGTH = 0.6;

    glBegin(GL_LINES);

    for(unsigned int i = 0; i < m_faces.size(); ++i) {
        const Face &f = m_faces[i];

        const Vector3 &n0 = m_normals[f.m_n0];
        const Vector3 &n1 = m_normals[f.m_n1];
        const Vector3 &n2 = m_normals[f.m_n2];

        const Vector3 &v0 = m_vertices[f.m_v0];
        const Vector3 &v1 = m_vertices[f.m_v1];
        const Vector3 &v2 = m_vertices[f.m_v2];

        const Vector3 e0 = v0 + NORMAL_LENGTH * n0;
        const Vector3 e1 = v1 + NORMAL_LENGTH * n1;
        const Vector3 e2 = v2 + NORMAL_LENGTH * n2;

        glVertex3f(v0.m_x, v0.m_y, v0.m_z);
        glVertex3f(e0.m_x, e0.m_y, e0.m_z);

        glVertex3f(v1.m_x, v1.m_y, v1.m_z);
        glVertex3f(e1.m_x, e1.m_y, e1.m_z);

        glVertex3f(v2.m_x, v2.m_y, v2.m_z);
        glVertex3f(e2.m_x, e2.m_y, e2.m_z);

/*      const Vector3 center = (v0 + v1 + v2) / 3;
        const Vector3 avg_normal = (n0 + n1 + n2).Normalized();
        const Vector3 end = center + NORMAL_LENGTH * avg_normal;

        glVertex3f(center.m_x, center.m_y, center.m_z);
        glVertex3f(end.m_x, end.m_y, end.m_z);*/
    }

    glEnd();

    glPopAttrib();
}

void GLMesh::SubMesh::do_rendering() const {
    assert(m_material);

    m_material->SetActive();

    glBegin(GL_TRIANGLES);

    if(m_material->GetTexture() && m_texcoords.size() > 0) {
        for(FaceVectorConstIt i = m_faces.begin(), e = m_faces.end(); i != e; ++i) {
            const Face &f = *i;

            // Make sure stuff is there.
            assert(m_vertices.size() > 0);
            assert(m_texcoords.size() > 0);
            assert(m_normals.size() > 0);

            // Make sure vertex indices are valid.
            assert(f.m_v0 >= 0 && f.m_v0 < static_cast<int>(m_vertices.size()));
            assert(f.m_v1 >= 0 && f.m_v1 < static_cast<int>(m_vertices.size()));
            assert(f.m_v2 >= 0 && f.m_v2 < static_cast<int>(m_vertices.size()));

            // Make sure texture coordinate indices are valid.
            assert(f.m_t0 >= 0 && f.m_t0 < static_cast<int>(m_texcoords.size()));
            assert(f.m_t1 >= 0 && f.m_t1 < static_cast<int>(m_texcoords.size()));
            assert(f.m_t2 >= 0 && f.m_t2 < static_cast<int>(m_texcoords.size()));

            // Make sure normal indices are valid.
            assert(f.m_n0 >= 0 && f.m_n0 < static_cast<int>(m_normals.size()));
            assert(f.m_n1 >= 0 && f.m_n1 < static_cast<int>(m_normals.size()));
            assert(f.m_n2 >= 0 && f.m_n2 < static_cast<int>(m_normals.size()));

            const Vector2 &t0 = m_texcoords[f.m_t0];
            const Vector2 &t1 = m_texcoords[f.m_t1];
            const Vector2 &t2 = m_texcoords[f.m_t2];

            const Vector3 &n0 = m_normals[f.m_n0];
            const Vector3 &n1 = m_normals[f.m_n1];
            const Vector3 &n2 = m_normals[f.m_n2];

            const Vector3 &v0 = m_vertices[f.m_v0];
            const Vector3 &v1 = m_vertices[f.m_v1];
            const Vector3 &v2 = m_vertices[f.m_v2];

            glTexCoord2f(t0.m_x, t0.m_y);
            glNormal3f(n0.m_x, n0.m_y, n0.m_z);
            glVertex3f(v0.m_x, v0.m_y, v0.m_z);

            glTexCoord2f(t1.m_x, t1.m_y);
            glNormal3f(n1.m_x, n1.m_y, n1.m_z);
            glVertex3f(v1.m_x, v1.m_y, v1.m_z);

            glTexCoord2f(t2.m_x, t2.m_y);
            glNormal3f(n2.m_x, n2.m_y, n2.m_z);
            glVertex3f(v2.m_x, v2.m_y, v2.m_z);
        }
    } else {
        for(FaceVectorConstIt i = m_faces.begin(), e = m_faces.end(); i != e; ++i) {
            const Face &f = *i;

            // Make sure stuff is there.
            assert(m_vertices.size() > 0);
            assert(m_normals.size() > 0);

            // Make sure vertex indices are valid.
            assert(f.m_v0 >= 0 && f.m_v0 < static_cast<int>(m_vertices.size()));
            assert(f.m_v1 >= 0 && f.m_v1 < static_cast<int>(m_vertices.size()));
            assert(f.m_v2 >= 0 && f.m_v2 < static_cast<int>(m_vertices.size()));

            // Make sure normal indices are valid.
            assert(f.m_n0 >= 0 && f.m_n0 < static_cast<int>(m_normals.size()));
            assert(f.m_n1 >= 0 && f.m_n1 < static_cast<int>(m_normals.size()));
            assert(f.m_n2 >= 0 && f.m_n2 < static_cast<int>(m_normals.size()));

            const Vector3 &n0 = m_normals[f.m_n0];
            const Vector3 &n1 = m_normals[f.m_n1];
            const Vector3 &n2 = m_normals[f.m_n2];

            const Vector3 &v0 = m_vertices[f.m_v0];
            const Vector3 &v1 = m_vertices[f.m_v1];
            const Vector3 &v2 = m_vertices[f.m_v2];

            glNormal3f(n0.m_x, n0.m_y, n0.m_z);
            glVertex3f(v0.m_x, v0.m_y, v0.m_z);

            glNormal3f(n1.m_x, n1.m_y, n1.m_z);
            glVertex3f(v1.m_x, v1.m_y, v1.m_z);

            glNormal3f(n2.m_x, n2.m_y, n2.m_z);
            glVertex3f(v2.m_x, v2.m_y, v2.m_z);
        }
    }

    glEnd();
}

GLMesh::GLMesh() :
    m_vertex_count(0),
    m_face_count(0)
{
}

GLMesh::~GLMesh() {
    for(SubMeshVectorConstIt i = m_sub_meshes.begin(), e = m_sub_meshes.end(); i != e; ++i) {
        delete *i;
    }
}

void GLMesh::Insert(SubMesh *m) {
    assert(m);

    m_sub_meshes.push_back(m);

    // Update vertex and face counters.
    m_vertex_count += m->m_vertices.size();
    m_face_count += m->m_faces.size();

    // Update the bounding box.
    for(SubMesh::Vector3VectorConstIt i = m->m_vertices.begin(),
        e = m->m_vertices.end(); i != e; ++i)
    {
        m_aabb.Include(*i);
    }
}

void GLMesh::FlipFaces() {
    for(SubMeshVectorConstIt i = m_sub_meshes.begin(), e = m_sub_meshes.end(); i != e; ++i) {
        SubMesh *sub_mesh = *i;

        // Reverse triangles orientation.
        for(SubMesh::FaceVectorIt j = sub_mesh->m_faces.begin(),
            e = sub_mesh->m_faces.end(); j != e; ++j)
        {
            SubMesh::Face &f = *j;

            swap(f.m_v1, f.m_v2);
            swap(f.m_n1, f.m_n2);
            swap(f.m_t1, f.m_t2);
        }

        // Flip normals.
        for(SubMesh::Vector3VectorIt j = sub_mesh->m_normals.begin(),
            e = sub_mesh->m_normals.end(); j != e; ++j)
        {
            *j = - *j;
        }
    }
}

void GLMesh::SetupRendering(RenderingMode mode) {
    for(SubMeshVectorConstIt i = m_sub_meshes.begin(), e = m_sub_meshes.end(); i != e; ++i) {
        (*i)->SetupRendering(mode);
    }
}

void GLMesh::Render() const {
    for(SubMeshVectorConstIt i = m_sub_meshes.begin(), e = m_sub_meshes.end(); i != e; ++i) {
        (*i)->Render();
    }
}

void GLMesh::DisplayNormals() const {
    for(SubMeshVectorConstIt i = m_sub_meshes.begin(), e = m_sub_meshes.end(); i != e; ++i) {
        (*i)->DisplayNormals();
    }
}

---