glfFramebufferObject.cpp

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003-2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "glfFramebufferObject.hh"
#include "glfException.hh"
#include <OpenGLFramework/Base/glfFBOAttachmentReleaseException.hh>

#include <OpenGLFramework/Base/glfCommon.hh>

using namespace BIAS;

glfFramebufferObject::glfFramebufferObject() : 
  id_(0), 
  numSimultaneousDrawBuffers_(0),
  listOfSimultaneousDrawBuffers_(NULL),
  FramebufferCreated_(false)
{
}

glfFramebufferObject& 
glfFramebufferObject::operator=(const glfFramebufferObject& fbo)
{
  return (*this);
}


glfFramebufferObject::glfFramebufferObject(const glfFramebufferObject& fbo)
{}

glfFramebufferObject::~glfFramebufferObject()
{
  delete listOfSimultaneousDrawBuffers_;

  if (FramebufferCreated_){
    glDeleteFramebuffersEXT(1, &id_);
  }
}

void glfFramebufferObject::Create()
{
  if(!GLEW_EXT_framebuffer_object) {
    GLF_THROW_EXCEPTION("Framebuffer objects are not supported");
  }

  if(id_ == 0) {
    glGenFramebuffersEXT(1, &id_);
    FramebufferCreated_=true;
  }

  GLF_THROW_ON_OPENGL_ERROR;
}

void glfFramebufferObject::AttachTexture(const glfTexture& texture,
                                         GLenum attachmentPoint,
                                         int attachedMipMapLevel,
                                         int zSlice, GLenum cubeMapSide)
{
  Bind();

  GLuint textureID = texture.GetTextureID();
  GLenum textureTarget = texture.GetTextureTarget();

  switch(textureTarget) {
  case GL_TEXTURE_1D :
    glFramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT, attachmentPoint,
                              GL_TEXTURE_1D, textureID, attachedMipMapLevel);
    break;
  case GL_TEXTURE_2D :
  case GL_TEXTURE_RECTANGLE_NV :
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, attachmentPoint,
                              textureTarget, textureID, attachedMipMapLevel);
    break;
  case GL_TEXTURE_3D :
    glFramebufferTexture3DEXT(GL_FRAMEBUFFER_EXT, attachmentPoint,
                              GL_TEXTURE_3D, textureID,
                              attachedMipMapLevel, zSlice);
    break;
  case GL_TEXTURE_CUBE_MAP :
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, attachmentPoint,
                              cubeMapSide, textureID, attachedMipMapLevel);
    break;
  default:
    GLF_THROW_EXCEPTION("Texture cannot be attached to framebuffer object");
    break;
  }

  GLF_THROW_ON_OPENGL_ERROR;
}

void glfFramebufferObject::AttachRenderbuffer(const glfRenderbuffer& renderbuffer,
                                              GLenum attachmentPoint)
{
  Bind();
  glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
                               attachmentPoint,
                               GL_RENDERBUFFER_EXT,
                               renderbuffer.GetRenderbufferID());
  GLF_THROW_ON_OPENGL_ERROR;
}

void glfFramebufferObject::ReleaseAttachment(GLenum attachmentPoint)
{
  Bind();

  GLint attachmentType;
  glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachmentPoint,
                                           GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT,
                                           &attachmentType);

  switch(attachmentType) {
  case GL_TEXTURE:
    glFramebufferTexture1DEXT( GL_FRAMEBUFFER_EXT, attachmentPoint,
                               GL_TEXTURE_1D, 0, 0 );
    break;
  case GL_RENDERBUFFER_EXT:
    glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, attachmentPoint,
                                 GL_RENDERBUFFER_EXT, 0);
    break;
  default:
    throw glfFBOAttachmentReleaseException(__FILE__, __LINE__, "nothing detachable attached");
    break;
  }

  GLF_THROW_ON_OPENGL_ERROR;
}

