#ifndef MSP_GL_SCENE_H_
#define MSP_GL_SCENE_H_
-#include <vector>
-#include <msp/core/typeregistry.h>
+#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
{
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::Loader
+ class GenericLoader: public DataFile::DynamicObjectLoader<Scene>
{
- private:
- template<typename T>
- struct CreateScene
- {
- void operator()(const std::string &, GenericLoader &) const;
- };
-
- DataFile::Collection &coll;
- Scene *scene;
- Loader *scene_loader;
-
- static ActionMap shared_actions;
+ friend class Scene;
public:
- GenericLoader(DataFile::Collection &);
- ~GenericLoader();
-
- Scene *get_scene() { Scene *s = scene; scene = 0; return s; }
- private:
- virtual void init_actions();
+ GenericLoader(DataFile::Collection &c): DynamicObjectLoader<Scene>(&c) { }
- void type(const DataFile::Symbol &);
-
- friend class Scene;
+ protected:
+ virtual const TypeRegistry &get_type_registry() const { return get_scene_registry(); }
};
-private:
- typedef TypeRegistry<GenericLoader::CreateScene, GenericLoader &> SceneRegistry;
-
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() { }
+ Scene() = default;
private:
Scene(const Scene &);
Scene &operator=(const Scene &);
public:
- virtual ~Scene();
+ virtual ~Scene() = default;
virtual void add(Renderable &) = 0;
virtual void remove(Renderable &) = 0;
template<typename T>
static void register_type(const std::string &);
private:
- static SceneRegistry &get_scene_registry();
+ static GenericLoader::TypeRegistry &get_scene_registry();
};
template<typename T>
get_scene_registry().register_type<T>(kw);
}
-template<typename T>
-void Scene::GenericLoader::CreateScene<T>::operator()(const std::string &, GenericLoader &ldr) const
-{
- if(ldr.scene)
- throw std::logic_error("Scene type was already specified");
-
- T *scene = new T;
- ldr.scene = scene;
- ldr.scene_loader = new typename T::Loader(*scene, ldr.coll);
- ldr.add_auxiliary_loader(*ldr.scene_loader);
-}
-
} // namespace GL
} // namespace Msp