pbuffer.cpp

Go to the documentation of this file.

/// 5/31/02     Aaron Lefohn    Scientific Computing and Imaging Institute      
/// School of Computing         University of Utah
/// - Pbuffer class. 
/// - This code based on a combination of code from ATI, Joe Kniss, and Milan Ikits


#include "pbuffer.h"
#include <stdio.h> // TODO: This needs to be nuked!
#include <iostream>
#include "glUtil.h"
#include <assert.h>
//#include "perfCounter.h"

#define MAX_PFORMATS 256
#define MAX_ATTRIBS  32

using namespace std;

PBuffer* PBuffer::m_curPbuff = NULL;

#ifdef WIN32
llong PBuffer::m_totEnableTime;
#endif

#define DEBUGGING 0

PBuffer::PBuffer( int xDim, int yDim, unsigned int mode, PBuffRenCTX renderCTX)
{
   initMembers(xDim, yDim, mode, renderCTX);
   create();
}

void PBuffer::initMembers( const int xDim, const int yDim, unsigned int mode, PBuffRenCTX renderCTX)
{
   m_xDim = xDim;
   m_yDim = yDim;
   m_mode  = mode;
   m_numSurfaces = numSurfaces(mode);
   m_stateSaved = false;
   m_buffer = 0;

#ifdef WIN32
   m_format = 0;
   m_surface = WGL_FRONT_LEFT_ARB;
   m_curBoundSurface = WGL_FRONT_LEFT_ARB;
   m_devCTX = NULL;
   m_renCTX = renderCTX;
   m_saveDevCTX = NULL;
   m_saveRenCTX = NULL;
#else //Linux
   m_renCTX = renderCTX;
   m_window = 0;
#endif

   m_saveDrawBuff = GL_FRONT;
   m_saveReadBuff = GL_FRONT;
   m_saveViewPort[0] = 0;
   m_saveViewPort[1] = 0;
   m_saveViewPort[2] = xDim;
   m_saveViewPort[3] = yDim;
}


PBuffer::~PBuffer()
{
   if ( m_buffer )
   {
#ifdef WIN32
      wglDeleteContext( m_renCTX );
      wglReleasePbufferDCARB( m_buffer, m_devCTX );
      wglDestroyPbufferARB( m_buffer );
#else
      glXDestroyPbuffer(glXGetCurrentDisplay(), m_buffer);
#endif
   }
}

// Extract the number of render surfaces from the 'mode'
int PBuffer::numSurfaces( unsigned int mode )
{
   int n = 0; // Number of surfaces

   // Enforce that single and double are not both specified.
   if( (mode & PBUFF_SINGLE) && (mode & PBUFF_DOUBLE) ) {
      cerr << "PBuffer::numSurfaces(...) Error:\n\t"
         << "Illegal to specify single and double buffered pbuffer\n\n";
      exit(1);
   }

   // Enforce only a single AUX buffer choice
   unsigned int auxs = PBUFF_AUX1 | PBUFF_AUX2 | PBUFF_AUX3 | 
      PBUFF_AUX4 | PBUFF_AUX5 | PBUFF_AUX6 |
      PBUFF_AUX7 | PBUFF_AUX8;
   auxs = mode & auxs;
   unsigned int auxsPrime = auxs & (auxs-1); // Zero-out the least signficant one bit
   if( auxsPrime != 0 ) {                          // Is powOfTwo if auxsPrime==0 b/c only 1, 1-bit
      cerr << "PBuffer::numSurfaces(...) Error:\n\t"
         << "Illegal to specify more than one PBUFF_AUX option\n\n";
      exit(1);
   }

   if( mode & PBUFF_SINGLE ) {
      n+=1;
   }
   if( mode & PBUFF_DOUBLE ) {
      n+=2;
   }
   if( mode & PBUFF_AUX1 ) {
      n+=1;
   }
   if( mode & PBUFF_AUX2 ) {
      n+=2;
   }
   if(  mode & PBUFF_AUX2 ) {
      n+=2;
   }
   if(  mode & PBUFF_AUX3 ) {
      n+=3;
   }
   if(  mode & PBUFF_AUX4 ) {
      n+=4;
   }
   if( mode & PBUFF_AUX5 ) {
      n+=5;
   }
   if(  mode & PBUFF_AUX6 ) {
      n+=6;
   }
   if(  mode & PBUFF_AUX7 ) {
      n+=7;
   }
   if(  mode & PBUFF_AUX8 ) {
      n+=8;
   }

   return n;
}

