source/framebuffer.cpp

   1 #include <msp/gl/extensions/arb_draw_buffers.h>
   2 #include <msp/gl/extensions/ext_framebuffer_blit.h>
   3 #include <msp/gl/extensions/ext_framebuffer_object.h>
   4 #include "error.h"
   5 #include "framebuffer.h"
   6 #include "misc.h"
   7 #include "renderbuffer.h"
   8 #include "texture2d.h"
   9
  10 using namespace std;
  11
  12 namespace Msp {
  13 namespace GL {
  14
  15 void operator<<(LexicalConverter &conv, FramebufferStatus status)
  16 {
  17         switch(status)
  18         {
  19         case FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
  20                 conv.result("incomplete attachment");
  21                 break;
  22         case FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
  23                 conv.result("missing attachment");
  24                 break;
  25         case FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
  26                 conv.result("mismatched attachment dimensions");
  27                 break;
  28         case FRAMEBUFFER_INCOMPLETE_FORMATS:
  29                 conv.result("mismatched attachment formats");
  30                 break;
  31         case FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
  32                 conv.result("missing draw buffer attachment");
  33                 break;
  34         case FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
  35                 conv.result("missing read buffer attachment");
  36                 break;
  37         case FRAMEBUFFER_UNSUPPORTED:
  38                 conv.result("unsupported");
  39                 break;
  40         default:
  41                 conv.result(lexical_cast<string, unsigned>(status, "%#x"));
  42                 break;
  43         }
  44 }
  45
  46 framebuffer_incomplete::framebuffer_incomplete(FramebufferStatus status):
  47         runtime_error(lexical_cast<string>(status))
  48 { }
  49
  50
  51 Framebuffer::Framebuffer(unsigned i):
  52         id(i),
  53         dirty(0)
  54 {
  55         if(id)
  56                 throw invalid_argument("System framebuffer must have id 0");
  57
  58         int viewport[4];
  59         glGetIntegerv(GL_VIEWPORT, viewport);
  60         width = viewport[2];
  61         height = viewport[3];
  62 }
  63
  64 Framebuffer::Framebuffer():
  65         width(0),
  66         height(0),
  67         dirty(0)
  68 {
  69         static Require _req(EXT_framebuffer_object);
  70
  71         glGenFramebuffers(1, &id);
  72 }
  73
  74 Framebuffer::~Framebuffer()
  75 {
  76         if(id)
  77                 glDeleteFramebuffers(1, &id);
  78         if(current()==this)
  79                 unbind();
  80 }
  81
  82 void Framebuffer::update_attachment(unsigned mask) const
  83 {
  84         if(current()==this)
  85         {
  86                 std::vector<GLenum> color_bufs;
  87                 color_bufs.reserve(attachments.size());
  88                 for(unsigned i=0; i<attachments.size(); ++i)
  89                 {
  90                         const Attachment &attch = attachments[i];
  91                         if(mask&(1<<i))
  92                         {
  93                                 if(attch.type==GL_RENDERBUFFER)
  94                                         glFramebufferRenderbuffer(GL_FRAMEBUFFER, attch.attachment, GL_RENDERBUFFER, attch.rbuf->get_id());
  95                                 else if(attch.type==GL_TEXTURE_2D)
  96                                 {
  97                                         static_cast<Texture2D *>(attch.tex)->allocate(attch.level);
  98                                         glFramebufferTexture2D(GL_FRAMEBUFFER, attch.attachment, attch.type, attch.tex->get_id(), attch.level);
  99                                 }
 100                                 else if(attch.type==GL_TEXTURE_CUBE_MAP)
 101                                 {
 102                                         static_cast<TextureCube *>(attch.tex)->allocate(attch.level);
 103                                         glFramebufferTexture2D(GL_FRAMEBUFFER, attch.attachment, attch.cube_face, attch.tex->get_id(), attch.level);
 104                                 }
 105                                 else
 106                                         glFramebufferRenderbuffer(GL_FRAMEBUFFER, attch.attachment, 0, 0);
 107                         }
 108
 109                         if(attch.attachment>=COLOR_ATTACHMENT0 && attch.attachment<=COLOR_ATTACHMENT3)
 110                                 color_bufs.push_back(attch.attachment);
 111                 }
 112
 113                 if(color_bufs.empty())
 114                 {
 115                         glDrawBuffer(GL_NONE);
 116                         glReadBuffer(GL_NONE);
 117                 }
 118                 else if(color_bufs.size()==1)
 119                 {
 120                         glDrawBuffer(color_bufs.front());
 121                         glReadBuffer(color_bufs.front());
 122                 }
 123                 else
 124                 {
 125                         static Require _req(ARB_draw_buffers);
 126                         glDrawBuffers(color_bufs.size(), &color_bufs[0]);
 127                         glReadBuffer(color_bufs.front());
 128                 }
 129         }
 130         else
 131                 dirty |= mask;
 132 }
 133
 134 void Framebuffer::check_size()
 135 {
 136         for(vector<Attachment>::iterator i=attachments.begin(); i!=attachments.end(); ++i)
 137                 if(i->type)
 138                 {
 139                         if(i->type==GL_RENDERBUFFER)
 140                         {
 141                                 width = i->rbuf->get_width();
 142                                 height = i->rbuf->get_height();
 143                         }
 144                         else if(i->type==GL_TEXTURE_2D)
 145                         {
 146                                 Texture2D *tex = static_cast<Texture2D *>(i->tex);
 147                                 width = tex->get_width();
 148                                 height = tex->get_height();
 149                         }
 150                         else if(i->type==GL_TEXTURE_CUBE_MAP)
 151                         {
 152                                 width = static_cast<TextureCube *>(i->tex)->get_size();
 153                                 height = width;
 154                         }
 155                         if(current()==this)
 156                                 glViewport(0, 0, width, height);
 157                         break;
 158                 }
 159 }
 160
 161 unsigned Framebuffer::get_attachment_index(FramebufferAttachment attch)
 162 {
 163         for(unsigned i=0; i<attachments.size(); ++i)
 164                 if(attachments[i].attachment==attch)
 165                         return i;
 166         attachments.push_back(Attachment(attch));
 167         return attachments.size()-1;
 168 }
 169
 170 void Framebuffer::attach(FramebufferAttachment attch, Renderbuffer &rbuf)
 171 {
 172         if(!id)
 173                 throw invalid_operation("Framebuffer::attach");
 174
 175         unsigned i = get_attachment_index(attch);
 176         attachments[i].set(rbuf);
 177         update_attachment(1<<i);
 178         check_size();
 179 }
 180
 181 void Framebuffer::attach(FramebufferAttachment attch, Texture2D &tex, unsigned level)
 182 {
 183         if(!id)
 184                 throw invalid_operation("Framebuffer::attach");
 185
 186         unsigned i = get_attachment_index(attch);
 187         attachments[i].set(tex, 0, level);
 188         update_attachment(1<<i);
 189         check_size();
 190 }
 191
 192 void Framebuffer::attach(FramebufferAttachment attch, TextureCube &tex, TextureCubeFace face, unsigned level)
 193 {
 194         if(!id)
 195                 throw invalid_operation("Framebuffer::attach");
 196
 197         unsigned i = get_attachment_index(attch);
 198         attachments[i].set(tex, face, level);
 199         update_attachment(1<<i);
 200         check_size();
 201 }
 202
 203 void Framebuffer::detach(FramebufferAttachment attch)
 204 {
 205         if(!id)
 206                 throw invalid_operation("Framebuffer::detach");
 207
 208         unsigned i = get_attachment_index(attch);
 209         attachments[i].clear();
 210         update_attachment(1<<i);
 211         check_size();
 212 }
 213
 214 FramebufferStatus Framebuffer::check_status() const
 215 {
 216         Bind _bind(this, true);
 217         return static_cast<FramebufferStatus>(glCheckFramebufferStatus(GL_FRAMEBUFFER));
 218 }
 219
 220 void Framebuffer::require_complete() const
 221 {
 222         FramebufferStatus status = check_status();
 223         if(status!=FRAMEBUFFER_COMPLETE)
 224                 throw framebuffer_incomplete(status);
 225 }
 226
 227 void Framebuffer::clear(BufferBits bits)
 228 {
 229         Bind _bind(this, true);
 230         glClear(bits);
 231 }
 232
 233 void Framebuffer::blit_from(const Framebuffer &other, int sx0, int sy0, int sx1, int sy1, int dx0, int dy0, int dx1, int dy1, BufferBits bits, bool filter)
 234 {
 235         static Require _req(EXT_framebuffer_blit);
 236
 237         const Framebuffer *old = current();
 238         if(set_current(this))
 239         {
 240                 glBindFramebuffer(GL_DRAW_FRAMEBUFFER, id);
 241                 if(dirty)
 242                 {
 243                         update_attachment(dirty);
 244                         dirty = 0;
 245                 }
 246         }
 247         if(old!=&other)
 248                 glBindFramebuffer(GL_READ_FRAMEBUFFER, other.id);
 249
 250         glBlitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, bits, (filter ? GL_LINEAR : GL_NEAREST));
 251
 252         set_current(old);
 253         glBindFramebuffer(GL_FRAMEBUFFER, (old ? old->id : 0));
 254 }
 255
 256 void Framebuffer::blit_from(const Framebuffer &other, int sx, int sy, unsigned wd, unsigned ht, int dx, int dy, BufferBits bits)
 257 {
 258         blit_from(other, sx, sy, sx+wd, sy+ht, dx, dy, dx+wd, dy+ht, bits, false);
 259 }
 260
 261 void Framebuffer::blit_from(const Framebuffer &other, BufferBits bits, bool filter)
 262 {
 263         blit_from(other, 0, 0, other.width, other.height, 0, 0, width, height, bits, filter);
 264 }
 265
 266 void Framebuffer::bind() const
 267 {
 268         if(set_current(this))
 269         {
 270                 glBindFramebuffer(GL_FRAMEBUFFER, id);
 271                 if(dirty)
 272                 {
 273                         update_attachment(dirty);
 274                         dirty = 0;
 275                 }
 276                 if(width && height)
 277                         glViewport(0, 0, width, height);
 278         }
 279 }
 280
 281 const Framebuffer *Framebuffer::current()
 282 {
 283         if(!cur_obj)
 284                 cur_obj = &system();
 285         return cur_obj;
 286 }
 287
 288 void Framebuffer::unbind()
 289 {
 290         system().bind();
 291 }
 292
 293 Framebuffer &Framebuffer::system()
 294 {
 295         static Framebuffer sys_framebuf(0);
 296         return sys_framebuf;
 297 }
 298
 299
 300 Framebuffer::Attachment::Attachment(FramebufferAttachment a):
 301         attachment(a),
 302         type(0),
 303         level(0)
 304 { }
 305
 306 void Framebuffer::Attachment::set(Renderbuffer &r)
 307 {
 308         type = GL_RENDERBUFFER;
 309         rbuf = &r;
 310         level = 0;
 311 }
 312
 313 void Framebuffer::Attachment::set(Texture &t, GLenum f, unsigned l)
 314 {
 315         type = t.get_target();
 316         tex = &t;
 317         cube_face = f;
 318         level = l;
 319 }
 320
 321 void Framebuffer::Attachment::clear()
 322 {
 323         type = 0;
 324 }
 325
 326 } // namespace GL
 327 } // namespace Msp