scenebuilder.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 "scenebuilder.h"   // include first
#include "common/math/point2.h"
#include "common/math/quaternion.h"
#include "common/meshio/aseloader.h"
#include "common/meshio/meshmodifier.h"
#include "common/meshio/objloader.h"
#include "common/meshio/smartloader.h"
#include "common/meshio/triloader.h"
#include "common/misc/iclonable.h"
#include "common/misc/stringutils.h"
#include "common/misc/xercesmanager.h"
#include "common/misc/xercesutils.h"
#include "parametermap.h"
#include "renderer/basicsurfaceshader.h"
#include "renderer/collection.h"
#include "renderer/constanttexture.h"
#include "renderer/framebuffer.h"
#include "renderer/ibdf.h"
#include "renderer/iedf.h"
#include "renderer/ilight.h"
#include "renderer/isurfaceshader.h"
#include "renderer/itexture.h"
#include "renderer/lambertianbrdf.h"
#include "renderer/lambertianedf.h"
#include "renderer/map2.h"
#include "renderer/meshbuilder.h"
#include "renderer/octree.h"
#include "renderer/perfectspecularbrdf.h"
#include "renderer/scene.h"

// Cameras.
#include "renderer/pinholecamera.h"
#include "renderer/thinlenscamera.h"

// Lights.
#include "renderer/pointlight.h"

// Objects.
#include "renderer/cube.h"
#include "renderer/mesh.h"
#include "renderer/plane.h"
#include "renderer/ring.h"
#include "renderer/sphere.h"
#include "renderer/square.h"

#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/sax/ErrorHandler.hpp>
#include <xercesc/sax/SAXParseException.hpp>

#include <algorithm>
#include <cassert>
#include <sstream>
#include <vector>

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

//! Default horizontal field of view in degrees (for all camera types).
const Real DEFAULT_CAMERA_HFOV = 70.0;

SceneBuilder::SceneBuilder(const Context &context,
                           const Framebuffer *framebuffer,
                           const string &filename,
                           const string &home_path,
                           ConsoleProgressMonitor *progmon) :
    m_context(context),
    m_framebuffer(framebuffer),
    m_path(StringUtils::GetPath(filename)),
    m_progmon(progmon),
    m_scene(new Scene()),
    m_camera(0)
{
    assert(m_framebuffer);
    assert(m_progmon);

    // The root object is always a collection (even if we're going to use
    // an octree, we'll still need a collection to store unbounded objects
    // like infinite planes).
    m_root = new Collection(Matrix4::Identity());
    m_scene->SetRootObject(m_root);

    //!\todo Choose between Collection and Octree at runtime, depending
    //! of the number of objects (with a user-defined thresold).
    bool use_octree = true;

    if(use_octree) {
        // Insert an octree into which we'll store bounded objects.
        m_octree = new Octree(Matrix4::Identity());
        m_root->Insert(m_octree);
    } else m_octree = 0;

//  m_progmon->Reset("     * Loading '" + GetFilename(filename) + "'");
//  m_progmon->StartJob(0.0, 1.0);
    parse_file(filename, home_path);
//  m_progmon->Done();

    if(!m_camera.get())
        throw LoadErrorException("No camera defined.");

    m_progmon->Reset("     * Finalizing");
    m_progmon->StartJob(0.0, 1.0);

    // Finalize objects of the scene.
    m_root->Finalize(context);

    // Finalize the camera.
    m_camera->Finalize(context, m_scene.get());

    m_progmon->Done();
}

SceneBuilder::~SceneBuilder() {}

auto_ptr<Scene> SceneBuilder::GetScene() {
    return m_scene;
}

auto_ptr<ICamera> SceneBuilder::GetCamera() {
    return m_camera;
}

namespace {
    class DefaultErrorHandler : public ErrorHandler {
    public:
        virtual void warning(const SAXParseException &e) {
            throw SceneBuilder::LoadErrorException(StrX(e.getMessage()));
        }

        virtual void error(const SAXParseException &e) {
            throw SceneBuilder::LoadErrorException(StrX(e.getMessage()));
        }

