Refactored code on Windows and X11 constructing attribute lists for

wglChoosePixelFormatARB / glXChooseVisual / glXChooseFBConfig to unify
code paths between on-screen drawables and pbuffers. This primarily
enables multisampling for pbuffers. Made small change to Mac native
code to stop specifying sample buffers if multisampling is not
enabled. Tested with demos on Windows and X11.


git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/trunk@484 232f8b59-042b-4e1e-8c03-345bb8c30851

4 files changed, 230 insertions, 259 deletions

diff --git a/src/classes/com/sun/opengl/impl/windows/WindowsGLDrawable.java b/src/classes/com/sun/opengl/impl/windows/WindowsGLDrawable.java
index b4e059b72..b3f772573 100644
--- a/src/classes/com/sun/opengl/impl/windows/WindowsGLDrawable.java
+++ b/src/classes/com/sun/opengl/impl/windows/WindowsGLDrawable.java
@@ -110,73 +110,16 @@ public abstract class WindowsGLDrawable extends GLDrawableImpl {
       boolean haveWGLARBMultisample = false;
       boolean gotAvailableCaps = false;
       if (dummyWGLExt != null) {
-        haveWGLChoosePixelFormatARB = dummyWGLExt.isExtensionAvailable("WGL_ARB_pixel_format");
-        haveWGLARBMultisample       = dummyWGLExt.isExtensionAvailable("WGL_ARB_multisample");
-
         try {
-          if (haveWGLChoosePixelFormatARB) {
-            int[]   iattributes = new int  [2 * MAX_ATTRIBS];
-            int[]   iresults    = new int  [2 * MAX_ATTRIBS];
-            float[] fattributes = new float[2 * MAX_ATTRIBS];
-            int niattribs = 0;
-            int nfattribs = 0;
-            iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL_ARB;
-            iattributes[niattribs++] = GL.GL_TRUE;
-            iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW_ARB;
-            iattributes[niattribs++] = GL.GL_TRUE;
-            iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
-            iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA_ARB;
-            iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER_ARB;
-            if (capabilities.getDoubleBuffered()) {
-              iattributes[niattribs++] = GL.GL_TRUE;
-            } else {
-              iattributes[niattribs++] = GL.GL_FALSE;
-            }
-            iattributes[niattribs++] = WGLExt.WGL_STEREO_ARB;
-            if (capabilities.getStereo()) {
-              iattributes[niattribs++] = GL.GL_TRUE;
-            } else {
-              iattributes[niattribs++] = GL.GL_FALSE;
-            }
-            iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS_ARB;
-            iattributes[niattribs++] = capabilities.getDepthBits();
-            iattributes[niattribs++] = WGLExt.WGL_RED_BITS_ARB;
-            iattributes[niattribs++] = capabilities.getRedBits();
-            iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS_ARB;
-            iattributes[niattribs++] = capabilities.getGreenBits();
-            iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS_ARB;
-            iattributes[niattribs++] = capabilities.getBlueBits();
-            iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS_ARB;
-            iattributes[niattribs++] = capabilities.getAlphaBits();
-            iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS_ARB;
-            iattributes[niattribs++] = capabilities.getStencilBits();
-            if (capabilities.getAccumRedBits()   > 0 ||
-                capabilities.getAccumGreenBits() > 0 ||
-                capabilities.getAccumBlueBits()  > 0 ||
-                capabilities.getAccumAlphaBits()  > 0) {
-              iattributes[niattribs++] = WGLExt.WGL_ACCUM_BITS_ARB;
-              iattributes[niattribs++] = (capabilities.getAccumRedBits() +
-                                          capabilities.getAccumGreenBits() +
-                                          capabilities.getAccumBlueBits() +
-                                          capabilities.getAccumAlphaBits());
-              iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS_ARB;
-              iattributes[niattribs++] = capabilities.getAccumRedBits();
-              iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS_ARB;
-              iattributes[niattribs++] = capabilities.getAccumGreenBits();
-              iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS_ARB;
-              iattributes[niattribs++] = capabilities.getAccumBlueBits();
-              iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS_ARB;
-              iattributes[niattribs++] = capabilities.getAccumAlphaBits();
-            }
-            if (haveWGLARBMultisample) {
-              if (capabilities.getSampleBuffers()) {
-                iattributes[niattribs++] = WGLExt.WGL_SAMPLE_BUFFERS_ARB;
-                iattributes[niattribs++] = GL.GL_TRUE;
-                iattributes[niattribs++] = WGLExt.WGL_SAMPLES_ARB;
-                iattributes[niattribs++] = capabilities.getNumSamples();
-              }
-            }
-          
+          int[]   iattributes = new int  [2 * MAX_ATTRIBS];
+          int[]   iresults    = new int  [2 * MAX_ATTRIBS];
+          float[] fattributes = new float[1];
+
+          if (glCapabilities2iattributes(capabilities,
+                                         iattributes,
+                                         dummyWGLExt,
+                                         false,
+                                         null)) {
             int[] pformats = new int[MAX_PFORMATS];
             int[] numFormatsTmp = new int[1];
             if (dummyWGLExt.wglChoosePixelFormatARB(hdc,
@@ -218,7 +161,7 @@ public abstract class WindowsGLDrawable extends GLDrawableImpl {
             // "HardwareAccelerated" bit, which is basically
             // meaningless, and put in whether it can render to a
             // window, to a pbuffer, or to a pixmap)
-            niattribs = 0;
+            int niattribs = 0;
             iattributes[0] = WGLExt.WGL_NUMBER_PIXEL_FORMATS_ARB;
             if (dummyWGLExt.wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, iattributes, 0, iresults, 0)) {
               numFormats = iresults[0];
@@ -252,7 +195,7 @@ public abstract class WindowsGLDrawable extends GLDrawableImpl {
                 if (!dummyWGLExt.wglGetPixelFormatAttribivARB(hdc, i+1, 0, niattribs, iattributes, 0, iresults, 0)) {
                   throw new GLException("Error getting pixel format attributes for pixel format " + (i + 1) + " of device context");
                 }
-                availableCaps[i] = iattributes2GLCapabilities(iattributes, iresults, niattribs, true);
+                availableCaps[i] = iattributes2GLCapabilities(iattributes, iresults, true);
               }
               gotAvailableCaps = true;
             } else {
@@ -398,13 +341,169 @@ public abstract class WindowsGLDrawable extends GLDrawableImpl {
     return res;
   }
 
+  protected static boolean glCapabilities2iattributes(GLCapabilities capabilities,
+                                                      int[] iattributes,
+                                                      WGLExt wglExt,
+                                                      boolean pbuffer,
+                                                      int[] floatMode) throws GLException {
+    if (!wglExt.isExtensionAvailable("WGL_ARB_pixel_format")) {
+      return false;
+    }
+
+    int niattribs = 0;
+
+    iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL_ARB;
+    iattributes[niattribs++] = GL.GL_TRUE;
+    if (pbuffer) {
+      iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_PBUFFER_ARB;
+      iattributes[niattribs++] = GL.GL_TRUE;
+    } else {
+      iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW_ARB;
+      iattributes[niattribs++] = GL.GL_TRUE;
+    }
+
+    iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER_ARB;
+    if (capabilities.getDoubleBuffered()) {
+      iattributes[niattribs++] = GL.GL_TRUE;
+    } else {
+      iattributes[niattribs++] = GL.GL_FALSE;
+    }
+
+    iattributes[niattribs++] = WGLExt.WGL_STEREO_ARB;
+    if (capabilities.getStereo()) {
+      iattributes[niattribs++] = GL.GL_TRUE;
+    } else {
+      iattributes[niattribs++] = GL.GL_FALSE;
+    }
+    
+    iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS_ARB;
+    iattributes[niattribs++] = capabilities.getDepthBits();
+    iattributes[niattribs++] = WGLExt.WGL_RED_BITS_ARB;
+    iattributes[niattribs++] = capabilities.getRedBits();
+    iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS_ARB;
+    iattributes[niattribs++] = capabilities.getGreenBits();
+    iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS_ARB;
+    iattributes[niattribs++] = capabilities.getBlueBits();
+    iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS_ARB;
+    iattributes[niattribs++] = capabilities.getAlphaBits();
+    iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS_ARB;
+    iattributes[niattribs++] = capabilities.getStencilBits();
+    if (capabilities.getAccumRedBits()   > 0 ||
+        capabilities.getAccumGreenBits() > 0 ||
+        capabilities.getAccumBlueBits()  > 0 ||
+        capabilities.getAccumAlphaBits() > 0) {
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_BITS_ARB;
+      iattributes[niattribs++] = (capabilities.getAccumRedBits() +
+                                  capabilities.getAccumGreenBits() +
+                                  capabilities.getAccumBlueBits() +
+                                  capabilities.getAccumAlphaBits());
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS_ARB;
+      iattributes[niattribs++] = capabilities.getAccumRedBits();
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS_ARB;
+      iattributes[niattribs++] = capabilities.getAccumGreenBits();
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS_ARB;
+      iattributes[niattribs++] = capabilities.getAccumBlueBits();
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS_ARB;
+      iattributes[niattribs++] = capabilities.getAccumAlphaBits();
+    }
+
+    if (wglExt.isExtensionAvailable("WGL_ARB_multisample")) {
+      if (capabilities.getSampleBuffers()) {
+        iattributes[niattribs++] = WGLExt.WGL_SAMPLE_BUFFERS_ARB;
+        iattributes[niattribs++] = GL.GL_TRUE;
+        iattributes[niattribs++] = WGLExt.WGL_SAMPLES_ARB;
+        iattributes[niattribs++] = capabilities.getNumSamples();
+      }
+    }
+
+    boolean rtt      = capabilities.getOffscreenRenderToTexture();
+    boolean rect     = capabilities.getOffscreenRenderToTextureRectangle();
+    boolean useFloat = capabilities.getOffscreenFloatingPointBuffers();
+    boolean ati      = false;
+    if (pbuffer) {
+      // Check some invariants and set up some state
+      if (rtt && !rect) {
+        throw new GLException("Render-to-texture-rectangle requires render-to-texture to be specified");
+      }
+
+      if (rect) {
+        if (!wglExt.isExtensionAvailable("GL_NV_texture_rectangle")) {
+          throw new GLException("Render-to-texture-rectangle requires GL_NV_texture_rectangle extension");
+        }
+      }
+
+      if (useFloat) {
+        if (!wglExt.isExtensionAvailable("WGL_ATI_pixel_format_float") &&
+            !wglExt.isExtensionAvailable("WGL_NV_float_buffer")) {
+          throw new GLException("Floating-point pbuffers not supported by this hardware");
+        }
+
+        // Prefer NVidia extension over ATI
+        if (wglExt.isExtensionAvailable("WGL_NV_float_buffer")) {
+          ati = false;
+          floatMode[0] = GLPbuffer.NV_FLOAT;
+        } else {
+          ati = true;
+          floatMode[0] = GLPbuffer.ATI_FLOAT;
+        }
+        if (DEBUG) {
+          System.err.println("Using " + (ati ? "ATI" : "NVidia") + " floating-point extension");
+        }
+      }
+
+      // See whether we need to change the pixel type to support ATI's
+      // floating-point pbuffers
+      if (useFloat && ati) {
+        if (rtt) {
+          throw new GLException("Render-to-floating-point-texture not supported on ATI hardware");
+        } else {
+          iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA_FLOAT_ATI;
+        }
+      } else {
+        if (!rtt) {
+          // Currently we don't support non-truecolor visuals in the
+          // GLCapabilities, so we don't offer the option of making
+          // color-index pbuffers.
+          iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA_ARB;
+        }
+      }
+
+      if (useFloat && !ati) {
+        iattributes[niattribs++] = WGLExt.WGL_FLOAT_COMPONENTS_NV;
+        iattributes[niattribs++] = GL.GL_TRUE;
+      }
+
+      if (rtt) {
+        if (useFloat) {
+          assert(!ati);
+          if (!rect) {
+            throw new GLException("Render-to-floating-point-texture only supported on NVidia hardware with render-to-texture-rectangle");
+          }
+          iattributes[niattribs++] = WGLExt.WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV;
+          iattributes[niattribs++] = GL.GL_TRUE;
+        } else {
+          iattributes[niattribs++] = rect ? WGLExt.WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV : WGLExt.WGL_BIND_TO_TEXTURE_RGB_ARB;
+          iattributes[niattribs++] = GL.GL_TRUE;
+        }
+      }
+    } else {
+      iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
+      iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA_ARB;
+    }
+
+    return true;
+  }
+
   protected static GLCapabilities iattributes2GLCapabilities(int[] iattribs,
                                                              int[] iresults,
-                                                             int   niattribs,
                                                              boolean requireRenderToWindow) {
     GLCapabilities res = new GLCapabilities();
-    for (int i = 0; i < niattribs; i++) {
-      switch (iattribs[i]) {
+    int attr = 0;
+    int i = 0;
+    while ((attr = iattribs[i]) != 0) {
+      switch (attr) {
         case WGLExt.WGL_DRAW_TO_WINDOW_ARB:
           if (iresults[i] != GL.GL_TRUE)
             return null;
@@ -483,6 +582,7 @@ public abstract class WindowsGLDrawable extends GLDrawableImpl {
         default:
           throw new GLException("Unknown pixel format attribute " + iattribs[i]);
       }
+      i++;
     }
     return res;
   }
diff --git a/src/classes/com/sun/opengl/impl/windows/WindowsPbufferGLDrawable.java b/src/classes/com/sun/opengl/impl/windows/WindowsPbufferGLDrawable.java
index 3874edfd6..1543f420d 100644
--- a/src/classes/com/sun/opengl/impl/windows/WindowsPbufferGLDrawable.java
+++ b/src/classes/com/sun/opengl/impl/windows/WindowsPbufferGLDrawable.java
@@ -143,9 +143,9 @@ public class WindowsPbufferGLDrawable extends WindowsGLDrawable {
 
   private void createPbuffer(long parentHdc, WGLExt wglExt) {
     int[]   iattributes = new int  [2*MAX_ATTRIBS];
-    float[] fattributes = new float[2*MAX_ATTRIBS];
-    int nfattribs = 0;
-    int niattribs = 0;
+    float[] fattributes = new float[1];
+    int[]   floatModeTmp = new int[1];
+    int     niattribs   = 0;
 
     if (DEBUG) {
       System.out.println("Pbuffer parentHdc = " + toHexString(parentHdc));
@@ -155,120 +155,24 @@ public class WindowsPbufferGLDrawable extends WindowsGLDrawable {
                          (capabilities.getOffscreenFloatingPointBuffers() ? " [float]" : ""));
     }
 
+    if (!glCapabilities2iattributes(capabilities,
+                                    iattributes,
+                                    wglExt,
+                                    true,
+                                    floatModeTmp)) {
+      throw new GLException("Pbuffer-related extensions not supported");
+    }
+
+    floatMode = floatModeTmp[0];
     boolean rtt      = capabilities.getOffscreenRenderToTexture();
     boolean rect     = capabilities.getOffscreenRenderToTextureRectangle();
     boolean useFloat = capabilities.getOffscreenFloatingPointBuffers();
     boolean ati      = false;
-    
-    // Since we are trying to create a pbuffer, the pixel format we
-    // request (and subsequently use) must be "p-buffer capable".
-    iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_PBUFFER_ARB;
-    iattributes[niattribs++] = GL.GL_TRUE;
-
-    if (rtt && !rect) {
-      throw new GLException("Render-to-texture-rectangle requires render-to-texture to be specified");
-    }
-
-    if (rect) {
-      if (!wglExt.isExtensionAvailable("GL_NV_texture_rectangle")) {
-        throw new GLException("Render-to-texture-rectangle requires GL_NV_texture_rectangle extension");
-      }
-    }
 
     if (useFloat) {
-      if (!wglExt.isExtensionAvailable("WGL_ATI_pixel_format_float") &&
-          !wglExt.isExtensionAvailable("WGL_NV_float_buffer")) {
-        throw new GLException("Floating-point pbuffers not supported by this hardware");
-      }
-
-      // Prefer NVidia extension over ATI
-      if (wglExt.isExtensionAvailable("WGL_NV_float_buffer")) {
-        ati = false;
-        floatMode = GLPbuffer.NV_FLOAT;
-      } else {
-        ati = true;
-        floatMode = GLPbuffer.ATI_FLOAT;
-      }
-      if (DEBUG) {
-        System.err.println("Using " + (ati ? "ATI" : "NVidia") + " floating-point extension");
-      }
-    }
-
-    if (useFloat && ati) {
-      if (rtt) {
-        throw new GLException("Render-to-floating-point-texture not supported on ATI hardware");
-      } else {
-        iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
-        iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA_FLOAT_ATI;
-      }
-    } else {
-      if (!rtt) {
-        // Currently we don't support non-truecolor visuals in the
-        // GLCapabilities, so we don't offer the option of making
-        // color-index pbuffers.
-        iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
-        iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA_ARB;
-      }
-    }
-
-    iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER_ARB;
-    if (capabilities.getDoubleBuffered()) {
-      iattributes[niattribs++] = GL.GL_TRUE;
-    } else {
-      iattributes[niattribs++] = GL.GL_FALSE;
-    }
-
-    iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS_ARB;
-    iattributes[niattribs++] = capabilities.getDepthBits();
-
-    iattributes[niattribs++] = WGLExt.WGL_RED_BITS_ARB;
-    iattributes[niattribs++] = capabilities.getRedBits();
-
-    iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS_ARB;
-    iattributes[niattribs++] = capabilities.getGreenBits();
-
-    iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS_ARB;
-    iattributes[niattribs++] = capabilities.getBlueBits();
-
-    iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS_ARB;
-    iattributes[niattribs++] = capabilities.getAlphaBits();
-
-    iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS_ARB;
-    if (capabilities.getStencilBits() > 0) {
-      iattributes[niattribs++] = GL.GL_TRUE;
-    } else {
-      iattributes[niattribs++] = GL.GL_FALSE;
-    }
-
-    if (capabilities.getAccumRedBits()   > 0 ||
-        capabilities.getAccumGreenBits() > 0 ||
-        capabilities.getAccumBlueBits()  > 0) {
-      iattributes[niattribs++] = WGLExt.WGL_ACCUM_BITS_ARB;
-      iattributes[niattribs++] = GL.GL_TRUE;
-    }
-
-    if (useFloat && !ati) {
-      iattributes[niattribs++] = WGLExt.WGL_FLOAT_COMPONENTS_NV;
-      iattributes[niattribs++] = GL.GL_TRUE;
-    }
-
-    if (rtt) {
-      if (useFloat) {
-        assert(!ati);
-        if (!rect) {
-          throw new GLException("Render-to-floating-point-texture only supported on NVidia hardware with render-to-texture-rectangle");
-        }
-        iattributes[niattribs++] = WGLExt.WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV;
-        iattributes[niattribs++] = GL.GL_TRUE;
-      } else {
-        iattributes[niattribs++] = rect ? WGLExt.WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV : WGLExt.WGL_BIND_TO_TEXTURE_RGB_ARB;
-        iattributes[niattribs++] = GL.GL_TRUE;
-      }
+      ati = (floatMode == GLPbuffer.ATI_FLOAT);
     }
 
-    iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL_ARB;
-    iattributes[niattribs++] = GL.GL_TRUE;
-    
     int[] pformats = new int[MAX_PFORMATS];
     int   nformats;
     int[] nformatsTmp = new int[1];
diff --git a/src/classes/com/sun/opengl/impl/x11/X11GLDrawableFactory.java b/src/classes/com/sun/opengl/impl/x11/X11GLDrawableFactory.java
index 48953739f..5bdc367e6 100644
--- a/src/classes/com/sun/opengl/impl/x11/X11GLDrawableFactory.java
+++ b/src/classes/com/sun/opengl/impl/x11/X11GLDrawableFactory.java
@@ -105,7 +105,7 @@ public class X11GLDrawableFactory extends GLDrawableFactoryImpl {
     // in pure Java, we're going to provide the underlying window
     // system's selection to the chooser as a hint
 
-    int[] attribs = glCapabilities2AttribList(capabilities, isMultisampleAvailable());
+    int[] attribs = glCapabilities2AttribList(capabilities, isMultisampleAvailable(), false, 0, 0);
     XVisualInfo[] infos = null;
     GLCapabilities[] caps = null;
     int recommendedIndex = -1;
@@ -309,7 +309,10 @@ public class X11GLDrawableFactory extends GLDrawableFactoryImpl {
   }
 
   public static int[] glCapabilities2AttribList(GLCapabilities caps,
-                                                boolean isMultisampleAvailable) {
+                                                boolean isMultisampleAvailable,
+                                                boolean pbuffer,
+                                                long display,
+                                                int screen) {
     int colorDepth = (caps.getRedBits() +
                       caps.getGreenBits() +
                       caps.getBlueBits());
@@ -318,7 +321,15 @@ public class X11GLDrawableFactory extends GLDrawableFactoryImpl {
     }
     int[] res = new int[MAX_ATTRIBS];
     int idx = 0;
-    res[idx++] = GLX.GLX_RGBA;
+    if (pbuffer) {
+      res[idx++] = GLXExt.GLX_DRAWABLE_TYPE;
+      res[idx++] = GLXExt.GLX_PBUFFER_BIT;
+
+      res[idx++] = GLXExt.GLX_RENDER_TYPE;
+      res[idx++] = GLXExt.GLX_RGBA_BIT;
+    } else {
+      res[idx++] = GLX.GLX_RGBA;
+    }
     if (caps.getDoubleBuffered()) {
       res[idx++] = GLX.GLX_DOUBLEBUFFER;
     }
@@ -335,20 +346,40 @@ public class X11GLDrawableFactory extends GLDrawableFactoryImpl {
     res[idx++] = caps.getAlphaBits();
     res[idx++] = GLX.GLX_DEPTH_SIZE;
     res[idx++] = caps.getDepthBits();
-    res[idx++] = GLX.GLX_STENCIL_SIZE;
-    res[idx++] = caps.getStencilBits();
-    res[idx++] = GLX.GLX_ACCUM_RED_SIZE;
-    res[idx++] = caps.getAccumRedBits();
-    res[idx++] = GLX.GLX_ACCUM_GREEN_SIZE;
-    res[idx++] = caps.getAccumGreenBits();
-    res[idx++] = GLX.GLX_ACCUM_BLUE_SIZE;
-    res[idx++] = caps.getAccumBlueBits();
+    if (caps.getStencilBits() > 0) {
+      res[idx++] = GLX.GLX_STENCIL_SIZE;
+      res[idx++] = caps.getStencilBits();
+    }
+    if (caps.getAccumRedBits()   > 0 ||
+        caps.getAccumGreenBits() > 0 ||
+        caps.getAccumBlueBits()  > 0 ||
+        caps.getAccumAlphaBits() > 0) {
+      res[idx++] = GLX.GLX_ACCUM_RED_SIZE;
+      res[idx++] = caps.getAccumRedBits();
+      res[idx++] = GLX.GLX_ACCUM_GREEN_SIZE;
+      res[idx++] = caps.getAccumGreenBits();
+      res[idx++] = GLX.GLX_ACCUM_BLUE_SIZE;
+      res[idx++] = caps.getAccumBlueBits();
+      res[idx++] = GLX.GLX_ACCUM_ALPHA_SIZE;
+      res[idx++] = caps.getAccumAlphaBits();
+    }
     if (isMultisampleAvailable && caps.getSampleBuffers()) {
       res[idx++] = GLXExt.GLX_SAMPLE_BUFFERS_ARB;
       res[idx++] = GL.GL_TRUE;
       res[idx++] = GLXExt.GLX_SAMPLES_ARB;
       res[idx++] = caps.getNumSamples();
     }
+    if (pbuffer) {
+      if (caps.getOffscreenFloatingPointBuffers()) {
+        String glXExtensions = GLX.glXQueryExtensionsString(display, screen);
+        if (glXExtensions == null ||
+            glXExtensions.indexOf("GLX_NV_float_buffer") < 0) {
+          throw new GLException("Floating-point pbuffers on X11 currently require NVidia hardware");
+        }
+        res[idx++] = GLX.GLX_FLOAT_COMPONENTS_NV;
+        res[idx++] = GL.GL_TRUE;
+      }
+    }
     res[idx++] = 0;
     return res;
   }
diff --git a/src/classes/com/sun/opengl/impl/x11/X11PbufferGLDrawable.java b/src/classes/com/sun/opengl/impl/x11/X11PbufferGLDrawable.java
index eddc5c14d..7ea10055c 100644
--- a/src/classes/com/sun/opengl/impl/x11/X11PbufferGLDrawable.java
+++ b/src/classes/com/sun/opengl/impl/x11/X11PbufferGLDrawable.java
@@ -114,74 +114,10 @@ public class X11PbufferGLDrawable extends X11GLDrawable {
         throw new GLException("Render-to-texture-rectangle pbuffers not supported yet on X11");
       }
 
-      int[]   iattributes = new int  [2*MAX_ATTRIBS];
-      float[] fattributes = new float[2*MAX_ATTRIBS];
-      int nfattribs = 0;
-      int niattribs = 0;
-
-      // Since we are trying to create a pbuffer, the GLXFBConfig we
-      // request (and subsequently use) must be "p-buffer capable".
-      iattributes[niattribs++] = GLXExt.GLX_DRAWABLE_TYPE;
-      iattributes[niattribs++] = GLXExt.GLX_PBUFFER_BIT;
-
-      iattributes[niattribs++] = GLXExt.GLX_RENDER_TYPE;
-      iattributes[niattribs++] = GLXExt.GLX_RGBA_BIT;
-
-      iattributes[niattribs++] = GLX.GLX_DOUBLEBUFFER;
-      if (capabilities.getDoubleBuffered()) {
-        iattributes[niattribs++] = GL.GL_TRUE;
-      } else {
-        iattributes[niattribs++] = GL.GL_FALSE;
-      }
-
-      iattributes[niattribs++] = GLX.GLX_DEPTH_SIZE;
-      iattributes[niattribs++] = capabilities.getDepthBits();
-
-      iattributes[niattribs++] = GLX.GLX_RED_SIZE;
-      iattributes[niattribs++] = capabilities.getRedBits();
-
-      iattributes[niattribs++] = GLX.GLX_GREEN_SIZE;
-      iattributes[niattribs++] = capabilities.getGreenBits();
-
-      iattributes[niattribs++] = GLX.GLX_BLUE_SIZE;
-      iattributes[niattribs++] = capabilities.getBlueBits();
-
-      iattributes[niattribs++] = GLX.GLX_ALPHA_SIZE;
-      iattributes[niattribs++] = capabilities.getAlphaBits();
-
-      if (capabilities.getStencilBits() > 0) {
-        iattributes[niattribs++] = GLX.GLX_STENCIL_SIZE;
-        iattributes[niattribs++] = capabilities.getStencilBits();
-      }
-
-      if (capabilities.getAccumRedBits()   > 0 ||
-          capabilities.getAccumGreenBits() > 0 ||
-          capabilities.getAccumBlueBits()  > 0) {
-        iattributes[niattribs++] = GLX.GLX_ACCUM_RED_SIZE;
-        iattributes[niattribs++] = capabilities.getAccumRedBits();
-        iattributes[niattribs++] = GLX.GLX_ACCUM_GREEN_SIZE;
-        iattributes[niattribs++] = capabilities.getAccumGreenBits();
-        iattributes[niattribs++] = GLX.GLX_ACCUM_BLUE_SIZE;
-        iattributes[niattribs++] = capabilities.getAccumBlueBits();
-      }
-
       int screen = 0; // FIXME: provide way to specify this?
-
-      if (capabilities.getOffscreenFloatingPointBuffers()) {
-        String glXExtensions = GLX.glXQueryExtensionsString(display, screen);
-        if (glXExtensions == null ||
-            glXExtensions.indexOf("GLX_NV_float_buffer") < 0) {
-          throw new GLException("Floating-point pbuffers on X11 currently require NVidia hardware");
-        }
-        iattributes[niattribs++] = GLX.GLX_FLOAT_COMPONENTS_NV;
-        iattributes[niattribs++] = GL.GL_TRUE;
-      }
-
-      // FIXME: add FSAA support? Don't want to get into a situation
-      // where we have to retry the glXChooseFBConfig call if it fails
-      // due to a lack of an antialiased visual...
-
-      iattributes[niattribs++] = 0; // null-terminate
+      int[] iattributes = X11GLDrawableFactory.glCapabilities2AttribList(capabilities,
+                                                                         X11GLDrawableFactory.isMultisampleAvailable(),
+                                                                         true, display, screen);
 
       int[] nelementsTmp = new int[1];
       GLXFBConfig[] fbConfigs = GLX.glXChooseFBConfig(display, screen, iattributes, 0, nelementsTmp, 0);
@@ -210,7 +146,7 @@ public class X11PbufferGLDrawable extends X11GLDrawable {
       }
 
       // Create the p-buffer.
-      niattribs = 0;
+      int niattribs = 0;
 
       iattributes[niattribs++] = GLXExt.GLX_PBUFFER_WIDTH;
       iattributes[niattribs++] = initWidth;