source/render/sequence.cpp

   1 #include <msp/core/maputils.h>
   2 #include "blend.h"
   3 #include "error.h"
   4 #include "framebuffer.h"
   5 #include "lighting.h"
   6 #include "postprocessor.h"
   7 #include "renderer.h"
   8 #include "sequence.h"
   9 #include "texture2d.h"
  10
  11 using namespace std;
  12
  13 namespace Msp {
  14 namespace GL {
  15
  16 Sequence::Sequence():
  17         width(0),
  18         height(0),
  19         target{0, 0},
  20         target_ms(0)
  21 { }
  22
  23 Sequence::Sequence(unsigned w, unsigned h, const FrameFormat &f):
  24         width(w),
  25         height(h),
  26         target_format(f),
  27         target_ms(0)
  28 {
  29         if(target_format.empty())
  30                 throw invalid_argument("Sequence::Sequence");
  31
  32         FrameFormat postproc_fmt = target_format;
  33         postproc_fmt.set_samples(1);
  34         target[0] = new RenderTarget(width, height, postproc_fmt);
  35         target[1] = new RenderTarget(width, height, postproc_fmt);
  36
  37         if(target_format.get_samples()>1)
  38                 target_ms = new RenderTarget(width, height, target_format);
  39 }
  40
  41 Sequence::~Sequence()
  42 {
  43         for(PostProcStep &p: postproc)
  44                 if(p.owned)
  45                         delete p.postproc;
  46         delete target[0];
  47         delete target[1];
  48         delete target_ms;
  49 }
  50
  51 Sequence::Step &Sequence::add_step(Tag tag, Renderable &r)
  52 {
  53         steps.push_back(Step(tag, &r));
  54         return steps.back();
  55 }
  56
  57 void Sequence::add_postprocessor(PostProcessor &pp)
  58 {
  59         add_postprocessor(&pp, false);
  60 }
  61
  62 void Sequence::add_postprocessor_owned(PostProcessor *pp)
  63 {
  64         add_postprocessor(pp, true);
  65 }
  66
  67 void Sequence::add_postprocessor(PostProcessor *pp, bool owned)
  68 {
  69         if(target_format.empty())
  70         {
  71                 if(owned)
  72                         delete pp;
  73                 throw invalid_operation("Sequence::add_postprocessor");
  74         }
  75         postproc.push_back(PostProcStep(pp, owned));
  76 }
  77
  78 void Sequence::setup_frame(Renderer &renderer)
  79 {
  80         for(const Step &s: steps)
  81                 if(Renderable *renderable = s.get_renderable())
  82                         renderable->setup_frame(renderer);
  83 }
  84
  85 void Sequence::finish_frame()
  86 {
  87         for(const Step &s: steps)
  88                 if(Renderable *renderable = s.get_renderable())
  89                         renderable->finish_frame();
  90 }
  91
  92 void Sequence::render(Renderer &renderer, Tag tag) const
  93 {
  94         if(tag.id)
  95                 return;
  96
  97         Renderer::Push _push(renderer);
  98
  99         const Framebuffer *out_fbo = renderer.get_framebuffer();
 100
 101         if(target[0])
 102         {
 103                 renderer.set_framebuffer(&(target_ms ? target_ms : target[0])->get_framebuffer());
 104                 renderer.clear();
 105         }
 106
 107         for(const Step &s: steps)
 108         {
 109                 Renderer::Push _push2(renderer);
 110
 111                 renderer.set_depth_test(&s.get_depth_test());
 112                 renderer.set_stencil_test(&s.get_stencil_test());
 113                 renderer.set_blend(&s.get_blend());
 114
 115                 if (const Lighting *lighting = s.get_lighting())
 116                         renderer.add_shader_data(lighting->get_shader_data());
 117                 renderer.set_clipping(s.get_clipping());
 118
 119                 if(const Renderable *renderable = s.get_renderable())
 120                         renderer.render(*renderable, s.get_tag());
 121         }
 122
 123         if(target[0])
 124         {
 125                 if(target_ms)
 126                         renderer.resolve_multisample(target[0]->get_framebuffer(), COLOR_BUFFER_BIT|DEPTH_BUFFER_BIT);
 127
 128                 renderer.set_depth_test(0);
 129                 renderer.set_stencil_test(0);
 130                 renderer.set_blend(0);
 131
 132                 for(unsigned i=0; i<postproc.size(); ++i)
 133                 {
 134                         unsigned j = i%2;
 135                         renderer.set_framebuffer(i+1<postproc.size() ? &target[1-j]->get_framebuffer() : out_fbo);
 136                         const Texture2D &color = target[j]->get_target_texture(COLOR_ATTACHMENT);
 137                         const Texture2D &depth = target[j]->get_target_texture(DEPTH_ATTACHMENT);
 138                         postproc[i].postproc->render(renderer, color, depth);
 139                 }
 140         }
 141 }
 142
 143 void Sequence::set_debug_name(const string &name)
 144 {
 145 #ifdef DEBUG
 146         for(unsigned i=0; i<2; ++i)
 147                 if(target[i])
 148                         target[i]->set_debug_name(format("%s [RT:%d]", name, i));
 149         if(target_ms)
 150                 target_ms->set_debug_name(name+" [RT:ms]");
 151 #else
 152         (void)name;
 153 #endif
 154 }
 155
 156
 157 Sequence::Step::Step(Tag t, Renderable *r):
 158         tag(t),
 159         lighting(0),
 160         clipping(0),
 161         renderable(r)
 162 { }
 163
 164 void Sequence::Step::set_lighting(const Lighting *l)
 165 {
 166         lighting = l;
 167 }
 168
 169 void Sequence::Step::set_depth_test(const DepthTest &dt)
 170 {
 171         depth_test = dt;
 172 }
 173
 174 void Sequence::Step::set_stencil_test(const StencilTest &st)
 175 {
 176         stencil_test = st;
 177 }
 178
 179 void Sequence::Step::set_blend(const Blend &b)
 180 {
 181         blend = b;
 182 }
 183
 184 void Sequence::Step::set_clipping(const Clipping *c)
 185 {
 186         clipping = c;
 187 }
 188
 189 } // namespace GL
 190 } // namespace Msp