        virtual void fatalError(const SAXParseException &e) {
            throw SceneBuilder::LoadErrorException(StrX(e.getMessage()));
        }

        virtual void resetErrors() {}
    };

    class Dictionary {
    public:
        void Insert(const string &s) {
            m_strings[s] = true;
        }

        bool Contains(const string &s) const {
            return m_strings.find(s) != m_strings.end();
        }

    private:
        map<string, bool> m_strings;
    };

    template<typename T>
    vector<T> parse_sequence(const string &s) {
        stringstream ss;
        vector<T> v;
        T x;

        ss << s;

        while(ss >> x)
            v.push_back(x);

        return v;
    }
}

Vector3 SceneBuilder::parse_vector3(const string &s) const {
    const vector<Real> u = parse_sequence<Real>(s);
    Vector3 v;

    switch(u.size()) {
    case 0:
        throw ParseErrorException("Invalid vector format.");
    case 1:
        v.m_x = v.m_y = v.m_z = u[0];
        break;
    case 3:
        v.m_x = u[0];
        v.m_y = u[1];
        v.m_z = u[2];
        break;
    default:
        throw ParseErrorException("Invalid vector format.");
    }

    return v;
}

Color3 SceneBuilder::parse_color3(const string &s) const {
    const vector<Real> v = parse_sequence<Real>(s);
    Color3 c;

    switch(v.size()) {
    case 0:
        throw ParseErrorException("Invalid color format.");
    case 1:
        c.m_r = c.m_g = c.m_b = v[0];
        break;
    case 3:
        c.m_r = v[0];
        c.m_g = v[1];
        c.m_b = v[2];
        break;
    default:
        throw ParseErrorException("Invalid color format.");
    }

    return c;
}

void SceneBuilder::parse_parameter(const DOMNode *node,
                                   string *name,
                                   string *value) const
{
    assert(node);
    assert(name);
    assert(value);

    const DOMElement *element = static_cast<const DOMElement *>(node);

    *name = StrX(element->getAttribute(XStr("name")));
    *value = StrX(element->getAttribute(XStr("value")));
}

void SceneBuilder::store_parameter(const string &name,
                                   const string &value,
                                   ParameterMap *params) const
{
    assert(params);

    try {
        params->Insert(name, value);
    }
    catch(const ParameterMap::DuplicateKeyException &e) {
        throw ParseErrorException("Duplicate parameter: '" + e.m_key + "'.");
    }
}

void SceneBuilder::parse_file(const string &filename, const string &home_path) {
    XercesManager::Initialize();

    // Create the XML DOM parser.
    XercesDOMParser *parser = new XercesDOMParser();

    // Configure the parser.
    parser->setValidationScheme(XercesDOMParser::Val_Always);
    parser->setDoNamespaces(true);
    parser->setDoSchema(true);
    parser->setValidationSchemaFullChecking(true);
    parser->setExternalNoNamespaceSchemaLocation((home_path + "schemas/toxicscene.xsd").c_str());

    // Install the error handler.
    ErrorHandler *error_handler = new DefaultErrorHandler();
    parser->setErrorHandler(error_handler);

    // Parse the XML file and create the DOM document.
    try {
        parser->parse(filename.c_str());
    }
    catch(const XMLException &e) {
        throw ParseErrorException(StrX(e.getMessage()));
    }
    catch(const DOMException &e) {
        throw ParseErrorException(StrX(e.msg));
    }

    // Traverse the document.
    parse_root(parser->getDocument()->getDocumentElement());

    // Clean up.
    delete error_handler;
    delete parser;

    XercesManager::Shutdown();
}

void SceneBuilder::parse_root(const DOMNode *node) {
    DOMNodeList *childs = node->getChildNodes();

    for(XMLSize_t i = 0; i < childs->getLength(); ++i) {
        DOMNode *child = childs->item(i);

        if(child->getNodeType() != DOMNode::ELEMENT_NODE)
            continue;

        const string name = StrX(child->getNodeName());

        if(name == "SurfaceShader")
            surface_shader_builder(child);
        else if(name == "Frame")
            parse_frame(child);
    }
}

