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         bool old_hdr= hdr;
  44         hdr = h;
  45         try
  46         {
  47                 create_targets(2);
  48         }
  49         catch(...)
  50         {
  51                 hdr = old_hdr;
  52                 throw;
  53         }
  54 }
  55
  56 void Pipeline::set_multisample(unsigned s)
  57 {
  58         if(s==samples)
  59                 return;
  60
  61         unsigned old_samples = samples;
  62         samples = s;
  63         try
  64         {
  65                 create_targets(1);
  66         }
  67         catch(...)
  68         {
  69                 samples = old_samples;
  70                 throw;
  71         }
  72 }
  73
  74 void Pipeline::set_camera(const Camera *c)
  75 {
  76         camera = c;
  77 }
  78
  79 Pipeline::Pass &Pipeline::add_pass(const Tag &tag)
  80 {
  81         passes.push_back(Pass(tag, 0));
  82         return passes.back();
  83 }
  84
  85 void Pipeline::add_renderable(const Renderable &r)
  86 {
  87         for(vector<Slot>::iterator i=renderables.begin(); i!=renderables.end(); ++i)
  88                 if(i->renderable==&r)
  89                 {
  90                         i->passes.clear();
  91                         return;
  92                 }
  93
  94         renderables.push_back(&r);
  95 }
  96
  97 void Pipeline::add_renderable_for_pass(const Renderable &r, const Tag &tag)
  98 {
  99         for(vector<Slot>::iterator i=renderables.begin(); i!=renderables.end(); ++i)
 100                 if(i->renderable==&r)
 101                 {
 102                         i->passes.insert(tag);
 103                         return;
 104                 }
 105
 106         renderables.push_back(&r);
 107         renderables.back().passes.insert(tag);
 108 }
 109
 110 void Pipeline::remove_renderable(const Renderable &r)
 111 {
 112         for(vector<Slot>::iterator i=renderables.begin(); i!=renderables.end(); ++i)
 113                 if(i->renderable==&r)
 114                 {
 115                         renderables.erase(i);
 116                         return;
 117                 }
 118 }
 119
 120 Pipeline::Pass &Pipeline::add_pass(const Tag &tag, const Renderable &r)
 121 {
 122         passes.push_back(Pass(tag, &r));
 123         return passes.back();
 124 }
 125
 126 void Pipeline::add_postprocessor(PostProcessor &pp)
 127 {
 128         postproc.push_back(&pp);
 129         try
 130         {
 131                 create_targets(0);
 132         }
 133         catch(...)
 134         {
 135                 postproc.pop_back();
 136                 throw;
 137         }
 138 }
 139
 140 void Pipeline::setup_frame() const
 141 {
 142         in_frame = true;
 143         for(PassList::const_iterator i=passes.begin(); i!=passes.end(); ++i)
 144                 if(const Renderable *renderable = i->get_renderable())
 145                         renderable->setup_frame();
 146         for(vector<Slot>::const_iterator i=renderables.begin(); i!=renderables.end(); ++i)
 147                 i->renderable->setup_frame();
 148 }
 149
 150 void Pipeline::finish_frame() const
 151 {
 152         in_frame = false;
 153         for(PassList::const_iterator i=passes.begin(); i!=passes.end(); ++i)
 154                 if(const Renderable *renderable = i->get_renderable())
 155                         renderable->finish_frame();
 156         for(vector<Slot>::const_iterator i=renderables.begin(); i!=renderables.end(); ++i)
 157                 i->renderable->finish_frame();
 158 }
 159
 160 void Pipeline::render(const Tag &tag) const
 161 {
 162         if(tag.id)
 163                 return;
 164
 165         Renderer renderer(camera);
 166         render(renderer, tag);
 167 }
 168
 169 void Pipeline::render(Renderer &renderer, const Tag &tag) const
 170 {
 171         if(tag.id)
 172                 return;
 173
 174         bool was_in_frame = in_frame;
 175         if(!in_frame)
 176                 setup_frame();
 177
 178         const Framebuffer *out_fbo = Framebuffer::current();
 179         // These is a no-ops but will ensure the related state gets restored
 180         BindRestore restore_fbo(out_fbo);
 181         BindRestore restore_depth_test(DepthTest::current());
 182         BindRestore restore_blend(Blend::current());
 183
 184         if(target[0])
 185         {
 186                 Framebuffer &fbo = (samples ? target_ms->fbo : target[0]->fbo);
 187                 fbo.bind();
 188                 fbo.clear(COLOR_BUFFER_BIT|DEPTH_BUFFER_BIT);
 189         }
 190
 191
 192         for(PassList::const_iterator i=passes.begin(); i!=passes.end(); ++i)
 193         {
 194                 if(const DepthTest *dt = i->get_depth_test())
 195                         dt->bind();
 196                 else
 197                         DepthTest::unbind();
 198
 199                 if(const Blend *b = i->get_blend())
 200                         b->bind();
 201                 else
 202                         Blend::unbind();
 203
 204                 renderer.set_lighting(i->get_lighting());
 205                 renderer.set_clipping(i->get_clipping());
 206
 207                 if(const Renderable *renderable = i->get_renderable())
 208                         renderer.render(*renderable, i->get_tag());
 209
 210                 for(vector<Slot>::const_iterator j=renderables.begin(); j!=renderables.end(); ++j)
 211                         if(j->passes.empty() || j->passes.count(i->get_tag()))
 212                                 renderer.render(*j->renderable, i->get_tag());
 213         }
 214
 215         if(target[0])
 216         {
 217                 BindRestore unbind_depth_test(static_cast<DepthTest *>(0));
 218                 BindRestore unbind_blend(static_cast<Blend *>(0));
 219
 220                 if(samples)
 221                         target[0]->fbo.blit_from(target_ms->fbo, COLOR_BUFFER_BIT|DEPTH_BUFFER_BIT, false);
 222
 223                 for(unsigned i=0; i<postproc.size(); ++i)
 224                 {
 225                         unsigned j = i%2;
 226                         if(i+1<postproc.size())
 227                                 target[1-j]->fbo.bind();
 228                         else
 229                                 out_fbo->bind();
 230                         postproc[i]->render(renderer, target[j]->color, target[j]->depth);
 231                 }
 232         }
 233
 234         if(!was_in_frame)
 235                 finish_frame();
 236 }
 237
 238 void Pipeline::create_targets(unsigned recreate)
 239 {
 240         if(recreate>=2)
 241         {
 242                 delete target[0];
 243                 delete target[1];
 244                 target[0] = 0;
 245                 target[1] = 0;
 246         }
 247         if(recreate>=1)
 248         {
 249                 delete target_ms;
 250                 target_ms = 0;
 251         }
 252
 253         PixelFormat fmt = (hdr ? RGB16F : RGB);
 254         if(!postproc.empty() || samples)
 255         {
 256                 if(!target[0])
 257                         target[0] = new RenderTarget(width, height, fmt);
 258                 if(!target[1] && postproc.size()>1)
 259                         target[1] = new RenderTarget(width, height, fmt);
 260         }
 261
 262         if(!target_ms && samples)
 263                 target_ms = new MultisampleTarget(width, height, samples, fmt);
 264 }
 265
 266
 267 Pipeline::Pass::Pass(const Tag &t, const Renderable *r):
 268         tag(t),
 269         lighting(0),
 270         depth_test(0),
 271         blend(0),
 272         clipping(0),
 273         renderable(r)
 274 { }
 275
 276 void Pipeline::Pass::set_lighting(const Lighting *l)
 277 {
 278         lighting = l;
 279 }
 280
 281 void Pipeline::Pass::set_depth_test(const DepthTest *d)
 282 {
 283         depth_test = d;
 284 }
 285
 286 void Pipeline::Pass::set_blend(const Blend *b)
 287 {
 288         blend = b;
 289 }
 290
 291 void Pipeline::Pass::set_clipping(const Clipping *c)
 292 {
 293         clipping =c;
 294 }
 295
 296
 297 Pipeline::Slot::Slot(const Renderable *r):
 298         renderable(r)
 299 { }
 300
 301
 302 Pipeline::RenderTarget::RenderTarget(unsigned w, unsigned h, PixelFormat f)
 303 {
 304         color.set_min_filter(NEAREST);
 305         color.set_mag_filter(NEAREST);
 306         color.set_wrap(CLAMP_TO_EDGE);
 307         color.storage(f, w, h);
 308         fbo.attach(COLOR_ATTACHMENT0, color, 0);
 309
 310         depth.set_min_filter(NEAREST);
 311         depth.set_mag_filter(NEAREST);
 312         depth.set_wrap(CLAMP_TO_EDGE);
 313         depth.storage(DEPTH_COMPONENT, w, h);
 314         fbo.attach(DEPTH_ATTACHMENT, depth, 0);
 315
 316         fbo.require_complete();
 317 }
 318
 319
 320 Pipeline::MultisampleTarget::MultisampleTarget(unsigned w, unsigned h, unsigned s, PixelFormat f)
 321 {
 322         color.storage_multisample(s, f, w, h);
 323         fbo.attach(COLOR_ATTACHMENT0, color);
 324
 325         depth.storage_multisample(s, DEPTH_COMPONENT, w, h);
 326         fbo.attach(DEPTH_ATTACHMENT, depth);
 327
 328         fbo.require_complete();
 329 }
 330
 331 } // namespace GL
 332 } // namespace Msp