source/builders/sequencetemplate.h

   1 #ifndef SEQUENCETEMPLATE_H_
   2 #define SEQUENCETEMPLATE_H_
   3
   4 #include <string>
   5 #include <vector>
   6 #include <msp/core/typeregistry.h>
   7 #include <msp/datafile/objectloader.h>
   8 #include "blend.h"
   9 #include "postprocessor.h"
  10 #include "predicate.h"
  11
  12 namespace Msp {
  13 namespace GL {
  14
  15 class DepthTest;
  16 class Lighting;
  17
  18 class SequenceTemplate
  19 {
  20 private:
  21         class PostProcLoader: virtual public DataFile::Loader
  22         {
  23         private:
  24                 template<typename T>
  25                 struct AddPostProc
  26                 {
  27                         void operator()(const std::string &kw, PostProcLoader &ldr) const { ldr.add(kw, &PostProcLoader::postprocessor<T>); }
  28                 };
  29
  30         protected:
  31                 RefPtr<PostProcessor::Template> postproc;
  32
  33         public:
  34                 PostProcLoader();
  35
  36                 PostProcessor::Template *get_postprocessor_template() { return postproc.release(); }
  37
  38         protected:
  39                 virtual void postprocessor_loaded() { }
  40
  41         private:
  42                 template<typename T>
  43                 void postprocessor();
  44
  45                 friend class SequenceTemplate;
  46         };
  47
  48 public:
  49         class Loader: public DataFile::CollectionObjectLoader<SequenceTemplate, Resources>, public PostProcLoader
  50         {
  51         public:
  52                 Loader(SequenceTemplate &, Collection &);
  53
  54                 virtual void postprocessor_loaded();
  55                 void multisample(unsigned);
  56                 void multisample_range(unsigned, unsigned);
  57                 void postprocessor(const std::string &);
  58                 void step(const std::string &, const std::string &);
  59         };
  60
  61         struct Step
  62         {
  63                 class Loader: public DataFile::CollectionObjectLoader<Step>
  64                 {
  65                 public:
  66                         Loader(Step &);
  67                         Loader(Step &, Collection &);
  68                 private:
  69                         void init();
  70
  71                         void blend(BlendFactor, BlendFactor);
  72                         void blend_predefined(const std::string &);
  73                         void depth_test(Predicate);
  74                         void depth_test_predefined(const std::string &);
  75                         void lighting(const std::string &);
  76                         void lighting_inline();
  77                         // TODO requires support for scenes in Resources
  78                         //void scene(const std::string &);
  79                 };
  80
  81                 std::string tag;
  82                 RefPtr<Lighting> lighting;
  83                 RefPtr<const DepthTest> depth_test;
  84                 RefPtr<const Blend> blend;
  85                 std::string slot_name;
  86                 //Renderable *default_renderable;
  87
  88                 ~Step();
  89         };
  90
  91         struct PostProcessor
  92         {
  93                 GL::PostProcessor::Template *postprocessor_template;
  94                 std::string slot_name;
  95
  96                 PostProcessor(GL::PostProcessor::Template * = 0);
  97         };
  98
  99         typedef std::vector<PostProcessor> PostProcessorArray;
 100
 101 private:
 102         typedef TypeRegistry<PostProcLoader::AddPostProc, PostProcLoader &> PostProcessorRegistry;
 103
 104         Resources *resources;
 105         bool hdr;
 106         bool alpha;
 107         unsigned required_multisample;
 108         unsigned max_multisample;
 109         std::vector<Step> steps;
 110         PostProcessorArray postprocessors;
 111
 112 public:
 113         SequenceTemplate();
 114         ~SequenceTemplate();
 115
 116         Resources &get_resources() const;
 117         bool get_hdr() const { return hdr; }
 118         bool get_alpha() const { return alpha; }
 119         unsigned get_required_multisample() const { return required_multisample; }
 120         unsigned get_maximum_multisample() const { return max_multisample; }
 121         const std::vector<Step> &get_steps() const { return steps; }
 122         const PostProcessorArray &get_postprocessors() const { return postprocessors; }
 123
 124         template<typename T>
 125         static void register_postprocessor(const std::string &);
 126 private:
 127         static PostProcessorRegistry &get_postprocessor_registry();
 128 };
 129
 130 template<typename T>
 131 void SequenceTemplate::register_postprocessor(const std::string &kw)
 132 {
 133         get_postprocessor_registry().register_type<T>(kw);
 134 }
 135
 136 template<typename T>
 137 void SequenceTemplate::PostProcLoader::postprocessor()
 138 {
 139         if(postproc)
 140                 throw std::logic_error("Only one postprocessor allowed per slot");
 141         RefPtr<typename T::Template> pp = new typename T::Template;
 142         load_sub(*pp);
 143         postproc = pp;
 144         pp = 0;
 145         postprocessor_loaded();
 146 }
 147
 148 } // namespace GL
 149 } // namespace Msp
 150
 151 #endif