]> git.tdb.fi Git - libs/gl.git/blob - source/render/scene.h
Refactor Renderer's texture management to make it more extensible
[libs/gl.git] / 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