void glfFramebufferObject::CheckComplete() const
{
  Bind();

  GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);

  switch(status) {

  case GL_FRAMEBUFFER_COMPLETE_EXT: // Everything's OK
    return;

  case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
    GLF_THROW_EXCEPTION( "FBO ERROR:\n\t GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT\n");
    break;
  case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
    GLF_THROW_EXCEPTION( "FBO  ERROR:\n\t"
             " GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT\n");
    break;

#ifdef GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT
  case GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT:
    GLF_THROW_EXCEPTION( "FBO  ERROR:\n\t"
             "GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT\n");
    break;
#endif // GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT

  case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
    GLF_THROW_EXCEPTION( "FBO  ERROR:\n\t"
             "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT\n");
    break;

  case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
    GLF_THROW_EXCEPTION( "FBO  ERROR:\n\t"
             << "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT\n");
    break;

  case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
    GLint answer;
    glGetIntegerv(GL_DRAW_BUFFER, &answer);
    if(answer == GL_NONE) {
      GLF_THROW_EXCEPTION( "FBO  ERROR:\n\t"
                      << "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\n"
                      <<" current draw buffer is set to GL_NONE!");
    } else {
    GLF_THROW_EXCEPTION( "FBO  ERROR:\n\t"
             << "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\n"
             <<" is any color attachment set to NONE?");
    }
    break;

  case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
    GLF_THROW_EXCEPTION( "FBO  ERROR:\n\t"
                  << "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT\n"
                  <<" is any color attachment set to NONE?");
    break;

  case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
    GLF_THROW_EXCEPTION( "FBO  ERROR:\n\t"
             << "GL_FRAMEBUFFER_UNSUPPORTED_EXT\n");
    break;

#ifdef GL_FRAMEBUFFER_STATUS_ERROR_EXT
  case GL_FRAMEBUFFER_STATUS_ERROR_EXT:
    GLF_THROW_EXCEPTION( "FBO  ERROR:\n\t"
             << "GL_FRAMEBUFFER_STATUS_ERROR_EXT\n");
    break;
#endif // GL_FRAMEBUFFER_STATUS_ERROR_EXT

  default:
    GLF_THROW_EXCEPTION( "FBO  ERROR:\n\t"
             << "Unknown ERROR\n");
    break;
  }
}


void glfFramebufferObject::Bind() const
{
  BIASASSERT(id_ != 0);  

  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, id_);
  //last call changed the draw buffer to  GL_COLOR_ATTACHMENT0_EXT
  if(numSimultaneousDrawBuffers_>0) {
    glDrawBuffers(numSimultaneousDrawBuffers_, listOfSimultaneousDrawBuffers_);
  }
  
  GLF_THROW_ON_OPENGL_ERROR;
}

void glfFramebufferObject::SetDrawBuffers(const std::vector<GLenum>& drawbuffers)
{
  GLint maxNumberOfSimultaneousBuffers = 0;
  glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxNumberOfSimultaneousBuffers);
  if(maxNumberOfSimultaneousBuffers < (GLint)drawbuffers.size()) {
    GLF_THROW_EXCEPTION("MRT ERROR : requesting too many drawbuffers max"
                        <<maxNumberOfSimultaneousBuffers);
  } else {
    numSimultaneousDrawBuffers_ = drawbuffers.size();
    delete[] listOfSimultaneousDrawBuffers_;
    listOfSimultaneousDrawBuffers_ = new GLenum[numSimultaneousDrawBuffers_];
    for(unsigned int i=0; i<drawbuffers.size(); i++) 
      listOfSimultaneousDrawBuffers_[i] = drawbuffers[i];    
  }  
}

void glfFramebufferObject::ResetDrawBuffers() 
{
  delete[] listOfSimultaneousDrawBuffers_;
  listOfSimultaneousDrawBuffers_ = NULL;
  numSimultaneousDrawBuffers_ = 0;
}

GLint 
glfFramebufferObject::MaxRenderTargets()
{
  GLint maxbuffers = 0;
  glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxbuffers);
  return maxbuffers;
}

void glfFramebufferObject::
BlitColorBuffer(glfFramebufferObject* source, 
                glfFramebufferObject* target, 
                GLenum colorFilter)
{
  Blit_(source, target, GL_COLOR_BUFFER_BIT, colorFilter);
}


void glfFramebufferObject::
Blit(glfFramebufferObject* source, 
     glfFramebufferObject* target, 
     GLbitfield bufferMask)
{
  Blit_(source, target, bufferMask, GL_NEAREST);
}


void glfFramebufferObject::
Blit_(glfFramebufferObject* source, 
      glfFramebufferObject* target, 
      GLbitfield bufferMask,
      GLenum colorFilter)
{

  //do this before because Bind() is called!!
  GLint widthSrc,heightSrc;
  source->GetSize(widthSrc,heightSrc);
  GLint widthTrgt,heightTrgt;  
  target->GetSize(widthTrgt,heightTrgt);

  glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT,  source->id_);
  glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT,  target->id_);  
  glBlitFramebufferEXT(0,0,widthSrc,heightSrc,0,0,widthTrgt,heightTrgt, bufferMask, colorFilter);
  GLF_THROW_ON_OPENGL_ERROR;
}

void glfFramebufferObject::
GetSize(GLint& width, GLint& height)
{
  Bind();
  glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_WIDTH_EXT, &width);
  glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_HEIGHT_EXT, &height);

  GLF_THROW_ON_OPENGL_ERROR;
}