source/render/scene.h

   1 #ifndef MSP_GL_SCENE_H_
   2 #define MSP_GL_SCENE_H_
   3
   4 #include <map>
   5 #include <msp/datafile/dynamicobjectloader.h>
   6 #include <msp/datafile/objectloader.h>
   7 #include "matrix.h"
   8 #include "renderable.h"
   9
  10 namespace Msp {
  11 namespace GL {
  12
  13 /**
  14 Container for other renderables.  Subclasses provide different ways of
  15 rendering the contents.
  16
  17 All types of Scenes perform frustum culling on the contents, skipping
  18 renderables whose bounding sphere is fully outside the view volume.  If a
  19 bounding sphere cannot be determined, culling is not performed on that
  20 renderable.
  21
  22 SimpleScene is a good default choice if there are no specific requirements.
  23 */
  24 class Scene: public Renderable
  25 {
  26 protected:
  27         class Loader: public DataFile::CollectionObjectLoader<Scene>
  28         {
  29         public:
  30                 typedef std::map<std::string, Renderable *> ContentMap;
  31
  32         private:
  33                 ContentMap *content;
  34
  35                 static unsigned inline_counter;
  36
  37         public:
  38                 Loader(Scene &s, Collection &c): Loader(s, c, 0) { }
  39                 Loader(Scene &s, Collection &c, ContentMap &m) : Loader(s, c, &m) { }
  40         private:
  41                 Loader(Scene &, Collection &, ContentMap *);
  42
  43                 void array(const std::string &);
  44                 void object(const std::string &);
  45                 void object_tagged(const std::string &, const std::string &);
  46                 void scene(const std::string &);
  47                 void scene_inline();
  48         };
  49
  50 public:
  51         class GenericLoader: public DataFile::DynamicObjectLoader<Scene>
  52         {
  53                 friend class Scene;
  54
  55         public:
  56                 GenericLoader(DataFile::Collection &c): DynamicObjectLoader<Scene>(&c) { }
  57
  58         protected:
  59                 virtual const TypeRegistry &get_type_registry() const { return get_scene_registry(); }
  60         };
  61
  62 protected:
  63         Scene() = default;
  64 public:
  65         virtual ~Scene() = default;
  66
  67         virtual void add(Renderable &) = 0;
  68         virtual void remove(Renderable &) = 0;
  69
  70         template<typename T>
  71         static void register_type(const std::string &);
  72 private:
  73         static GenericLoader::TypeRegistry &get_scene_registry();
  74 };
  75
  76 template<typename T>
  77 void Scene::register_type(const std::string &kw)
  78 {
  79         get_scene_registry().register_type<T>(kw);
  80 }
  81
  82 } // namespace GL
  83 } // namespace Msp
  84
  85 #endif