Support named postprocessor slots in pipeline templates

[libs/gl.git] / source / pipelinetemplate.h

diff --git a/source/pipelinetemplate.h b/source/pipelinetemplate.h
index d98633539e06dff0dac89b3ef71d5f1478243676..a18eead4836401020a7a0e87d7abcaa2fbeee7cb 100644 (file)
--- a/source/pipelinetemplate.h
+++ b/source/pipelinetemplate.h
@@ -17,30 +17,48 @@ class Lighting;
 
 class PipelineTemplate
 {
-public:
-       class Loader: public DataFile::CollectionObjectLoader<PipelineTemplate>
+private:
+       class PostProcLoader: virtual public DataFile::Loader
        {
        private:
                template<typename T>
                struct AddPostProc
                {
-                       static void add(Loader &ldr, const std::string &kw) { ldr.add(kw, &Loader::postprocessor<T>); }
+                       static void add(PostProcLoader &ldr, const std::string &kw) { ldr.add(kw, &PostProcLoader::postprocessor<T>); }
                };
 
+       protected:
+               RefPtr<PostProcessor::Template> postproc;
+
+       public:
+               PostProcLoader();
+
+               PostProcessor::Template *get_postprocessor_template() { return postproc.release(); }
+
+       protected:
+               virtual void postprocessor_loaded() { }
+
+       private:
+               template<typename T>
+               void postprocessor();
+
+               friend class PipelineTemplate;
+       };
+
+public:
+       class Loader: public DataFile::CollectionObjectLoader<PipelineTemplate>, public PostProcLoader
+       {
        public:
                Loader(PipelineTemplate &);
                Loader(PipelineTemplate &, Collection &);
        private:
                void init();
 
+               virtual void postprocessor_loaded();
                void multisample(unsigned);
                void multisample_range(unsigned, unsigned);
                void pass(const std::string &, const std::string &);
-
-               template<typename T>
-               void postprocessor();
-
-               friend class PipelineTemplate;
+               void postprocessor(const std::string &);
        };
 
        struct Pass
@@ -73,11 +91,19 @@ public:
                ~Pass();
        };
 
+       struct PostProcessor
+       {
+               GL::PostProcessor::Template *postprocessor_template;
+               std::string slot_name;
+
+               PostProcessor(GL::PostProcessor::Template * = 0);
+       };
+
        typedef std::vector<Pass> PassArray;
-       typedef std::vector<PostProcessor::Template *> PostProcessorArray;
+       typedef std::vector<PostProcessor> PostProcessorArray;
 
 private:
-       typedef DataFile::LoadableTypeRegistry<Loader, Loader::AddPostProc> PostProcessorRegistry;
+       typedef DataFile::LoadableTypeRegistry<PostProcLoader, PostProcLoader::AddPostProc> PostProcessorRegistry;
 
        bool hdr;
        unsigned required_multisample;
@@ -108,11 +134,15 @@ void PipelineTemplate::register_postprocessor(const std::string &kw)
 }
 
 template<typename T>
-void PipelineTemplate::Loader::postprocessor()
+void PipelineTemplate::PostProcLoader::postprocessor()
 {
-       RefPtr<typename T::Template> postproc = new typename T::Template;
-       load_sub(*postproc);
-       obj.postprocessors.push_back(postproc.release());
+       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();
 }
 
 } // namespace GL