Scene.hh

/**********************************************************************
 * blaRAY -- photon mapper/raytracer
 * (C) 2008 by Tomasz bla Fortuna <bla@thera.be>, <bla@af.gliwice.pl>
 *
 * This program 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 3 of the License, or
 * any later version.
 *
 * See Docs/LICENSE
 *********************/

#ifndef _SCENE_H_
#define _SCENE_H_

#include <vector>
#include <map>
#include <stdexcept>

#include <libxml/xmlmemory.h>
#include <libxml/parser.h>

#include "General/Debug.hh"
#include "Render/Ray.hh"

#include "World/Color.hh"
#include "World/Texture.hh"
#include "World/Material.hh"

#include "World/Object.hh"
#include "World/Plane.hh"
#include "World/Sphere.hh"

#include "World/Light.hh"
#include "World/Camera.hh"


namespace World {
        static const Double NearestCollision(0.001);

        class Scene {
                std::vector<Material *> Materials;

                std::vector<Texture *> Textures;

                std::vector<Object *> Objects;

                std::vector<Light *> Lights;

                Color Background;

                Double AtmosphereIdx;

                Camera C;

                /*** Facilities for reading XML Files */
                void CreateLibrary();
                
                void DumpLibrary();

                Color ParseColor(xmlNodePtr Node);
                Math::Vector ParseVector(xmlNodePtr Node);
                Double ParseIdx(xmlNodePtr Node);

                const Material *GetMaterial(const std::string &id);
                const Texture *GetTexture(const std::string &id);

                void ParseTexture(xmlNodePtr Node);
                void ParseMaterial(xmlNodePtr Node);
                void ParseLight(xmlNodePtr Node);

                void ParseCamera(xmlNodePtr Node);

                void ParseSphere(xmlNodePtr Node);
                void ParsePlane(xmlNodePtr Node);
                std::map<std::string, Color> ColMap;
                std::map<std::string, const Texture *> TexMap;
                std::map<std::string, const Material *> MatMap;
                std::map<std::string, const Double> IdxMap;

                typedef std::map<std::string, Color>::iterator ColIter;
                typedef std::map<std::string, const Texture *>::iterator TexIter;
                typedef std::map<std::string, const Material *>::iterator MatIter;
                typedef std::map<std::string, const Double>::iterator IdxIter;
        public:
                Scene(const Camera &C = Camera(),
                      const Color &Background = ColLib::Black(),
                      const Double AtmosphereIdx = MatLib::IdxAir)
                        : Background(Background),
                          AtmosphereIdx(AtmosphereIdx),
                          C(C) {
                        Materials.reserve(20);
                        Objects.reserve(20);
                        Lights.reserve(20);
                        Textures.reserve(20);
                }

                ~Scene();

                void Purge();

                inline void AddObject(Object *O) {
                        if (DEBUG && O == NULL)
                                throw std::invalid_argument
                                        ("Argument can't be a NULL pointer");
                        Objects.push_back(O);
                }

                inline void AddLight(Light *L) {
                        if (DEBUG && L == NULL)
                                throw std::invalid_argument
                                        ("Argument can't be a NULL pointer");
                        Lights.push_back(L);
                }

                inline void AddMaterial(Material *M) {
                        if (DEBUG && M == NULL)
                                throw std::invalid_argument
                                        ("Argument can't be a NULL pointer");
                        Materials.push_back(M);
                }

                inline void AddTexture(Texture *T) {
                        if (DEBUG && T == NULL)
                                throw std::invalid_argument
                                        ("Argument can't be a NULL pointer");
                        Textures.push_back(T);
                }

                Bool Collide(const Render::Ray &R, Double &RayPos, const Object* &O) const;

                Bool ParseFile(const std::string &File);

                inline const Color &GetBackground() const {
                        return this->Background;
                }

                inline Double GetAtmosphere() const {
                        return this->AtmosphereIdx;
                }

                inline const Camera &GetCamera() const {
                        return this->C;
                }

                template<typename T>
                class Iterator {
                protected:
                        typename std::vector<T *>::const_iterator Cur;
                        typename std::vector<T *>::const_iterator End;

                public:
                        Iterator(const Scene &S);

                        inline const T *Next() {
                                if (Cur == End)
                                        return NULL;
                                else    return *(Cur++);
                        }

                        friend class Scene;
                };

                typedef Iterator<Light> LightIterator;
                typedef Iterator<Object> ObjectIterator;
                typedef Iterator<Texture> TextureIterator;
                typedef Iterator<Material> MaterialIterator;
        };

};

#endif

---