meshbuilder.cpp

Go to the documentation of this file.

/*
    toxic - A Global Illumination Renderer
    Copyright (C) 2003-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of toxic.

    toxic 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.

    toxic 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 toxic; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "meshbuilder.h"    // include first
#include "basicsurfaceshader.h"
#include "constanttexture.h"
#include "imagetexture.h"
#include "isurfaceshader.h"
#include "lambertianbrdf.h"
#include "map2.h"

#include <cassert>

using namespace sheep;
using namespace std;
using namespace toxic;

MeshBuilder::MeshBuilder(const Matrix4 &m,
                         const ISurfaceShader *surface_shader,
                         IObject::IntersectionMask intersection_mask 
                             /*= IObject::INTERSECT_ALL_RAYS*/) :
    m_m(m),
    m_surface_shader(surface_shader),
    m_intersection_mask(intersection_mask)
{
}

MeshBuilder::~MeshBuilder() {}

// IMeshBuilder interface.

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

IMeshBuilder::IMaterialBuilder *MeshBuilder::MaterialBuilder() {
    if(m_surface_shader)
        return 0;
    else return this;
}

MeshBuilder::MeshVector MeshBuilder::GetMeshes() const {
    return m_meshes;
}

// IGeometryBuilder interface.

void MeshBuilder::BeginSubMesh(const string &name) {
    m_meshes.push_back(new Mesh(m_m, m_surface_shader, m_intersection_mask));
}

void MeshBuilder::EndSubMesh() {}

IMeshBuilder::FeatureId MeshBuilder::AppendVertex(const Vector3 &v) {
    return m_meshes.back()->AppendVertex(v);
}

IMeshBuilder::FeatureId MeshBuilder::AppendNormal(const Vector3 &vn) {
    assert(vn.IsUnitLength());

    return m_meshes.back()->AppendNormal(vn);
}

IMeshBuilder::FeatureId MeshBuilder::AppendTexCoord(const Vector2 &vt) {
    return m_meshes.back()->AppendTexCoord(vt);
}

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

    return m_meshes.back()->AppendTriangle(v[0], v[1], v[2]);
}

void MeshBuilder::SetFaceNormals(FeatureId face, int n, const FeatureId *vn) {
    assert(n == 3);
    assert(vn);

    m_meshes.back()->SetTriangleNormals(face, vn[0], vn[1], vn[2]);
}

void MeshBuilder::SetFaceTexCoords(FeatureId face, int n, const FeatureId *vt) {
    assert(n == 3);
    assert(vt);

    m_meshes.back()->SetTriangleTexCoords(face, vt[0], vt[1], vt[2]);
}

void MeshBuilder::SetMaterial(FeatureId material_id) {
    if(m_surface_shader == 0) {
        assert(material_id >= 0 && material_id < m_surface_shaders.size());
        m_meshes.back()->SetSurfaceShader(m_surface_shaders[material_id]);
    } 
}

// IMaterialBuilder interface.

IMeshBuilder::FeatureId MeshBuilder::BeginMaterial(const string &name) {
    m_texture_map = 0;
    return static_cast<FeatureId>(m_surface_shaders.size());
}

void MeshBuilder::EndMaterial() {
    ISurfaceShader *surface_shader;

    if(m_texture_map) {
        surface_shader = new BasicSurfaceShader(
            0,
            Color3(0.0),
            new LambertianBRDF(),
            new ImageTexture(m_texture_map));
    } else {
        surface_shader = new BasicSurfaceShader(
            0,
            Color3(0.0),
            new LambertianBRDF(),
            new ConstantTexture(m_diffuse_color));
    }

    m_surface_shaders.push_back(surface_shader);

    // Do not delete m_texture_map!

    m_texture_map = 0;
}

void MeshBuilder::SetAmbientColor(Real r, Real g, Real b) {
    // Ignore.
}

void MeshBuilder::SetDiffuseColor(Real r, Real g, Real b) {
    m_diffuse_color.m_r = r;
    m_diffuse_color.m_g = g;
    m_diffuse_color.m_b = b;
}

void MeshBuilder::SetSpecularColor(Real r, Real g, Real b) {
    // Ignore.
}

void MeshBuilder::SetTexture(int w, int h, const unsigned char *texels) {   //!< 24-bit RGB format.
    delete m_texture_map;
    m_texture_map = new Map2(w, h, texels);
}

---