void SceneBuilder::parse_frame(const DOMNode *node) {
    ParameterMap params;

    DOMNodeList *childs = node->getChildNodes();

    for(XMLSize_t i = 0; i < childs->getLength(); ++i) {
        DOMNode *child = childs->item(i);

        if(child->getNodeType() != DOMNode::ELEMENT_NODE)
            continue;

        const string name = StrX(child->getNodeName());

        if(name == "Parameter") {
            string name, value;
            parse_parameter(child, &name, &value);
            store_parameter(name, value, &params);  // just to detect duplicate parameters

            if(name == "ambientillum")
                m_scene->SetAmbientIllumination(parse_color3(value));
            else if(name == "backgroundcolor")
                m_scene->SetBackgroundColor(parse_color3(value));
        }
        else if(name == "Object")
            object_builder(child);
        else if(name == "SurfaceShader")
            surface_shader_builder(child);
    }
}

const IBDF *SceneBuilder::bdf_builder(const DOMNode *node) const {
    const DOMElement *element = static_cast<const DOMElement *>(node);
    const string type = StrX(element->getAttribute(XStr("type")));

    if(type == "lambertian")
        return new LambertianBRDF();
    else if(type == "perfectspecular")
        return new PerfectSpecularBRDF();
    else throw ParseErrorException("Invalid BDF type.");

    return 0;   // keep the compiler happy
}

const ConstantTexture *SceneBuilder::constant_texture_builder(const DOMNode *node) const {
    const DOMElement *element = static_cast<const DOMElement *>(node);
    const string value = StrX(element->getAttribute(XStr("value")));

    return new ConstantTexture(parse_color3(value));
}

const IEDF *SceneBuilder::edf_builder(const DOMNode *node) const {
    const DOMElement *element = static_cast<const DOMElement *>(node);
    const string type = StrX(element->getAttribute(XStr("type")));

    if(type == "none")
        return 0;
    else if(type == "lambertian")
        return new LambertianEDF();
    else throw ParseErrorException("Invalid EDF type.");

    return 0;   // keep the compiler happy
}

const ImageTexture *SceneBuilder::image_texture_builder(const DOMNode *node) const {
    const DOMElement *element = static_cast<const DOMElement *>(node);
    const string href = StrX(element->getAttribute(XStr("href")));

    const Map2 *map;

    try {
        map = new Map2(m_path + href);
    }
    catch(const Map2::FileNotFoundException &e) {
        throw ParseErrorException("Could not load image file '" + e.m_filename + "'.");
    }

    return new ImageTexture(map);
}

Matrix4 SceneBuilder::matrix_builder(const DOMNode *node) const {
    DOMNodeList *childs = node->getChildNodes();

    for(XMLSize_t i = 0; i < childs->getLength(); ++i) {
        DOMNode *child = childs->item(i);

        if(child->getNodeType() != DOMNode::TEXT_NODE)
            continue;

        const vector<Real> v = parse_sequence<Real>(StrX(child->getTextContent()));

        if(v.size() != 16)  // 4x4 matrix -> 16 coefficients
            break;

        Matrix4 m;

        for(int j = 0; j < 16; ++j)
            m[j] = v[j];

        return m;
    }

    throw ParseErrorException("Invalid matrix format.");

    return Matrix4::Identity(); // keep the compiler happy
}

