Use the GLX 1.3 pbuffer/fbconfig functions in preference to the SGIX ones.

Added more functions to pbutil.[ch] to better isolate API differences.

1 files changed, 226 insertions, 84 deletions

diff --git a/progs/xdemos/pbutil.c b/progs/xdemos/pbutil.c
index 0dd4b409f4a..50456e9f94f 100644
--- a/progs/xdemos/pbutil.c
+++ b/progs/xdemos/pbutil.c
@@ -3,8 +3,10 @@
  * OpenGL pbuffers utility functions.
  *
  * Brian Paul
- * April 1997
+ * Original code: April 1997
  * Updated on 5 October 2002
+ * Updated again on 3 January 2005 to use GLX 1.3 functions in preference
+ * to the GLX_SGIX_fbconfig/pbuffer extensions.
  */
 
 
@@ -13,51 +15,140 @@
 #include "pbutil.h"
 
 
-
-/*
+/**
  * Test if we pixel buffers are available for a particular X screen.
  * Input:  dpy - the X display
  *         screen - screen number
  * Return:  0 = pixel buffers not available.
- *          1 = pixel buffers are available.
+ *          1 = pixel buffers are available via GLX 1.3.
+ *          2 = pixel buffers are available via GLX_SGIX_fbconfig/pbuffer.
  */
 int
 QueryPbuffers(Display *dpy, int screen)
 {
+#if defined(GLX_VERSION_1_3)
+   {
+      /* GLX 1.3 supports pbuffers */
+      int glxVersionMajor, glxVersionMinor;
+      if (!glXQueryVersion(dpy, &glxVersionMajor, &glxVersionMinor)) {
+         /* GLX not available! */
+         return 0;
+      }
+      if (glxVersionMajor * 100 + glxVersionMinor >= 103) {
+         return 1;
+      }
+      /* fall-through */
+   }
+#endif
+
 #if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
-   char *extensions;
+   /* Try the SGIX extensions */
+   {
+      char *extensions;
+      extensions = (char *) glXQueryServerString(dpy, screen, GLX_EXTENSIONS);
+      if (!extensions ||
+          !strstr(extensions,"GLX_SGIX_fbconfig") ||
+          !strstr(extensions,"GLX_SGIX_pbuffer")) {
+         return 0;
+      }
+      return 2;
+   }
+#endif
 
-   extensions = (char *) glXQueryServerString(dpy, screen, GLX_EXTENSIONS);
-   if (!strstr(extensions,"GLX_SGIX_fbconfig")) {
-      return 0;
+   return 0;
+}
+
+
+
+FBCONFIG *
+ChooseFBConfig(Display *dpy, int screen, const int attribs[], int *nConfigs)
+{
+   int pbSupport = QueryPbuffers(dpy, screen);
+#if defined(GLX_VERSION_1_3)
+   if (pbSupport == 1) {
+      return glXChooseFBConfig(dpy, screen, attribs, nConfigs);
    }
-   if (!strstr(extensions,"GLX_SGIX_pbuffer")) {
-      return 0;
+#endif
+#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
+   if (pbSupport == 2) {
+      return glXChooseFBConfigSGIX(dpy, screen, (int *) attribs, nConfigs);
    }
-   return 1;
-#else
-   return 0;
 #endif
+   return NULL;
 }
 
 
 
-#ifdef GLX_SGIX_fbconfig
+XVisualInfo *
+GetVisualFromFBConfig(Display *dpy, int screen, FBCONFIG config)
+{
+   int pbSupport = QueryPbuffers(dpy, screen);
+#if defined(GLX_VERSION_1_3)
+   if (pbSupport == 1) {
+      return glXGetVisualFromFBConfig(dpy, config);
+   }
+#endif
+#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
+   if (pbSupport == 2) {
+      return glXGetVisualFromFBConfigSGIX(dpy, config);
+   }
+#endif
+   return NULL;
+}
 
 
-/*
+/**
+ * Either use glXGetFBConfigAttrib() or glXGetFBConfigAttribSGIX()
+ * to query an fbconfig attribute.
+ */
+static int
+GetFBConfigAttrib(Display *dpy,
+#if defined(GLX_VERSION_1_3)
+                  const GLXFBConfig config,
+#elif defined(GLX_SGIX_fbconfig)
+                  const GLXFBConfigSGIX config,
+#endif
+                  int attrib
+                  )
+{
+   int value;
+
+#if defined(GLX_VERSION_1_3)
+   int glxVersionMajor, glxVersionMinor;
+   if (glXQueryVersion(dpy, &glxVersionMajor, &glxVersionMinor)
+       && glxVersionMajor * 100 + glxVersionMinor >= 103) {
+      /* ok */
+      if (glXGetFBConfigAttrib(dpy, config, attrib, &value) != 0) {
+         value = 0;
+      }
+      return value;
+   }
+   /* fall-through */
+#endif
+
+#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
+   if (glXGetFBConfigAttribSGIX(dpy, config, attrib, &value) != 0) {
+      value = 0;
+   }
+   return value;
+#endif
+   
+   return 0;
+}
+
+
+
+/**
  * Print parameters for a GLXFBConfig to stdout.
  * Input:  dpy - the X display
+ *         screen - the X screen number
  *         fbConfig - the fbconfig handle
  *         horizFormat - if true, print in horizontal format
  */
 void
-PrintFBConfigInfo(Display *dpy, GLXFBConfigSGIX fbConfig, Bool horizFormat)
+PrintFBConfigInfo(Display *dpy, int screen, FBCONFIG config, Bool horizFormat)
 {
-   int pbAttribs[] = {GLX_LARGEST_PBUFFER_SGIX, True,
-		      GLX_PRESERVED_CONTENTS_SGIX, False,
-		      None};
-   GLXPbufferSGIX pBuffer;
+   PBUFFER pBuffer;
    int width=2, height=2;
    int bufferSize, level, doubleBuffer, stereo, auxBuffers;
    int redSize, greenSize, blueSize, alphaSize;
@@ -67,44 +158,49 @@ PrintFBConfigInfo(Display *dpy, GLXFBConfigSGIX fbConfig, Bool horizFormat)
    int drawableType, renderType, xRenderable, xVisual, id;
    int maxWidth, maxHeight, maxPixels;
    int optWidth, optHeight;
+   int floatComponents;
 
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_BUFFER_SIZE, &bufferSize);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_LEVEL, &level);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_DOUBLEBUFFER, &doubleBuffer);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_STEREO, &stereo);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_AUX_BUFFERS, &auxBuffers);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_RED_SIZE, &redSize);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_GREEN_SIZE, &greenSize);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_BLUE_SIZE, &blueSize);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_ALPHA_SIZE, &alphaSize);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_DEPTH_SIZE, &depthSize);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_STENCIL_SIZE, &stencilSize);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_ACCUM_RED_SIZE, &accumRedSize);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_ACCUM_GREEN_SIZE, &accumGreenSize);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_ACCUM_BLUE_SIZE, &accumBlueSize);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_ACCUM_ALPHA_SIZE, &accumAlphaSize);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_SAMPLE_BUFFERS_SGIS, &sampleBuffers);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_SAMPLES_SGIS, &samples);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_DRAWABLE_TYPE_SGIX, &drawableType);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_RENDER_TYPE_SGIX, &renderType);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_X_RENDERABLE_SGIX, &xRenderable);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_X_VISUAL_TYPE_EXT, &xVisual);
+   /* do queries using the GLX 1.3 tokens (same as the SGIX tokens) */
+   bufferSize     = GetFBConfigAttrib(dpy, config, GLX_BUFFER_SIZE);
+   level          = GetFBConfigAttrib(dpy, config, GLX_LEVEL);
+   doubleBuffer   = GetFBConfigAttrib(dpy, config, GLX_DOUBLEBUFFER);
+   stereo         = GetFBConfigAttrib(dpy, config, GLX_STEREO);
+   auxBuffers     = GetFBConfigAttrib(dpy, config, GLX_AUX_BUFFERS);
+   redSize        = GetFBConfigAttrib(dpy, config, GLX_RED_SIZE);
+   greenSize      = GetFBConfigAttrib(dpy, config, GLX_GREEN_SIZE);
+   blueSize       = GetFBConfigAttrib(dpy, config, GLX_BLUE_SIZE);
+   alphaSize      = GetFBConfigAttrib(dpy, config, GLX_ALPHA_SIZE);
+   depthSize      = GetFBConfigAttrib(dpy, config, GLX_DEPTH_SIZE);
+   stencilSize    = GetFBConfigAttrib(dpy, config, GLX_STENCIL_SIZE);
+   accumRedSize   = GetFBConfigAttrib(dpy, config, GLX_ACCUM_RED_SIZE);
+   accumGreenSize = GetFBConfigAttrib(dpy, config, GLX_ACCUM_GREEN_SIZE);
+   accumBlueSize  = GetFBConfigAttrib(dpy, config, GLX_ACCUM_BLUE_SIZE);
+   accumAlphaSize = GetFBConfigAttrib(dpy, config, GLX_ACCUM_ALPHA_SIZE);
+   sampleBuffers  = GetFBConfigAttrib(dpy, config, GLX_SAMPLE_BUFFERS);
+   samples        = GetFBConfigAttrib(dpy, config, GLX_SAMPLES);
+   drawableType   = GetFBConfigAttrib(dpy, config, GLX_DRAWABLE_TYPE);
+   renderType     = GetFBConfigAttrib(dpy, config, GLX_RENDER_TYPE);
+   xRenderable    = GetFBConfigAttrib(dpy, config, GLX_X_RENDERABLE);
+   xVisual        = GetFBConfigAttrib(dpy, config, GLX_X_VISUAL_TYPE);
    if (!xRenderable || !(drawableType & GLX_WINDOW_BIT_SGIX))
       xVisual = -1;
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_FBCONFIG_ID_SGIX, &id);
 
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_MAX_PBUFFER_WIDTH_SGIX,
-			    &maxWidth);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_MAX_PBUFFER_HEIGHT_SGIX,
-			    &maxHeight);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_MAX_PBUFFER_PIXELS_SGIX,
-			    &maxPixels);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_OPTIMAL_PBUFFER_WIDTH_SGIX,
-			    &optWidth);
-   glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX,
-			    &optHeight);
+   id        = GetFBConfigAttrib(dpy, config, GLX_FBCONFIG_ID);
+   maxWidth  = GetFBConfigAttrib(dpy, config, GLX_MAX_PBUFFER_WIDTH);
+   maxHeight = GetFBConfigAttrib(dpy, config, GLX_MAX_PBUFFER_HEIGHT);
+   maxPixels = GetFBConfigAttrib(dpy, config, GLX_MAX_PBUFFER_PIXELS);
+#if defined(GLX_SGIX_pbuffer)
+   optWidth  = GetFBConfigAttrib(dpy, config, GLX_OPTIMAL_PBUFFER_WIDTH_SGIX);
+   optHeight = GetFBConfigAttrib(dpy, config, GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX);
+#else
+   optWidth = optHeight = 0;
+#endif
+#if defined(GLX_NV_float_buffer)
+   floatComponents = GetFBConfigAttrib(dpy, config, GLX_FLOAT_COMPONENTS_NV);
+#endif
 
