#include <msp/datafile/dynamicobjectloader.h>
#include <msp/datafile/objectloader.h>
#include "depthtest.h"
+#include "effect.h"
#include "postprocessor.h"
#include "resources.h"
#include "stenciltest.h"
public:
class Loader: public DataFile::CollectionObjectLoader<SequenceTemplate>
{
+ private:
+ static ActionMap shared_actions;
+
public:
Loader(SequenceTemplate &, Collection &);
-
private:
+ virtual void init_actions();
+
void clear();
+ void effect(const std::string &);
void multisample(unsigned);
void multisample_range(unsigned, unsigned);
void postprocessor();
void postprocessor_with_slot(const std::string &);
void renderable(const std::string &);
void renderable_with_default(const std::string &, const std::string &);
+ void sequence(const std::string &, const std::string &);
void step(const std::string &, const std::string &);
};
struct Renderable
{
+ Effect::Template *effect_template = 0;
GL::Renderable *renderable = 0;
+ SequenceTemplate *sequence_template = 0;
+ std::map<std::string, std::string> sequence_renderables;
std::string slot_name;
};
private:
std::string inline_base_name;
+ static ActionMap shared_actions;
+
public:
Loader(Step &, Collection &);
+ private:
+ virtual void init_actions();
+ public:
void set_inline_base_name(const std::string &);
private:
private:
class ClearLoader: public DataFile::ObjectLoader<SequenceTemplate>
{
+ private:
+ static ActionMap shared_actions;
+
public:
ClearLoader(SequenceTemplate &);
-
private:
+ virtual void init_actions();
+
void color(float, float, float, float);
void depth(float);
void stencil(int);
};
+ class SequenceLoader: public DataFile::ObjectLoader<Renderable>
+ {
+ private:
+ static ActionMap shared_actions;
+
+ public:
+ SequenceLoader(Renderable &);
+ private:
+ virtual void init_actions();
+
+ void renderable(const std::string &, const std::string &);
+ };
+
bool hdr = false;
bool alpha = false;
unsigned required_multisample = 0;
float get_clear_depth() const { return clear_depth; }
int get_clear_stencil() const { return clear_stencil; }
+ template<typename T>
+ static void register_effect(const std::string &);
+
template<typename T>
static void register_postprocessor(const std::string &);
static TemplateRegistry<T> &get_registry();
};
+template<typename T>
+void SequenceTemplate::register_effect(const std::string &kw)
+{
+ get_registry<Effect>().register_type<typename T::Template>(kw);
+}
+
template<typename T>
void SequenceTemplate::register_postprocessor(const std::string &kw)
{