// Set WGL_FRONT_LEFT_ARB,      WGL_BACK_LEFT_ARB, WGL_FRONT_LEFT_ARB, 
//         WGL_FRONT_RIGHT_ARB, WGL_BACK_LEFT_ARB, WGL_BACK_RIGHT_ARB 
//     WGL_AUX0_ARB,            WGL_AUX1_ARB,      WGL_AUX2_ARB,                WGL_AUX3_ARB
void PBuffer::setSurface( GLenum surface )
{
#ifdef WIN32
   if( surface != WGL_FRONT_LEFT_ARB &&
      surface != WGL_FRONT_RIGHT_ARB &&
      surface != WGL_BACK_LEFT_ARB &&
      surface != WGL_BACK_RIGHT_ARB &&
      surface != WGL_AUX0_ARB &&
      surface != WGL_AUX1_ARB &&
      surface != WGL_AUX2_ARB &&
      surface != WGL_AUX3_ARB ) {
         cerr << "PBuffer::setTarget(...) Error:\n\tInvalid face specification.\n";
         exit(1);
      }

      m_surface = surface;
#endif
}

// Set mip level that is rendered to.
// Default = 0
void PBuffer::setMipLevel( int level )
{
#ifdef WIN32
   assert( level >= 0 );

   int attrib[3];
   attrib[0] = WGL_MIPMAP_LEVEL_ARB ;
   attrib[1] = level;
   attrib[2] = 0;

   wglSetPbufferAttribARB( m_buffer, attrib ); 
#endif
}

// Set  WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB,    WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 
//              WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB,    WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 
//              WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB,    WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB
// Default = POSITIVE_X
void PBuffer::setCubeFace( GLenum cubeFace )
{
#ifdef WIN32
   assert( cubeFace == WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB ||
      cubeFace == WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB ||
      cubeFace == WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB ||
      cubeFace == WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB ||
      cubeFace == WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB ||
      cubeFace == WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB );

   int attrib[3];
   attrib[0] = WGL_CUBE_MAP_FACE_ARB ;
   attrib[1] = cubeFace;
   attrib[2] = 0;

   wglSetPbufferAttribARB( m_buffer, attrib );
#endif
}

void PBuffer::bind()
{
#ifdef WIN32
   wglBindTexImageARB(m_buffer, m_surface);
   //           m_curBoundSurface = m_surface;
#endif
}

// WARNING: 'setSurface()' MUST be set to the correct surface!!!
void PBuffer::release()
{
#ifdef WIN32
   wglReleaseTexImageARB(m_buffer, m_surface);
#endif
}

