TAPsPBuffer.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsPBuffer.hpp

Class PBuffer (Pixel Buffer) is a class for managing a pbuffer.

SUKITTI PUNAK   (05/18/2005)
UPDATE          (09/10/2010)
******************************************************************************/
// Modified from NVIDIA SDK 9.1 shared/pbuffer.h
// The pixel format for the pbuffer is controlled by the mode string passed
// into the PBuffer constructor. This string can have the following attributes:
//
// r            - r pixel format (for float buffer).
// rg           - rg pixel format (for float buffer).
// rgb          - rgb pixel format. 8 bit or 16/32 bit in float buffer mode
// rgba         - same as "rgb alpha" string
// alpha        - must have alpha channel
// depth        - must have a depth buffer
// depth=n      - must have n-bit depth buffer
// stencil      - must have a stencil buffer
// double       - must support double buffered rendering
// samples=n    - must support n-sample antialiasing (n can be 2 or 4)
// float=n      - must support n-bit per channel floating point
// 
// texture2D
// textureRECT
// textureCUBE  - must support binding pbuffer as texture to specified target
//              - binding the depth buffer is also supporting by specifying
//                '=depth' like so: texture2D=depth or textureRECT=depth
//              - the internal format of the texture will be rgba by default or
//                float if pbuffer is floating point
//      
/******************************************************************************/
#ifndef TAPs_PIXEL_BUFFER_HPP
#define TAPs_PIXEL_BUFFER_HPP

#include "../Core/TAPsDef.hpp"

#if defined ( WIN32 )
    //#define GLEW_STATIC 1
    #include <GL/glew.h>
    #include <GL/wglew.h>
    #include <GL/glut.h>
    #include <GL/wglext.h>
    //#include <windows.h>
//#  pragma warning (disable : 4786)
#elif defined ( UNIX )
    #error "UNIX is not supported!"
    #include <GL/glx.h>
    #include <GL/glxext.h>
#elif defined ( MACOS )
    #error "MacOSX is not supported!"
    #include <AGL/agl.h>
#else
    #error "This OS is not supported!"
#endif

#include <iostream>
#include <cstdio>   // for stdin, stdout, and stderr
#include <string>
#include <vector>

BEGIN_NAMESPACE_TAPs__OpenGL
//=============================================================================
class PBuffer {
//=============================================================================
// MEMBER FUNCTIONS
//=============================================================================
public:
    //-------------------------------------------------------------------------
    // Output Operator <<
    friend std::ostream & operator<< ( std::ostream &output, 
                                       PBuffer const &o )
    {
        output  << "PBuffer with ..."
                << "\n";
        return output;
    }
    //-------------------------------------------------------------------------
    // Constructor(s) and Destructor
    // see above for documentation on strMode format
    // set managed to true if you want the class to cleanup OpenGL objects in destructor
    PBuffer ( const char *strMode, bool managed = false );
    ~PBuffer ();
    //-------------------------------------------------------------------------
    // Operation(s): Create or Destroy the PBuffer
    bool Create ( int iWidth, int iHeight, bool bShareContexts, bool bShareObjects );
    void Destroy ();
    //-------------------------------------------------------------------------
    // Operation(s): Activate or Deactivate the PBuffer
    // To switch between pbuffers, pass active pbuffer as argument
    void Activate   ( PBuffer *current = NULL );
    void Deactivate ();
    //-------------------------------------------------------------------------
#if defined ( WIN32 )
    // Operation(s): Bind as a texture or Release it from a texture
    //void Bind  ( unsigned int buffer = GL_FRONT );
    //void Release ( unsigned int buffer = GL_FRONT );
    int Bind    ( int iBuffer );
    int Release ( int iBuffer );
    // Check to see if the PBuffer was lost.
    //   If it was lost, destroy it and then recreate it.
    void HandleModeSwitch ();
    //void Swap (); // Swap if applicable (flush if single)
#endif
    //-------------------------------------------------------------------------
    // Get/Set Fns
    // Return the total size in bytes of the PBuffer
    unsigned int    GetSizeInBytes  ();
    // Make a copy of the entire PBuffer in the memory
    //   have to allocate this area (ptr).
    //   if want to read a smaller size : 
    //     specify it through w and h 
    //     otherwise w = h =-1
    unsigned int    CopyToBuffer    ( void *ptr, int w = -1, int h = -1 );
    inline int  GetNoOfComponents   ()  { return m_iNoOfComponents; }
    inline int  GetBitsPerComponent ()  { return m_iBitsPerComponent; }
    inline int  GetWidth  ()    { return m_iWidth; }
    inline int  GetHeight ()    { return m_iHeight; }
    inline bool IsSharedContext ()  { return m_bSharedContextStatus; }
#if defined ( WIN32 )
    inline bool IsTexture ()    { return m_bIsTexture; }
#endif
    //-------------------------------------------------------------------------
    // Operation(s): Swap if applicable (flush if single)
    //void Swap ();
    //-------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//=============================================================================
// DATA MEMBERS
//=============================================================================
protected:
    int m_iWidth, m_iHeight;            // height and width
    int m_iNoOfComponents;              // # of components
    int m_iBitsPerComponent;            // # of bits / components
    const char *m_cpMode;               // string mode for PBuffer
    bool m_bSharedContextStatus;        // shared context status
    bool m_bShareObjectsStatus;         // shared object status
#if defined ( WIN32 )
    HDC         m_hDC;      // Handle to a device context
    HGLRC       m_hGLRC;    // Handle to a GL context
    HPBUFFERARB m_hPBuffer; // Handle to a pbuffer
    HDC         m_hOldDC;
    HGLRC       m_hOldGLRC;
    std::vector<int>    m_pfAttribList;
    std::vector<int>    m_pbAttribList;
    bool        m_bIsTexture;
#elif defined ( UNIX )
    Display *   m_pDisplay;
    GLXPbuffer  m_glxPBuffer;
    GLXContext  m_glxContext;
    Display *   m_pOldDisplay
    GLXPbuffer  m_glxOldDrawable;
    GLXContext  m_glxOldContext;
    std::vector<int>    m_pfAttribList;
    std::vector<int>    m_pbAttribList;
#elif defined ( MACOS )
    AGLContext  m_context;
    WindowPtr   m_window;
    std::vector<int>    m_pfAttribList;
#endif
//=============================================================================
// Helper Member Fn(s) and Data Member(s)
private:
    std::string GetStrValue( std::string sToken );
    int GetIntValue ( std::string sToken );
#if defined(UNIX) || defined(WIN32)
    void ParseModeString(   const char *modeString, 
                            std::vector<int> *pfAttribList, 
                            std::vector<int> *pbAttribList );
    bool m_bIsBound;
    bool m_bIsActive;
    bool m_bManaged;
#endif
//-----------------------------------------------------------------------------
}; // END CLASS PBuffer
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
#if !defined( TAPs_USE_EXPORT )
    #include "TAPsPBuffer.cpp"
#endif
//-----------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8