FramebufferObject.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://visualizationlibrary.org                                                   */
/*                                                                                    */
/*  Copyright (c) 2005-2020, Michele Bosi                                             */
/*  All rights reserved.                                                              */
/*                                                                                    */
/*  Redistribution and use in source and binary forms, with or without modification,  */
/*  are permitted provided that the following conditions are met:                     */
/*                                                                                    */
/*  - Redistributions of source code must retain the above copyright notice, this     */
/*  list of conditions and the following disclaimer.                                  */
/*                                                                                    */
/*  - Redistributions in binary form must reproduce the above copyright notice, this  */
/*  list of conditions and the following disclaimer in the documentation and/or       */
/*  other materials provided with the distribution.                                   */
/*                                                                                    */
/*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
/*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
/*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
/*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
/*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
/*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
/*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
/*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
/*                                                                                    */
/**************************************************************************************/

#ifndef FramebufferObject_INCLUDE_ONCE
#define FramebufferObject_INCLUDE_ONCE

#include <vlGraphics/Camera.hpp>
#include <vlGraphics/Texture.hpp>
#include <set>
#include <map>

namespace vl
{
  class FramebufferObject;
//-----------------------------------------------------------------------------
// FBOAbstractAttachment
//-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOAbstractAttachment: public Object
  {
    VL_INSTRUMENT_ABSTRACT_CLASS(vl::FBOAbstractAttachment, Object)

    friend class FramebufferObject;

  private:
    // no copy constructor and no assignment operator
    FBOAbstractAttachment( const FBOAbstractAttachment& other ): Object( other ) {}
    void operator=( const FBOAbstractAttachment& ) {}

  public:
    FBOAbstractAttachment() {}

    virtual ~FBOAbstractAttachment() { VL_CHECK(fboFramebuffers().size() == 0); }

    virtual void unbindFromAllFBO();

    const std::set< ref<FramebufferObject> >& fboFramebuffers() const { return mFramebufferObjects; }

  protected:
    virtual void bindAttachment( FramebufferObject* fbo, EAttachmentPoint attach_point ) = 0;

  protected:
    std::set< ref<FramebufferObject> > mFramebufferObjects;
  };
  //-----------------------------------------------------------------------------
  // FBORenderbufferAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBORenderbufferAttachment: public FBOAbstractAttachment
  {
    VL_INSTRUMENT_ABSTRACT_CLASS(vl::FBORenderbufferAttachment, FBOAbstractAttachment)

    friend class FramebufferObject;

  public:
    FBORenderbufferAttachment(): mHandle( 0 ), mWidth( 0 ), mHeight( 0 ), mSamples( 0 ), mReallocateRenderbuffer( true ) {}

    ~FBORenderbufferAttachment() { deleteRenderBuffer(); }

    void createRenderBuffer();

    void deleteRenderBuffer();

    void setHandle( GLuint  handle ) { if ( mHandle != handle ) { mHandle = handle; mReallocateRenderbuffer = false; } }

    GLuint handle() const { return mHandle; }

    void initStorage( int w, int h, int samples );

    void initStorage() { initStorage( width(), height(), samples() ); }

    int width() const { return mWidth; }

    int height() const { return mHeight; }

    int samples() const { return mSamples; }

    void setWidth( int w ) { if ( w != mWidth ) /* schedules recreation */ mReallocateRenderbuffer = true; mWidth = w; }

    void setHeight( int h ) { if ( h != mHeight ) /* schedules recreation */ mReallocateRenderbuffer = true; mHeight = h; }

    void setSamples( int samples ) { if ( samples != mSamples ) /* schedules recreation */ mReallocateRenderbuffer = true; mSamples = samples; }

    bool renderbufferStorageReady() const { return !mReallocateRenderbuffer; }

  protected:
    void bindAttachment( FramebufferObject* fbo, EAttachmentPoint attach_point );
    virtual int internalType() = 0;

  protected:
    GLuint mHandle;
    int mWidth;
    int mHeight;
    int mSamples;
    bool mReallocateRenderbuffer;
  };
  //-----------------------------------------------------------------------------
  // FBOColorBufferAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOColorBufferAttachment: public FBORenderbufferAttachment
  {
    VL_INSTRUMENT_CLASS(vl::FBOColorBufferAttachment, FBOColorBufferAttachment)

  public:
    FBOColorBufferAttachment( EColorBufferFormat type = CBF_RGBA )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mType = type;
    }

