glmeshbuilder.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 "glmeshbuilder.h"  // include first
#include "material.h"
#include "texture.h"

#include <cassert>
#include <iostream>
#include <string>

using namespace sheep;
using namespace std;

GLMeshBuilder::GLMeshBuilder() :
    m_mesh(new GLMesh()),
    m_submesh(0),
    m_material(0)
{
}

GLMeshBuilder::~GLMeshBuilder() {
    assert(m_submesh == 0);
    assert(m_material == 0);

    // Do not delete the materials now!
    //!\todo Delete the materials somewhere.
}

// IMeshBuilder interface.

IMeshBuilder::IGeometryBuilder *GLMeshBuilder::GeometryBuilder() {
    return this;
}

IMeshBuilder::IMaterialBuilder *GLMeshBuilder::MaterialBuilder() {
    return this;
}

auto_ptr<GLMesh> GLMeshBuilder::GetMesh() {
    return m_mesh;
}

// IGeometryBuilder interface.

void GLMeshBuilder::BeginSubMesh(const string &name) {
    assert(m_submesh == 0);
    m_submesh = new GLMesh::SubMesh();
}

void GLMeshBuilder::EndSubMesh() {
    assert(m_submesh);

    if(m_submesh->GetMaterial() == 0) {
        Material *material = new Material();

        // Set material defaults.
        material->SetAmbientColor(Color3(0.2));
        material->SetDiffuseColor(Color3(1.0));
        material->SetSpecularColor(Color3(0.0));

        m_submesh->SetMaterial(material);
    }

    m_mesh->Insert(m_submesh);

    m_submesh = 0;
}

IMeshBuilder::FeatureId GLMeshBuilder::AppendVertex(const Vector3 &v) {
    assert(m_submesh);
    m_submesh->m_vertices.push_back(v);

    return static_cast<FeatureId>(m_submesh->m_vertices.size() - 1);
}

IMeshBuilder::FeatureId GLMeshBuilder::AppendNormal(const Vector3 &vn) {
    assert(m_submesh);
    m_submesh->m_normals.push_back(vn);

    return static_cast<FeatureId>(m_submesh->m_normals.size() - 1);
}

IMeshBuilder::FeatureId GLMeshBuilder::AppendTexCoord(const Vector2 &vt) {
    assert(m_submesh);
    m_submesh->m_texcoords.push_back(vt);

    return static_cast<FeatureId>(m_submesh->m_texcoords.size() - 1);
}

IMeshBuilder::FeatureId GLMeshBuilder::AppendFace(int n, const FeatureId *v) {
    assert(m_submesh);
    assert(n == 3);
    assert(v);

    GLMesh::SubMesh::Face f;

    f.m_v0 = v[0];
    f.m_v1 = v[1];
    f.m_v2 = v[2];

    f.m_n0 = f.m_n1 = f.m_n2 = -1;  // no normals yet
    f.m_t0 = f.m_t1 = f.m_t2 = -1;  // no texture coordinates yet

    m_submesh->m_faces.push_back(f);

    return static_cast<FeatureId>(m_submesh->m_faces.size() - 1);
}

void GLMeshBuilder::SetFaceNormals(FeatureId face, int n, const FeatureId *vn) {
    assert(m_submesh);
    assert(face >= 0 && face < m_submesh->m_faces.size());
    assert(n == 3);
    assert(vn);

    GLMesh::SubMesh::Face &f = m_submesh->m_faces[face];

    f.m_n0 = vn[0];
    f.m_n1 = vn[1];
    f.m_n2 = vn[2];
}

void GLMeshBuilder::SetFaceTexCoords(FeatureId face, int n, const FeatureId *vt) {
    assert(m_submesh);
    assert(face >= 0 && face < m_submesh->m_faces.size());
    assert(n == 3);
    assert(vt);

    GLMesh::SubMesh::Face &f = m_submesh->m_faces[face];

    f.m_t0 = vt[0];
    f.m_t1 = vt[1];
    f.m_t2 = vt[2];
}

void GLMeshBuilder::SetMaterial(FeatureId material_id) {
    assert(m_submesh);
    assert(material_id >= 0 && material_id < m_materials.size());

    m_submesh->SetMaterial(m_materials[material_id]);
}

// IMaterialBuilder interface.

IMeshBuilder::FeatureId GLMeshBuilder::BeginMaterial(const string &name) {
    assert(m_material == 0);

    m_material = new Material();

    // Set material defaults.
    m_material->SetAmbientColor(Color3(0.2));
    m_material->SetDiffuseColor(Color3(1.0));
    m_material->SetSpecularColor(Color3(0.0));

    m_materials.push_back(m_material);

    return static_cast<FeatureId>(m_materials.size() - 1);
}

void GLMeshBuilder::EndMaterial() {
    assert(m_material);
    m_material = 0;
}

void GLMeshBuilder::SetAmbientColor(Real r, Real g, Real b) {
    assert(m_material);
    m_material->SetAmbientColor(Color3(r, g, b));
}

void GLMeshBuilder::SetDiffuseColor(Real r, Real g, Real b) {
    assert(m_material);
    m_material->SetDiffuseColor(Color3(r, g, b));
}

void GLMeshBuilder::SetSpecularColor(Real r, Real g, Real b) {
    assert(m_material);
    m_material->SetSpecularColor(Color3(r, g, b));
}

void GLMeshBuilder::SetTexture(int w, int h, const unsigned char *texels) { //!< 24-bit RGB format.
    assert(m_material);

    //!\todo Delete the texture somewhere.
    m_material->SetTexture(new Texture(w, h, texels));
}

---