Support effects and subordinate sequences inside sequence templates

[libs/gl.git] / source / builders / sequencetemplate.h

diff --git a/source/builders/sequencetemplate.h b/source/builders/sequencetemplate.h
index 044cbd5e083f7ee90610cec18753c7bb404212e7..5c13aebebc2263677447e93e33ab96de25883cf0 100644 (file)
--- a/source/builders/sequencetemplate.h
+++ b/source/builders/sequencetemplate.h
@@ -4,8 +4,10 @@
 #include <string>
 #include <vector>
 #include <msp/core/typeregistry.h>
+#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"
@@ -19,46 +21,51 @@ class Renderable;
 class SequenceTemplate
 {
 private:
-       class PostProcLoader: virtual public DataFile::Loader
+       template<typename T>
+       class TemplateLoader: public DataFile::DynamicObjectLoader<typename T::Template>
        {
-       private:
-               template<typename T>
-               struct AddPostProc
-               {
-                       void operator()(const std::string &kw, PostProcLoader &ldr) const { ldr.add(kw, &PostProcLoader::postprocessor<T>); }
-               };
-
-       protected:
-               RefPtr<PostProcessor::Template> postproc;
+               friend class SequenceTemplate;
 
        public:
-               PostProcLoader();
-
-               PostProcessor::Template *get_postprocessor_template() { return postproc.release(); }
-
-       protected:
-               virtual void postprocessor_loaded() { }
+               TemplateLoader(typename DataFile::DynamicObjectLoader<typename T::Template>::Collection &c): DataFile::DynamicObjectLoader<typename T::Template>(&c) { }
 
        private:
-               template<typename T>
-               void postprocessor();
-
-               friend class SequenceTemplate;
+               virtual typename DataFile::DynamicObjectLoader<typename T::Template>::TypeRegistry &get_type_registry() const { return get_registry<T>(); }
        };
 
+       template<typename T>
+       using TemplateRegistry = typename TemplateLoader<T>::TypeRegistry;
+
 public:
-       class Loader: public DataFile::CollectionObjectLoader<SequenceTemplate, Resources>, public PostProcLoader
+       class Loader: public DataFile::CollectionObjectLoader<SequenceTemplate>
        {
+       private:
+               static ActionMap shared_actions;
+
        public:
                Loader(SequenceTemplate &, Collection &);
+       private:
+               virtual void init_actions();
 
-               virtual void postprocessor_loaded();
                void clear();
+               void effect(const std::string &);
                void multisample(unsigned);
                void multisample_range(unsigned, unsigned);
-               void postprocessor(const std::string &);
-               void step(const std::string &);
-               void step_with_slot(const std::string &, const std::string &);
+               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;
        };
 
        struct Step
@@ -68,9 +75,14 @@ public:
                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:
@@ -78,8 +90,6 @@ public:
                        void depth_compare(Predicate);
                        void lighting(const std::string &);
                        void lighting_inline();
-                       void object(const std::string &);
-                       void scene(const std::string &);
                        void stencil_test();
                };
 
@@ -87,8 +97,7 @@ public:
                const Lighting *lighting = 0;
                DepthTest depth_test;
                StencilTest stencil_test;
-               std::string slot_name;
-               Renderable *default_renderable = 0;
+               std::string renderable_name;
        };
 
        struct PostProcessor
@@ -102,21 +111,37 @@ public:
 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);
        };
 
-       typedef TypeRegistry<PostProcLoader::AddPostProc, PostProcLoader &> PostProcessorRegistry;
+       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;
        unsigned max_multisample = 0;
+       std::vector<Renderable> renderables;
        std::vector<Step> steps;
        std::vector<PostProcessor> postprocessors;
        bool clear_enabled = false;
@@ -131,6 +156,7 @@ public:
        bool get_alpha() const { return alpha; }
        unsigned get_required_multisample() const { return required_multisample; }
        unsigned get_maximum_multisample() const { return max_multisample; }
+       const std::vector<Renderable> &get_renderables() const { return renderables; }
        const std::vector<Step> &get_steps() const { return steps; }
        const std::vector<PostProcessor> &get_postprocessors() const { return postprocessors; }
        bool is_clear_enabled() const { return clear_enabled; }
@@ -138,28 +164,27 @@ public:
        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 &);
+
 private:
-       static PostProcessorRegistry &get_postprocessor_registry();
+       template<typename T>
+       static TemplateRegistry<T> &get_registry();
 };
 
 template<typename T>
-void SequenceTemplate::register_postprocessor(const std::string &kw)
+void SequenceTemplate::register_effect(const std::string &kw)
 {
-       get_postprocessor_registry().register_type<T>(kw);
+       get_registry<Effect>().register_type<typename T::Template>(kw);
 }
 
 template<typename T>
-void SequenceTemplate::PostProcLoader::postprocessor()
+void SequenceTemplate::register_postprocessor(const std::string &kw)
 {
-       if(postproc)
-               throw std::logic_error("Only one postprocessor allowed per slot");
-       RefPtr<typename T::Template> pp = new typename T::Template;
-       load_sub(*pp);
-       postproc = pp;
-       pp = 0;
-       postprocessor_loaded();
+       get_registry<GL::PostProcessor>().register_type<typename T::Template>(kw);
 }
 
 } // namespace GL