/*
* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
* Copyright (c) 2010 JogAmp Community. 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.
*/
package jogamp.opengl.macosx.cgl;
import com.jogamp.common.nio.PointerBuffer;
import java.security.*;
import java.util.*;
import javax.media.opengl.*;
import javax.media.nativewindow.*;
import jogamp.opengl.*;
public class MacOSXPbufferCGLContext extends MacOSXCGLContext {
// 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 = Debug.getProperty("os.version", false, AccessController.getContext());
StringTokenizer tok = new StringTokenizer(osVersion, ". ");
int major = Integer.parseInt(tok.nextToken());
int minor = Integer.parseInt(tok.nextToken());
isTigerOrLater = ((major > 10) || (minor > 3));
}
public MacOSXPbufferCGLContext(MacOSXPbufferCGLDrawable drawable,
GLContext shareWith) {
super(drawable, shareWith);
initOpenGLImpl();
}
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(contextHandle, drawable.getHandle(), GL.GL_FRONT);
}
public void releasePbufferFromTexture() {
}
protected void makeCurrentImpl(boolean newCreated) throws GLException {
if (getOpenGLMode() != ((MacOSXPbufferCGLDrawable)drawable).getOpenGLMode()) {
setOpenGLMode(((MacOSXPbufferCGLDrawable)drawable).getOpenGLMode());
}
if (!impl.makeCurrent(contextHandle)) {
throw new GLException("Error making Context (NS) current");
}
if (newCreated) {
// Initialize render-to-texture support if requested
DefaultGraphicsConfiguration config = (DefaultGraphicsConfiguration) drawable.getNativeSurface().getGraphicsConfiguration().getNativeGraphicsConfiguration();
GLCapabilitiesImmutable capabilities = (GLCapabilitiesImmutable)config.getChosenCapabilities();
GL gl = getGL();
boolean rect = gl.isGL2GL3() && capabilities.getPbufferRenderToTextureRectangle();
if (rect) {
if (!gl.isExtensionAvailable("GL_EXT_texture_rectangle")) {
System.err.println("MacOSXPbufferCGLContext: WARNING: GL_EXT_texture_rectangle extension not " +
"supported; skipping requested render_to_texture_rectangle support for pbuffer");
rect = false;
}
}
textureTarget = (rect ? GL2.GL_TEXTURE_RECTANGLE : 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);
}
}
protected void releaseImpl() throws GLException {
if (!impl.release(contextHandle)) {
throw new GLException("Error releasing OpenGL Context (NS)");
}
}
protected void destroyImpl() throws GLException {
if (!impl.destroy(contextHandle)) {
throw new GLException("Unable to delete OpenGL context");
}
if (DEBUG) {
System.err.println("!!! Destroyed OpenGL context " + contextHandle);
}
}
protected void setSwapIntervalImpl(int interval) {
impl.setSwapInterval(contextHandle, interval);
currentSwapInterval = impl.getSwapInterval() ;
}
public int getFloatingPointMode() {
return GLPbuffer.APPLE_FLOAT;
}
protected boolean createImpl() throws GLException {
DefaultGraphicsConfiguration config = (DefaultGraphicsConfiguration) drawable.getNativeSurface().getGraphicsConfiguration().getNativeGraphicsConfiguration();
GLCapabilitiesImmutable capabilities = (GLCapabilitiesImmutable)config.getChosenCapabilities();
if (capabilities.getPbufferFloatingPointBuffers() &&
!isTigerOrLater) {
throw new GLException("Floating-point pbuffers supported only on OS X 10.4 or later");
}
// Change our OpenGL mode to match that of any share context before we create ourselves
MacOSXCGLContext other = (MacOSXCGLContext) GLContextShareSet.getShareContext(this);
if (other != null) {
setOpenGLMode(other.getOpenGLMode());
}
// Will throw exception upon error
isNSContext = impl.isNSContext();
contextHandle = impl.create();
if (!impl.makeCurrent(contextHandle)) {
throw new GLException("Error making Context (NS:"+isNSContext()+") current");
}
if(!isNSContext()) { // FIXME: ??
throw new GLException("Not a NS Context");
}
setGLFunctionAvailability(true, true, 0, 0, CTX_PROFILE_COMPAT|CTX_OPTION_ANY);
return true;
}
//---------------------------------------------------------------------------
// OpenGL "mode switching" functionality
//
private boolean haveSetOpenGLMode = false;
// FIXME: should consider switching the default mode based on
// whether the Java2D/JOGL bridge is active -- need to ask ourselves
// whether it's more likely that we will share with a GLCanvas or a
// GLJPanel when the bridge is turned on
private int openGLMode = MacOSXCGLDrawable.NSOPENGL_MODE;
// Implementation object (either NSOpenGL-based or CGL-based)
protected Impl impl;
public void setOpenGLMode(int mode) {
if (mode == openGLMode) {
return;
}
if (haveSetOpenGLMode) {
throw new GLException("Can't switch between using NSOpenGLPixelBuffer and CGLPBufferObj more than once");
}
destroyImpl();
((MacOSXPbufferCGLDrawable)drawable).setOpenGLMode(mode);
openGLMode = mode;
haveSetOpenGLMode = true;
if (DEBUG) {
System.err.println("Switching PBuffer context mode to " +
((mode == MacOSXCGLDrawable.NSOPENGL_MODE) ? "NSOPENGL_MODE" : "CGL_MODE"));
}
initOpenGLImpl();
}
public int getOpenGLMode() {
return openGLMode;
}
private void initOpenGLImpl() {
switch (openGLMode) {
case MacOSXCGLDrawable.NSOPENGL_MODE:
impl = new NSOpenGLImpl();
break;
case MacOSXCGLDrawable.CGL_MODE:
impl = new CGLImpl();
break;
default:
throw new InternalError("Illegal implementation mode " + openGLMode);
}
}
// Abstract interface for implementation of this context (either
// NSOpenGL-based or CGL-based)
interface Impl {
public boolean isNSContext();
public long create();
public boolean destroy(long ctx);
public boolean makeCurrent(long ctx);
public boolean release(long ctx);
public void setSwapInterval(long ctx, int interval);
public int getSwapInterval();
}
// NSOpenGLContext-based implementation
class NSOpenGLImpl implements Impl {
public boolean isNSContext() { return true; }
public long create() {
DefaultGraphicsConfiguration config = (DefaultGraphicsConfiguration) drawable.getNativeSurface().getGraphicsConfiguration().getNativeGraphicsConfiguration();
GLCapabilitiesImmutable capabilities = (GLCapabilitiesImmutable)config.getChosenCapabilities();
if (capabilities.getPbufferFloatingPointBuffers() &&
!isTigerOrLater) {
throw new GLException("Floating-point pbuffers supported only on OS X 10.4 or later");
}
if (!MacOSXPbufferCGLContext.this.create(true, capabilities.getPbufferFloatingPointBuffers())) {
throw new GLException("Error creating context for pbuffer");
}
// Must now associate the pbuffer with our newly-created context
CGL.setContextPBuffer(contextHandle, drawable.getHandle());
return contextHandle;
}
public boolean destroy(long ctx) {
return CGL.deleteContext(ctx);
}
public boolean makeCurrent(long ctx) {
return CGL.makeCurrentContext(ctx);
}
public boolean release(long ctx) {
return CGL.clearCurrentContext(ctx);
}
private int currentSwapInterval = 0 ;
public void setSwapInterval(long ctx, int interval) {
CGL.setSwapInterval(ctx, interval);
currentSwapInterval = interval ;
}
public int getSwapInterval() {
return currentSwapInterval;
}
}
class CGLImpl implements Impl {
public boolean isNSContext() { return false; }
public long create() {
// Find and configure share context
MacOSXCGLContext other = (MacOSXCGLContext) GLContextShareSet.getShareContext(MacOSXPbufferCGLContext.this);
long share = 0;
if (other != null) {
// Reconfigure pbuffer-based GLContexts
if (other instanceof MacOSXPbufferCGLContext) {
MacOSXPbufferCGLContext ctx = (MacOSXPbufferCGLContext) other;
ctx.setOpenGLMode(MacOSXCGLDrawable.CGL_MODE);
} else {
if (other.isNSContext()) {
throw new GLException("Can't share between NSOpenGLContexts and CGLContextObjs");
}
}
share = other.getHandle();
// Note we don't check for a 0 return value, since switching
// the context's mode causes it to be destroyed and not
// re-initialized until the next makeCurrent
}
// Set up pixel format attributes
// FIXME: shall go into MacOSXCGLGraphicsConfiguration
int[] attrs = new int[256];
int i = 0;
attrs[i++] = CGL.kCGLPFAPBuffer;
DefaultGraphicsConfiguration config = (DefaultGraphicsConfiguration) drawable.getNativeSurface().getGraphicsConfiguration().getNativeGraphicsConfiguration();
GLCapabilitiesImmutable capabilities = (GLCapabilitiesImmutable)config.getChosenCapabilities();
if (capabilities.getPbufferFloatingPointBuffers())
attrs[i++] = CGL.kCGLPFAColorFloat;
if (capabilities.getDoubleBuffered())
attrs[i++] = CGL.kCGLPFADoubleBuffer;
if (capabilities.getStereo())
attrs[i++] = CGL.kCGLPFAStereo;
attrs[i++] = CGL.kCGLPFAColorSize;
attrs[i++] = (capabilities.getRedBits() +
capabilities.getGreenBits() +
capabilities.getBlueBits());
attrs[i++] = CGL.kCGLPFAAlphaSize;
attrs[i++] = capabilities.getAlphaBits();
attrs[i++] = CGL.kCGLPFADepthSize;
attrs[i++] = capabilities.getDepthBits();
// FIXME: should validate stencil size as is done in MacOSXWindowSystemInterface.m
attrs[i++] = CGL.kCGLPFAStencilSize;
attrs[i++] = capabilities.getStencilBits();
attrs[i++] = CGL.kCGLPFAAccumSize;
attrs[i++] = (capabilities.getAccumRedBits() +
capabilities.getAccumGreenBits() +
capabilities.getAccumBlueBits() +
capabilities.getAccumAlphaBits());
if (capabilities.getSampleBuffers()) {
attrs[i++] = CGL.kCGLPFASampleBuffers;
attrs[i++] = 1;
attrs[i++] = CGL.kCGLPFASamples;
attrs[i++] = capabilities.getNumSamples();
}
// Use attribute array to select pixel format
PointerBuffer fmt = PointerBuffer.allocateDirect(1);
long[] numScreens = new long[1];
int res = CGL.CGLChoosePixelFormat(attrs, 0, fmt, numScreens, 0);
if (res != CGL.kCGLNoError) {
throw new GLException("Error code " + res + " while choosing pixel format");
}
// Create new context
PointerBuffer ctx = PointerBuffer.allocateDirect(1);
if (DEBUG) {
System.err.println("Share context for CGL-based pbuffer context is " + toHexString(share));
}
res = CGL.CGLCreateContext(fmt.get(0), share, ctx);
CGL.CGLDestroyPixelFormat(fmt.get(0));
if (res != CGL.kCGLNoError) {
throw new GLException("Error code " + res + " while creating context");
}
// Attach newly-created context to the pbuffer
res = CGL.CGLSetPBuffer(ctx.get(0), drawable.getHandle(), 0, 0, 0);
if (res != CGL.kCGLNoError) {
throw new GLException("Error code " + res + " while attaching context to pbuffer");
}
return ctx.get(0);
}
public boolean destroy(long ctx) {
return (CGL.CGLDestroyContext(ctx) == CGL.kCGLNoError);
}
public boolean makeCurrent(long ctx) {
return CGL.CGLSetCurrentContext(ctx) == CGL.kCGLNoError;
}
public boolean release(long ctx) {
return (CGL.CGLSetCurrentContext(0) == CGL.kCGLNoError);
}
public void setSwapInterval(long ctx, int interval) {
// For now not supported (not really relevant for off-screen contexts anyway)
}
public int getSwapInterval() {
return 0;
}
}
}