path: root/src/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLDrawable.java

/*
 * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * 
 * - Redistribution of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * 
 * - Redistribution in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * 
 * Neither the name of Sun Microsystems, Inc. or the names of
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 * 
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
 * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
 * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
 * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
 * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
 * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
 * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 * 
 * You acknowledge that this software is not designed or intended for use
 * in the design, construction, operation or maintenance of any nuclear
 * facility.
 * 
 * Sun gratefully acknowledges that this software was originally authored
 * and developed by Kenneth Bradley Russell and Christopher John Kline.
 */

package com.sun.opengl.impl.windows.wgl;

import javax.media.opengl.*;
import com.sun.opengl.impl.*;

public abstract class WindowsWGLDrawable extends GLDrawableImpl {
  protected static final boolean DEBUG = Debug.debug("WindowsWGLDrawable");

  protected GLCapabilitiesChooser chooser;
  protected boolean pixelFormatChosen;

  // Workaround for problems on Intel 82855 cards
  private int  setPixelFormatFailCount;
  private static final int MAX_SET_PIXEL_FORMAT_FAIL_COUNT = 5;

  protected static final int MAX_PFORMATS = 256;
  protected static final int MAX_ATTRIBS  = 256;

  public WindowsWGLDrawable(GLDrawableFactory factory, NativeWindow comp, boolean realized,
                            GLCapabilities capabilities,
                            GLCapabilitiesChooser chooser) {
    super(factory, comp, realized);
    setChosenGLCapabilities(capabilities);
    this.chooser = chooser;
  }

  public int lockSurface() throws GLException {
    int ret = super.lockSurface();
    if(NativeWindow.LOCK_SURFACE_NOT_READY == ret) {
      if (DEBUG) {
          System.err.println("WindowsWGLDrawable.lockSurface: surface not ready");
      }
      return ret;
    }
    if (!pixelFormatChosen) {
      try {
        choosePixelFormat(true);
        setPixelFormatFailCount = 0;
      } catch (RuntimeException e) {
        if (DEBUG) {
          System.err.println("WindowsWGLDrawable.lockSurface: squelching exception");
          e.printStackTrace();
        }
        // Workaround for problems seen on Intel 82855 cards in particular
        // Make it look like the lockSurface() call didn't succeed
        unlockSurface();
        if (e instanceof GLException) {
          if (++setPixelFormatFailCount == MAX_SET_PIXEL_FORMAT_FAIL_COUNT) {
            setPixelFormatFailCount = 0;
            throw e;
          }
          return NativeWindow.LOCK_SURFACE_NOT_READY;
        } else {
          // Probably a user error in the GLCapabilitiesChooser or similar.
          // Don't propagate non-GLExceptions out because calling code
          // expects to catch only that exception type
          throw new GLException(e);
        }
      }
    }
    return ret;
  }