void PBuffer::enable(bool saveState)
{
   //   llong t0 = g_perfCounter.query();

   // DEBUGGING
   //HDC          curDC = wglGetCurrentDC();
   //HGLRC curRC = wglGetCurrentContext();
   // END DEBUG
   //cerr << "Pbuffer::enable(...) WARNING: Caching commented out\n\n";
   if( this != m_curPbuff ) { /// Avoid the ctxt switch if we are already current.
      //        if( curDC != m_devCTX ||
      //                curRC != m_renCTX ) {
      m_curPbuff = this;
      m_stateSaved = saveState;

      //handleModeSwitch();                     /// * \/\/\/\/ AEL 5/23/02

      /// Always-Saved state                            /// * \/\/\/\/ AEL 5/23/02 from here down based on Milan's code
      glGetIntegerv(GL_VIEWPORT,    &m_saveViewPort[0]);
      glGetIntegerv(GL_DRAW_BUFFER, &m_saveDrawBuff);
      glGetIntegerv(GL_READ_BUFFER, &m_saveReadBuff);

      // Conditionally saved state
      if( saveState ) {
#ifdef WIN32
         //wglGetLastError("PBuffer::enable() 1");
         m_saveDevCTX = wglGetCurrentDC();        //Device context
         m_saveRenCTX = wglGetCurrentContext();//Render context
         //wglGetLastError("PBuffer::enable() 2");
#endif
         //TODO: What about Linux?
      }

      /// set read/write context to pbuffer
      //wglGetLastError("PBuffer::enable() 3");
      glErr(cerr,"Pbuffer","enable() 2");
#ifdef WIN32
      //                        #if WGL_ARB_make_current_read
      //                                if( wglMakeContextCurrentARB( m_devCTX, m_devCTX, m_renCTX ) == NULL ) {
      //                                        fprintf(stderr, "PBuffer:Enable() failed.\n"); }//exit(1); }
      //                        #else
      if( wglMakeCurrent( m_devCTX, m_renCTX ) == NULL) {
         fprintf(stderr, "PBuffer:Enable() failed.\n"); }//exit(1); }
      //                        #endif
      //                        DWORD err = GetLastError();
#else //Linux
      //m_window = curWindow;
      glXMakeCurrent(glXGetCurrentDisplay(), 
         m_buffer, 
         glXGetCurrentContext());
#endif
      //wglGetLastError("PBuffer::enable() 4");
      glErr(cerr,"Pbuffer","enable() 3");

      /// draw & read the front m_buffer of pbuffer
      glDrawBuffer(GL_FRONT);
      glReadBuffer(GL_FRONT);

      /// resize view port. generally you'll want to set this to the
      /// size of your pbuffer so that you render to the entire pbuffer
      /// but there are cases where you might want to render to just a
      /// sub-region of the pbuffer.
      /// TODO: Does this need to be here?
      //glViewport(0, 0, m_dimen.w, m_dimen.h );

      glErr(cerr,"Pbuffer","enable() 4");
   } 

   //   llong t1 = g_perfCounter.query();
   //   m_totEnableTime += (t1 - t0) / g_perfCounter.frequency();
}

void PBuffer::disable() //AEL 5/23/02
{
   glDrawBuffer(m_saveDrawBuff);
   glReadBuffer(m_saveReadBuff);
   //glViewport(m_saveViewPort[0], m_saveViewPort[1], m_saveViewPort[2], m_saveViewPort[3]);

   /// make sure the pbuffer has been initialized
   if (m_buffer==0) return;

   if( m_stateSaved ) {
#ifdef WIN32
      /// make sure we haven't lost our pbuffer due to a display mode change
      int flag = 0;
      wglQueryPbufferARB(m_buffer, WGL_PBUFFER_LOST_ARB, &flag);
      if (flag != 0) return;

      /// reset the saved state
      //#if WGL_ARB_make_current_read
      //        wglMakeContextCurrentARB(m_saveDevCTX, m_saveDevCTX, m_saveRenCTX);
      //#else
      wglMakeCurrent(m_saveDevCTX, m_saveRenCTX);
      //#endif
#else /// Linux
      // TODO: Does this work?? Don't we need to save some state in "enable()"?
      glXMakeCurrent(glXGetCurrentDisplay(), m_window, glXGetCurrentContext());
#endif

   }

   m_stateSaved = false;
   m_curPbuff = NULL; 
   glErr(cerr,"PBuffer", "disable()");
}

