source/pipeline.cpp

   1 #include <msp/core/maputils.h>
   2 #include "blend.h"
   3 #include "camera.h"
   4 #include "framebuffer.h"
   5 #include "lighting.h"
   6 #include "pipeline.h"
   7 #include "postprocessor.h"
   8 #include "renderbuffer.h"
   9 #include "renderer.h"
  10 #include "tests.h"
  11 #include "texture2d.h"
  12
  13 using namespace std;
  14
  15 namespace Msp {
  16 namespace GL {
  17
  18 Pipeline::Pipeline(unsigned w, unsigned h, bool d):
  19         camera(0),
  20         width(w),
  21         height(h),
  22         hdr(d),
  23         samples(0),
  24         target_ms(0),
  25         in_frame(false)
  26 {
  27         target[0] = 0;
  28         target[1] = 0;
  29 }
  30
  31 Pipeline::~Pipeline()
  32 {
  33         delete target[0];
  34         delete target[1];
  35         delete target_ms;
  36 }
  37
  38 void Pipeline::set_hdr(bool h)
  39 {
  40         if(h==hdr)
  41                 return;
  42
  43         hdr = h;
  44         create_targets(2);
  45 }
  46
  47 void Pipeline::set_multisample(unsigned s)
  48 {
  49         if(s==samples)
  50                 return;
  51
  52         unsigned old_samples = samples;
  53         samples = s;
  54         try
  55         {
  56                 create_targets(1);
  57         }
  58         catch(...)
  59         {
  60                 samples = old_samples;
  61                 throw;
  62         }
  63 }
  64
  65 void Pipeline::set_camera(const Camera *c)
  66 {
  67         camera = c;
  68 }
  69
  70 Pipeline::Pass &Pipeline::add_pass(const Tag &tag)
  71 {
  72         passes.push_back(Pass(tag));
  73         return passes.back();
  74 }
  75
  76 void Pipeline::add_renderable(const Renderable &r)
  77 {
  78         for(vector<Slot>::iterator i=renderables.begin(); i!=renderables.end(); ++i)
  79                 if(i->renderable==&r)
  80                 {
  81                         i->passes.clear();
  82                         return;
  83                 }
  84
  85         renderables.push_back(&r);
  86 }
  87
  88 void Pipeline::add_renderable_for_pass(const Renderable &r, const Tag &tag)
  89 {
  90         for(vector<Slot>::iterator i=renderables.begin(); i!=renderables.end(); ++i)
  91                 if(i->renderable==&r)
  92                 {
  93                         i->passes.insert(tag);
  94                         return;
  95                 }
  96
  97         renderables.push_back(&r);
  98         renderables.back().passes.insert(tag);
  99 }
 100
 101 void Pipeline::remove_renderable(const Renderable &r)
 102 {
 103         for(vector<Slot>::iterator i=renderables.begin(); i!=renderables.end(); ++i)
 104                 if(i->renderable==&r)
 105                 {
 106                         renderables.erase(i);
 107                         return;
 108                 }
 109 }
 110
 111 void Pipeline::add_postprocessor(PostProcessor &pp)
 112 {
 113         postproc.push_back(&pp);
 114         create_targets(0);
 115 }
 116
 117 void Pipeline::setup_frame() const
 118 {
 119         in_frame = true;
 120         for(vector<Slot>::const_iterator i=renderables.begin(); i!=renderables.end(); ++i)
 121                 i->renderable->setup_frame();
 122 }
 123
 124 void Pipeline::finish_frame() const
 125 {
 126         in_frame = false;
 127         for(vector<Slot>::const_iterator i=renderables.begin(); i!=renderables.end(); ++i)
 128                 i->renderable->finish_frame();
 129 }
 130
 131 void Pipeline::render(const Tag &tag) const
 132 {
 133         if(tag.id)
 134                 return;
 135
 136         Renderer renderer(camera);
 137         render(renderer, tag);
 138 }
 139
 140 void Pipeline::render(Renderer &renderer, const Tag &tag) const
 141 {
 142         if(tag.id)
 143                 return;
 144
 145         bool was_in_frame = in_frame;
 146         if(!in_frame)
 147                 setup_frame();
 148
 149         const Framebuffer *out_fbo = Framebuffer::current();
 150         // XXX Make sure the correct FBO is restored if an exception is thrown
 151
 152         if(target[0])
 153         {
 154                 Framebuffer &fbo = (samples ? target_ms->fbo : target[0]->fbo);
 155                 fbo.bind();
 156                 fbo.clear(COLOR_BUFFER_BIT|DEPTH_BUFFER_BIT);
 157         }
 158
 159         for(PassList::const_iterator i=passes.begin(); i!=passes.end(); ++i)
 160         {
 161                 Bind bind_depth_test(i->get_depth_test());
 162                 Bind bind_blend(i->get_blend());
 163                 renderer.set_lighting(i->get_lighting());
 164
 165                 for(vector<Slot>::const_iterator j=renderables.begin(); j!=renderables.end(); ++j)
 166                         if(j->passes.empty() || j->passes.count(i->get_tag()))
 167                                 renderer.render(*j->renderable, i->get_tag());
 168         }
 169
 170         renderer.end();
 171
 172         if(target[0])
 173         {
 174                 if(samples)
 175                         target[0]->fbo.blit_from(target_ms->fbo, COLOR_BUFFER_BIT|DEPTH_BUFFER_BIT, false);
 176
 177                 for(unsigned i=0; i<postproc.size(); ++i)
 178                 {
 179                         unsigned j = i%2;
 180                         if(i+1<postproc.size())
 181                                 target[1-j]->fbo.bind();
 182                         else
 183                                 out_fbo->bind();
 184                         postproc[i]->render(target[j]->color, target[j]->depth);
 185                 }
 186
 187                 out_fbo->bind();
 188         }
 189
 190         if(!was_in_frame)
 191                 finish_frame();
 192 }
 193
 194 void Pipeline::create_targets(unsigned recreate)
 195 {
 196         if(recreate>=2)
 197         {
 198                 delete target[0];
 199                 delete target[1];
 200                 target[0] = 0;
 201                 target[1] = 0;
 202         }
 203         if(recreate>=1)
 204         {
 205                 delete target_ms;
 206                 target_ms = 0;
 207         }
 208
 209         PixelFormat fmt = (hdr ? RGB16F : RGB);
 210         if(!postproc.empty() || samples)
 211         {
 212                 if(!target[0])
 213                         target[0] = new RenderTarget(width, height, fmt);
 214                 if(!target[1] && postproc.size()>1)
 215                         target[1] = new RenderTarget(width, height, fmt);
 216         }
 217
 218         if(!target_ms && samples)
 219                 target_ms = new MultisampleTarget(width, height, samples, fmt);
 220 }
 221
 222
 223 Pipeline::Pass::Pass(const Tag &t):
 224         tag(t),
 225         lighting(0),
 226         depth_test(0),
 227         blend(0)
 228 { }
 229
 230 void Pipeline::Pass::set_lighting(const Lighting *l)
 231 {
 232         lighting = l;
 233 }
 234
 235 void Pipeline::Pass::set_depth_test(const DepthTest *d)
 236 {
 237         depth_test = d;
 238 }
 239
 240 void Pipeline::Pass::set_blend(const Blend *b)
 241 {
 242         blend = b;
 243 }
 244
 245
 246 Pipeline::Slot::Slot(const Renderable *r):
 247         renderable(r)
 248 { }
 249
 250
 251 Pipeline::RenderTarget::RenderTarget(unsigned w, unsigned h, PixelFormat f)
 252 {
 253         color.set_min_filter(NEAREST);
 254         color.set_mag_filter(NEAREST);
 255         color.set_wrap(CLAMP_TO_EDGE);
 256         color.storage(f, w, h);
 257         fbo.attach(COLOR_ATTACHMENT0, color, 0);
 258
 259         depth.set_min_filter(NEAREST);
 260         depth.set_mag_filter(NEAREST);
 261         depth.set_wrap(CLAMP_TO_EDGE);
 262         depth.storage(DEPTH_COMPONENT, w, h);
 263         fbo.attach(DEPTH_ATTACHMENT, depth, 0);
 264
 265         fbo.require_complete();
 266 }
 267
 268
 269 Pipeline::MultisampleTarget::MultisampleTarget(unsigned w, unsigned h, unsigned s, PixelFormat f)
 270 {
 271         color.storage_multisample(s, f, w, h);
 272         fbo.attach(COLOR_ATTACHMENT0, color);
 273
 274         depth.storage_multisample(s, DEPTH_COMPONENT, w, h);
 275         fbo.attach(DEPTH_ATTACHMENT, depth);
 276
 277         fbo.require_complete();
 278 }
 279
 280 } // namespace GL
 281 } // namespace Msp