-   pBuffer = CreatePbuffer(dpy, fbConfig, width, height, pbAttribs);
+   /* See if we can create a pbuffer with this config */
+   pBuffer = CreatePbuffer(dpy, screen, config, width, height, False, False);
 
    if (horizFormat) {
       printf("0x%03x ", id);
@@ -125,7 +221,8 @@ PrintFBConfigInfo(Display *dpy, GLXFBConfigSGIX fbConfig, Bool horizFormat)
       printf("%2d %2d %2d %2d", accumRedSize, accumGreenSize, accumBlueSize,
 	     accumAlphaSize);
       printf("    %2d    %2d", sampleBuffers, samples);
-      printf("       %s", pBuffer ? "y" : "n");
+      printf("       %s       %c", pBuffer ? "y" : "n",
+             "ny"[floatComponents]);
       printf("\n");
    }
    else {
@@ -148,27 +245,28 @@ PrintFBConfigInfo(Display *dpy, GLXFBConfigSGIX fbConfig, Bool horizFormat)
       printf("  Sample Buffers: %d\n", sampleBuffers);
       printf("  Samples/Pixel: %d\n", samples);
       printf("  Drawable Types: ");
-      if (drawableType & GLX_WINDOW_BIT_SGIX)  printf("Window ");
-      if (drawableType & GLX_PIXMAP_BIT_SGIX)  printf("Pixmap ");
-      if (drawableType & GLX_PBUFFER_BIT_SGIX)  printf("PBuffer");
+      if (drawableType & GLX_WINDOW_BIT)  printf("Window ");
+      if (drawableType & GLX_PIXMAP_BIT)  printf("Pixmap ");
+      if (drawableType & GLX_PBUFFER_BIT)  printf("PBuffer");
       printf("\n");
       printf("  Render Types: ");
       if (renderType & GLX_RGBA_BIT_SGIX)  printf("RGBA ");
       if (renderType & GLX_COLOR_INDEX_BIT_SGIX)  printf("CI ");
       printf("\n");
       printf("  X Renderable: %s\n", xRenderable ? "yes" : "no");
-      /*
-      printf("  Max width: %d\n", maxWidth);
-      printf("  Max height: %d\n", maxHeight);
-      printf("  Max pixels: %d\n", maxPixels);
-      printf("  Optimum width: %d\n", optWidth);
-      printf("  Optimum height: %d\n", optHeight);
-      */
+
       printf("  Pbuffer: %s\n", pBuffer ? "yes" : "no");
+      printf("  Max Pbuffer width: %d\n", maxWidth);
+      printf("  Max Pbuffer height: %d\n", maxHeight);
+      printf("  Max Pbuffer pixels: %d\n", maxPixels);
+      printf("  Optimum Pbuffer width: %d\n", optWidth);
+      printf("  Optimum Pbuffer height: %d\n", optHeight);
+
+      printf("  Float Components: %s\n", floatComponents ? "yes" : "no");
    }
 
    if (pBuffer) {
-      glXDestroyGLXPbufferSGIX(dpy, pBuffer);
+      DestroyPbuffer(dpy, screen, pBuffer);
    }
 }
 