void SceneBuilder::object_builder(const DOMNode *node) {
    const DOMElement *element = static_cast<const DOMElement *>(node);
    const string object_type = StrX(element->getAttribute(XStr("type")));
    const string object_name = StrX(element->getAttribute(XStr("name")));
    const string object_base = StrX(element->getAttribute(XStr("base")));

    // Default values.
    Matrix4 transform(Matrix4::Identity());
    ParameterMap params;

    DOMNodeList *childs = node->getChildNodes();
    Dictionary dictionary;

    for(XMLSize_t i = 0; i < childs->getLength(); ++i) {
        DOMNode *child = childs->item(i);

        if(child->getNodeType() != DOMNode::ELEMENT_NODE)
            continue;

        const string name = StrX(child->getNodeName());

        // Special handling of <Parameter> elements.
        if(name == "Parameter") {
            string name, value;
            parse_parameter(child, &name, &value);
            store_parameter(name, value, &params);
            continue;
        }

        if(dictionary.Contains(name))
            throw MultipleDefinitionException(name);
        else dictionary.Insert(name);

        if(name == "Transform")
            transform = transform_builder(child);
    }

    try {
        // Cameras.
        if(object_type == "pinholecamera") {
            if(m_camera.get())
                throw ParseErrorException("Camera redefinition.");
            else m_camera.reset(pinholecamera_builder(transform, params));
        }
        else if(object_type == "thinlenscamera") {
            if(m_camera.get())
                throw ParseErrorException("Camera redefinition.");
            else m_camera.reset(thinlenscamera_builder(transform, params));
        }

        // Lights.
        else if(object_type == "pointlight") {
            m_scene->InsertLight(pointlight_builder(transform, params));
        }

        // Objects.
        else {
            IObject::IntersectionMask intersection_mask;

            // Extract value of the "visible" parameter.
            if(params.GetOptionalValue<bool>("visible", true))
                intersection_mask = IObject::INTERSECT_ALL_RAYS;
            else intersection_mask = IObject::INTERSECT_VISIBILITY_RAYS;

            // Unbounded objects.
            if(object_type == "plane") {
                Plane *plane = plane_builder(
                    transform,
                    intersection_mask,
                    params
                );

                // Insert the object into object repository.
                insert_into_repository(object_name, plane);

                // Insert the object into the scene.
                insert_into_scene(plane);
            }

            // Composite objects.
            else if(object_type == "mesh") {
                const MeshBuilder::MeshVector meshes = mesh_builder(
                    transform,
                    intersection_mask,
                    params
                );

                if(meshes.size() > 0) {
                    // Insert all meshes into the scene.
                    for(MeshBuilder::MeshVector::const_iterator i = meshes.begin(),
                        e = meshes.end(); i != e; ++i)
                    {
                        Mesh *mesh = *i;

                        if(mesh->GetSurfaceShader() == 0) {
                            throw ParseErrorException("One or several meshes have no surface shader.");
                        }

                        // Insert mesh into the scene.
                        insert_into_scene(mesh);
                    }

                    const IObject *front_object = meshes.front();

                    // Insert the first mesh into object repository.
                    insert_into_repository(object_name, front_object);

                    // If meshes emit light, insert them into the scene's list of light.
                    if( front_object->GetSurfaceShader()->GetEDF() &&
                        !front_object->GetSurfaceShader()->GetRadiantExitance().IsBlack())
                    {
                        for(MeshBuilder::MeshVector::const_iterator i = meshes.begin(), e = meshes.end(); i != e; ++i) {
                            m_scene->InsertLight(*i);
                        }
                    }
                }
            }

            // Bounded objects.
            else {
                IAreaLight *object;

                if(object_type == "cube")
                    object = cube_builder(
                        transform,
                        intersection_mask,
                        params
                    );
                else if(object_type == "ring")
                    object = ring_builder(
                        transform,
                        intersection_mask,
                        params
                    );
                else if(object_type == "sphere")
                    object = sphere_builder(
                        transform,
                        intersection_mask,
                        params
                    );
                else if(object_type == "square")
                    object = square_builder(
                        transform,
                        intersection_mask,
                        params
                    );
                else throw ParseErrorException("Invalid object type: '" + object_type + "'.");

                // Insert the object into object repository.
                insert_into_repository(object_name, object);

                // Insert the object into the scene.
                insert_into_scene(object);

                // If the object emits light, insert it into scene light list.
                if( object->GetSurfaceShader()->GetEDF() &&
                    !object->GetSurfaceShader()->GetRadiantExitance().IsBlack())
                {
                    m_scene->InsertLight(object);
                }
            }
        }
    }
    catch(const ParameterMap::InvalidKeyException &e) {
        throw ParseErrorException("Missing or invalid parameter: '" + e.m_key + "'.");
    }
    catch(const SurfaceShaderRepository::InvalidKeyException &e) {
        throw ParseErrorException("Surface shader does not exist: '" + e.m_key + "'.");
    }
    catch(const ObjectRepository::InvalidKeyException &e) {
        throw ParseErrorException("Object does not exist: '" + e.m_key + "'.");
    }
}

