Merged JSR-231 branch on to the main JOGL trunk. The main trunk now

contains the evolving JSR-231 Reference Implementation and the JSR-231
branch is permanently closed.


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

10 files changed, 1285 insertions, 0 deletions

diff --git a/src/classes/com/sun/opengl/impl/macosx/MacOSXDummyGLContext.java b/src/classes/com/sun/opengl/impl/macosx/MacOSXDummyGLContext.java
new file mode 100644
index 000000000..fef5584ab
--- /dev/null
+++ b/src/classes/com/sun/opengl/impl/macosx/MacOSXDummyGLContext.java
@@ -0,0 +1,87 @@
+/*
+ * 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.macosx;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+/** This MacOSXGLContext implementation provides interoperability with
+    the NSOpenGLView Cocoa widget. The MacOSXGLImpl can be
+    instantiated without a GLContext, in which case it expects that
+    the end user will handle all OpenGL context management. Dynamic
+    function lookup is supported in this configuration by having this
+    object provide the FunctionAvailabilityTable. */
+
+public class MacOSXDummyGLContext extends MacOSXGLContext
+{
+  public MacOSXDummyGLContext() {
+    super(null, null);
+  }
+	
+  public int getOffscreenContextReadBuffer() {
+    throw new GLException("Should not call this");
+  }
+	
+  public boolean offscreenImageNeedsVerticalFlip() {
+    throw new GLException("Should not call this");
+  }
+	
+  public boolean canCreatePbufferContext() {
+    throw new GLException("Should not call this");
+  }
+	
+  public GLDrawableImpl createPbufferDrawable(GLCapabilities capabilities,
+                                              int initialWidth,
+                                              int initialHeight) {
+    throw new GLException("Should not call this");
+  }
+
+  public void bindPbufferToTexture() {
+    throw new GLException("Should not call this");
+  }
+	
+  public void releasePbufferFromTexture() {
+    throw new GLException("Should not call this");
+  }
+	
+  public void resetGLFunctionAvailability() {
+    super.resetGLFunctionAvailability();
+  }
+}
diff --git a/src/classes/com/sun/opengl/impl/macosx/MacOSXGLContext.java b/src/classes/com/sun/opengl/impl/macosx/MacOSXGLContext.java
new file mode 100644
index 000000000..e7b06e32e
--- /dev/null
+++ b/src/classes/com/sun/opengl/impl/macosx/MacOSXGLContext.java
@@ -0,0 +1,261 @@
+/*
+ * 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.macosx;
+
+import java.nio.*;
+import java.util.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public abstract class MacOSXGLContext extends GLContextImpl
+{	
+  protected MacOSXGLDrawable drawable;
+  protected long nsContext; // NSOpenGLContext
+  private CGLExt cglExt;
+  // Table that holds the addresses of the native C-language entry points for
+  // CGL extension functions.
+  private CGLExtProcAddressTable cglExtProcAddressTable;
+  
+  public MacOSXGLContext(MacOSXGLDrawable drawable,
+                         GLContext shareWith)
+  {
+    super(shareWith);
+    this.drawable = drawable;
+  }
+	
+  public Object getPlatformGLExtensions() {
+    return getCGLExt();
+  }
+
+  public CGLExt getCGLExt() {
+    if (cglExt == null) {
+      cglExt = new CGLExtImpl(this);
+    }
+    return cglExt;
+  }
+
+  public GLDrawable getGLDrawable() {
+    return drawable;
+  }
+
+  protected String mapToRealGLFunctionName(String glFunctionName)
+  {
+    return glFunctionName;
+  }
+	
+  protected String mapToRealGLExtensionName(String glExtensionName)
+  {
+    return glExtensionName;
+  }
+	
+  protected boolean create() {
+    return create(false, false);
+  }
+
+  /**
+   * Creates and initializes an appropriate OpenGl nsContext. Should only be
+   * called by {@link makeCurrentImpl()}.
+   */
+  protected boolean create(boolean pbuffer, boolean floatingPoint) {
+    MacOSXGLContext other = (MacOSXGLContext) GLContextShareSet.getShareContext(this);
+    long share = 0;
+    if (other != null) {
+      share = other.getNSContext();
+      if (share == 0) {
+        throw new GLException("GLContextShareSet returned an invalid OpenGL context");
+      }
+    }
+    int[] viewNotReady = new int[1];
+    GLCapabilities capabilities = drawable.getCapabilities();
+    nsContext = CGL.createContext(share,
+                                  drawable.getView(),
+                                  capabilities.getDoubleBuffered() ? 1 : 0,
+                                  capabilities.getStereo() ? 1 : 0,
+                                  capabilities.getRedBits(),
+                                  capabilities.getGreenBits(),
+                                  capabilities.getBlueBits(),
+                                  capabilities.getAlphaBits(),
+                                  capabilities.getDepthBits(),
+                                  capabilities.getStencilBits(),
+                                  capabilities.getAccumRedBits(),
+                                  capabilities.getAccumGreenBits(),
+                                  capabilities.getAccumBlueBits(),
+                                  capabilities.getAccumAlphaBits(),
+                                  capabilities.getSampleBuffers() ? 1 : 0,
+                                  capabilities.getNumSamples(),
+                                  (pbuffer ? 1 : 0),
+                                  (floatingPoint ? 1 : 0),
+                                  viewNotReady, 0);
+    if (nsContext == 0) {
+      if (viewNotReady[0] == 1) {
+        if (DEBUG) {
+          System.err.println("!!! View not ready for " + getClass().getName());
+        }
+        // View not ready at the window system level -- this is OK
+        return false;
+      }
+      throw new GLException("Error creating nsContext");
+    }
+    GLContextShareSet.contextCreated(this);
+    return true;
+  }    
+	
+  protected int makeCurrentImpl() throws GLException {
+    boolean created = false;
+    if (nsContext == 0) {
+      if (!create()) {
+        return CONTEXT_NOT_CURRENT;
+      }
+      if (DEBUG) {
+        System.err.println("!!! Created GL nsContext for " + getClass().getName());
+      }
+      created = true;
+    }
+            
+    if (!CGL.makeCurrentContext(nsContext, drawable.getView())) {
+      throw new GLException("Error making nsContext current");
+    }
+            
+    if (created) {
+      resetGLFunctionAvailability();
+      return CONTEXT_CURRENT_NEW;
+    }
+    return CONTEXT_CURRENT;
+  }
+	
+  protected void releaseImpl() throws GLException {
+    if (!CGL.clearCurrentContext(nsContext, drawable.getView())) {
+      throw new GLException("Error freeing OpenGL nsContext");
+    }
+  }
+	
+  protected void destroyImpl() throws GLException {
+    if (nsContext != 0) {
+      if (!CGL.deleteContext(nsContext, 0)) {
+        throw new GLException("Unable to delete OpenGL context");
+      }
+      if (DEBUG) {
+        System.err.println("!!! Destroyed OpenGL context " + nsContext);
+      }
+      nsContext = 0;
+      GLContextShareSet.contextDestroyed(this);
+    }
+  }
+
+  public boolean isCreated() {
+    return (nsContext != 0);
+  }
+	
+  protected void resetGLFunctionAvailability()
+  {
+    super.resetGLFunctionAvailability();
+    if (DEBUG) {
+      System.err.println("!!! Initializing CGL extension address table");
+    }
+    resetProcAddressTable(getCGLExtProcAddressTable());
+  }
+	
+  public CGLExtProcAddressTable getCGLExtProcAddressTable() {
+    if (cglExtProcAddressTable == null) {
+      // FIXME: cache ProcAddressTables by capability bits so we can
+      // share them among contexts with the same capabilities
+      cglExtProcAddressTable = new CGLExtProcAddressTable();
+    }          
+    return cglExtProcAddressTable;
+  }
+
+  public String getPlatformExtensionsString()
+  {
+    return "";
+  }
+	
+  public void setSwapInterval(int interval) {
+    if (nsContext == 0) {
+      throw new GLException("OpenGL context not current");
+    }
+    CGL.setSwapInterval(nsContext, interval);
+  }
+
+  public ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+    // FIXME: apparently the Apple extension doesn't require a custom memory allocator
+    throw new GLException("Not yet implemented");
+  }
+
+  protected boolean isFunctionAvailable(String glFunctionName)
+  {
+    return super.isFunctionAvailable(glFunctionName);
+  }
+  
+  public boolean isExtensionAvailable(String glExtensionName) {
+    if (glExtensionName.equals("GL_ARB_pbuffer") ||
+        glExtensionName.equals("GL_ARB_pixel_format")) {
+      return true;
+    }
+    return super.isExtensionAvailable(glExtensionName);
+  }
+  
+  public int getOffscreenContextPixelDataType() {
+    throw new GLException("Should not call this");
+  }
+
+  public int getOffscreenContextReadBuffer() {
+    throw new GLException("Should not call this");
+  }
+
+  public boolean offscreenImageNeedsVerticalFlip() {
+    throw new GLException("Should not call this");
+  }
+
+  public void bindPbufferToTexture() {
+    throw new GLException("Should not call this");
+  }
+    
+  public void releasePbufferFromTexture() {
+    throw new GLException("Should not call this");
+  }
+    
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+	
+  protected long getNSContext() {
+    return nsContext;
+  }
+}
diff --git a/src/classes/com/sun/opengl/impl/macosx/MacOSXGLDrawable.java b/src/classes/com/sun/opengl/impl/macosx/MacOSXGLDrawable.java
new file mode 100644
index 000000000..26ea8ec54
--- /dev/null
+++ b/src/classes/com/sun/opengl/impl/macosx/MacOSXGLDrawable.java
@@ -0,0 +1,78 @@
+/*
+ * 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.macosx;
+
+import java.awt.Component;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public abstract class MacOSXGLDrawable extends GLDrawableImpl {
+  protected static final boolean DEBUG = Debug.debug("MacOSXGLDrawable");
+
+  protected long nsView; // NSView
+  protected GLCapabilities capabilities;
+  protected GLCapabilitiesChooser chooser;
+
+  public MacOSXGLDrawable(GLCapabilities capabilities,
+                          GLCapabilitiesChooser chooser) {
+    this.capabilities = (GLCapabilities) capabilities.clone();
+    this.chooser = chooser;
+  }
+
+  public void setRealized(boolean val) {
+    throw new GLException("Should not call this (should only be called for onscreen GLDrawables)");
+  }
+
+  public void destroy() {
+    throw new GLException("Should not call this (should only be called for offscreen GLDrawables)");
+  }
+
+  public void swapBuffers() throws GLException {
+  }
+
+  public GLCapabilities getCapabilities() {
+    return capabilities;
+  }
+
+  public long getView() {
+    return nsView;
+  }
+}
\ No newline at end of file
diff --git a/src/classes/com/sun/opengl/impl/macosx/MacOSXGLDrawableFactory.java b/src/classes/com/sun/opengl/impl/macosx/MacOSXGLDrawableFactory.java
new file mode 100644
index 000000000..62b7f3b93
--- /dev/null
+++ b/src/classes/com/sun/opengl/impl/macosx/MacOSXGLDrawableFactory.java
@@ -0,0 +1,141 @@
+/*
+ * 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.macosx;
+
+import java.awt.Component;
+import java.awt.EventQueue;
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsDevice;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.List;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXGLDrawableFactory extends GLDrawableFactoryImpl {
+  static {
+    NativeLibLoader.load();
+  }
+
+  public GraphicsConfiguration chooseGraphicsConfiguration(GLCapabilities capabilities,
+                                                           GLCapabilitiesChooser chooser,
+                                                           GraphicsDevice device) {
+    return null;
+  }
+
+  public GLDrawable getGLDrawable(Object target,
+                                  GLCapabilities capabilities,
+                                  GLCapabilitiesChooser chooser) {
+    if (target == null) {
+      throw new IllegalArgumentException("Null target");
+    }
+    if (!(target instanceof Component)) {
+      throw new IllegalArgumentException("GLDrawables not supported for objects of type " +
+                                         target.getClass().getName() + " (only Components are supported in this implementation)");
+    }
+    if (capabilities == null) {
+      capabilities = new GLCapabilities();
+    }
+    if (chooser == null) {
+      chooser = new DefaultGLCapabilitiesChooser();
+    }
+    return new MacOSXOnscreenGLDrawable((Component) target, capabilities, chooser);
+  }
+
+  public GLDrawableImpl createOffscreenDrawable(GLCapabilities capabilities,
+                                                GLCapabilitiesChooser chooser) {
+    return new MacOSXOffscreenGLDrawable(capabilities);
+  }
+
+  public boolean canCreateGLPbuffer() {
+    return true;
+  }
+
+  public GLPbuffer createGLPbuffer(final GLCapabilities capabilities,
+                                   final int initialWidth,
+                                   final int initialHeight,
+                                   final GLContext shareWith) {
+    final List returnList = new ArrayList();
+    Runnable r = new Runnable() {
+        public void run() {
+          MacOSXPbufferGLDrawable pbufferDrawable = new MacOSXPbufferGLDrawable(capabilities,
+										initialWidth,
+										initialHeight);
+          GLPbufferImpl pbuffer = new GLPbufferImpl(pbufferDrawable, shareWith);
+          returnList.add(pbuffer);
+        }
+      };
+    maybeDoSingleThreadedWorkaround(r);
+    return (GLPbuffer) returnList.get(0);
+  }
+
+  public GLContext createExternalGLContext() {
+    // FIXME
+    throw new GLException("Not yet implemented");
+  }
+
+  public boolean canCreateExternalGLDrawable() {
+    return false;
+  }
+
+  public GLDrawable createExternalGLDrawable() {
+    // FIXME
+    throw new GLException("Not yet implemented");
+  }
+
+  public long dynamicLookupFunction(String glFuncName) {
+    return CGL.getProcAddress(glFuncName);
+  }
+
+  private void maybeDoSingleThreadedWorkaround(Runnable action) {
+    if (Threading.isSingleThreaded() &&
+        !Threading.isOpenGLThread()) {
+      Threading.invokeOnOpenGLThread(action);
+    } else {
+      action.run();
+    }
+  }
+
+  public void lockAWTForJava2D() {
+  }
+
+  public void unlockAWTForJava2D() {
+  }
+}
diff --git a/src/classes/com/sun/opengl/impl/macosx/MacOSXOffscreenGLContext.java b/src/classes/com/sun/opengl/impl/macosx/MacOSXOffscreenGLContext.java
new file mode 100644
index 000000000..c1d106da8
--- /dev/null
+++ b/src/classes/com/sun/opengl/impl/macosx/MacOSXOffscreenGLContext.java
@@ -0,0 +1,64 @@
+/*
+ * 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.macosx;
+
+import java.awt.image.BufferedImage;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXOffscreenGLContext extends MacOSXPbufferGLContext
+{  
+  public MacOSXOffscreenGLContext(MacOSXPbufferGLDrawable drawable,
+                                  GLContext shareWith) {
+    super(drawable, shareWith);
+  }
+	
+  public int getOffscreenContextPixelDataType() {
+    return GL.GL_UNSIGNED_INT_8_8_8_8_REV;
+  }
+
+  public int getOffscreenContextReadBuffer() {
+    return GL.GL_FRONT;
+  }
+
+  public boolean offscreenImageNeedsVerticalFlip() {
+    return true;
+  }
+}
diff --git a/src/classes/com/sun/opengl/impl/macosx/MacOSXOffscreenGLDrawable.java b/src/classes/com/sun/opengl/impl/macosx/MacOSXOffscreenGLDrawable.java
new file mode 100644
index 000000000..f478f43fc
--- /dev/null
+++ b/src/classes/com/sun/opengl/impl/macosx/MacOSXOffscreenGLDrawable.java
@@ -0,0 +1,61 @@
+/*
+ * 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.macosx;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXOffscreenGLDrawable extends MacOSXPbufferGLDrawable {
+
+  public MacOSXOffscreenGLDrawable(GLCapabilities capabilities) {
+    super(capabilities, 0, 0);
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new MacOSXOffscreenGLContext(this, shareWith);
+  }
+
+  public void setSize(int width, int height) {
+    destroy();
+    initWidth = width;
+    initHeight = height;
+    createPbuffer();
+  }
+}
diff --git a/src/classes/com/sun/opengl/impl/macosx/MacOSXOnscreenGLContext.java b/src/classes/com/sun/opengl/impl/macosx/MacOSXOnscreenGLContext.java
new file mode 100644
index 000000000..9e20dd6dd
--- /dev/null
+++ b/src/classes/com/sun/opengl/impl/macosx/MacOSXOnscreenGLContext.java
@@ -0,0 +1,104 @@
+/*
+ * 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.macosx;
+
+import java.util.*;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXOnscreenGLContext extends MacOSXGLContext {
+  protected MacOSXOnscreenGLDrawable drawable;
+
+  public MacOSXOnscreenGLContext(MacOSXOnscreenGLDrawable drawable,
+                                 GLContext shareWith) {
+    super(drawable, shareWith);
+    this.drawable = drawable;
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    try {
+      int lockRes = drawable.lockSurface();
+      if (lockRes == MacOSXOnscreenGLDrawable.LOCK_SURFACE_NOT_READY) {
+        return CONTEXT_NOT_CURRENT;
+      }
+      if (lockRes == MacOSXOnscreenGLDrawable.LOCK_SURFACE_CHANGED) {
+        super.destroy();
+      }
+      int ret = super.makeCurrentImpl();
+      if ((ret == CONTEXT_CURRENT) ||
+          (ret == CONTEXT_CURRENT_NEW)) {
+        // Assume the canvas might have been resized or moved and tell the OpenGL
+        // context to update itself. This used to be done only upon receiving a
+        // reshape event but that doesn't appear to be sufficient. An experiment
+        // was also done to add a HierarchyBoundsListener to the GLCanvas and
+        // do this updating only upon reshape of this component or reshape or movement
+        // of an ancestor, but this also wasn't sufficient and left garbage on the
+        // screen in some situations.
+        CGL.updateContext(nsContext, drawable.getView());
+      } else {
+        // View might not have been ready
+        drawable.unlockSurface();
+      }
+      return ret;
+    } catch (RuntimeException e) {
+      try {
+        drawable.unlockSurface();
+      } catch (Exception e2) {
+        // do nothing if unlockSurface throws
+      }
+      throw(e); 
+    }
+  }
+    
+  protected void releaseImpl() throws GLException {
+    try {
+      super.releaseImpl();
+    } finally {
+      drawable.unlockSurface();
+    }
+  }
+    
+  public void swapBuffers() throws GLException {
+    if (!CGL.flushBuffer(nsContext, drawable.getView())) {
+      throw new GLException("Error swapping buffers");
+    }
+  }
+}
diff --git a/src/classes/com/sun/opengl/impl/macosx/MacOSXOnscreenGLDrawable.java b/src/classes/com/sun/opengl/impl/macosx/MacOSXOnscreenGLDrawable.java
new file mode 100644
index 000000000..e7f6537b9
--- /dev/null
+++ b/src/classes/com/sun/opengl/impl/macosx/MacOSXOnscreenGLDrawable.java
@@ -0,0 +1,228 @@
+/*
+ * 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.macosx;
+
+import java.awt.Component;
+import java.lang.ref.WeakReference;
+import java.security.*;
+import java.util.*;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXOnscreenGLDrawable extends MacOSXGLDrawable {
+  public static final int LOCK_SURFACE_NOT_READY = 1;
+  public static final int LOCK_SURFACE_CHANGED = 2;
+  public static final int LOCK_SUCCESS = 3;
+
+  private static JAWT jawt;
+  protected Component component;
+
+  private List/*<WeakReference<GLContext>>*/ createdContexts =
+    new ArrayList();
+
+  // Variables for lockSurface/unlockSurface
+  private JAWT_DrawingSurface ds;
+  private JAWT_DrawingSurfaceInfo dsi;
+  private JAWT_MacOSXDrawingSurfaceInfo macosxdsi;
+
+  // Indicates whether the component (if an onscreen context) has been
+  // realized. Plausibly, before the component is realized the JAWT
+  // should return an error or NULL object from some of its
+  // operations; this appears to be the case on Win32 but is not true
+  // at least with Sun's current X11 implementation (1.4.x), which
+  // crashes with no other error reported if the DrawingSurfaceInfo is
+  // fetched from a locked DrawingSurface during the validation as a
+  // result of calling show() on the main thread. To work around this
+  // we prevent any JAWT or OpenGL operations from being done until
+  // addNotify() is called on the component.
+  protected boolean realized;
+
+  // Workaround for instance of 4796548
+  private boolean firstLock = true;
+
+  public MacOSXOnscreenGLDrawable(Component component,
+                                  GLCapabilities capabilities,
+                                  GLCapabilitiesChooser chooser) {
+    super(capabilities, chooser);
+    this.component = component;
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    MacOSXOnscreenGLContext context =
+      new MacOSXOnscreenGLContext(this, shareWith);
+    // NOTE: we need to keep track of the created contexts in order to
+    // implement swapBuffers() because of how Mac OS X implements its
+    // OpenGL window interface
+    synchronized (this) {
+      List newContexts = new ArrayList();
+      newContexts.addAll(createdContexts);
+      newContexts.add(new WeakReference(context));
+      createdContexts = newContexts;
+    }
+    return context;
+  }
+
+  public void setRealized(boolean realized) {
+    this.realized = realized;
+  }
+
+  public void setSize(int width, int height) {
+    component.setSize(width, height);
+  }
+
+  public int getWidth() {
+    return component.getWidth();
+  }
+
+  public int getHeight() {
+    return component.getHeight();
+  }
+
+  public void swapBuffers() throws GLException {
+    for (Iterator iter = createdContexts.iterator(); iter.hasNext(); ) {
+      WeakReference ref = (WeakReference) iter.next();
+      MacOSXOnscreenGLContext ctx = (MacOSXOnscreenGLContext) ref.get();
+      // FIXME: clear out unreachable contexts
+      if (ctx != null) {
+        ctx.swapBuffers();
+      }
+    }
+  }
+  
+  public int lockSurface() throws GLException {
+    if (!realized) {
+      return LOCK_SURFACE_NOT_READY;
+    }
+    if (nsView != 0) {
+      throw new GLException("Surface already locked");
+    }
+    ds = getJAWT().GetDrawingSurface(component);
+    if (ds == null) {
+      // Widget not yet realized
+      return LOCK_SURFACE_NOT_READY;
+    }
+    int res = ds.Lock();
+    if ((res & JAWTFactory.JAWT_LOCK_ERROR) != 0) {
+      throw new GLException("Unable to lock surface");
+    }
+    // See whether the surface changed and if so destroy the old
+    // OpenGL context so it will be recreated (NOTE: removeNotify
+    // should handle this case, but it may be possible that race
+    // conditions can cause this code to be triggered -- should test
+    // more)
+    int ret = LOCK_SUCCESS;
+    if ((res & JAWTFactory.JAWT_LOCK_SURFACE_CHANGED) != 0) {
+      ret = LOCK_SURFACE_CHANGED;
+    }
+    if (firstLock) {
+      AccessController.doPrivileged(new PrivilegedAction() {
+          public Object run() {
+            dsi = ds.GetDrawingSurfaceInfo();
+            return null;
+          }
+        });
+    } else {
+      dsi = ds.GetDrawingSurfaceInfo();
+    }
+    if (dsi == null) {
+      // Widget not yet realized
+      ds.Unlock();
+      getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      return LOCK_SURFACE_NOT_READY;
+    }
+    firstLock = false;
+    macosxdsi = (JAWT_MacOSXDrawingSurfaceInfo) dsi.platformInfo();
+    if (macosxdsi == null) {
+      // Widget not yet realized
+      ds.FreeDrawingSurfaceInfo(dsi);
+      ds.Unlock();
+      getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      dsi = null;
+      return LOCK_SURFACE_NOT_READY;
+    }
+    nsView = macosxdsi.cocoaViewRef();
+    if (nsView == 0) {
+      // Widget not yet realized
+      ds.FreeDrawingSurfaceInfo(dsi);
+      ds.Unlock();
+      getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      dsi = null;
+      macosxdsi = null;
+      return LOCK_SURFACE_NOT_READY;
+    }
+    return ret;
+  }
+    
+  public void unlockSurface() throws GLException {
+    if (nsView == 0) {
+      throw new GLException("Surface already unlocked");
+    }
+    ds.FreeDrawingSurfaceInfo(dsi);
+    ds.Unlock();
+    getJAWT().FreeDrawingSurface(ds);
+    ds = null;
+    dsi = null;
+    macosxdsi = null;
+    nsView = 0;
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  private JAWT getJAWT()
+  {
+    if (jawt == null)
+      {
+	JAWT j = new JAWT();
+	j.version(JAWTFactory.JAWT_VERSION_1_4);
+	if (!JAWTFactory.JAWT_GetAWT(j))
+	  {
+	    throw new RuntimeException("Unable to initialize JAWT");
+	  }
+	jawt = j;
+      }
+    return jawt;
+  }
+}
\ No newline at end of file
diff --git a/src/classes/com/sun/opengl/impl/macosx/MacOSXPbufferGLContext.java b/src/classes/com/sun/opengl/impl/macosx/MacOSXPbufferGLContext.java
new file mode 100644
index 000000000..048a256ea
--- /dev/null
+++ b/src/classes/com/sun/opengl/impl/macosx/MacOSXPbufferGLContext.java
@@ -0,0 +1,101 @@
+package com.sun.opengl.impl.macosx;
+
+import java.security.*;
+import java.util.*;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXPbufferGLContext extends MacOSXGLContext {
+  protected MacOSXPbufferGLDrawable drawable;
+
+  // State for render-to-texture and render-to-texture-rectangle support
+  private int textureTarget; // e.g. GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_NV
+  private int texture;       // actual texture object
+
+  private static boolean isTigerOrLater;
+
+  static {
+    String osVersion =
+      (String) AccessController.doPrivileged(new PrivilegedAction() {
+	  public Object run() {
+	    return System.getProperty("os.version");
+	  }
+	});
+    StringTokenizer tok = new StringTokenizer(osVersion, ". ");
+    int major = Integer.parseInt(tok.nextToken());
+    int minor = Integer.parseInt(tok.nextToken());
+    isTigerOrLater = ((major > 10) || (minor > 3));
+  }
+
+  public MacOSXPbufferGLContext(MacOSXPbufferGLDrawable drawable,
+                                GLContext shareWith) {
+    super(drawable, shareWith);
+    this.drawable = drawable;
+  }
+
+  public void bindPbufferToTexture() {
+    GL gl = getGL();
+    gl.glBindTexture(textureTarget, texture);
+    // FIXME: not clear whether this is really necessary, but since
+    // the API docs seem to imply it is and since it doesn't seem to
+    // impact performance, leaving it in
+    CGL.setContextTextureImageToPBuffer(nsContext, drawable.getPbuffer(), GL.GL_FRONT);
+  }
+
+  public void releasePbufferFromTexture() {
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    if (drawable.getPbuffer() == 0) {
+      if (DEBUG) {
+        System.err.println("Pbuffer not instantiated yet for " + this);
+      }
+      // pbuffer not instantiated yet
+      return CONTEXT_NOT_CURRENT;
+    }
+
+    int res = super.makeCurrentImpl();
+    if (res == CONTEXT_CURRENT_NEW) {
+      // Initialize render-to-texture support if requested
+      boolean rect = drawable.getCapabilities().getOffscreenRenderToTextureRectangle();
+      GL gl = getGL();
+      if (rect) {
+        if (!gl.isExtensionAvailable("GL_EXT_texture_rectangle")) {
+          System.err.println("MacOSXPbufferGLContext: WARNING: GL_EXT_texture_rectangle extension not " +
+                             "supported; skipping requested render_to_texture_rectangle support for pbuffer");
+          rect = false;
+        }
+      }
+      textureTarget = (rect ? GL.GL_TEXTURE_RECTANGLE_EXT : GL.GL_TEXTURE_2D);
+      int[] tmp = new int[1];
+      gl.glGenTextures(1, tmp, 0);
+      texture = tmp[0];
+      gl.glBindTexture(textureTarget, texture);
+      gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
+      gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
+      gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
+      gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
+      gl.glCopyTexImage2D(textureTarget, 0, GL.GL_RGB, 0, 0, drawable.getWidth(), drawable.getHeight(), 0);
+    }
+    return res;
+  }
+
+  public int getFloatingPointMode() {
+    return GLPbuffer.APPLE_FLOAT;
+  }
+
+  protected boolean create() {
+    GLCapabilities capabilities = drawable.getCapabilities();
+    if (capabilities.getOffscreenFloatingPointBuffers() &&
+	!isTigerOrLater) {
+      throw new GLException("Floating-point pbuffers supported only on OS X 10.4 or later");
+    }
+    if (!super.create(true, capabilities.getOffscreenFloatingPointBuffers())) {
+      return false;
+    }
+    // Must now associate the pbuffer with our newly-created context
+    CGL.setContextPBuffer(nsContext, drawable.getPbuffer());
+    return true;
+  }
+}
diff --git a/src/classes/com/sun/opengl/impl/macosx/MacOSXPbufferGLDrawable.java b/src/classes/com/sun/opengl/impl/macosx/MacOSXPbufferGLDrawable.java
new file mode 100644
index 000000000..038b1d759
--- /dev/null
+++ b/src/classes/com/sun/opengl/impl/macosx/MacOSXPbufferGLDrawable.java
@@ -0,0 +1,160 @@
+/*
+ * 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.macosx;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXPbufferGLDrawable extends MacOSXGLDrawable {
+  private static final boolean DEBUG = Debug.debug("MacOSXPbufferGLContext");
+  
+  protected int  initWidth;
+  protected int  initHeight;
+
+  protected long pBuffer;
+  
+  protected int  width;
+  protected int  height;
+
+  // State for render-to-texture and render-to-texture-rectangle support
+  private int textureTarget; // e.g. GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_NV
+  private int texture;       // actual texture object
+
+  public MacOSXPbufferGLDrawable(GLCapabilities capabilities, int initialWidth, int initialHeight) {
+    super(capabilities, null);
+    this.initWidth  = initialWidth;
+    this.initHeight = initialHeight;
+
+    createPbuffer();
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new MacOSXPbufferGLContext(this, shareWith);
+  }
+
+  public void destroy() {
+    if (this.pBuffer != 0) {
+      CGL.destroyPBuffer(0, pBuffer);
+      this.pBuffer = 0;
+    
+      if (DEBUG) {
+        System.err.println("Destroyed pbuffer " + width + " x " + height);
+      }
+    }
+  }
+
+  public void setSize(int width, int height) {
+    // FIXME
+    throw new GLException("Not yet implemented");
+  }
+
+  public int getWidth() {
+    return width;
+  }
+
+  public int getHeight() {
+    return height;
+  }
+
+  public GLCapabilities getCapabilities() {
+    return capabilities;
+  }
+
+  public long getPbuffer() {
+    return pBuffer;
+  }
+  
+  public void swapBuffers() throws GLException {
+    // FIXME: do we need to do anything if the pbuffer is double-buffered?
+  }
+
+  protected void createPbuffer() {
+    int renderTarget;
+    if (capabilities.getOffscreenRenderToTextureRectangle()) {
+      width = initWidth;
+      height = initHeight;
+      renderTarget = GL.GL_TEXTURE_RECTANGLE_EXT;
+    } else {
+      width = getNextPowerOf2(initWidth);
+      height = getNextPowerOf2(initHeight);
+      renderTarget = GL.GL_TEXTURE_2D;
+    }
+
+    int internalFormat = GL.GL_RGBA;
+    if (capabilities.getOffscreenFloatingPointBuffers()) {
+      // FIXME: want to check availability of GL_APPLE_float_pixels
+      // extension, but need valid OpenGL context in order to do so --
+      // in worst case would need to create dummy window / GLCanvas
+      // (undesirable) -- could maybe also do this with pbuffers
+      /*
+      if (!gl.isExtensionAvailable("GL_APPLE_float_pixels")) {
+	throw new GLException("Floating-point support (GL_APPLE_float_pixels) not available");
+      }
+      */
+      switch (capabilities.getRedBits()) {
+        case 16: internalFormat = GL.GL_RGBA_FLOAT16_APPLE; break;
+        case 32: internalFormat = GL.GL_RGBA_FLOAT32_APPLE; break;
+        default: throw new GLException("Invalid floating-point bit depth (only 16 and 32 supported)");
+      }
+    }
+		
+    pBuffer = CGL.createPBuffer(renderTarget, internalFormat, width, height);
+    if (pBuffer == 0) {
+      throw new GLException("pbuffer creation error: CGL.createPBuffer() failed");
+    }
+	
+    if (DEBUG) {
+      System.err.println("Created pbuffer 0x" + toHexString(pBuffer) + ", " + width + " x " + height + " for " + this);
+    }
+  }
+
+  private int getNextPowerOf2(int number) {
+    if (((number-1) & number) == 0) {
+      //ex: 8 -> 0b1000; 8-1=7 -> 0b0111; 0b1000&0b0111 == 0
+      return number;
+    }
+    int power = 0;
+    while (number > 0) {
+      number = number>>1;
+      power++;
+    }
+    return (1<<power);
+  }
+}