X:/dropbox/visualizationlibrary/src/vlGraphics/FramebufferObject.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://www.visualizationlibrary.org                                               */
/*                                                                                    */
/*  Copyright (c) 2005-2010, 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 Framebuffer
  {
    VL_INSTRUMENT_CLASS(vl::FramebufferObject, Framebuffer)

    friend class OpenGLContext;

  private:
    FramebufferObject( const FramebufferObject& other ): Framebuffer( other ), mHandle( 0 ) {}
    
    void operator=( const FramebufferObject& ) {}
    
    FramebufferObject(): 
    Framebuffer( NULL, 0, 0, RDB_COLOR_ATTACHMENT0, RDB_COLOR_ATTACHMENT0 ), mHandle( 0 )
    {
      VL_DEBUG_SET_OBJECT_NAME()
    }

    FramebufferObject( OpenGLContext* ctx, int w, int h, 
        EReadDrawBuffer draw_buffer=RDB_COLOR_ATTACHMENT0, 
        EReadDrawBuffer read_buffer=RDB_COLOR_ATTACHMENT0 ):
    Framebuffer( ctx, w, h, draw_buffer, read_buffer ), mHandle( 0 )
    {
      VL_DEBUG_SET_OBJECT_NAME()
    }

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

    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; }
    
  public:
    std::map< EAttachmentPoint, ref<FBOAbstractAttachment> > mFBOAttachments;
    GLuint mHandle;
  };
}

#endif