Color3 SceneBuilder::radiant_exitance_builder(const DOMNode *node) const {
    const DOMElement *element = static_cast<const DOMElement *>(node);
    const string value = StrX(element->getAttribute(XStr("value")));

    return parse_color3(value);
}

const ITexture *SceneBuilder::reflectance_builder(const DOMNode *node) const {
    DOMNodeList *childs = node->getChildNodes();

    for(XMLSize_t i = 0; i < childs->getLength(); ++i) {
        DOMNode *child = childs->item(i);

        if(child->getNodeType() != DOMNode::ELEMENT_NODE)
            continue;

        const string name = StrX(child->getNodeName());

        if(name == "ConstantTexture")
            return constant_texture_builder(child);
        else if(name == "ImageTexture")
            return image_texture_builder(child);
    }

    return 0;   // keep the compiler happy
}

Matrix4 SceneBuilder::rotation_builder(const DOMNode *node) const {
    const DOMElement *element = static_cast<const DOMElement *>(node);
    const string angle = StrX(element->getAttribute(XStr("angle")));
    const string axis = StrX(element->getAttribute(XStr("axis")));

    return Matrix4::Rotation(Quaternion::Rotation(
        dtor(StringUtils::FromString<Real>(angle)),
        parse_vector3(axis)));
}

Matrix4 SceneBuilder::scale_builder(const DOMNode *node) const {
    const DOMElement *element = static_cast<const DOMElement *>(node);
    const string value = StrX(element->getAttribute(XStr("value")));

    return Matrix4::Scale(parse_vector3(value));
}

void SceneBuilder::surface_shader_builder(const DOMNode *node) {
    const DOMElement *element = static_cast<const DOMElement *>(node);
    const string shader_name = StrX(element->getAttribute(XStr("name")));
    const string shader_base = StrX(element->getAttribute(XStr("base")));

    assert(shader_name != "");

    const IEDF *edf;
    Color3 radiant_exitance;
    const IBDF *bdf;
    const ITexture *reflectance;

    if(shader_base == "") {
        // Use default values.
        edf = 0;
        radiant_exitance = Color3(0.0);
        bdf = new LambertianBRDF();
        reflectance = new ConstantTexture(Color3(0.5));
    } else {
        // Use base shader values.
        //!\todo Implement forward definition of objects and shaders.
        const BasicSurfaceShader *surface_shader;
        try {
            surface_shader = static_cast<const BasicSurfaceShader *>(m_surface_shaders.Find(shader_base));
        }
        catch(SurfaceShaderRepository::InvalidKeyException) {
            throw ParseErrorException("Undefined object: '" + shader_base + "'.");
        }

        edf = clone(surface_shader->GetEDF());
        radiant_exitance = surface_shader->GetRadiantExitance();
        bdf = clone(surface_shader->GetBDF());
        reflectance = clone(surface_shader->GetReflectance());
    }

    const DOMNodeList *childs = node->getChildNodes();
    Dictionary dictionary;

    for(XMLSize_t i = 0; i < childs->getLength(); ++i) {
        const DOMNode *child = childs->item(i);

        if(child->getNodeType() != DOMNode::ELEMENT_NODE)
            continue;

        const string name = StrX(child->getNodeName());

        if(dictionary.Contains(name))
            throw MultipleDefinitionException(name);
        else dictionary.Insert(name);

        if(name == "EDF") {
            delete edf;
            edf = edf_builder(child);
        } else if(name == "RadiantExitance") {
            radiant_exitance = radiant_exitance_builder(child);
        } else if(name == "BDF") {
            delete bdf;
            bdf = bdf_builder(child);
        } else if(name == "Reflectance") {
            delete reflectance;
            reflectance = reflectance_builder(child);
        }
    }

    const ISurfaceShader *surface_shader = new BasicSurfaceShader(
        edf,
        radiant_exitance,
        bdf,
        reflectance);

    try {
        m_surface_shaders.Insert(shader_name, surface_shader);
    }
    catch(const SurfaceShaderRepository::DuplicateKeyException &e) {
        throw ParseErrorException("Duplicate surface shader name: '" + e.m_key + "'.");
    }
}