/// Check to see if the pbuffer was lost.
/// If it was lost, destroy it and then recreate it.
void PBuffer::handleModeSwitch()
{
#ifdef WIN32
   int lost = 0;

   wglQueryPbufferARB( m_buffer, WGL_PBUFFER_LOST_ARB, &lost );

   if( lost )
   {
      this->~PBuffer();
      create();
   }

   glErr(cerr,"PBuffer", "handleModeSwitch()");
#else
   /// In GLX, this info is sent via an event generation, so
   /// we are not going to handle this for now.
#endif
}

void PBuffer::create()
{
#ifdef WIN32
   /// Get the current context
   HDC   curDevCTX = wglGetCurrentDC();
   assert(curDevCTX);

   /// Attempt to match the pixel format of "m_mode"
   /// Returns 
   int format = GetPixelFormat( curDevCTX );
   int requestedFormat = setPixelFormat( curDevCTX );

#ifndef NDEBUG
   cerr << "PBuffer::create: requestedFormat = " << requestedFormat << endl;
#endif

   /// Create the pbuffer.
   int  iAttrib[2*MAX_ATTRIBS];
   iAttrib[0] = 0;
   if(m_mode & PBUFF_REND_TO_TEX){
      if( wglew.NV_float_buffer && (m_mode & PBUFF_FLOAT16 || m_mode & PBUFF_FLOAT32) ) {
         // Nvidia float buffer
         iAttrib[0] = WGL_TEXTURE_FORMAT_ARB;
         iAttrib[1] = WGL_TEXTURE_FLOAT_RGBA_NV;
      }
      else { // ATI or Nvidia fixed-point
         iAttrib[0] = WGL_TEXTURE_FORMAT_ARB;
         iAttrib[1] = WGL_TEXTURE_RGBA_ARB;
      }

      if( m_mode & PBUFF_CUBE ) {
         iAttrib[2] = WGL_TEXTURE_TARGET_ARB;
         iAttrib[3] = WGL_TEXTURE_CUBE_MAP_ARB;
      }
      else if( m_mode & PBUFF_RECT && wglew.NV_render_texture_rectangle ) {
         iAttrib[2] = WGL_TEXTURE_TARGET_ARB;
         iAttrib[3] = WGL_TEXTURE_RECTANGLE_NV;
      }
      else {
         iAttrib[2] = WGL_TEXTURE_TARGET_ARB;
         iAttrib[3] = WGL_TEXTURE_2D_ARB;
      }

      iAttrib[4] = WGL_MIPMAP_TEXTURE_ARB;
      iAttrib[5] = (m_mode & PBUFF_MIPMAP) > 0;

      iAttrib[6] = WGL_PBUFFER_LARGEST_ARB;
      iAttrib[7] = false;

      iAttrib[8] = 0;    //the last one in an attribute array must be zero!!!

#if DEBUGGING
      fprintf(stderr, "Using Render To Texture P-Buffer\n");
#endif
   }

   /// Finally...create the buffer!
   m_buffer = wglCreatePbufferARB( curDevCTX, requestedFormat, m_xDim, m_yDim, iAttrib );
   m_format = requestedFormat;

   /// If something went wrong, figure out what and report it.
   if ( !m_buffer )
   {
      DWORD err = GetLastError();
      fprintf( stderr, "pbuffer creation error:  wglCreatePbufferARB() failed\n" );
      if ( err == ERROR_INVALID_PIXEL_FORMAT )
      {
         fprintf( stderr, "error:  ERROR_INVALID_PIXEL_FORMAT\n" );
      }
      else if ( err == ERROR_NO_SYSTEM_RESOURCES )
      {
         fprintf( stderr, "error:  ERROR_NO_SYSTEM_RESOURCES\n" );
      }
      else if ( err == ERROR_INVALID_DATA )
      {
         fprintf( stderr, "error:  ERROR_INVALID_DATA\n" );
      }
      exit( -1 );
   }

   /// Get the device context.
   m_devCTX = wglGetPbufferDCARB( m_buffer );
   if ( !m_devCTX )
   {
      fprintf( stderr, "pbuffer creation error:  wglGetPbufferDCARB() failed\n" );
      exit( -1 );
   }

   /// Create a gl render-context for the pbuffer.
   if( m_renCTX == NULL ) {
      m_renCTX = wglCreateContext( m_devCTX );

      if( m_mode & PBUFF_SHARE )
      {
         HGLRC curRenCTX = wglGetCurrentContext();

         /// Share the textures/displayLists/etc between the current context and this pbuffer
         if( !wglShareLists( curRenCTX,  m_renCTX ) )
         {
            fprintf( stderr, "pbuffer: wglShareLists() failed\n" );
            exit( -1 );
         }
      }
   }

   if ( !m_renCTX ) {
      fprintf( stderr, "pbuffer creation error:  m_renCTX==NULL\n" );
      exit( -1 );
   }

   /// Determine the actual m_dimen.w and m_dimen.h we were able to create.
   wglQueryPbufferARB( m_buffer, WGL_PBUFFER_WIDTH_ARB, &m_xDim );
   wglQueryPbufferARB( m_buffer, WGL_PBUFFER_HEIGHT_ARB, &m_yDim);

   // Ensure that DC is correct by binding buffer once and releasing it.
   //this->enable(true);
   //m_devCTX = wglGetCurrentDC();
   //m_renCTX = wglGetCurrentContext();
   //this->disable();

#else /// Linux
   int  iAttrib[2*MAX_ATTRIBS];

   GLXFBConfigID configid;
   if ( glXQueryContext( glXGetCurrentDisplay(), glXGetCurrentContext(), GLX_FBCONFIG_ID, (int*)&configid ) != Success )
   {
      cerr << "PBuffer::Create() Error: glXQueryContext failed.\n" << endl;
      exit(1);
   }
   //glXQueryDrawable( glXGetCurrentDisplay(), glXGetCurrentDrawable(), GLX_FBCONFIG_ID, (int*)&configid );
   iAttrib[0] = GLX_FBCONFIG_ID;
   iAttrib[1] = configid;
   iAttrib[2] = 0;
   int n;
   GLXFBConfig* config = glXChooseFBConfig(glXGetCurrentDisplay(), DefaultScreen(glXGetCurrentDisplay()), iAttrib, &n);
   if (config == NULL || n == 0)
   {
      cerr << "PBuffer::Create() Error: glXChooseFBConfig failed.\n" << endl;
      exit(1);
   }
   iAttrib[0] = GLX_PBUFFER_WIDTH;
   iAttrib[1] = m_xDim;
   iAttrib[2] = GLX_PBUFFER_HEIGHT;
   iAttrib[3] = m_yDim;
   iAttrib[4] = GLX_PRESERVED_CONTENTS; /// we don't want to lose the buffer
   iAttrib[5] = true;
   iAttrib[6] = GLX_LARGEST_PBUFFER; /// we need exact size or fail
   iAttrib[7] = false;
   iAttrib[8] = 0;    
   m_buffer = glXCreatePbuffer( glXGetCurrentDisplay(), *config, iAttrib);
   if (m_buffer == 0)
   {
      cerr << "PBuffer::Create() Error: glXCreatePbuffer failed.\n" << endl;
      exit(1);
   }            
#endif
}

