scene.h

Go to the documentation of this file.

#ifndef VART_SCENE_H
#define VART_SCENE_H

#ifdef WIN32
    #define WINGDI
    #include <windows.h>
#endif
#ifdef VART_OGL
    #include <GL/gl.h>
#endif

#include "vart/light.h"
#include "vart/camera.h"
#include "vart/color.h" // for background color
#include "vart/boundingbox.h"
#include <string> //STL include
#include <list>   //STL include
#include <iostream> // for XmlPrintOn

namespace VART {
    class GraphicObj;
    class Scene {
        public:
            Scene();
            virtual ~Scene();

            std::list<const Light*> GetLights();

            std::list<Camera*> GetCameras();

            void AddLight(Light* newLight);

            void AddLight(const Light& newLight);

            void AddCamera(Camera* newCamera);

            void AddObject(SceneNode* newObjectPtr);

            void Unreference(const SceneNode* sceneNodePtr);

            const Light* GetLight(const std::string& lightName);

            const Camera* GetCamera(const std::string& cameraName);

            void SetCamera(const std::string& cameraName);

            std::list<SceneNode*> GetObjects();

            SceneNode* GetObject(const std::string& objectName) const;

            SceneNode* GetObjectRec(const std::string& objectName) const;

            const Color& GetBackgroundColor();

            void SetBackgroundColor(Color color);

            virtual bool DrawOGL(Camera* cameraPtr = NULL) const;

            bool DrawLightsOGL() const;

            Camera* GetCurrentCamera() const;

            const Camera* UseNextCamera();

            const Camera* UsePreviousCamera();

            void SetCamerasAspectRatio(const std::string& cameraDescription, float newAspectRatio);

            void SetAllCamerasAspectRatio(float newAspectRatio);

            void ChangeAllCamerasViewVolume(float horScale, float verScale);

            bool ComputeBoundingBox();

            const BoundingBox& GetBoundingBox() const { return bBox; }

            void SetBBoxVisibility(bool value)    { bBox.visible = value; };

            void SetBoundingBox(double minX, double minY, double minZ,
                                double maxX, double maxY, double maxZ);

            void ToggleBBoxVisibility() { bBox.visible = !bBox.visible; }

            size_t GetNumLights() const { return lights.size(); }

            void MakeCameraViewAll();

            void SetDescription(const std::string& newDescr) { description = newDescr; }

            const std::string& GetDescription() { return description; }

            std::list<SceneNode*> GetAllSceneJoints();

            std::list<SceneNode*> GetAllSceneTypeObject(SceneNode::TypeID type);

            void Pick(int x, int y, std::list<GraphicObj*>* resultListPtr);

            void XmlPrintOn(std::ostream& os) const;

        protected:
            // PROTECTED METHODS
            // PROTECTED ATTRIBUTES
            std::list<const Light*> lights;
            // FixMe: Viewers should manipulate a local copy of the current camera, allowing
            // pointers to be const.
            std::list<Camera*> cameras;
            std::list<SceneNode*> objects;
            Color background;
        private:
            // PRIVATE METHODS
            GraphicObj* GetObject(unsigned int pickName);

            // PRIVATE ATTRIBUTES
            // FixMe: Viewers should manipulate a local copy of the current camera, a different
            // method to switch between cameras should be developed.
            std::list<Camera*>::const_iterator currentCamera;
            BoundingBox bBox;
            std::string description;
    }; // end class declaration
} // end namespace
#endif  // VART_SCENE_H