Matrix4 SceneBuilder::transform_builder(const DOMNode *node) const {
    Matrix4 transform = Matrix4::Identity();

    DOMNodeList *childs = node->getChildNodes();

    for(XMLSize_t i = 0; i < childs->getLength(); ++i) {
        DOMNode *child = childs->item(i);

        if(child->getNodeType() != DOMNode::ELEMENT_NODE)
            continue;

        const string name = StrX(child->getNodeName());

        if(name == "Matrix4")
            transform = matrix_builder(child) * transform;
        else if(name == "Scale")
            transform = scale_builder(child) * transform;
        else if(name == "Rotation")
            transform = rotation_builder(child) * transform;
        else if(name == "Translation")
            transform = translation_builder(child) * transform;
    }

    return transform;
}

Matrix4 SceneBuilder::translation_builder(const DOMNode *node) const {
    const DOMElement *element = static_cast<const DOMElement *>(node);
    const string value = StrX(element->getAttribute(XStr("value")));

    return Matrix4::Translation(parse_vector3(value));
}

void SceneBuilder::insert_into_repository(const string &key, const IObject *object) {
    // If the object is named, insert it into object repository.
    if(key != "") {
        try {
            m_objects.Insert(key, object);
        }
        catch(const ObjectRepository::DuplicateKeyException &e) {
            throw ParseErrorException("Duplicate object name: '" + e.m_key + "'.");
        }
    }
}

void SceneBuilder::insert_into_scene(IBoundedObject *object) {
    if(m_octree)
        m_octree->Insert(object);
    else m_root->Insert(object);
}

void SceneBuilder::insert_into_scene(Plane *plane) {
    m_root->Insert(plane);
}

PinholeCamera *SceneBuilder::pinholecamera_builder(const Matrix4 &transform,
                                                   const ParameterMap &params) const
{
    const Real default_aspect_ratio =
        static_cast<Real>(m_framebuffer->GetWidth()) / m_framebuffer->GetHeight();

    return new PinholeCamera(
        transform,
        dtor(params.GetOptionalValue<Real>("hfov", DEFAULT_CAMERA_HFOV)),
        params.GetOptionalValue<Real>("aspectratio", default_aspect_ratio));
}

ThinLensCamera *SceneBuilder::thinlenscamera_builder(const Matrix4 &transform,
                                                     const ParameterMap &params) const
{
    const Real default_aspect_ratio =
        static_cast<Real>(m_framebuffer->GetWidth()) / m_framebuffer->GetHeight();

    const Real hfov = dtor(params.GetOptionalValue<Real>("hfov", DEFAULT_CAMERA_HFOV));
    const Real aspect_ratio = params.GetOptionalValue<Real>("aspectratio", default_aspect_ratio);
    const Real fstop = params.GetValue<Real>("fstop");
    const Real focal_length = params.GetValue<Real>("focallength");
    Real focal_distance;
    bool af_enabled = false;
    Point2 af_target;

    try {
        // Try to get back the autofocus target point.
        const vector<Real> v = parse_sequence<Real>(params.GetValue<string>("autofocus"));

        if(v.size() != 2)
            throw ParseErrorException("Invalid NDC point format.");

        af_enabled = true;
        af_target.m_x = v[0];
        af_target.m_y = v[1];
    }
    catch(ParameterMap::InvalidKeyException) {
        // No autofocus target: autofocus is disabled.

        // Try to get back the focal distance.
        try {
            focal_distance = params.GetValue<Real>("focaldistance");
        }
        catch(ParameterMap::InvalidKeyException) {
            throw ParseErrorException("Either 'autofocus' or 'focaldistance' parameters must be specified.");
        }
    }

    if(af_enabled) {
        return new ThinLensCamera(
            transform,
            hfov,
            aspect_ratio,
            fstop,
            focal_length,
            af_target);
    } else {
        return new ThinLensCamera(
            transform,
            hfov,
            aspect_ratio,
            fstop,
            focal_length,
            focal_distance);
    }
}

