pbuffer.h

Go to the documentation of this file.

/// 10/02/02    Aaron Lefohn    Scientific Computing and Imaging Institute      
/// School of Computing                 University of Utah
/// - Pbuffer class. 
/// - This has only been tested on ATI Radeon 8500 (5/31/02)
/// - This code based on a combination of code from ATI, Nvidia, Joe Kniss, and Milan Ikits

#ifndef CHIMERA_PBUFFERS_H
#define CHIMERA_PBUFFERS_H

#include <GL/glew.h>
#include <GL/wglew.h>
#ifndef WIN32
#include <GL/glx.h>
#endif

// Forward Decls
class PBuffer;

//we have different context types for win & linux
#ifdef WIN32
typedef HGLRC PBuffRenCTX;
typedef __int64 llong;
#else
typedef GLXContext PBuffRenCTX;
#endif

// PBuffer Modes
enum PbuffModes { 
   PBUFF_NONE             = 0,
   PBUFF_REND_TO_TEX = 1<<0, // Render-to-texture buffer
   PBUFF_RECT      = 1<<1,   // Rectangle (default is 2D)
   PBUFF_SHARE            = 1<<2,   // Share textures, display lists, vertex/frag programs, etc.
   PBUFF_SINGLE   = 1<<3,
   PBUFF_DOUBLE   = 1<<4,
   PBUFF_DEPTH16   = 1<<5,
   PBUFF_DEPTH24          = 1<<6, // Default is Depth16
   PBUFF_STENCIL          = 1<<7,
   PBUFF_ACCUM            = 1<<8, 
   PBUFF_MIPMAP   = 1<<9, // Mipmapped buffer
   PBUFF_CUBE             = 1<<10, // Cube map buffer
   PBUFF_FIXED16          = 1<<11, // 16-bit-per-channel Fixed-point buffer
   PBUFF_FLOAT16          = 1<<12, // 16-bit-per-channel Float buffer
   PBUFF_FLOAT32          = 1<<13,// 32-bit-per-channel Float buffer
   PBUFF_AUX1             = 1<<14,// 1 AUX buffer
   PBUFF_AUX2             = 1<<15,// 2 AUX buffers
   PBUFF_AUX3             = 1<<16,// 3 AUX buffers
   PBUFF_AUX4             = 1<<17,// 4 AUX buffers
   PBUFF_AUX5             = 1<<18,// 5 AUX buffers
   PBUFF_AUX6             = 1<<19,// 6  "   "
   PBUFF_AUX7             = 1<<20,// 7  "   "
   PBUFF_AUX8             = 1<<21,// 8  "   "
   PBUFF_PBUFF_LAST  = 1<<22 };

   ///////////////////////////////
   ///  PBuffer class
   ///////////////////////////////
   class PBuffer
   {
   public:
      PBuffer( int xDim, int yDim, unsigned int mode, PBuffRenCTX renderCTX=NULL ); 
      // Using default copy constructor and assignment operator

      virtual   ~PBuffer();

      // Enable/Disable pbuffer as a draw target
      // Disable will restore previous state if enable(true) was called.
      void enable(bool saveState=false);
      void disable();

      // Clear pbuffer caching
      static void clearCache() {        m_curPbuff = NULL;} 

      // How many surfaces are defined in 'mode'?
      static int  numSurfaces( unsigned int mode ); 

      // Bind/Release pbuffer as a texture
      void bind();
      void release();// WARNING: 'setSurface()' MUST be set to the correct surface!!!

      // Set WGL_FRONT_LEFT_ARB,        WGL_AUX0_ARB, etc.
      void setSurface( GLenum surface );

      // Set mip level that is rendered to. Default = 0
      void setMipLevel( int level );

      // Set    WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, etc. : Default = POSITIVE_X
      void setCubeFace( GLenum cubeFace );

      // Accessors
      void               dimen( int& xDim, int& yDim ) const {xDim=m_xDim; yDim=m_yDim;}
      unsigned int mode() const                                          {return m_mode;}
      PBuffRenCTX        renderCTX() const                                       {return m_renCTX;}

      // Convenience mode accessors
      bool              hasRendToTex()  const {return (m_mode & PBUFF_REND_TO_TEX) && true;     }
      bool              hasMipMap()             const {return (m_mode & PBUFF_MIPMAP) && true;          }
      bool              hasCube()               const {return (m_mode & PBUFF_CUBE) && true;            }
      int                       numSurfaces() const                              {return m_numSurfaces;}

      // Timer Calls
#ifdef WIN32
      static void        resetTimer() {m_totEnableTime = 0; }
      static llong getTotEnableTime() {return m_totEnableTime;}
#endif
   private:
      int                               m_xDim;
      int                               m_yDim;
      bool                      m_stateSaved; /// Has a state been saved?
      unsigned int      m_mode;           /// Flags indicating the type of pbuffer.
      int                               m_numSurfaces;/// Number of render surfaces in this pbuffer
      static PBuffer* m_curPbuff;   /// Used to avoid unneccesary ctxt switches
      GLenum                    m_surface;
      GLenum                    m_curBoundSurface;

#ifdef WIN32
      static llong m_totEnableTime;
      unsigned int m_format;    /// The number of the visual used for the buffer
      HPBUFFERARB  m_buffer;    /// Handle to this pbuffer.
      HDC          m_devCTX;  /// Handle to this pbuff's device context.
      HGLRC        m_renCTX;  /// Handle to this pbuff's GL, render context.
      HDC                        m_saveDevCTX;  /// Saved state
      HGLRC              m_saveRenCTX;
      int setPixelFormat( HDC curDevCTX );
      int setPixelFormatNV_HACK( HDC curDevCTX );
#else //linux & unix
      GLXPbuffer         m_buffer;
      Drawable   m_window;
      GLXContext   m_renCTX;
      //GLXFBConfig* mFBConfig;
      //GLXFBConfig* ChooseFBConfig (GLXFBConfig* config, int n,
      ///                             GLXFBConfig* config0, bool dbuff);
#endif

      int       m_saveViewPort[4];
      int                       m_saveDrawBuff;
      int                       m_saveReadBuff;

      // Extract the number of render surfaces from the 'mode'
      void initMembers( const int xDim, const int yDim, unsigned int mode, PBuffRenCTX);
      void create();
      void handleModeSwitch(); /// Recover the pbuffer if it is killed by a mode change
   };

#endif

---

Send questions, comments, and bug reports to: