scenebuilder.h

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
*/

#ifndef TOXIC_DRIVER_SCENEBUILDER_H
#define TOXIC_DRIVER_SCENEBUILDER_H

#include "common/math/matrix4.h"
#include "common/math/real.h"
#include "common/math/vector3.h"
#include "common/misc/consoleprogressmonitor.h"
#include "common/misc/stringutils.h"
#include "objectrepository.h"
#include "renderer/color3.h"
#include "renderer/globals.h"
#include "renderer/imagetexture.h"
#include "renderer/iobject.h"
#include "renderer/meshbuilder.h"
#include "surfaceshaderrepository.h"

#include <xercesc/dom/DOM.hpp>

#include <memory>   // std::auto_ptr<>
#include <string>

namespace toxic {

    class Collection;
    class Color3;
    class ConstantTexture;
    class Context;
    class Framebuffer;
    class IBDF;
    class IEDF;
//  class ImageTexture;
    class ISurfaceShader;
    class ITexture;
    class Octree;
    class ParameterMap;
    class Scene;

    //! Cameras forward definition.
    class PinholeCamera;
    class ThinLensCamera;

    //! Lights forward definition.
    class PointLight;

    //! Objects forward definition.
    class Cube;
    class Mesh;
    class Plane;
    class Ring;
    class Sphere;
    class Square;

    class SceneBuilder {
    public:
        //! This is the base class for all exceptions thrown by the SceneBuilder class.
        struct LoadErrorException {
            LoadErrorException(const std::string &message) :
                m_message(message) {}

            std::string m_message;
        };

        //! This exception is thrown if an error occurs when loading the XML document.
        //! It is either an I/O error or, if a schema was provided, a XML document
        //! validation error (the XML document could not be validated against the schema).
        struct ParseErrorException : public LoadErrorException {
            ParseErrorException(const std::string &message) :
                LoadErrorException(message) {}
        };

        struct MultipleDefinitionException : public LoadErrorException {
            MultipleDefinitionException(const std::string &element) :
                LoadErrorException("Multiple definition of '" + element + "'.") {}
        };

        SceneBuilder(
            const Context &context,
            const Framebuffer *framebuffer,
            const std::string &filename,
            const std::string &home_path,
            sheep::ConsoleProgressMonitor *progmon);

        ~SceneBuilder();

        std::auto_ptr<Scene> GetScene();
        std::auto_ptr<ICamera> GetCamera();

    private:
        const Context &m_context;
        const Framebuffer *m_framebuffer;
        const std::string m_path;                   //!< Path to scene file.
        sheep::ConsoleProgressMonitor *m_progmon;

        SurfaceShaderRepository m_surface_shaders;
        ObjectRepository m_objects;

        Collection *m_root; //!< The root object is always allocated and allow to store unbounded objects.
        Octree *m_octree;   //!< If non-null, bounded objects must be stored into this octree.

        std::auto_ptr<Scene> m_scene;
        std::auto_ptr<ICamera> m_camera;

        sheep::Vector3 parse_vector3(const std::string &s) const;
        Color3 parse_color3(const std::string &s) const;

        void parse_parameter(
            const xercesc::DOMNode *node,
            std::string *name,
            std::string *value
        ) const;

        void store_parameter(
            const std::string &name,
            const std::string &value,
            ParameterMap *params
        ) const;

        void parse_file(const std::string &filename, const std::string &home_path);
        void parse_root(const xercesc::DOMNode *noden);
        void parse_frame(const xercesc::DOMNode *node);

        const IBDF *bdf_builder(const xercesc::DOMNode *node) const;
        const ConstantTexture *constant_texture_builder(const xercesc::DOMNode *node) const;
        const IEDF *edf_builder(const xercesc::DOMNode *node) const;
        const ImageTexture *image_texture_builder(const xercesc::DOMNode *node) const;
        sheep::Matrix4 matrix_builder(const xercesc::DOMNode *node) const;
        void object_builder(const xercesc::DOMNode *node);
        Color3 radiant_exitance_builder(const xercesc::DOMNode *node) const;
        const ITexture *reflectance_builder(const xercesc::DOMNode *node) const;
        sheep::Matrix4 rotation_builder(const xercesc::DOMNode *node) const;
        sheep::Matrix4 scale_builder(const xercesc::DOMNode *node) const;
        void surface_shader_builder(const xercesc::DOMNode *node);
        sheep::Matrix4 transform_builder(const xercesc::DOMNode *node) const;
        sheep::Matrix4 translation_builder(const xercesc::DOMNode *node) const;

        void insert_into_repository(const std::string &key, const IObject *object);
        void insert_into_scene(IBoundedObject *object);
        void insert_into_scene(Plane *plane);

        // Camera builders.

        PinholeCamera *pinholecamera_builder(
            const sheep::Matrix4 &transform,
            const ParameterMap &params
        ) const;

        ThinLensCamera *thinlenscamera_builder(
            const sheep::Matrix4 &transform,
            const ParameterMap &params
        ) const;

        // Light builders.

        PointLight *pointlight_builder(
            const sheep::Matrix4 &transform,
            const ParameterMap &params
        ) const;

        // Object builders.

        Cube *cube_builder(
            const sheep::Matrix4 &transform,
            IObject::IntersectionMask intersection_mask,
            const ParameterMap &params
        ) const;

        MeshBuilder::MeshVector mesh_builder(
            const sheep::Matrix4 &transform,
            IObject::IntersectionMask intersection_mask,
            const ParameterMap &params
        ) const;

        Plane *plane_builder(
            const sheep::Matrix4 &transform,
            IObject::IntersectionMask intersection_mask,
            const ParameterMap &params
        ) const;

        Ring *ring_builder(
            const sheep::Matrix4 &transform,
            IObject::IntersectionMask intersection_mask,
            const ParameterMap &params
        ) const;

        Sphere *sphere_builder(
            const sheep::Matrix4 &transform,
            IObject::IntersectionMask intersection_mask,
            const ParameterMap &params
        ) const;

        Square *square_builder(
            const sheep::Matrix4 &transform,
            IObject::IntersectionMask intersection_mask,
            const ParameterMap &params
        ) const;
    };

#include "scenebuilder.inl"

}

#endif  // !TOXIC_DRIVER_SCENEBUILDER_H

---