Refactor the structure of sequence template files

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

diff --git a/source/builders/sequencetemplate.h b/source/builders/sequencetemplate.h
index acc852d4fa0ef0113e4a79a6ab6f46ffbead7087..6b943dd1499f962bea05968643a936d01e16a8f9 100644 (file)
--- a/source/builders/sequencetemplate.h
+++ b/source/builders/sequencetemplate.h
@@ -4,6 +4,7 @@
 #include <string>
 #include <vector>
 #include <msp/core/typeregistry.h>
+#include <msp/datafile/dynamicobjectloader.h>
 #include <msp/datafile/objectloader.h>
 #include "depthtest.h"
 #include "postprocessor.h"
@@ -19,47 +20,42 @@ 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>
        {
        public:
                Loader(SequenceTemplate &, Collection &);
 
        private:
-               virtual void postprocessor_loaded();
                void clear();
                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 step(const std::string &, const std::string &);
+       };
+
+       struct Renderable
+       {
+               GL::Renderable *renderable = 0;
+               std::string slot_name;
        };
 
        struct Step
@@ -79,8 +75,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();
                };
 
@@ -88,8 +82,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
@@ -112,12 +105,11 @@ private:
                void stencil(int);
        };
 
-       typedef TypeRegistry<PostProcLoader::AddPostProc, PostProcLoader &> PostProcessorRegistry;
-
        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;
@@ -132,6 +124,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; }
@@ -141,26 +134,16 @@ public:
 
        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)
 {
-       get_postprocessor_registry().register_type<T>(kw);
-}
-
-template<typename T>
-void SequenceTemplate::PostProcLoader::postprocessor()
-{
-       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