source/builders/sequencetemplate.cpp

   1 #include <msp/core/maputils.h>
   2 #include <msp/datafile/collection.h>
   3 #include "ambientocclusion.h"
   4 #include "blend.h"
   5 #include "bloom.h"
   6 #include "colorcurve.h"
   7 #include "lighting.h"
   8 #include "resources.h"
   9 #include "sequencetemplate.h"
  10 #include "tests.h"
  11
  12 using namespace std;
  13
  14 namespace Msp {
  15 namespace GL {
  16
  17 SequenceTemplate::SequenceTemplate():
  18         resources(0),
  19         hdr(false),
  20         alpha(false),
  21         required_multisample(0),
  22         max_multisample(0)
  23 { }
  24
  25 SequenceTemplate::~SequenceTemplate()
  26 {
  27         for(PostProcessorArray::iterator i=postprocessors.begin(); i!=postprocessors.end(); ++i)
  28                 delete i->postprocessor_template;
  29 }
  30
  31 Resources &SequenceTemplate::get_resources() const
  32 {
  33         if(!resources)
  34                 throw logic_error("no resources");
  35         return *resources;
  36 }
  37
  38
  39 SequenceTemplate::PostProcessorRegistry &SequenceTemplate::get_postprocessor_registry()
  40 {
  41         static PostProcessorRegistry registry;
  42         static bool initialized = false;
  43         if(!initialized)
  44         {
  45                 registry.register_type<AmbientOcclusion>("ambient_occlusion");
  46                 registry.register_type<Bloom>("bloom");
  47                 registry.register_type<ColorCurve>("colorcurve");
  48                 initialized = true;
  49         }
  50         return registry;
  51 }
  52
  53
  54 SequenceTemplate::Step::~Step()
  55 { }
  56
  57
  58 SequenceTemplate::PostProcessor::PostProcessor(GL::PostProcessor::Template *ppt):
  59         postprocessor_template(ppt)
  60 { }
  61
  62
  63 SequenceTemplate::PostProcLoader::PostProcLoader()
  64 {
  65         get_postprocessor_registry().invoke_all(*this);
  66 }
  67
  68
  69 SequenceTemplate::Loader::Loader(SequenceTemplate &t, Collection &c):
  70         DataFile::CollectionObjectLoader<SequenceTemplate, Resources>(t, &c)
  71 {
  72         add("hdr", &SequenceTemplate::hdr);
  73         add("alpha", &SequenceTemplate::alpha);
  74         add("multisample", &Loader::multisample);
  75         add("multisample", &Loader::multisample_range);
  76         add("postprocessor", &Loader::postprocessor);
  77         add("step", &Loader::step);
  78
  79         // Deprecated
  80         add("pass", &Loader::step);
  81
  82         obj.resources = &c;
  83 }
  84
  85 void SequenceTemplate::Loader::postprocessor_loaded()
  86 {
  87         obj.postprocessors.push_back(get_postprocessor_template());
  88 }
  89
  90 void SequenceTemplate::Loader::multisample(unsigned samples)
  91 {
  92         obj.required_multisample = samples;
  93         obj.max_multisample = samples;
  94 }
  95
  96 void SequenceTemplate::Loader::multisample_range(unsigned req, unsigned max)
  97 {
  98         obj.required_multisample = req;
  99         obj.max_multisample = max;
 100 }
 101
 102 void SequenceTemplate::Loader::postprocessor(const string &slot)
 103 {
 104         PostProcLoader ldr;
 105         load_sub_with(ldr);
 106         PostProcessor pp;
 107         pp.postprocessor_template = ldr.get_postprocessor_template();
 108         pp.slot_name = slot;
 109         obj.postprocessors.push_back(pp);
 110 }
 111
 112 void SequenceTemplate::Loader::step(const string &tag, const string &rend)
 113 {
 114         Step stp;
 115         stp.tag = tag;
 116         stp.slot_name = rend;
 117         if(coll)
 118                 load_sub(stp, *coll);
 119         else
 120                 load_sub(stp);
 121
 122         obj.steps.push_back(stp);
 123 }
 124
 125
 126 SequenceTemplate::Step::Loader::Loader(Step &p):
 127         DataFile::CollectionObjectLoader<Step>(p, 0)
 128 {
 129         init();
 130 }
 131
 132 SequenceTemplate::Step::Loader::Loader(Step &p, Collection &c):
 133         DataFile::CollectionObjectLoader<Step>(p, &c)
 134 {
 135         init();
 136 }
 137
 138 void SequenceTemplate::Step::Loader::init()
 139 {
 140         add("blend", &Loader::blend);
 141         add("blend", &Loader::blend_predefined);
 142         add("depth_test", &Loader::depth_test);
 143         add("depth_test", &Loader::depth_test_predefined);
 144         add("lighting", &Loader::lighting);
 145         add("lighting", &Loader::lighting_inline);
 146 }
 147
 148 void SequenceTemplate::Step::Loader::blend_predefined(const string &name)
 149 {
 150         const Blend *bln = 0;
 151         if(name=="alpha")
 152                 bln = &Blend::alpha();
 153         else if(name=="additive")
 154                 bln = &Blend::additive();
 155         else if(name=="additive_alpha")
 156                 bln = &Blend::additive_alpha();
 157         else
 158                 throw key_error(name);
 159
 160         obj.blend = bln;
 161         obj.blend.keep();
 162 }
 163
 164 void SequenceTemplate::Step::Loader::blend(BlendFactor src, BlendFactor dest)
 165 {
 166         obj.blend = new Blend(src, dest);
 167 }
 168
 169 void SequenceTemplate::Step::Loader::depth_test_predefined(const string &name)
 170 {
 171         const DepthTest *dtest = 0;
 172         if(name=="lequal")
 173                 dtest = &DepthTest::lequal();
 174         else
 175                 throw key_error(name);
 176
 177         obj.depth_test = dtest;
 178         obj.depth_test.keep();
 179 }
 180
 181 void SequenceTemplate::Step::Loader::depth_test(Predicate pred)
 182 {
 183         obj.depth_test = new DepthTest(pred);
 184 }
 185
 186 void SequenceTemplate::Step::Loader::lighting_inline()
 187 {
 188         RefPtr<Lighting> lightn = new Lighting;
 189         load_sub(*lightn);
 190         obj.lighting = lightn;
 191 }
 192
 193 void SequenceTemplate::Step::Loader::lighting(const string &name)
 194 {
 195         obj.lighting = &get_collection().get<Lighting>(name);
 196         obj.lighting.keep();
 197 }
 198
 199 /*void SequenceTemplate::Step::Loader::scene(const string &name)
 200 {
 201         obj.default_renderable = get_collection().get<Scene>(name);
 202 }*/
 203
 204 } // namespace GL
 205 } // namespace Msp