/cygdrive/d/src/svn/vrut/trunk/core/src/scene.h

Go to the documentation of this file.

#ifndef __SCENE__H__
#define __SCENE__H__

#include <deque>
#include <wx/hashmap.h>
#include <wx/glcanvas.h>
#include "bvh.h"
#include "geometry.h"
#include "lightnode.h"
#include "material.h"


namespace VRUT
{
       class SceneManager;
       class EventHandler;

       class Scene
       {
       public:
              typedef std::vector<SceneNode *> NodeList;
              WX_DECLARE_STRING_HASH_MAP(NODE_ID, NodeIDHashMap);
              typedef std::list<NODE_ID> LightNodeIDList;
              WX_DECLARE_STRING_HASH_MAP(GEOMETRY_ID, GeometryIDHashMap);
              typedef std::vector<Geometry *> GeometryList;
              WX_DECLARE_STRING_HASH_MAP(MATERIAL_ID, MaterialIDHashMap);
              typedef std::vector<Material *> MaterialList;

       private:
              SCENE_ID sceneID;
              NodeList sceneNodes;
              NodeIDHashMap sceneNodeIDMap;
              NODE_ID rootID;
              BVH * bvh;
              MaterialIDHashMap materialIDMap;
              MaterialList materials;
              GeometryIDHashMap geometryIDMap;
              GeometryList geometries;
              LightNodeIDList lightNodeIDs;
              wxString sceneName;
              SceneManager * sceneManager;
              EventHandler * msgSink;

              std::deque<NODE_ID> itemsPending;

              SceneNode * getNode(NODE_ID id) const
              {
                     return ( id < sceneNodes.size() ? sceneNodes[id] : (SceneNode *)NULL );
              }
              void setNodeValid(SceneNode * node, bool _valid = true, bool markBVH = true) const;

       public:
              Scene(SCENE_ID id, EventHandler * _msgSink);

              ~Scene();

              SCENE_ID GetID() const
              {
                     return sceneID;
              }
              NODE_ID GetRootID() const
              {
                     return rootID;
              }

              const SceneNode * GetNode(NODE_ID id) const
              {
                     return getNode(id);
              }

              NODE_ID GetNodeID(const wxString & uid) const
              {
                     NodeIDHashMap::const_iterator it = sceneNodeIDMap.find(uid);
                     return ( it == sceneNodeIDMap.end() ? NODE_ID_NONE : it->second );
              }

              size_t GetNodeMaxID() const
              {
                     return sceneNodes.size();
              }

              void GetNodeIDs(std::vector<NODE_ID> * nodes) const;

              BVH * GetBVH() const
              {
                     return bvh;
              }

              void SetName(const wxString & name)
              {
                     sceneName = name;
              }

              const wxString & GetName() const
              {
                     return sceneName;
              }

              BVH * UpdateBVH();

              MATERIAL_ID AddMaterial(Material * material);

              bool RemoveMaterial(MATERIAL_ID matID);

              MATERIAL_ID GetMaterialID(const wxString & name) const
              {
                     MaterialIDHashMap::const_iterator it = materialIDMap.find(name);
                     return ( it != materialIDMap.end() ? it->second : MATERIAL_ID_NONE );
              }

              const Material * GetMaterial(MATERIAL_ID mid) const
              {
                     return (mid < materials.size() ? materials[mid] : (Material *)NULL );
              }

              const MaterialList * GetMaterials() const
              {
                     return &materials;
              }

              const Image * GetImage(const wxString & texPath) const;

              GEOMETRY_ID AddGeometry(Geometry * geometry);

              bool RemoveGeometry(GEOMETRY_ID geomID);

              GEOMETRY_ID GetGeometryID(const wxString & name) const
              {
                     GeometryIDHashMap::const_iterator it = geometryIDMap.find(name);
                     return ( it != geometryIDMap.end() ? it->second : GEOMETRY_ID_NONE );
              }

              const Geometry * GetGeometry(GEOMETRY_ID gid) const
              {
                     return (gid < geometries.size() ? geometries[gid] : (Geometry *)NULL );
              }

              const GeometryList * GetGeometries() const
              {
                     return &geometries;
              }

              const LightNodeIDList * GetLightIDs() const
              {
                     return &lightNodeIDs;
              }

#ifdef GRAPHVIZ_SUPPORT
              void CreateGraphVizFile() const;
#endif

#ifdef __WXDEBUG__
              void Dump() const;
#endif



              NODE_ID Insert(SceneNode * node, NODE_ID targetID);

              NODE_ID Copy(Scene * srcScene, NODE_ID srcID, NODE_ID targetID);

              void Move(NODE_ID srcID, NODE_ID targetID);

              void Remove(NODE_ID id);

              void SetUid(NODE_ID id, const wxString & uid);

              void SetName(NODE_ID id, const wxString & name);

              void SetTransformation(NODE_ID id, const MATRIX & matrix) const;

              void Transform(NODE_ID id, const MATRIX & matrix) const;

              void UpdateTransformation(NODE_ID id) const;

              void TranslateAbs(NODE_ID id, const VECTOR3 & transl) const;

              void SetGeometry(NODE_ID id, GEOMETRY_ID geometryID);

              void SetMaterial(NODE_ID id, MATERIAL_ID mid) const;

              void SetLight(NODE_ID id, Light * light) const;

              void SetInvalid(NODE_ID id) const
              {
                     setNodeValid(getNode(id), false);
              }

              bool WriteLock(NODE_ID id)
              {
                     SceneNode * node = getNode(id);
                     if (node)
                            node->WriteLock();
                     return node != (SceneNode *)NULL;
              }
              bool WriteUnlock(NODE_ID id)
              {
                     SceneNode * node = getNode(id);
                     if (node)
                            node->WriteUnlock();
                     return node != (SceneNode *)NULL;
              }



              void SetProjectionParams(NODE_ID camID, unsigned width = 0, unsigned height = 0, float nearPlane = 0.0f, float farPlane = 0.0f, float fov = 0.0f) const;

              void Fit(NODE_ID camID, bool updateBVH = true, bool farNearOnly = false);

              void ResetView(NODE_ID camID, bool updateBVH = true);


              friend class SceneManager;
       };
};


#endif

---