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