#ifndef MSP_GL_SCENE_H_
#define MSP_GL_SCENE_H_
-#include <vector>
+#include <map>
+#include <msp/datafile/dynamicobjectloader.h>
#include <msp/datafile/objectloader.h>
#include "matrix.h"
#include "renderable.h"
-#include "vector.h"
namespace Msp {
namespace GL {
/**
-Scenes are containers for other Renderables. This is a base class that can't
-be instantiated. Examples of available Scene types are SimpleScene,
-InstancedScene and OrderedScene.
+Container for other renderables. Subclasses provide different ways of
+rendering the contents.
+
+All types of Scenes perform frustum culling on the contents, skipping
+renderables whose bounding sphere is fully outside the view volume. If a
+bounding sphere cannot be determined, culling is not performed on that
+renderable.
+
+SimpleScene is a good default choice if there are no specific requirements.
*/
class Scene: public Renderable
{
-public:
+protected:
class Loader: public DataFile::CollectionObjectLoader<Scene>
{
public:
private:
ContentMap *content;
+ static unsigned inline_counter;
+
public:
- Loader(Scene &, Collection &);
- Loader(Scene &, Collection &, ContentMap &);
+ Loader(Scene &s, Collection &c): Loader(s, c, 0) { }
+ Loader(Scene &s, Collection &c, ContentMap &m) : Loader(s, c, &m) { }
private:
- void init();
+ Loader(Scene &, Collection &, ContentMap *);
void object(const std::string &);
void object_tagged(const std::string &, const std::string &);
+ void scene(const std::string &);
+ void scene_inline();
+ };
+
+public:
+ class GenericLoader: public DataFile::DynamicObjectLoader<Scene>
+ {
+ friend class Scene;
+
+ public:
+ GenericLoader(DataFile::Collection &c): DynamicObjectLoader<Scene>(&c) { }
+
+ protected:
+ virtual const TypeRegistry &get_type_registry() const { return get_scene_registry(); }
};
protected:
- // XXX If a loaded renderable is removed from the scene it needs to be removed from here as well
- std::vector<Renderable *> owned_data;
mutable Matrix culling_matrix;
mutable Vector4 frustum_edges[6];
- Scene() { }
-private:
- Scene(const Scene &);
- Scene &operator=(const Scene &);
+ Scene() = default;
public:
- virtual ~Scene();
+ virtual ~Scene() = default;
virtual void add(Renderable &) = 0;
virtual void remove(Renderable &) = 0;
protected:
bool setup_frustum(const Renderer &) const;
bool frustum_cull(const Renderable &) const;
+
+public:
+ template<typename T>
+ static void register_type(const std::string &);
+private:
+ static GenericLoader::TypeRegistry &get_scene_registry();
};
+template<typename T>
+void Scene::register_type(const std::string &kw)
+{
+ get_scene_registry().register_type<T>(kw);
+}
+
} // namespace GL
} // namespace Msp