    void setType( EColorBufferFormat type ) { if ( type != mType ) /* schedules recreation */ mReallocateRenderbuffer = true; mType = type; }

    EColorBufferFormat type() const { return mType; }

  protected:
    virtual int internalType() { return type(); }

  protected:
    EColorBufferFormat mType;
  };
  //-----------------------------------------------------------------------------
  // FBODepthBufferAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBODepthBufferAttachment: public FBORenderbufferAttachment
  {
    VL_INSTRUMENT_CLASS(vl::FBODepthBufferAttachment, FBORenderbufferAttachment)

  public:
    FBODepthBufferAttachment( EDepthBufferFormat type = DBF_DEPTH_COMPONENT )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mType = type;
    }

    void setType( EDepthBufferFormat type ) { if ( type != mType ) /* schedules recreation */ mReallocateRenderbuffer = true; mType = type; }

    EDepthBufferFormat type() const { return mType; }

  protected:
    virtual int internalType() { return type(); }

  protected:
    EDepthBufferFormat mType;
  };
  //-----------------------------------------------------------------------------
  // FBOStencilBufferAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOStencilBufferAttachment: public FBORenderbufferAttachment
  {
    VL_INSTRUMENT_CLASS(vl::FBOStencilBufferAttachment, FBORenderbufferAttachment)

  public:
    FBOStencilBufferAttachment( EStencilBufferFormat type = SBF_STENCIL_INDEX8 )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mType = type;
    }

    void setType( EStencilBufferFormat type ) { if ( type != mType ) /* schedules recreation */ mReallocateRenderbuffer = true; mType = type; }

    EStencilBufferFormat type() const { return mType; }

  protected:
    virtual int internalType() { return type(); }

  protected:
    EStencilBufferFormat mType;
  };
  //-----------------------------------------------------------------------------
  // FBODepthStencilBufferAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBODepthStencilBufferAttachment: public FBORenderbufferAttachment
  {
    VL_INSTRUMENT_CLASS(vl::FBODepthStencilBufferAttachment, FBORenderbufferAttachment)

  public:
    FBODepthStencilBufferAttachment( EDepthStencilBufferFormat type = DSBT_DEPTH_STENCIL )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mType = type;
    }

    void setType( EDepthStencilBufferFormat type ) { if ( type != mType ) /* schedules recreation */ mReallocateRenderbuffer = true; mType = type; }

    EDepthStencilBufferFormat type() const { return mType; }

  protected:
    virtual int internalType() { return type(); }

  protected:
    EDepthStencilBufferFormat mType;
  };
  //-----------------------------------------------------------------------------
  // FBOAbstractTextureAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOAbstractTextureAttachment: public FBOAbstractAttachment
  {
    VL_INSTRUMENT_ABSTRACT_CLASS(vl::FBOAbstractTextureAttachment, FBOAbstractAttachment)

  public:
    FBOAbstractTextureAttachment( Texture* texture, int mipmap_level ): mTexture(texture), mMipmapLevel(mipmap_level)
    {
      VL_DEBUG_SET_OBJECT_NAME()
    }

    void setTexture( Texture* texture ) { mTexture = texture; }

    Texture* texture() { return mTexture.get(); }

    const Texture* texture() const { return mTexture.get(); }

    void setMipmapLevel( int mipmap_level ) { mMipmapLevel = mipmap_level; }

    int mipmapLevel() const { return mMipmapLevel; }

  protected:
    ref<Texture> mTexture;
    int mMipmapLevel;
  };
  //-----------------------------------------------------------------------------
  // FBOTexture1DAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOTexture1DAttachment: public FBOAbstractTextureAttachment
  {
    VL_INSTRUMENT_CLASS(vl::FBOTexture1DAttachment, FBOAbstractTextureAttachment)

  public:
    FBOTexture1DAttachment(): FBOAbstractTextureAttachment( NULL, 0 )
    {
      VL_DEBUG_SET_OBJECT_NAME()
    }

    FBOTexture1DAttachment( Texture* texture, int mipmap_level ): FBOAbstractTextureAttachment( texture, mipmap_level )
    {
      VL_DEBUG_SET_OBJECT_NAME()
    }

  protected:
    virtual void bindAttachment( FramebufferObject* fbo, EAttachmentPoint attach_point );
  };
  //-----------------------------------------------------------------------------
  // FBOTexture2DAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOTexture2DAttachment: public FBOAbstractTextureAttachment
  {
    VL_INSTRUMENT_CLASS(vl::FBOTexture2DAttachment, FBOAbstractTextureAttachment)

  public:
    FBOTexture2DAttachment( ): FBOAbstractTextureAttachment( NULL, 0 )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mTextureTarget = T2DT_TEXTURE_2D;
    }

    FBOTexture2DAttachment( Texture* texture, int mipmap_level, ETex2DTarget target ): FBOAbstractTextureAttachment( texture, mipmap_level )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mTextureTarget = target;
    }

    void setTextureTarget( ETex2DTarget target ) { mTextureTarget = target; }

    ETex2DTarget textureTarget() const { return mTextureTarget; }

  protected:
    virtual void bindAttachment( FramebufferObject* fbo, EAttachmentPoint attach_point );

  protected:
    ETex2DTarget mTextureTarget;
  };
  //-----------------------------------------------------------------------------
  // FBOTextureAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOTextureAttachment: public FBOAbstractTextureAttachment
  {
    VL_INSTRUMENT_CLASS(vl::FBOTextureAttachment, FBOAbstractTextureAttachment)

  public:
    FBOTextureAttachment(): FBOAbstractTextureAttachment( NULL, 0 )
    {
      VL_DEBUG_SET_OBJECT_NAME()
    }

    FBOTextureAttachment( Texture* texture, int mipmap_level ): FBOAbstractTextureAttachment( texture, mipmap_level )
    {
      VL_DEBUG_SET_OBJECT_NAME()
    }

  protected:
    virtual void bindAttachment( FramebufferObject* fbo, EAttachmentPoint attach_point );

  };
  //-----------------------------------------------------------------------------
  // FBOTexture3DAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOTexture3DAttachment: public FBOAbstractTextureAttachment
  {
    VL_INSTRUMENT_CLASS(vl::FBOTexture3DAttachment, FBOAbstractTextureAttachment)

  public:
    FBOTexture3DAttachment(): FBOAbstractTextureAttachment( NULL, 0 )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mLayer = 0;
    }

    FBOTexture3DAttachment( Texture* texture, int mipmap_level, int layer ): FBOAbstractTextureAttachment( texture, mipmap_level )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mLayer   = layer;
    }

    void setLayer( int layer ) { mLayer = layer; }

    int layer() const { return mLayer; }

  protected:
    virtual void bindAttachment( FramebufferObject* fbo, EAttachmentPoint attach_point );

  protected:
    int mLayer;
  };
  //-----------------------------------------------------------------------------
  // FBOTextureLayerAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOTextureLayerAttachment: public FBOAbstractTextureAttachment
  {
    VL_INSTRUMENT_CLASS(vl::FBOTextureLayerAttachment, FBOAbstractTextureAttachment)

  public:
    FBOTextureLayerAttachment(): FBOAbstractTextureAttachment( NULL, 0 )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mLayer = 0;
    }

    FBOTextureLayerAttachment( Texture* texture, int mipmap_level, int layer ): FBOAbstractTextureAttachment( texture, mipmap_level )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mLayer   = layer;
    }

    int layer() const { return mLayer; }

    void setLayer( int layer ) { mLayer = layer; }

  protected:
    virtual void bindAttachment( FramebufferObject* fbo, EAttachmentPoint attach_point );

  protected:
    ref<Texture> mTexture;
    int mMipmapLevel;
    int mLayer;
  };
  //-----------------------------------------------------------------------------
  // FramebufferObject
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FramebufferObject: public Object
  {
    VL_INSTRUMENT_CLASS(vl::FramebufferObject, Object)

    friend class OpenGLContext;

  private:
    void operator=( const FramebufferObject& ) {}

    FramebufferObject( const FramebufferObject& other ): 
      Object( other ),
      mOpenGLContext(0), 
      mWidth(0), 
      mHeight(0),
      mHandle( 0 ), 
      mExternallyManaged(false) 
    {
      // setDrawBuffer(draw_buffer);
      // setReadBuffer(read_buffer);
    }

    FramebufferObject():
      mOpenGLContext(NULL), 
      mWidth(0), 
      mHeight(0),
      mHandle( 0 ), 
      mExternallyManaged( false )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      setDrawBuffer(RDB_COLOR_ATTACHMENT0);
      setReadBuffer(RDB_COLOR_ATTACHMENT0);
    }

    FramebufferObject( OpenGLContext* ctx, 
                       int w, 
                       int h,
                       EReadDrawBuffer draw_buffer = RDB_COLOR_ATTACHMENT0,
                       EReadDrawBuffer read_buffer = RDB_COLOR_ATTACHMENT0 ):
      mOpenGLContext(ctx), 
      mWidth(w), 
      mHeight(h),
      mHandle( 0 ), 
      mExternallyManaged( false )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      setDrawBuffer(draw_buffer);
      setReadBuffer(read_buffer);
    }

  public:
    ~FramebufferObject() { if (openglContext()) deleteFBO(); }

    OpenGLContext* openglContext() { return mOpenGLContext; }
    
    const OpenGLContext* openglContext() const { return mOpenGLContext; }

    int width() const { return mWidth; }
    
    int height() const { return mHeight; }
    
    void setWidth(int width) { mWidth = width; }
    
    void setHeight(int height) { mHeight = height; }

    void activate(EFramebufferBind target = FBB_FRAMEBUFFER)  { bindFramebuffer(target); }

    void bindReadBuffer();

    void bindDrawBuffers() const;

    bool checkDrawBuffers() const;

    void setDrawBuffer(EReadDrawBuffer draw_buffer)
    {
      mDrawBuffers.clear();
      mDrawBuffers.push_back(draw_buffer);
    }

    void setDrawBuffers(EReadDrawBuffer draw_buffer1, EReadDrawBuffer draw_buffer2)
    {
      mDrawBuffers.clear();
      mDrawBuffers.push_back(draw_buffer1);
      mDrawBuffers.push_back(draw_buffer2);
    }

    void setDrawBuffers(EReadDrawBuffer draw_buffer1, EReadDrawBuffer draw_buffer2, EReadDrawBuffer draw_buffer3)
    {
      mDrawBuffers.clear();
      mDrawBuffers.push_back(draw_buffer1);
      mDrawBuffers.push_back(draw_buffer2);
      mDrawBuffers.push_back(draw_buffer3);
    }

    void setDrawBuffers(EReadDrawBuffer draw_buffer1, EReadDrawBuffer draw_buffer2, EReadDrawBuffer draw_buffer3, EReadDrawBuffer draw_buffer4)
    {
      mDrawBuffers.clear();
      mDrawBuffers.push_back(draw_buffer1);
      mDrawBuffers.push_back(draw_buffer2);
      mDrawBuffers.push_back(draw_buffer3);
      mDrawBuffers.push_back(draw_buffer4);
    }

    void setDrawBuffers(const std::vector< EReadDrawBuffer >& draw_buffers) { mDrawBuffers = draw_buffers; }

    const std::vector< EReadDrawBuffer >& drawBuffers() { return mDrawBuffers; }

    EReadDrawBuffer readBuffer() const { return mReadBuffer; }
    
    void setReadBuffer(EReadDrawBuffer read_buffer) { mReadBuffer = read_buffer; }

    // ---------- FramebufferObject proper functions ----------

    void createFBO();

    void deleteFBO();

    void setHandle( GLuint handle ) { mHandle = handle; }

    virtual GLuint handle() const { return mHandle; }

    virtual void bindFramebuffer( EFramebufferBind target = FBB_FRAMEBUFFER );

    GLenum checkFramebufferStatus();

    void printFramebufferError( GLenum status ) const;

    void addColorAttachment( EAttachmentPoint attach_point, FBOColorBufferAttachment* attachment );

    void addTextureAttachment( EAttachmentPoint attach_point, FBOAbstractTextureAttachment* attachment );

    void addDepthAttachment( FBOAbstractAttachment* attachment );

    void addStencilAttachment( FBOAbstractAttachment* attachment );

    void addDepthStencilAttachment( FBOAbstractAttachment* attachment );

    void removeAttachment( FBOAbstractAttachment* attachment );

    void removeAttachment( EAttachmentPoint attach_point );

    void removeAllAttachments();

    const std::map< EAttachmentPoint, ref<FBOAbstractAttachment> >& fboAttachments() const { return mFBOAttachments; }

    bool externallyManaged() const { return mExternallyManaged; }
    void setExternallyManaged( bool em ) { mExternallyManaged = em; }

  public:
    std::vector< EReadDrawBuffer > mDrawBuffers;
    EReadDrawBuffer mReadBuffer;
    OpenGLContext* mOpenGLContext;
    int mWidth;
    int mHeight;

    std::map< EAttachmentPoint, ref<FBOAbstractAttachment> > mFBOAttachments;
    GLuint mHandle;
    bool mExternallyManaged;
  };
}

#endif