  protected void choosePixelFormat(boolean onscreen) {
    PIXELFORMATDESCRIPTOR pfd = null;
    int pixelFormat = 0;
    GLCapabilities chosenCaps = null;
    GLCapabilities capabilities = getCapabilities();
    long hdc = getNativeWindow().getSurfaceHandle();
    if (onscreen) {
      if ((pixelFormat = WGL.GetPixelFormat(hdc)) != 0) {
        // The Java2D/OpenGL pipeline probably already set a pixel
        // format for this canvas.
        if (DEBUG) {
          System.err.println("NOTE: pixel format already chosen (by Java2D/OpenGL pipeline?) for window: " + 
                             WGL.GetPixelFormat(hdc));
        }
        pfd = newPixelFormatDescriptor();
        if (WGL.DescribePixelFormat(hdc, pixelFormat, pfd.size(), pfd) == 0) {
          // FIXME: should this just be a warning? Not really critical...
          throw new GLException("Unable to describe pixel format " + pixelFormat +
                                " of window set by Java2D/OpenGL pipeline");
        }
        setChosenGLCapabilities(pfd2GLCapabilities(pfd));
        pixelFormatChosen = true;
        return;
      }

      GLCapabilities[] availableCaps = null;
      int numFormats = 0;
      pfd = newPixelFormatDescriptor();
      // Produce a recommended pixel format selection for the GLCapabilitiesChooser.
      // Use wglChoosePixelFormatARB if user requested multisampling and if we have it available
      WindowsWGLDrawable dummyDrawable = null;
      GLContextImpl     dummyContext  = null;
      WGLExt            dummyWGLExt   = null;
      if (capabilities.getSampleBuffers()) {
        dummyDrawable = new WindowsDummyWGLDrawable(getFactory());
        dummyContext  = (GLContextImpl) dummyDrawable.createContext(null);
        if (dummyContext != null) {
          dummyContext.makeCurrent();
          dummyWGLExt = (WGLExt) dummyContext.getPlatformGLExtensions();
        }
      }      
      int recommendedPixelFormat = -1;
      boolean haveWGLChoosePixelFormatARB = false;
      boolean haveWGLARBMultisample = false;
      boolean gotAvailableCaps = false;
      if (dummyWGLExt != null) {
        try {
          haveWGLChoosePixelFormatARB = dummyWGLExt.isExtensionAvailable("WGL_ARB_pixel_format");
          if (haveWGLChoosePixelFormatARB) {
            haveWGLARBMultisample = dummyWGLExt.isExtensionAvailable("WGL_ARB_multisample");

            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,
                                                      iattributes, 0,
                                                      fattributes, 0,
                                                      MAX_PFORMATS,
                                                      pformats, 0,
                                                      numFormatsTmp, 0)) {
                numFormats = numFormatsTmp[0];
                if (numFormats > 0) {
                  // Remove one-basing of pixel format (added on later)
                  recommendedPixelFormat = pformats[0] - 1;
                  if (DEBUG) {
                    System.err.println(getThreadName() + ": Used wglChoosePixelFormatARB to recommend pixel format " + recommendedPixelFormat);
                  }
                }
              } else {
                if (DEBUG) {
                  System.err.println(getThreadName() + ": wglChoosePixelFormatARB failed: " + WGL.GetLastError() );
                  Thread.dumpStack();
                }
              }
              if (DEBUG) {
                if (recommendedPixelFormat < 0) {
                  System.err.print(getThreadName() + ": wglChoosePixelFormatARB didn't recommend a pixel format");
                  if (capabilities.getSampleBuffers()) {
                    System.err.print(" for multisampled GLCapabilities");
                  }
                  System.err.println();
                }
              }

              // Produce a list of GLCapabilities to give to the
              // GLCapabilitiesChooser.
              // Use wglGetPixelFormatAttribivARB instead of
              // DescribePixelFormat to get higher-precision information
              // about the pixel format (should make the GLCapabilities
              // more precise as well...i.e., remove the
              // "HardwareAccelerated" bit, which is basically
              // meaningless, and put in whether it can render to a
              // window, to a pbuffer, or to a pixmap)
              int niattribs = 0;
              iattributes[0] = WGLExt.WGL_NUMBER_PIXEL_FORMATS;
              if (dummyWGLExt.wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, iattributes, 0, iresults, 0)) {
                numFormats = iresults[0];

                if (DEBUG) {
                  System.err.println("wglGetPixelFormatAttribivARB reported WGL_NUMBER_PIXEL_FORMATS = " + numFormats);
                }

                // Should we be filtering out the pixel formats which aren't
                // applicable, as we are doing here?
                // We don't have enough information in the GLCapabilities to
                // represent those that aren't...
                iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW;
                iattributes[niattribs++] = WGLExt.WGL_ACCELERATION;
                iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL;
                iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS;
                iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS;
                iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER;
                iattributes[niattribs++] = WGLExt.WGL_STEREO;
                iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE;
                iattributes[niattribs++] = WGLExt.WGL_RED_BITS;
                iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS;
                iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS;
                iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS;
                iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS;
                iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS;
                iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS;
                iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS;
                if (haveWGLARBMultisample) {
                  iattributes[niattribs++] = WGLExt.WGL_SAMPLE_BUFFERS;
                  iattributes[niattribs++] = WGLExt.WGL_SAMPLES;
                }

                availableCaps = new GLCapabilities[numFormats];
                for (int i = 0; i < numFormats; i++) {
                  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, niattribs, iresults, true);
                }
                gotAvailableCaps = true;
              } else {
                long lastErr = WGL.GetLastError();
                // Intel Extreme graphics fails with a zero error code
                if (lastErr != 0) {
                  throw new GLException("Unable to enumerate pixel formats of window using wglGetPixelFormatAttribivARB: error code " + WGL.GetLastError());
                }
              }
            }
          }
        } finally {
          dummyContext.release();
          dummyContext.destroy();
          dummyDrawable.destroy();
        }
      }

      // Fallback path for older cards, in particular Intel Extreme motherboard graphics
      if (!gotAvailableCaps) {
        if (DEBUG) {
          if (!capabilities.getSampleBuffers()) {
            System.err.println(getThreadName() + ": Using ChoosePixelFormat because multisampling not requested");
          } else {
            System.err.println(getThreadName() + ": Using ChoosePixelFormat because no wglChoosePixelFormatARB");
          }
        }
        pfd = glCapabilities2PFD(capabilities, onscreen);
        // Remove one-basing of pixel format (added on later)
        recommendedPixelFormat = WGL.ChoosePixelFormat(hdc, pfd) - 1;
        if (DEBUG) {
          System.err.println(getThreadName() + ": Recommended pixel format = " + recommendedPixelFormat);
        }

        numFormats = WGL.DescribePixelFormat(hdc, 1, 0, null);
        if (numFormats == 0) {
          throw new GLException("Unable to enumerate pixel formats of window " +
                                toHexString(hdc) + " for GLCapabilitiesChooser");
        }
        availableCaps = new GLCapabilities[numFormats];
        for (int i = 0; i < numFormats; i++) {
          if (WGL.DescribePixelFormat(hdc, 1 + i, pfd.size(), pfd) == 0) {
            throw new GLException("Error describing pixel format " + (1 + i) + " of device context");
          }
          availableCaps[i] = pfd2GLCapabilities(pfd);
        }
      }

      // NOTE: officially, should make a copy of all of these
      // GLCapabilities to avoid mutation by the end user during the
      // chooseCapabilities call, but for the time being, assume they
      // won't be changed

      // Supply information to chooser
      pixelFormat = chooser.chooseCapabilities(capabilities, availableCaps, recommendedPixelFormat);
      if ((pixelFormat < 0) || (pixelFormat >= numFormats)) {
        throw new GLException("Invalid result " + pixelFormat +
                              " from GLCapabilitiesChooser (should be between 0 and " +
                              (numFormats - 1) + ")");
      }
      if (DEBUG) {
        System.err.println(getThreadName() + ": Chosen pixel format (" + pixelFormat + "):");
        System.err.println(availableCaps[pixelFormat]);
      }
      chosenCaps = availableCaps[pixelFormat];
      pixelFormat += 1; // one-base the index
      if (WGL.DescribePixelFormat(hdc, pixelFormat, pfd.size(), pfd) == 0) {
        throw new GLException("Error re-describing the chosen pixel format: " + WGL.GetLastError());
      }
    } else {
      // For now, use ChoosePixelFormat for offscreen surfaces until
      // we figure out how to properly choose an offscreen-
      // compatible pixel format
      pfd = glCapabilities2PFD(capabilities, onscreen);
      pixelFormat = WGL.ChoosePixelFormat(hdc, pfd);
    }
    if (!WGL.SetPixelFormat(hdc, pixelFormat, pfd)) {
      long lastError = WGL.GetLastError();
      if (DEBUG) {
        System.err.println(getThreadName() + ": SetPixelFormat failed: current context = " + WGL.wglGetCurrentContext() +
                           ", current DC = " + WGL.wglGetCurrentDC());
        System.err.println(getThreadName() + ": GetPixelFormat(hdc " + toHexString(hdc) + ") returns " + WGL.GetPixelFormat(hdc));
      }
      throw new GLException("Unable to set pixel format " + pixelFormat + " for device context " + toHexString(hdc) + ": error code " + lastError);
    }
    // Reuse the previously-constructed GLCapabilities because it
    // turns out that using DescribePixelFormat on some pixel formats
    // (which, for example, support full-scene antialiasing) for some
    // reason return that they are not OpenGL-capable
    if (chosenCaps != null) {
      setChosenGLCapabilities(chosenCaps);
    } else {
      setChosenGLCapabilities(pfd2GLCapabilities(pfd));
    }
    pixelFormatChosen = true;
  }

  protected static PIXELFORMATDESCRIPTOR glCapabilities2PFD(GLCapabilities caps, boolean onscreen) {
    int colorDepth = (caps.getRedBits() +
                      caps.getGreenBits() +
                      caps.getBlueBits());
    if (colorDepth < 15) {
      throw new GLException("Bit depths < 15 (i.e., non-true-color) not supported");
    }
    PIXELFORMATDESCRIPTOR pfd = newPixelFormatDescriptor();
    int pfdFlags = (WGL.PFD_SUPPORT_OPENGL |
                    WGL.PFD_GENERIC_ACCELERATED);
    if (caps.getDoubleBuffered()) {
      pfdFlags |= WGL.PFD_DOUBLEBUFFER;
    }
    if (onscreen) {
      pfdFlags |= WGL.PFD_DRAW_TO_WINDOW;
    } else {
      pfdFlags |= WGL.PFD_DRAW_TO_BITMAP;
    }
    if (caps.getStereo()) {
      pfdFlags |= WGL.PFD_STEREO;
    }
    pfd.dwFlags(pfdFlags);
    pfd.iPixelType((byte) WGL.PFD_TYPE_RGBA);
    pfd.cColorBits((byte) colorDepth);
    pfd.cRedBits  ((byte) caps.getRedBits());
    pfd.cGreenBits((byte) caps.getGreenBits());
    pfd.cBlueBits ((byte) caps.getBlueBits());
    pfd.cAlphaBits((byte) caps.getAlphaBits());
    int accumDepth = (caps.getAccumRedBits() +
                      caps.getAccumGreenBits() +
                      caps.getAccumBlueBits());
    pfd.cAccumBits     ((byte) accumDepth);
    pfd.cAccumRedBits  ((byte) caps.getAccumRedBits());
    pfd.cAccumGreenBits((byte) caps.getAccumGreenBits());
    pfd.cAccumBlueBits ((byte) caps.getAccumBlueBits());
    pfd.cAccumAlphaBits((byte) caps.getAccumAlphaBits());
    pfd.cDepthBits((byte) caps.getDepthBits());
    pfd.cStencilBits((byte) caps.getStencilBits());
    pfd.iLayerType((byte) WGL.PFD_MAIN_PLANE);
    return pfd;
  }

  protected static PIXELFORMATDESCRIPTOR newPixelFormatDescriptor() {
    PIXELFORMATDESCRIPTOR pfd = PIXELFORMATDESCRIPTOR.create();
    pfd.nSize((short) pfd.size());
    pfd.nVersion((short) 1);
    return pfd;
  }

  protected static GLCapabilities pfd2GLCapabilities(PIXELFORMATDESCRIPTOR pfd) {
    if ((pfd.dwFlags() & WGL.PFD_SUPPORT_OPENGL) == 0) {
      return null;
    }
    GLCapabilities res = new GLCapabilities();
    res.setRedBits       (pfd.cRedBits());
    res.setGreenBits     (pfd.cGreenBits());
    res.setBlueBits      (pfd.cBlueBits());
    res.setAlphaBits     (pfd.cAlphaBits());
    res.setAccumRedBits  (pfd.cAccumRedBits());
    res.setAccumGreenBits(pfd.cAccumGreenBits());
    res.setAccumBlueBits (pfd.cAccumBlueBits());
    res.setAccumAlphaBits(pfd.cAccumAlphaBits());
    res.setDepthBits     (pfd.cDepthBits());
    res.setStencilBits   (pfd.cStencilBits());
    res.setDoubleBuffered((pfd.dwFlags() & WGL.PFD_DOUBLEBUFFER) != 0);
    res.setStereo        ((pfd.dwFlags() & WGL.PFD_STEREO) != 0);
    res.setHardwareAccelerated(((pfd.dwFlags() & WGL.PFD_GENERIC_FORMAT) == 0) ||
			       ((pfd.dwFlags() & WGL.PFD_GENERIC_ACCELERATED) != 0));
    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;
    iattributes[niattribs++] = GL.GL_TRUE;
    if (pbuffer) {
      iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_PBUFFER;
      iattributes[niattribs++] = GL.GL_TRUE;
    } else {
      iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW;
      iattributes[niattribs++] = GL.GL_TRUE;
    }

    iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER;
    if (capabilities.getDoubleBuffered()) {
      iattributes[niattribs++] = GL.GL_TRUE;
    } else {
      iattributes[niattribs++] = GL.GL_FALSE;
    }

    iattributes[niattribs++] = WGLExt.WGL_STEREO;
    if (capabilities.getStereo()) {
      iattributes[niattribs++] = GL.GL_TRUE;
    } else {
      iattributes[niattribs++] = GL.GL_FALSE;
    }
    
    iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS;
    iattributes[niattribs++] = capabilities.getDepthBits();
    iattributes[niattribs++] = WGLExt.WGL_RED_BITS;
    iattributes[niattribs++] = capabilities.getRedBits();
    iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS;
    iattributes[niattribs++] = capabilities.getGreenBits();
    iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS;
    iattributes[niattribs++] = capabilities.getBlueBits();
    iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS;
    iattributes[niattribs++] = capabilities.getAlphaBits();
    iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS;
    iattributes[niattribs++] = capabilities.getStencilBits();
    if (capabilities.getAccumRedBits()   > 0 ||
        capabilities.getAccumGreenBits() > 0 ||
        capabilities.getAccumBlueBits()  > 0 ||
        capabilities.getAccumAlphaBits() > 0) {
      iattributes[niattribs++] = WGLExt.WGL_ACCUM_BITS;
      iattributes[niattribs++] = (capabilities.getAccumRedBits() +
                                  capabilities.getAccumGreenBits() +
                                  capabilities.getAccumBlueBits() +
                                  capabilities.getAccumAlphaBits());
      iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS;
      iattributes[niattribs++] = capabilities.getAccumRedBits();
      iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS;
      iattributes[niattribs++] = capabilities.getAccumGreenBits();
      iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS;
      iattributes[niattribs++] = capabilities.getAccumBlueBits();
      iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS;
      iattributes[niattribs++] = capabilities.getAccumAlphaBits();
    }

    if (wglExt.isExtensionAvailable("WGL_ARB_multisample")) {
      if (capabilities.getSampleBuffers()) {
        iattributes[niattribs++] = WGLExt.WGL_SAMPLE_BUFFERS;
        iattributes[niattribs++] = GL.GL_TRUE;
        iattributes[niattribs++] = WGLExt.WGL_SAMPLES;
        iattributes[niattribs++] = capabilities.getNumSamples();
      }
    }

    boolean rtt      = capabilities.getPbufferRenderToTexture();
    boolean rect     = capabilities.getPbufferRenderToTextureRectangle();
    boolean useFloat = capabilities.getPbufferFloatingPointBuffers();
    boolean ati      = false;
    if (pbuffer) {
      // Check some invariants and set up some state
      if (rect && !rtt) {
        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;
          iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA_FLOAT;
        }
      } 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;
          iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA;
        }
      }

      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;
          iattributes[niattribs++] = GL.GL_TRUE;
        }
      }
    } else {
      iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE;
      iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA;
    }

    return true;
  }

  protected static GLCapabilities iattributes2GLCapabilities(int[] iattribs,
                                                             int niattribs,
                                                             int[] iresults,
                                                             boolean requireRenderToWindow) {
    GLCapabilities res = new GLCapabilities();
    for (int i = 0; i < niattribs; i++) {
      int attr = iattribs[i];
      switch (attr) {
        case WGLExt.WGL_DRAW_TO_WINDOW:
          if (requireRenderToWindow && iresults[i] != GL.GL_TRUE)
            return null;
          break;

        case WGLExt.WGL_DRAW_TO_PBUFFER:
          break;

        case WGLExt.WGL_ACCELERATION:
          res.setHardwareAccelerated(iresults[i] == WGLExt.WGL_FULL_ACCELERATION);
          break;

        case WGLExt.WGL_SUPPORT_OPENGL:
          if (iresults[i] != GL.GL_TRUE)
            return null;
          break;

        case WGLExt.WGL_DEPTH_BITS:
          res.setDepthBits(iresults[i]);
          break;

        case WGLExt.WGL_STENCIL_BITS:
          res.setStencilBits(iresults[i]);
          break;

        case WGLExt.WGL_DOUBLE_BUFFER:
          res.setDoubleBuffered(iresults[i] == GL.GL_TRUE);
          break;

        case WGLExt.WGL_STEREO:
          res.setStereo(iresults[i] == GL.GL_TRUE);
          break;

        case WGLExt.WGL_PIXEL_TYPE:
          // Fail softly with unknown results here
          if (iresults[i] == WGLExt.WGL_TYPE_RGBA||
              iresults[i] == WGLExt.WGL_TYPE_RGBA_FLOAT) {
            res.setPbufferFloatingPointBuffers(true);
          }
          break;

        case WGLExt.WGL_FLOAT_COMPONENTS_NV:
          if (iresults[i] != 0) {
            res.setPbufferFloatingPointBuffers(true);
          }
          break;

        case WGLExt.WGL_RED_BITS:
          res.setRedBits(iresults[i]);
          break;
          
        case WGLExt.WGL_GREEN_BITS:
          res.setGreenBits(iresults[i]);
          break;

        case WGLExt.WGL_BLUE_BITS:
          res.setBlueBits(iresults[i]);
          break;

        case WGLExt.WGL_ALPHA_BITS:
          res.setAlphaBits(iresults[i]);
          break;

        case WGLExt.WGL_ACCUM_RED_BITS:
          res.setAccumRedBits(iresults[i]);
          break;

        case WGLExt.WGL_ACCUM_GREEN_BITS:
          res.setAccumGreenBits(iresults[i]);
          break;

        case WGLExt.WGL_ACCUM_BLUE_BITS:
          res.setAccumBlueBits(iresults[i]);
          break;

        case WGLExt.WGL_ACCUM_ALPHA_BITS:
          res.setAccumAlphaBits(iresults[i]);
          break;

        case WGLExt.WGL_SAMPLE_BUFFERS:
          res.setSampleBuffers(iresults[i] != 0);
          break;

        case WGLExt.WGL_SAMPLES:
          res.setNumSamples(iresults[i]);
          break;

        default:
          throw new GLException("Unknown pixel format attribute " + iattribs[i]);
      }
    }
    return res;
  }

  protected static String getThreadName() {
    return Thread.currentThread().getName();
  }
}