PointLight *SceneBuilder::pointlight_builder(const Matrix4 &transform,
                                             const ParameterMap &params) const
{
    return new PointLight(
        transform,
        parse_color3(params.GetValue<string>("power")),
        params.GetOptionalValue<bool>("castshadow", true));
}

Cube *SceneBuilder::cube_builder(const Matrix4 &transform,
                                 IObject::IntersectionMask intersection_mask,
                                 const ParameterMap &params) const
{
    return new Cube(
        transform,
        m_surface_shaders.Find(params.GetValue<string>("surfaceshader")),
        intersection_mask);
}

MeshBuilder::MeshVector SceneBuilder::mesh_builder(const Matrix4 &transform,
                                                   IObject::IntersectionMask intersection_mask,
                                                   const ParameterMap &params) const
{
    const string filename = m_path + params.GetValue<string>("href");

    m_progmon->Reset("     * Loading '" + StringUtils::GetFilename(filename) + "'");

    const ISurfaceShader *surface_shader;
    try {
        const string surface_shader_name = params.GetValue<string>("surfaceshader");
        surface_shader = m_surface_shaders.Find(surface_shader_name);
    }
    catch(ParameterMap::InvalidKeyException) {
        surface_shader = 0;
    }

    MeshBuilder builder(transform, surface_shader, intersection_mask);

    const bool rebuild_normals = params.GetOptionalValue<bool>("rebuildnormals", false);
    const bool optimize_mesh = params.GetOptionalValue<bool>("optimizemesh", false);

    MeshModifier *mesh_modifier = 0;

    if(rebuild_normals || optimize_mesh)
        mesh_modifier = new MeshModifier(builder);

    if(rebuild_normals) {
        // Get back normal vertex normals smoothing settings.
        try {
            mesh_modifier->ComputeSmoothedVertexNormals(
                dtor(params.GetValue<Real>("smoothingthresholdangle")));
        }
        catch(ParameterMap::InvalidKeyException) {
            throw ParseErrorException(
                "'smoothingthresholdangle' parameter must be specified in order to enable "
                "computation of smoothed vertex normals."
            );
        }
    }

    if(optimize_mesh) {
        // Get back mesh optimization settings.
        try {
            mesh_modifier->OptimizeMesh(
                params.GetValue<Real>("vertexweldingthreshold"),
                dtor(params.GetValue<Real>("normalweldingthreshold"))
            );
        }
        catch(ParameterMap::InvalidKeyException) {
            throw ParseErrorException(
                "'vertexweldingthreshold' and 'normalweldingthreshold' parameters must be specified "
                "in order to enable mesh optimization."
            );
        }
    }

//  const int option_mask = IMeshLoader::DEFAULT_CONFIGURATION_BIT;
    const int option_mask = IMeshLoader::STOP_ON_MISSING_FILE_BIT;

    try {
        if(mesh_modifier)
            SmartLoader().Load(filename, *mesh_modifier, option_mask, m_progmon);
        else SmartLoader().Load(filename, builder, option_mask, m_progmon);
    }

    // Catch exceptions thrown by ASELoader class.
    catch(const ASELoader::ParsingException &e) {
        throw ParseErrorException("Parse error on line " + StringUtils::ToString(e.m_line) + ".");
    }
    catch(const ASELoader::ExtendedLoadingException &e) {
        throw ParseErrorException("Unknown load error on line " + StringUtils::ToString(e.m_line) + ".");
    }

    // Catch exceptions thrown by OBJLoader class.
    catch(const OBJLoader::ParsingException &e) {
        throw ParseErrorException("Parse error on line " + StringUtils::ToString(e.m_line) + ".");
    }
    catch(const OBJLoader::InvalidFaceException &e) {
        throw ParseErrorException("Invalid face on line " + StringUtils::ToString(e.m_line) + ".");
    }
    catch(const OBJLoader::TriangulationException &e) {
        throw ParseErrorException("Triangulation error on line " + StringUtils::ToString(e.m_line) + ".");
    }
    catch(const OBJLoader::ExtendedLoadingException &e) {
        throw ParseErrorException("Unknown load error on line " + StringUtils::ToString(e.m_line) + ".");
    }

    // Catch exceptions thrown by SmartLoader class.
    catch(SmartLoader::UnknownFileFormatException) {
        throw ParseErrorException("This file format is not supported.");
    }

    // Catch exceptions thrown by TRILoader class.
    catch(const TRILoader::ReadingException &e) {
        throw ParseErrorException("Read error at offset " + StringUtils::ToString(e.m_offset) + ".");
    }
    catch(const TRILoader::ExtendedLoadingException &e) {
        throw ParseErrorException("Unknown load error at offset " + StringUtils::ToString(e.m_offset) + ".");
    }

    // Catch common exceptions.
    catch(const IMeshLoader::FileNotFoundException &e) {
        throw ParseErrorException("File '" + e.m_filename + "' not found.");
    }
    catch(IMeshLoader::LoadingException) {
        throw ParseErrorException("Unknown load error.");
    }
    catch(...) {
        throw ParseErrorException("Unknown error.");
    }

    delete mesh_modifier;

    MeshBuilder::MeshVector meshes = builder.GetMeshes();

    //!\todo Print the number of meshes added to the scene.

    bool include = true, exclude = true;
    string param_value;

    try {
        param_value = params.GetValue<string>("include");
    }
    catch(ParameterMap::InvalidKeyException) {
        include = false;
    }

    try {
        param_value = params.GetValue<string>("exclude");
    }
    catch(ParameterMap::InvalidKeyException) {
        exclude = false;
    }

    if(!include && !exclude)
        return meshes;

    if(include && exclude)
        throw ParseErrorException("'include' and 'exclude' parameters are mutually exclusive.");

    const string param_name = include ? "include" : "exclude";

    // Convert the parameter value (which is a string) to a vector of int.
    vector<int> indices = parse_sequence<int>(param_value);

    if(indices.size() == 0) {
        if(include)
            return MeshBuilder::MeshVector();
        else return meshes;
    }

    // Sort the vector and remove duplicate indices.
    sort(indices.begin(), indices.end());
    const vector<int>::iterator new_indices_end =
        unique(indices.begin(), indices.end());

    // Make sure all indices are valid.
    const int index_vec[2] = { *indices.begin(), *(new_indices_end - 1) };
    for(int i = 0; i < 2; ++i) {
        const int index = index_vec[i];
        if(index < 0 || index >= meshes.size()) {
            throw ParseErrorException("Invalid index in '" + param_name + "' parameter: " +
                StringUtils::ToString(index));
        }
    }

    MeshBuilder::MeshVector selected_meshes;

    if(include) {
        for(vector<int>::const_iterator i = indices.begin(), e = new_indices_end; i != e; ++i)
            selected_meshes.push_back(meshes[*i]);
    } else {
        for(int i = 0; i < meshes.size(); ++i) {
            if(!binary_search(indices.begin(), new_indices_end, i))
                selected_meshes.push_back(meshes[i]);
        }
    }

    return selected_meshes;
}