#ifdef WIN32

///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
/// Attempts to find a pixel format that matches "m_mode"
int PBuffer::setPixelFormat( HDC curDevCTX )
{
   /// Query for a suitable pixel format based on the specified m_mode.
   int iAttrib[MAX_ATTRIBS][2] = {0};
   int nI = 0;

   /// Since we are trying to create a pbuffer, the pixel format we
   /// request (and subsequently use) must be "p-m_buffer capable".
   iAttrib[nI][0] = WGL_DRAW_TO_PBUFFER_ARB;
   iAttrib[nI][1] = true;
   nI++;

   // Data Format Type: Fixed or floating point: Default is RGBA, fixed-point

   if ( (m_mode & PBUFF_FLOAT16) || (m_mode & PBUFF_FLOAT32) ) {// Floating point buffer
      if( wglew.ATI_pixel_format_float ) {
         iAttrib[nI][0] = WGL_PIXEL_TYPE_ARB;
         iAttrib[nI][1] = WGL_TYPE_RGBA_FLOAT_ATI;
         nI++;
      }
      else if( wglew.NV_float_buffer ) {
         iAttrib[nI][0] = WGL_FLOAT_COMPONENTS_NV;
         iAttrib[nI][1] = GL_TRUE;
         nI++;
      }
      else {
         cerr << "Pbuffer::setPixelFormat(...) Error:\n\t"
            "GPU not capable of floating point pbuffers.\n"
            "At least ATI 9500/9700 or Nvidia GeForceFX is required.\n";
         exit(1);
      }
   }
   else {                                                                                                               // Fixed-point
      iAttrib[nI][0] = WGL_PIXEL_TYPE_ARB;
      iAttrib[nI][1] = WGL_TYPE_RGBA_ARB;
      nI++;
   }

   // Data Format Size: 8, 16, or 32 bits per color channel: Default is 8
   int bitsPerChannel = 8;
   if (  (m_mode & PBUFF_FIXED16) ||
      (m_mode & PBUFF_FLOAT16)  ) { bitsPerChannel = 16; }
   else if( (m_mode & PBUFF_FLOAT32)  ) { bitsPerChannel = 32; }
   else                                                      { bitsPerChannel = 8;  }

   iAttrib[nI][0] = WGL_RED_BITS_ARB;
   iAttrib[nI][1] = bitsPerChannel;
   nI++;
   iAttrib[nI][0] = WGL_GREEN_BITS_ARB;
   iAttrib[nI][1] = bitsPerChannel;
   nI++;
   iAttrib[nI][0] = WGL_BLUE_BITS_ARB;
   iAttrib[nI][1] = bitsPerChannel;
   nI++;
   iAttrib[nI][0] = WGL_ALPHA_BITS_ARB;
   iAttrib[nI][1] = bitsPerChannel;
   nI++;

   if ( m_mode & PBUFF_DOUBLE )
   {
      iAttrib[nI][0] = WGL_DOUBLE_BUFFER_ARB;
      iAttrib[nI][1] = true;
      nI++;
   }

   // Depth buffer
   int depthBits = (m_mode & PBUFF_DEPTH24) ? 24 : (m_mode & PBUFF_DEPTH16) ? 16 : 0;
   iAttrib[nI][0] = WGL_DEPTH_BITS_ARB;
   iAttrib[nI][1] = depthBits;
   nI++;

   if ( m_mode & PBUFF_STENCIL )
   {
      iAttrib[nI][0] = WGL_STENCIL_BITS_ARB;
      iAttrib[nI][1] = 8;
      nI++;
   }

   if ( m_mode & PBUFF_ACCUM )
   {
      iAttrib[nI][0] = WGL_ACCUM_BITS_ARB;
      iAttrib[nI][1] = 24;
      nI++;
   }

   // AUX buffers
   if( m_mode & PBUFF_AUX1 ) {
      iAttrib[nI][0] = WGL_AUX_BUFFERS_ARB;
      iAttrib[nI][1] = 1;
      nI++;
   }
   else if( m_mode & PBUFF_AUX2 ) {
      iAttrib[nI][0] = WGL_AUX_BUFFERS_ARB;
      iAttrib[nI][1] = 2;
      nI++;
   }
   else if( m_mode & PBUFF_AUX3 ) {
      iAttrib[nI][0] = WGL_AUX_BUFFERS_ARB;
      iAttrib[nI][1] = 3;
      nI++;
   }

   iAttrib[nI][0] = WGL_SUPPORT_OPENGL_ARB;
   iAttrib[nI][1] = true;
   nI++;

   if( m_mode & PBUFF_REND_TO_TEX ){
      // Nvidia floating point RTT
      if( glew.NV_float_buffer && (m_mode & PBUFF_FLOAT16 || m_mode & PBUFF_FLOAT32)) {
         m_mode |= PBUFF_RECT;
         iAttrib[nI][0] = WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV;
         iAttrib[nI][1] = true;
         nI++;
      }
      else if( wglew.NV_render_texture_rectangle ) {
         // Nvidia fixed point RTT
         m_mode |= PBUFF_RECT;
         iAttrib[nI][0] = WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV;
         iAttrib[nI][1] = true;
         nI++;
      }
      else {
         // ATI all formats
         iAttrib[nI][0] = WGL_BIND_TO_TEXTURE_RGBA_ARB;
         iAttrib[nI][1] = true;
         nI++;
      }
   }
   iAttrib[nI][0] = 0;

   int format;
   int pformat[MAX_PFORMATS];
   unsigned int nformats;
   if ( !wglChoosePixelFormatARB( curDevCTX, &iAttrib[0][0], NULL, MAX_PFORMATS, pformat, &nformats ) )
   {
      fprintf( stderr, "pbuffer creation error:  Couldn't find a suitable pixel format.\n" );
      exit( -1 );
   }
   format = pformat[0];


#if DEBUGGING
   FILE *fp = fopen( "debug.txt", "w" );
   if ( !fp )
   {
      fprintf( stderr, "Couldn't open file: debug.txt\n" );
      exit( -1 );
   }

   fprintf( fp, "nformats = %d\n\n", nformats );
   int values[MAX_ATTRIBS];
   int iatr[MAX_ATTRIBS] = { WGL_PIXEL_TYPE_ARB, WGL_COLOR_BITS_ARB,
      WGL_RED_BITS_ARB, WGL_GREEN_BITS_ARB, WGL_BLUE_BITS_ARB,
      WGL_ALPHA_BITS_ARB, WGL_DEPTH_BITS_ARB, WGL_STENCIL_BITS_ARB, WGL_ACCUM_BITS_ARB,
      WGL_DOUBLE_BUFFER_ARB, WGL_SUPPORT_OPENGL_ARB, WGL_ACCELERATION_ARB };
   int niatr = 12;
   for ( int j = 0; j < MAX_ATTRIBS; j++ )
   {
      values[j] = false;
      iAttrib[j] = iAttrib[2*j];
   }
   for ( unsigned int i = 0; i < nformats; i++ )
   {
      HDC   curDevCTX = wglGetCurrentDC();
      if ( !wglGetPixelFormatAttribivARB( curDevCTX, pformat[i], 0, niatr, iatr, values ) )
      {
         fprintf( stderr, "pbuffer creation error:  wglGetPixelFormatAttribiv() failed\n" );
         exit( -1 );
      }
      fprintf( fp, "%d. pformat = %d\n", i, pformat[i] );
      fprintf( fp, "--------------------\n" );
      for ( int k = 0; k < niatr; k++ )
      {
         if ( iatr[k] == WGL_PIXEL_TYPE_ARB )
         {
            if ( values[k] == WGL_TYPE_COLORINDEX_ARB )
               fprintf( fp, " Pixel type = WGL_TYPE_COLORINDEX_ARB\n" );
            if ( values[k] == WGL_TYPE_RGBA_ARB )
               fprintf( fp, " Pixel type = WGL_TYPE_RGBA_ARB\n" );
         }
         if ( iatr[k] == WGL_COLOR_BITS_ARB )
         {
            fprintf( fp, " Color bits = %d\n", values[k] );
         }
         if ( iatr[k] == WGL_RED_BITS_ARB )
         {
            fprintf( fp, "      red         %d\n", values[k] );
         }
         if ( iatr[k] == WGL_GREEN_BITS_ARB )
         {
            fprintf( fp, "      green       %d\n", values[k] );
         }
         if ( iatr[k] == WGL_BLUE_BITS_ARB )
         {
            fprintf( fp, "      blue        %d\n", values[k] );
         }
         if ( iatr[k] == WGL_ALPHA_BITS_ARB )
         {
            fprintf( fp, "      alpha       %d\n", values[k] );
         }
         if ( iatr[k] == WGL_DEPTH_BITS_ARB )
         {
            fprintf( fp, " Depth bits =   %d\n", values[k] );
         }
         if ( iatr[k] == WGL_STENCIL_BITS_ARB )
         {
            fprintf( fp, " Stencil bits = %d\n", values[k] );
         }
         if ( iatr[k] == WGL_ACCUM_BITS_ARB )
         {
            fprintf( fp, " Accum bits =   %d\n", values[k] );
         }
         if ( iatr[k] == WGL_DOUBLE_BUFFER_ARB )
         {
            fprintf( fp, " Double Buffer  = %d\n", values[k] );
         }
         if ( iatr[k] == WGL_SUPPORT_OPENGL_ARB )
         {
            fprintf( fp, " Support OpenGL = %d\n", values[k] );
         }
         if ( iatr[k] == WGL_ACCELERATION_ARB )
         {
            if ( values[k] == WGL_FULL_ACCELERATION_ARB ) {
               fprintf( fp, " Acceleration   = WGL_FULL_ACCELERATION_ARB\n" );
            }
            if ( values[k] == WGL_GENERIC_ACCELERATION_ARB ) {
               fprintf( fp, " Acceleration   = WGL_GENERIC_ACCELERATION_ARB\n" );
            }
         }
      }
      fprintf( fp, "\n" );
   }
   fprintf( fp, "selected pformat = %d\n", format );
   fprintf( stderr, "Created a %d x %d pbuffer\n", m_xDim, m_yDim );
   fclose( fp );
#endif

   return format;
}

