D:/VL/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlGraphics/FramebufferObject.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://www.visualizationlibrary.com                                               */
/*                                                                                    */
/*  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 FBORenderTarget;
//-----------------------------------------------------------------------------
// FBOAbstractAttachment
//-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOAbstractAttachment: public Object
  {
    friend class FBORenderTarget;

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

  public:
    virtual const char* className() { return "vl::FBOAbstractAttachment"; }

    FBOAbstractAttachment() {}

    virtual ~FBOAbstractAttachment() { destroy(); }

    virtual void destroy();

    const std::set< ref<FBORenderTarget> >& fboRenderTargets() const { return mFBORenderTargets; }

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

  protected:
    std::set< ref<FBORenderTarget> > mFBORenderTargets;
  };
  //-----------------------------------------------------------------------------
  // FBORenderbufferAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBORenderbufferAttachment: public FBOAbstractAttachment
  {
    friend class FBORenderTarget;

  public:
    virtual const char* className() { return "vl::FBORenderbufferAttachment"; }
    
    FBORenderbufferAttachment(): mHandle( 0 ), mWidth( 0 ), mHeight( 0 ), mSamples( 0 ), mReallocateRenderbuffer( true ) {}
    
    void create();
    
    void destroy();
    
    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( FBORenderTarget* 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
  {
  public:
    virtual const char* className() { return "vl::FBOColorBufferAttachment"; }

    FBOColorBufferAttachment( EColorBufferFormat type )
    {
      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
  {
  public:
    virtual const char* className() { return "vl::FBODepthBufferAttachment"; }

    FBODepthBufferAttachment( EDepthBufferFormat type )
    {
      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
  {
  public:
    virtual const char* className() { return "vl::FBOStencilBufferAttachment"; }

    FBOStencilBufferAttachment( EStencilBufferFormat type )
    {
      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
  {
  public:
    virtual const char* className() { return "vl::FBODepthStencilBufferAttachment"; }

    FBODepthStencilBufferAttachment( EDepthStencilBufferFormat type )
    {
      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
  {
  public:
    virtual const char* className() { return "vl::FBOAbstractTextureAttachment"; }

    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
  {
  public:
    virtual const char* className() { return "vl::FBOTexture1DAttachment"; }

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

  protected:
    virtual void bindAttachment( FBORenderTarget* fbo, EAttachmentPoint attach_point );
  };
  //-----------------------------------------------------------------------------
  // FBOTexture2DAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOTexture2DAttachment: public FBOAbstractTextureAttachment
  {
  public:
    virtual const char* className() { return "vl::FBOTexture2DAttachment"; }

    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( FBORenderTarget* fbo, EAttachmentPoint attach_point );

  protected:
    ETex2DTarget mTextureTarget;
  };
  //-----------------------------------------------------------------------------
  // FBOTextureAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOTextureAttachment: public FBOAbstractTextureAttachment
  {
  public:
    virtual const char* className() { return "vl::FBOTextureAttachment"; }

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

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

  };
  //-----------------------------------------------------------------------------
  // FBOTexture3DAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOTexture3DAttachment: public FBOAbstractTextureAttachment
  {
  public:
    virtual const char* className() { return "vl::FBOTexture3DAttachment"; }

    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( FBORenderTarget* fbo, EAttachmentPoint attach_point );

  protected:
    int mLayer;
  };
  //-----------------------------------------------------------------------------
  // FBOTextureLayerAttachment
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBOTextureLayerAttachment: public FBOAbstractTextureAttachment
  {
  public:
    virtual const char* className() { return "vl::FBOTextureLayerAttachment"; }

    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( FBORenderTarget* fbo, EAttachmentPoint attach_point );

  protected:
    ref<Texture> mTexture;
    int mMipmapLevel;
    int mLayer;
  };
  //-----------------------------------------------------------------------------
  // FBORenderTarget
  //-----------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT FBORenderTarget: public RenderTarget
  {
    friend class OpenGLContext;

  private:
    FBORenderTarget( const FBORenderTarget& other ): RenderTarget( other ), mHandle( 0 ) {}
    
    void operator=( const FBORenderTarget& ) {}
    
    FBORenderTarget( OpenGLContext* ctx, int w, int h ): RenderTarget( ctx, w, h ), mHandle( 0 )
    {
      VL_DEBUG_SET_OBJECT_NAME()
      setDrawBuffer( RDB_COLOR_ATTACHMENT0 );
      setReadBuffer( RDB_COLOR_ATTACHMENT0 );
    }

  public:
    virtual const char* className() { return "vl::FBORenderTarget"; }

    ~FBORenderTarget() { if (openglContext()) destroy(); }

    void create();

    void destroy();

    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