Plane *SceneBuilder::plane_builder(const Matrix4 &transform,
                                   IObject::IntersectionMask intersection_mask,
                                   const ParameterMap &params) const
{
    return new Plane(
        transform,
        m_surface_shaders.Find(params.GetValue<string>("surfaceshader")),
        intersection_mask);
}

Ring *SceneBuilder::ring_builder(const Matrix4 &transform,
                                 IObject::IntersectionMask intersection_mask,
                                 const ParameterMap &params) const
{
    return new Ring(
        transform,
        m_surface_shaders.Find(params.GetValue<string>("surfaceshader")),
        params.GetValue<Real>("innerradius"),
        intersection_mask);
}

Sphere *SceneBuilder::sphere_builder(const Matrix4 &transform,
                                     IObject::IntersectionMask intersection_mask,
                                     const ParameterMap &params) const
{
    return new Sphere(
        transform,
        m_surface_shaders.Find(params.GetValue<string>("surfaceshader")),
        intersection_mask);
}

Square *SceneBuilder::square_builder(const Matrix4 &transform,
                                     IObject::IntersectionMask intersection_mask,
                                     const ParameterMap &params) const
{
    return new Square(
        transform,
        m_surface_shaders.Find(params.GetValue<string>("surfaceshader")),
        intersection_mask);
}

---