@@ -176,42 +274,73 @@ PrintFBConfigInfo(Display *dpy, GLXFBConfigSGIX fbConfig, Bool horizFormat)
 
 /* This is only used by CreatePbuffer() */
 static int XErrorFlag = 0;
-static int HandleXError( Display *dpy, XErrorEvent *event )
+static int HandleXError(Display *dpy, XErrorEvent *event)
 {
     XErrorFlag = 1;
     return 0;
 }
 
 
-/*
+/**
  * Create a Pbuffer.  Use an X error handler to deal with potential
  * BadAlloc errors.
  *
  * Input:  dpy - the X display
  *         fbConfig - an FBConfig as returned by glXChooseFBConfigSGIX().
  *         width, height - size of pixel buffer to request, in pixels.
- *         pbAttribs - list of pixel buffer attributes as used by
- *                     glXCreateGLXPbufferSGIX().
- * Return:  a pixel buffer or None.
+ *         pbAttribs - list of optional pixel buffer attributes
+ * Return:  a Pbuffer or None.
  */
-GLXPbufferSGIX
-CreatePbuffer( Display *dpy, GLXFBConfigSGIX fbConfig,
-	       int width, int height, int *pbAttribs )
+PBUFFER
+CreatePbuffer(Display *dpy, int screen, FBCONFIG config,
+              int width, int height, Bool largest, Bool preserve)
 {
-   int (*oldHandler)( Display *, XErrorEvent * );
-   GLXPbufferSGIX pBuffer = None;
+   int (*oldHandler)(Display *, XErrorEvent *);
+   PBUFFER pBuffer = None;
+   int pbSupport = QueryPbuffers(dpy, screen);
 
    /* Catch X protocol errors with our own error handler */
-   oldHandler = XSetErrorHandler( HandleXError );
-
+   oldHandler = XSetErrorHandler(HandleXError);
    XErrorFlag = 0;
-   pBuffer = glXCreateGLXPbufferSGIX(dpy, fbConfig, width, height, pbAttribs);
+
+#if defined(GLX_VERSION_1_3)
+   if (pbSupport == 1) {
+      /* GLX 1.3 */
+      int attribs[100], i = 0;
+      attribs[i++] = GLX_PBUFFER_WIDTH;
+      attribs[i++] = width;
+      attribs[i++] = GLX_PBUFFER_HEIGHT;
+      attribs[i++] = height;
+      attribs[i++] = GLX_PRESERVED_CONTENTS;
+      attribs[i++] = preserve;
+      attribs[i++] = GLX_LARGEST_PBUFFER;
+      attribs[i++] = largest;
+      attribs[i++] = 0;
+      pBuffer = glXCreatePbuffer(dpy, config, attribs);
+   }
+   else
+#endif
+#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
+   if (pbSupport == 2) {
+      int attribs[100], i = 0;
+      attribs[i++] = GLX_PRESERVED_CONTENTS;
+      attribs[i++] = preserve;
+      attribs[i++] = GLX_LARGEST_PBUFFER;
+      attribs[i++] = largest;
+      attribs[i++] = 0;
+      pBuffer = glXCreateGLXPbufferSGIX(dpy, config, width, height, attribs);
+   }
+   else
+#endif
+   {
+      pBuffer = None;
+   }
 
    /* Restore original X error handler */
-   (void) XSetErrorHandler( oldHandler );
+   (void) XSetErrorHandler(oldHandler);
 
    /* Return pbuffer (may be None) */
-   if (!XErrorFlag && pBuffer!=None) {
+   if (!XErrorFlag && pBuffer != None) {
       /*printf("config %d worked!\n", i);*/
       return pBuffer;
    }
@@ -221,7 +350,20 @@ CreatePbuffer( Display *dpy, GLXFBConfigSGIX fbConfig,
 }
 
 
-
-#endif  /*GLX_SGIX_fbconfig*/
-
-
+void
+DestroyPbuffer(Display *dpy, int screen, PBUFFER pbuffer)
+{
+   int pbSupport = QueryPbuffers(dpy, screen);
+#if defined(GLX_VERSION_1_3)
+   if (pbSupport == 1) {
+      glXDestroyPbuffer(dpy, pbuffer);
+      return;
+   }
+#endif
+#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
+   if (pbSupport == 2) {
+      glXDestroyGLXPbufferSGIX(dpy, pbuffer);
+      return;
+   }
+#endif
+}