Rearrange soucre files into subdirectories

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

diff --git a/source/builders/pipelinetemplate.h b/source/builders/pipelinetemplate.h
new file mode 100644 (file)
index 0000000..fb24ea2
--- /dev/null
+++ b/source/builders/pipelinetemplate.h
@@ -0,0 +1,153 @@
+#ifndef PIPELINETEMPLATE_H_
+#define PIPELINETEMPLATE_H_
+
+#include <string>
+#include <vector>
+#include <msp/datafile/loadabletyperegistry.h>
+#include <msp/datafile/objectloader.h>
+#include "blend.h"
+#include "postprocessor.h"
+#include "predicate.h"
+
+namespace Msp {
+namespace GL {
+
+class DepthTest;
+class Lighting;
+
+class PipelineTemplate
+{
+private:
+       class PostProcLoader: virtual public DataFile::Loader
+       {
+       private:
+               template<typename T>
+               struct AddPostProc
+               {
+                       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 &);
+               void postprocessor(const std::string &);
+       };
+
+       struct Pass
+       {
+               class Loader: public DataFile::CollectionObjectLoader<Pass>
+               {
+               public:
+                       Loader(Pass &);
+                       Loader(Pass &, Collection &);
+               private:
+                       void init();
+
+                       void blend(BlendFactor, BlendFactor);
+                       void blend_predefined(const std::string &);
+                       void depth_test(Predicate);
+                       void depth_test_predefined(const std::string &);
+                       void lighting(const std::string &);
+                       void lighting_inline();
+                       // TODO requires support for scenes in Resources
+                       //void scene(const std::string &);
+               };
+
+               std::string tag;
+               RefPtr<Lighting> lighting;
+               RefPtr<const DepthTest> depth_test;
+               RefPtr<const Blend> blend;
+               std::string renderable_name;
+               //Renderable *default_renderable;
+
+               ~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> PostProcessorArray;
+
+private:
+       typedef DataFile::LoadableTypeRegistry<PostProcLoader, PostProcLoader::AddPostProc> PostProcessorRegistry;
+
+       bool hdr;
+       bool alpha;
+       unsigned required_multisample;
+       unsigned max_multisample;
+       PassArray passes;
+       PostProcessorArray postprocessors;
+
+public:
+       PipelineTemplate();
+       ~PipelineTemplate();
+
+       bool get_hdr() const { return hdr; }
+       bool get_alpha() const { return alpha; }
+       unsigned get_required_multisample() const { return required_multisample; }
+       unsigned get_maximum_multisample() const { return max_multisample; }
+       const PassArray &get_passes() const { return passes; }
+       const PostProcessorArray &get_postprocessors() const { return postprocessors; }
+
+       template<typename T>
+       static void register_postprocessor(const std::string &);
+private:
+       static PostProcessorRegistry &get_postprocessor_registry();
+};
+
+template<typename T>
+void PipelineTemplate::register_postprocessor(const std::string &kw)
+{
+       get_postprocessor_registry().register_type<T>(kw);
+}
+
+template<typename T>
+void PipelineTemplate::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();
+}
+
+} // namespace GL
+} // namespace Msp
+
+#endif