int PBuffer::setPixelFormatNV_HACK( HDC curDevCTX )
{
   int iattributes[MAX_ATTRIBS*2] = {0};
   int niattribs= 0;
   int bitsPerChannel= 32;


   // This Pbuffer would have to be bound a WGL_TEXTURE_RECTANGLE_NV texture
   // with the format WGL_TEXTURE_RECTANGLE_FLOAT_RGBA_NV
   iattributes[niattribs] = WGL_RED_BITS_ARB;
   iattributes[++niattribs] = bitsPerChannel;
   iattributes[++niattribs] = WGL_GREEN_BITS_ARB;
   iattributes[++niattribs] = bitsPerChannel;
   iattributes[++niattribs] = WGL_BLUE_BITS_ARB;
   iattributes[++niattribs] = bitsPerChannel;
   iattributes[++niattribs] = WGL_ALPHA_BITS_ARB;
   iattributes[++niattribs] = bitsPerChannel;
   iattributes[++niattribs] = WGL_DRAW_TO_PBUFFER_ARB;
   iattributes[++niattribs] = GL_TRUE;
   iattributes[++niattribs] = WGL_FLOAT_COMPONENTS_NV;
   iattributes[++niattribs] = GL_TRUE;
   iattributes[++niattribs] = WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV;
   iattributes[++niattribs] = GL_TRUE;

   /*
   // 8 bit doesn't work with the rest of the code
   iattributes[niattribs] = WGL_DRAW_TO_PBUFFER_ARB;
   iattributes[++niattribs] = GL_TRUE;
   iattributes[++niattribs] = WGL_BIND_TO_TEXTURE_RGBA_ARB;
   iattributes[++niattribs] = GL_TRUE;
   */
   int format;
   int pformat[MAX_PFORMATS];
   unsigned int nformats;
   if ( !wglChoosePixelFormatARB( curDevCTX, &iattributes[0], NULL, MAX_PFORMATS, pformat, &nformats ) )
   {
      fprintf( stderr, "pbuffer creation error:  Couldn't find a suitable pixel format.\n" );
      exit( -1 );
   }
   format = pformat[0];

   return format;
}
#endif //WIN32

---

Send questions, comments, and bug reports to: