diff options
12 files changed, 535 insertions, 182 deletions
diff --git a/make/build-jogl.xml b/make/build-jogl.xml index c541748f8..64e5cf93a 100644 --- a/make/build-jogl.xml +++ b/make/build-jogl.xml @@ -1408,6 +1408,7 @@ <condition property="c.compiler.use-debug"><istrue value="${c.compiler.debug}"/></condition> <patternset id="c.src.files.jogl.gl2"> + <include name="${rootrel.src.c}/macosx/MacOSXCustomCGLCode.c" if="isOSX"/> <include name="${rootrel.src.c}/macosx/MacOSXWindowSystemInterface.m" if="isOSX"/> <include name="${rootrel.src.c}/macosx/ContextUpdater.m" if="isOSX"/> <include name="${rootrel.src.c}/GLXGetProcAddressARB.c" if="isX11"/> @@ -1426,6 +1427,7 @@ </patternset> <patternset id="c.src.files.jogl.gl2es12"> + <include name="${rootrel.src.c}/macosx/MacOSXCustomCGLCode.c" if="isOSX"/> <include name="${rootrel.src.c}/macosx/MacOSXWindowSystemInterface.m" if="isOSX"/> <include name="${rootrel.src.c}/macosx/ContextUpdater.m" if="isOSX"/> <include name="${rootrel.src.c}/GLXGetProcAddressARB.c" if="isX11"/> diff --git a/make/stub_includes/macosx/OpenGL/OpenGL.h b/make/stub_includes/macosx/OpenGL/OpenGL.h index 16225b46b..afb11efea 100644 --- a/make/stub_includes/macosx/OpenGL/OpenGL.h +++ b/make/stub_includes/macosx/OpenGL/OpenGL.h @@ -73,18 +73,44 @@ typedef enum _CGLError { kCGLBadConnection = 10017 /* invalid CoreGraphics connection */ } CGLError; +typedef enum _CGLContextParameter { + kCGLCPSwapRectangle = 200, + kCGLCPSwapInterval = 222, + kCGLCPDispatchTableSize = 224, + kCGLCPClientStorage = 226, + kCGLCPSurfaceTexture = 228, + kCGLCPSurfaceOrder = 235, + kCGLCPSurfaceOpacity = 236, + kCGLCPSurfaceBackingSize = 304, + kCGLCPSurfaceSurfaceVolatile = 306, + kCGLCPReclaimResources = 308, + kCGLCPCurrentRendererID = 309, + kCGLCPGPUVertexProcessing = 310, + kCGLCPGPUFragmentProcessing = 311, + kCGLCPHasDrawable = 314, + kCGLCPMPSwapsInFlight = 315, +} CGLContextParameter; + /* Pixel format manipulation */ CGLError CGLChoosePixelFormat(const CGLPixelFormatAttribute *attribs, CGLPixelFormatObj *pix, long *npix); CGLError CGLDestroyPixelFormat(CGLPixelFormatObj pix); +CGLPixelFormatObj CGLGetPixelFormat ( CGLContextObj ctx ); /* Context manipulation */ CGLError CGLCreateContext(CGLPixelFormatObj pix, CGLContextObj share, CGLContextObj* ctx); +void CGLReleaseContext(CGLContextObj ctx); CGLError CGLDestroyContext(CGLContextObj ctx); CGLError CGLSetCurrentContext(CGLContextObj ctx); +CGLContextObj CGLGetCurrentContext (void); +CGLError CGLFlushDrawable ( CGLContextObj ctx); +CGLError CGLSetParameter ( CGLContextObj ctx, CGLContextParameter pname, const int *params ); +CGLError CGLCopyContext ( CGLContextObj src, CGLContextObj dst, int mask ); + + /* PBuffer manipulation */ CGLError CGLCreatePBuffer(long width, diff --git a/make/stub_includes/opengl/GL3/gl3.h b/make/stub_includes/opengl/GL3/gl3.h index 7db3851bd..437830dfa 100755 --- a/make/stub_includes/opengl/GL3/gl3.h +++ b/make/stub_includes/opengl/GL3/gl3.h @@ -1067,6 +1067,52 @@ typedef void GLvoid; #define GL_COPY_WRITE_BUFFER 0x8F37 #endif +#ifndef GL_ARB_depth_buffer_float +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#endif + +#ifndef GL_ARB_framebuffer_sRGB +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#endif + +#ifndef GL_ARB_half_float_pixel +#define GL_HALF_FLOAT_ARB 0x140B +#endif + +#ifndef GL_ARB_texture_compression_rgtc +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#endif + +#ifndef GL_ARB_texture_rg +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#endif + /*************************************************************/ diff --git a/make/stub_includes/opengl/macosx-window-system.h b/make/stub_includes/opengl/macosx-window-system.h index f43adb546..7d2704be4 100644 --- a/make/stub_includes/opengl/macosx-window-system.h +++ b/make/stub_includes/opengl/macosx-window-system.h @@ -9,27 +9,36 @@ typedef int Bool; +// CGL .. +void CGLQueryPixelFormat(void* pixelFormat, int* iattrs, int niattrs, int* ivalues); + +// NS .. void* createPixelFormat(int* iattrs, int niattrs, int* ivalues); void queryPixelFormat(void* pixelFormat, int* iattrs, int niattrs, int* ivalues); void deletePixelFormat(void* pixelFormat); +// NS .. +void *getCurrentContext(void); +void *getNSView(void* nsContext); + void* createContext(void* shareContext, void* nsView, void* pixelFormat, int* viewNotReady); +void *getCGLContext(void* nsContext); Bool makeCurrentContext(void* nsContext); -Bool clearCurrentContext(void* nsContext); +Bool clearCurrentContext(void *nsContext); Bool deleteContext(void* nsContext); Bool flushBuffer(void* nsContext); -void setContextOpacity(void* context, int opacity); +void setContextOpacity(void* nsContext, int opacity); void updateContext(void* nsContext); void copyContext(void* destContext, void* srcContext, int mask); void* updateContextRegister(void* nsContext, void* nsView); -void updateContextUnregister(void* nsContext, void* nsView, void* updater); +void updateContextUnregister(void* updater); void* createPBuffer(int renderTarget, int internalFormat, int width, int height); -Bool destroyPBuffer(void* nsContext, void* pBuffer); +Bool destroyPBuffer(void* pBuffer); void setContextPBuffer(void* nsContext, void* pBuffer); void setContextTextureImageToPBuffer(void* nsContext, void* pBuffer, int colorBuffer); diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLContext.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLContext.java index 181efc8bb..111b215e3 100644 --- a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLContext.java +++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLContext.java @@ -49,7 +49,8 @@ import com.sun.gluegen.runtime.ProcAddressTable; public abstract class MacOSXCGLContext extends GLContextImpl { protected MacOSXCGLDrawable drawable; - protected long nsContext; // NSOpenGLContext + protected long nsContext; // NSOpenGLContext + protected long cglContext; // CGLContextObj private CGLExt cglExt; // Table that holds the addresses of the native C-language entry points for // CGL extension functions. @@ -111,44 +112,23 @@ public abstract class MacOSXCGLContext extends GLContextImpl } } MacOSXCGLGraphicsConfiguration config = (MacOSXCGLGraphicsConfiguration) drawable.getNativeWindow().getGraphicsConfiguration().getNativeGraphicsConfiguration(); - GLCapabilities capabilities = (GLCapabilities)config.getRequestedCapabilities(); - GLProfile glProfile = capabilities.getGLProfile(); + GLCapabilities capabilitiesRequested = (GLCapabilities)config.getRequestedCapabilities(); + GLProfile glProfile = capabilitiesRequested.getGLProfile(); if(glProfile.isGL3()) { throw new GLException("GL3 profile currently not supported on MacOSX, due to the lack of a OpenGL 3.1 implementation"); } - // FIXME: Shall being moved to MacOSXCGLGraphicsConfiguration ! - int[] viewNotReady = new int[1]; - int[] iattribs = new int[128]; - int[] ivalues = new int[128]; - int idx = 0; - if (pbuffer) { - iattribs[idx] = CGL.NSOpenGLPFAPixelBuffer; ivalues[idx] = 1; idx++; - } - if (floatingPoint) { - iattribs[idx] = CGL.kCGLPFAColorFloat; ivalues[idx] = 1; idx++; - } - iattribs[idx] = CGL.NSOpenGLPFADoubleBuffer; ivalues[idx] = (capabilities.getDoubleBuffered() ? 1 : 0); idx++; - iattribs[idx] = CGL.NSOpenGLPFAStereo; ivalues[idx] = (capabilities.getStereo() ? 1 : 0); idx++; - iattribs[idx] = CGL.NSOpenGLPFAColorSize; ivalues[idx] = (capabilities.getRedBits() + - capabilities.getGreenBits() + - capabilities.getBlueBits()); idx++; - iattribs[idx] = CGL.NSOpenGLPFAAlphaSize; ivalues[idx] = capabilities.getAlphaBits(); idx++; - iattribs[idx] = CGL.NSOpenGLPFADepthSize; ivalues[idx] = capabilities.getDepthBits(); idx++; - iattribs[idx] = CGL.NSOpenGLPFAAccumSize; ivalues[idx] = (capabilities.getAccumRedBits() + - capabilities.getAccumGreenBits() + - capabilities.getAccumBlueBits() + - capabilities.getAccumAlphaBits()); idx++; - iattribs[idx] = CGL.NSOpenGLPFAStencilSize; ivalues[idx] = capabilities.getStencilBits(); idx++; - if (capabilities.getSampleBuffers()) { - iattribs[idx] = CGL.NSOpenGLPFASampleBuffers; ivalues[idx] = 1; idx++; - iattribs[idx] = CGL.NSOpenGLPFASamples; ivalues[idx] = capabilities.getNumSamples(); idx++; - } + // HACK .. bring in OnScreen/PBuffer selection to the DrawableFactory !! + GLCapabilities capabilities = (GLCapabilities) capabilitiesRequested.clone(); + capabilities.setPBuffer(pbuffer); + capabilities.setPbufferFloatingPointBuffers(floatingPoint); - long pixelFormat = CGL.createPixelFormat(iattribs, 0, idx, ivalues, 0); + long pixelFormat = MacOSXCGLGraphicsConfiguration.GLCapabilities2NSPixelFormat(capabilities); if (pixelFormat == 0) { throw new GLException("Unable to allocate pixel format with requested GLCapabilities"); } + config.setChosenPixelFormat(pixelFormat); try { + int[] viewNotReady = new int[1]; // Try to allocate a context with this nsContext = CGL.createContext(share, drawable.getNativeWindow().getSurfaceHandle(), @@ -170,80 +150,8 @@ public abstract class MacOSXCGLContext extends GLContextImpl CGL.setContextOpacity(nsContext, 0); } - // On this platform the pixel format is associated with the - // context and not the drawable. However it's a reasonable - // approximation to just store the chosen pixel format up in the - // NativeWindow's AbstractGraphicsConfiguration, - // since the public API doesn't provide for a different GLCapabilities per context. - // Note: These restrictions of the platform's API might be considered as a bug anyways. - { - // Figure out what attributes we really got - GLCapabilities caps = new GLCapabilities(glProfile); - CGL.queryPixelFormat(pixelFormat, iattribs, 0, idx, ivalues, 0); - for (int i = 0; i < idx; i++) { - int attr = iattribs[i]; - switch (attr) { - case CGL.kCGLPFAColorFloat: - caps.setPbufferFloatingPointBuffers(ivalues[i] != 0); - break; - - case CGL.NSOpenGLPFADoubleBuffer: - caps.setDoubleBuffered(ivalues[i] != 0); - break; - - case CGL.NSOpenGLPFAStereo: - caps.setStereo(ivalues[i] != 0); - break; - - case CGL.NSOpenGLPFAColorSize: - { - int bitSize = ivalues[i]; - if (bitSize == 32) - bitSize = 24; - bitSize /= 3; - caps.setRedBits(bitSize); - caps.setGreenBits(bitSize); - caps.setBlueBits(bitSize); - } - break; - - case CGL.NSOpenGLPFAAlphaSize: - caps.setAlphaBits(ivalues[i]); - break; - - case CGL.NSOpenGLPFADepthSize: - caps.setDepthBits(ivalues[i]); - break; - - case CGL.NSOpenGLPFAAccumSize: - { - int bitSize = ivalues[i] / 4; - caps.setAccumRedBits(bitSize); - caps.setAccumGreenBits(bitSize); - caps.setAccumBlueBits(bitSize); - caps.setAccumAlphaBits(bitSize); - } - break; - - case CGL.NSOpenGLPFAStencilSize: - caps.setStencilBits(ivalues[i]); - break; - - case CGL.NSOpenGLPFASampleBuffers: - caps.setSampleBuffers(ivalues[i] != 0); - break; - - case CGL.NSOpenGLPFASamples: - caps.setNumSamples(ivalues[i]); - break; - - default: - break; - } - } - - config.setChosenCapabilities(caps); - } + GLCapabilities caps = MacOSXCGLGraphicsConfiguration.NSPixelFormat2GLCapabilities(glProfile, pixelFormat); + config.setChosenCapabilities(caps); } finally { CGL.deletePixelFormat(pixelFormat); } @@ -256,14 +164,14 @@ public abstract class MacOSXCGLContext extends GLContextImpl } protected int makeCurrentImpl() throws GLException { - if (drawable.getNativeWindow().getSurfaceHandle() == 0) { + if (0 == cglContext && drawable.getNativeWindow().getSurfaceHandle() == 0) { if (DEBUG) { System.err.println("drawable not properly initialized"); } return CONTEXT_NOT_CURRENT; } boolean created = false; - if (nsContext == 0) { + if ( 0 == cglContext && 0 == nsContext) { if (!create()) { return CONTEXT_NOT_CURRENT; } @@ -273,8 +181,14 @@ public abstract class MacOSXCGLContext extends GLContextImpl created = true; } - if (!CGL.makeCurrentContext(nsContext)) { - throw new GLException("Error making nsContext current"); + if ( 0 != cglContext ) { + if (CGL.kCGLNoError != CGL.CGLSetCurrentContext(cglContext)) { + throw new GLException("Error making cglContext current"); + } + } else { + if (!CGL.makeCurrentContext(nsContext)) { + throw new GLException("Error making nsContext current"); + } } if (created) { @@ -285,38 +199,64 @@ public abstract class MacOSXCGLContext extends GLContextImpl } protected void releaseImpl() throws GLException { - if (!CGL.clearCurrentContext(nsContext)) { - throw new GLException("Error freeing OpenGL nsContext"); + if ( 0 != cglContext ) { + CGL.CGLReleaseContext(cglContext); + } else { + if (!CGL.clearCurrentContext(nsContext)) { + throw new GLException("Error freeing OpenGL nsContext"); + } } } protected void destroyImpl() throws GLException { - if (nsContext != 0) { + boolean hadContext = isCreated(); + if ( 0 != cglContext ) { + if (CGL.kCGLNoError != CGL.CGLDestroyContext(cglContext)) { + throw new GLException("Unable to delete OpenGL cglContext"); + } + if (DEBUG) { + System.err.println("!!! Destroyed OpenGL cglContext " + cglContext); + } + cglContext = 0; + GLContextShareSet.contextDestroyed(this); + } else if ( 0 != nsContext ) { if (!CGL.deleteContext(nsContext)) { - throw new GLException("Unable to delete OpenGL context"); + throw new GLException("Unable to delete OpenGL nsContext"); } if (DEBUG) { - System.err.println("!!! Destroyed OpenGL context " + nsContext); + System.err.println("!!! Destroyed OpenGL nsContext " + nsContext); } nsContext = 0; + } + if(hadContext) { GLContextShareSet.contextDestroyed(this); } } public boolean isCreated() { - return (nsContext != 0); + return 0 != cglContext || 0 != nsContext ; } public void copy(GLContext source, int mask) throws GLException { - long dst = getNSContext(); - long src = ((MacOSXCGLContext) source).getNSContext(); - if (src == 0) { - throw new GLException("Source OpenGL context has not been created"); - } - if (dst == 0) { - throw new GLException("Destination OpenGL context has not been created"); + long dst = getCGLContext(); + long src = 0; + if( 0 != dst ) { + src = ((MacOSXCGLContext) source).getCGLContext(); + if (src == 0) { + throw new GLException("Source OpenGL cglContext has not been created ; Destination has a cglContext."); + } + CGL.CGLCopyContext(src, dst, mask); + } else { + dst = getNSContext(); + src = ((MacOSXCGLContext) source).getNSContext(); + if (src == 0) { + throw new GLException("Source OpenGL nsContext has not been created"); + } + if (dst == 0) { + throw new GLException("Destination OpenGL nsContext has not been created"); + } + CGL.copyContext(dst, src, mask); } - CGL.copyContext(dst, src, mask); } protected void updateGLProcAddressTable() { @@ -338,10 +278,14 @@ public abstract class MacOSXCGLContext extends GLContextImpl } protected void setSwapIntervalImpl(int interval) { - if (nsContext == 0) { + if ( 0 != cglContext ) { + int[] lval = new int[] { (int) interval } ; + CGL.CGLSetParameter(cglContext, CGL.kCGLCPSwapInterval, lval, 0); + } else if ( 0 != nsContext ) { + CGL.setSwapInterval(nsContext, interval); + } else { throw new GLException("OpenGL context not current"); } - CGL.setSwapInterval(nsContext, interval); currentSwapInterval = interval ; } @@ -391,6 +335,9 @@ public abstract class MacOSXCGLContext extends GLContextImpl // Internals only below this point // + public long getCGLContext() { + return cglContext; + } public long getNSContext() { return nsContext; } diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLDrawableFactory.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLDrawableFactory.java index d8c2a016d..7bcc4ca14 100644 --- a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLDrawableFactory.java +++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLDrawableFactory.java @@ -105,8 +105,7 @@ public class MacOSXCGLDrawableFactory extends GLDrawableFactoryImpl implements D } public GLContext createExternalGLContext() { - AbstractGraphicsScreen aScreen = DefaultGraphicsScreen.createDefault(); - return new MacOSXExternalCGLContext(aScreen); + return MacOSXExternalCGLContext.create(this, null); } public boolean canCreateExternalGLDrawable() { diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java index b5d2fc38e..c94efc92b 100644 --- a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java +++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java @@ -42,16 +42,193 @@ import com.sun.opengl.impl.*; import com.sun.gluegen.runtime.NativeLibrary; public class MacOSXCGLGraphicsConfiguration extends DefaultGraphicsConfiguration implements Cloneable { - public MacOSXCGLGraphicsConfiguration(AbstractGraphicsScreen screen, GLCapabilities capsChosen, GLCapabilities capsRequested) { + long pixelformat; + + public MacOSXCGLGraphicsConfiguration(AbstractGraphicsScreen screen, GLCapabilities capsChosen, GLCapabilities capsRequested, + long pixelformat) { super(screen, capsChosen, capsRequested); + this.pixelformat=pixelformat; } public Object clone() { return super.clone(); } + protected void setChosenPixelFormat(long pixelformat) { + this.pixelformat=pixelformat; + } + protected void setChosenCapabilities(GLCapabilities caps) { super.setChosenCapabilities(caps); } + + protected static final int[] cglInternalAttributeToken = new int[] { + CGL.kCGLPFAColorFloat, + CGL.NSOpenGLPFAPixelBuffer, + CGL.NSOpenGLPFADoubleBuffer, + CGL.NSOpenGLPFAStereo, + CGL.NSOpenGLPFAColorSize, + CGL.NSOpenGLPFAAlphaSize, + CGL.NSOpenGLPFADepthSize, + CGL.NSOpenGLPFAAccumSize, + CGL.NSOpenGLPFAStencilSize, + CGL.NSOpenGLPFASampleBuffers, + CGL.NSOpenGLPFASamples }; + + protected static int[] GLCapabilities2AttribList(GLCapabilities caps) { + int[] ivalues = new int[cglInternalAttributeToken.length]; + + for (int idx = 0; idx < cglInternalAttributeToken.length; idx++) { + int attr = cglInternalAttributeToken[idx]; + switch (attr) { + case CGL.kCGLPFAColorFloat: + ivalues[idx] = caps.getPbufferFloatingPointBuffers() ? 1 : 0; + break; + + case CGL.NSOpenGLPFAPixelBuffer: + ivalues[idx] = caps.isPBuffer() ? 1 : 0; + break; + + case CGL.NSOpenGLPFADoubleBuffer: + ivalues[idx] = (caps.getDoubleBuffered() ? 1 : 0); + break; + + case CGL.NSOpenGLPFAStereo: + ivalues[idx] = (caps.getStereo() ? 1 : 0); + break; + + case CGL.NSOpenGLPFAColorSize: + ivalues[idx] = (caps.getRedBits() + caps.getGreenBits() + caps.getBlueBits()); + break; + + case CGL.NSOpenGLPFAAlphaSize: + ivalues[idx] = caps.getAlphaBits(); + break; + + case CGL.NSOpenGLPFADepthSize: + ivalues[idx] = caps.getDepthBits(); + break; + + case CGL.NSOpenGLPFAAccumSize: + ivalues[idx] = (caps.getAccumRedBits() + caps.getAccumGreenBits() + caps.getAccumBlueBits() + caps.getAccumAlphaBits()); + break; + + case CGL.NSOpenGLPFAStencilSize: + ivalues[idx] = caps.getStencilBits(); + break; + + case CGL.NSOpenGLPFASampleBuffers: + ivalues[idx] = caps.getSampleBuffers() ? 1 : 0; + break; + + case CGL.NSOpenGLPFASamples: + ivalues[idx] = caps.getSampleBuffers() ? ivalues[idx] = caps.getNumSamples() : 0; + break; + + default: + break; + } + } + return ivalues; + } + + protected static long GLCapabilities2NSPixelFormat(GLCapabilities caps) { + int[] ivalues = GLCapabilities2AttribList(caps); + return CGL.createPixelFormat(cglInternalAttributeToken, 0, cglInternalAttributeToken.length, ivalues, 0); + } + + protected static GLCapabilities NSPixelFormat2GLCapabilities(GLProfile glp, long pixelFormat) { + return PixelFormat2GLCapabilities(glp, pixelFormat, true); + } + + protected static GLCapabilities CGLPixelFormat2GLCapabilities(GLProfile glp, long pixelFormat) { + return PixelFormat2GLCapabilities(glp, pixelFormat, false); + } + + private static GLCapabilities PixelFormat2GLCapabilities(GLProfile glp, long pixelFormat, boolean nsUsage) { + int[] ivalues = new int[cglInternalAttributeToken.length]; + + // On this platform the pixel format is associated with the + // context and not the drawable. However it's a reasonable + // approximation to just store the chosen pixel format up in the + // NativeWindow's AbstractGraphicsConfiguration, + // since the public API doesn't provide for a different GLCapabilities per context. + // Note: These restrictions of the platform's API might be considered as a bug anyways. + + // Figure out what attributes we really got + GLCapabilities caps = new GLCapabilities(glp); + if(nsUsage) { + CGL.queryPixelFormat(pixelFormat, cglInternalAttributeToken, 0, cglInternalAttributeToken.length, ivalues, 0); + } else { + CGL.CGLQueryPixelFormat(pixelFormat, cglInternalAttributeToken, 0, cglInternalAttributeToken.length, ivalues, 0); + } + for (int i = 0; i < cglInternalAttributeToken.length; i++) { + int attr = cglInternalAttributeToken[i]; + switch (attr) { + case CGL.kCGLPFAColorFloat: + caps.setPbufferFloatingPointBuffers(ivalues[i] != 0); + break; + + case CGL.NSOpenGLPFAPixelBuffer: + caps.setPBuffer(ivalues[i] != 0); + break; + + case CGL.NSOpenGLPFADoubleBuffer: + caps.setDoubleBuffered(ivalues[i] != 0); + break; + + case CGL.NSOpenGLPFAStereo: + caps.setStereo(ivalues[i] != 0); + break; + + case CGL.NSOpenGLPFAColorSize: + { + int bitSize = ivalues[i]; + if (bitSize == 32) + bitSize = 24; + bitSize /= 3; + caps.setRedBits(bitSize); + caps.setGreenBits(bitSize); + caps.setBlueBits(bitSize); + } + break; + + case CGL.NSOpenGLPFAAlphaSize: + caps.setAlphaBits(ivalues[i]); + break; + + case CGL.NSOpenGLPFADepthSize: + caps.setDepthBits(ivalues[i]); + break; + + case CGL.NSOpenGLPFAAccumSize: + { + int bitSize = ivalues[i] / 4; + caps.setAccumRedBits(bitSize); + caps.setAccumGreenBits(bitSize); + caps.setAccumBlueBits(bitSize); + caps.setAccumAlphaBits(bitSize); + } + break; + + case CGL.NSOpenGLPFAStencilSize: + caps.setStencilBits(ivalues[i]); + break; + + case CGL.NSOpenGLPFASampleBuffers: + caps.setSampleBuffers(ivalues[i] != 0); + break; + + case CGL.NSOpenGLPFASamples: + caps.setNumSamples(ivalues[i]); + break; + + default: + break; + } + } + + return caps; + } } diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java index f59268b5e..7c2c7b751 100644 --- a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java +++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java @@ -78,7 +78,7 @@ public class MacOSXCGLGraphicsConfigurationFactory extends GraphicsConfiguration capabilities = new GLCapabilities(null); } - return new MacOSXCGLGraphicsConfiguration(absScreen, (GLCapabilities)capabilities, (GLCapabilities)capabilities); + return new MacOSXCGLGraphicsConfiguration(absScreen, (GLCapabilities)capabilities, (GLCapabilities)capabilities, 0); } } diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXExternalCGLContext.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXExternalCGLContext.java index 7283122f4..03116f6bd 100644 --- a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXExternalCGLContext.java +++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXExternalCGLContext.java @@ -40,38 +40,75 @@ package com.sun.opengl.impl.macosx.cgl; import javax.media.opengl.*; -import javax.media.nativewindow.*; import com.sun.opengl.impl.*; +import javax.media.nativewindow.*; +import com.sun.nativewindow.impl.NullWindow; + public class MacOSXExternalCGLContext extends MacOSXCGLContext { private boolean firstMakeCurrent = true; private boolean created = true; private GLContext lastContext; - public MacOSXExternalCGLContext(AbstractGraphicsScreen absScreen) { - super(null, null); - - // FIXME: we don't have a "current context" primitive implemented - // yet on OS X. In the current implementation this would need to - // return an NSOpenGLContext*, but "external" toolkits are not - // guaranteed to be using the Cocoa OpenGL API. Additionally, if - // we switched this implementation to use the low-level CGL APIs, - // we would lose the ability to share textures and display lists - // between contexts since you need an NSOpenGLContext, not a - // CGLContextObj, in order to share textures and display lists - // between two NSOpenGLContexts. - // - // The ramifications here are that it is not currently possible to - // share textures and display lists between an OpenGL context - // created by JOGL and one created by a third-party library on OS - // X. - - // context = CGL.CGLGetCurrentContext(); - + private MacOSXExternalCGLContext(Drawable drawable, long cglContext, long nsContext) { + super(drawable, null); + drawable.setExternalCGLContext(this); + this.cglContext = cglContext; + this.nsContext = nsContext; GLContextShareSet.contextCreated(this); setGLFunctionAvailability(false); } + protected static MacOSXExternalCGLContext create(GLDrawableFactory factory, GLProfile glp) { + ((GLDrawableFactoryImpl)factory).lockToolkit(); + try { + long pixelFormat = 0; + long currentDrawable = 0; + long cglContext = 0; + long nsContext = CGL.getCurrentContext(); // Check: MacOSX 10.3 .. + if( 0 != nsContext ) { + currentDrawable = CGL.getNSView(nsContext); + long ctx = CGL.getCGLContext(nsContext); + if (ctx == 0) { + throw new GLException("Error: NULL cglContext of nsContext 0x" +Long.toHexString(nsContext)); + } + pixelFormat = CGL.CGLGetPixelFormat(ctx); + if(DEBUG) { + System.err.println("MacOSXExternalCGLContext Create nsContext 0x"+Long.toHexString(nsContext)+ + ", cglContext 0x"+Long.toHexString(ctx)+ + ", pixelFormat 0x"+Long.toHexString(pixelFormat)); + } + } else { + cglContext = CGL.CGLGetCurrentContext(); + if (cglContext == 0) { + throw new GLException("Error: current cglContext null, no nsContext"); + } + pixelFormat = CGL.CGLGetPixelFormat(cglContext); + if(DEBUG) { + System.err.println("MacOSXExternalCGLContext Create cglContext 0x"+Long.toHexString(cglContext)+ + ", pixelFormat 0x"+Long.toHexString(pixelFormat)); + } + } + + if (0 == pixelFormat) { + throw new GLException("Error: current pixelformat of current cglContext 0x"+Long.toHexString(cglContext)+" is null"); + } + GLCapabilities caps = MacOSXCGLGraphicsConfiguration.CGLPixelFormat2GLCapabilities(glp, pixelFormat); + if(DEBUG) { + System.err.println("MacOSXExternalCGLContext Create "+caps); + } + + AbstractGraphicsScreen aScreen = DefaultGraphicsScreen.createDefault(); + MacOSXCGLGraphicsConfiguration cfg = new MacOSXCGLGraphicsConfiguration(aScreen, caps, caps, pixelFormat); + + NullWindow nw = new NullWindow(cfg); + nw.setSurfaceHandle(currentDrawable); + return new MacOSXExternalCGLContext(new Drawable(factory, nw), cglContext, nsContext); + } finally { + ((GLDrawableFactoryImpl)factory).unlockToolkit(); + } + } + protected boolean create() { return true; } @@ -87,6 +124,16 @@ public class MacOSXExternalCGLContext extends MacOSXCGLContext { return super.makeCurrent(); } + protected void swapBuffers() { + DefaultGraphicsConfiguration config = (DefaultGraphicsConfiguration) drawable.getNativeWindow().getGraphicsConfiguration().getNativeGraphicsConfiguration(); + GLCapabilities caps = (GLCapabilities)config.getChosenCapabilities(); + if(caps.isOnscreen()) { + if (CGL.kCGLNoError != CGL.CGLFlushDrawable(cglContext)) { + throw new GLException("Error swapping buffers"); + } + } + } + public void release() throws GLException { super.release(); setCurrent(lastContext); @@ -114,11 +161,55 @@ public class MacOSXExternalCGLContext extends MacOSXCGLContext { } public void setOpenGLMode(int mode) { - if (mode != MacOSXCGLDrawable.NSOPENGL_MODE) + if (mode != MacOSXCGLDrawable.CGL_MODE) throw new GLException("OpenGL mode switching not supported for external GLContexts"); } public int getOpenGLMode() { - return MacOSXCGLDrawable.NSOPENGL_MODE; + return MacOSXCGLDrawable.CGL_MODE; + } + + // Need to provide the display connection to extension querying APIs + static class Drawable extends MacOSXCGLDrawable { + MacOSXExternalCGLContext extCtx; + + Drawable(GLDrawableFactory factory, NativeWindow comp) { + super(factory, comp, true); + } + + void setExternalCGLContext(MacOSXExternalCGLContext externalContext) { + extCtx = externalContext; + } + + public GLContext createContext(GLContext shareWith) { + throw new GLException("Should not call this"); + } + + public int getWidth() { + throw new GLException("Should not call this"); + } + + public int getHeight() { + throw new GLException("Should not call this"); + } + + public void setSize(int width, int height) { + throw new GLException("Should not call this"); + } + + protected void swapBuffersImpl() { + if (extCtx != null) { + extCtx.swapBuffers(); + } + } + + public void setOpenGLMode(int mode) { + if (mode != CGL_MODE) + throw new GLException("OpenGL mode switching not supported for external GLContext's drawables"); + } + + public int getOpenGLMode() { + return CGL_MODE; + } } } diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11ExternalGLXContext.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11ExternalGLXContext.java index 0603f1cf0..b509447f7 100755 --- a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11ExternalGLXContext.java +++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11ExternalGLXContext.java @@ -53,7 +53,6 @@ public class X11ExternalGLXContext extends X11GLXContext { private X11ExternalGLXContext(Drawable drawable, long context) { super(drawable, null); - this.drawable = drawable; this.context = context; GLContextShareSet.contextCreated(this); setGLFunctionAvailability(false); diff --git a/src/jogl/native/macosx/MacOSXCustomCGLCode.c b/src/jogl/native/macosx/MacOSXCustomCGLCode.c new file mode 100644 index 000000000..c29be889d --- /dev/null +++ b/src/jogl/native/macosx/MacOSXCustomCGLCode.c @@ -0,0 +1,24 @@ +#include <stdlib.h> + +#include <assert.h> + +#include </usr/include/machine/types.h> +#include "macosx-window-system.h" + +void CGLQueryPixelFormat(void* pixelFormat, int* iattrs, int niattrs, int* ivalues) { + CGLPixelFormatObj pix = (CGLPixelFormatObj) pixelFormat; + // FIXME: think about how specifying this might affect the API + int virtualScreen = 0; + + int i; + GLint value; + for (i = 0; i < niattrs && iattrs[i]>0; i++) { + CGLPixelFormatAttribute attr = (CGLPixelFormatAttribute) iattrs[i]; + if ( kCGLNoError == CGLDescribePixelFormat(pix, virtualScreen, attr, &value) ) { + ivalues[i] = value; + } else { + ivalues[i] = 0; + } + } +} + diff --git a/src/jogl/native/macosx/MacOSXWindowSystemInterface.m b/src/jogl/native/macosx/MacOSXWindowSystemInterface.m index 350f6152f..5405ad4ee 100644 --- a/src/jogl/native/macosx/MacOSXWindowSystemInterface.m +++ b/src/jogl/native/macosx/MacOSXWindowSystemInterface.m @@ -382,7 +382,7 @@ void* createPixelFormat(int* iattrs, int niattrs, int* ivalues) { int idx = 0; int i; - for (i = 0; i < niattrs; i++) { + for (i = 0; i < niattrs && iattrs[i]>0; i++) { int attr = iattrs[i]; switch (attr) { case NSOpenGLPFAPixelBuffer: @@ -451,7 +451,7 @@ void queryPixelFormat(void* pixelFormat, int* iattrs, int niattrs, int* ivalues) int virtualScreen = 0; int i; - for (i = 0; i < niattrs; i++) { + for (i = 0; i < niattrs && iattrs[i]>0; i++) { [fmt getValues: &tmp forAttribute: (NSOpenGLPixelFormatAttribute) iattrs[i] forVirtualScreen: virtualScreen]; @@ -524,8 +524,37 @@ void* createContext(void* shareContext, return nsContext; } -Bool makeCurrentContext(void* context) { - NSOpenGLContext *nsContext = (NSOpenGLContext*)context; +void * getCurrentContext() { + NSOpenGLContext *nsContext = NULL; + + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + nsContext = [NSOpenGLContext currentContext]; + [pool release]; + return nsContext;; +} + +void * getCGLContext(void* nsJContext) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; + void * cglContext = NULL; + + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + cglContext = [nsContext CGLContextObj]; + [pool release]; + return cglContext; +} + +void * getNSView(void* nsJContext) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; + void * view = NULL; + + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + view = [nsContext view]; + [pool release]; + return view; +} + +Bool makeCurrentContext(void* nsJContext) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; [nsContext makeCurrentContext]; @@ -533,15 +562,21 @@ Bool makeCurrentContext(void* context) { return true; } -Bool clearCurrentContext(void* context) { +Bool clearCurrentContext(void* nsJContext) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + NSOpenGLContext *currentNSContext = [NSOpenGLContext currentContext]; + if( currentNSContext != nsContext ) { + [nsContext makeCurrentContext]; + } [NSOpenGLContext clearCurrentContext]; [pool release]; return true; } -Bool deleteContext(void* context) { - NSOpenGLContext *nsContext = (NSOpenGLContext*)context; +Bool deleteContext(void* nsJContext) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; [nsContext clearDrawable]; @@ -550,8 +585,8 @@ Bool deleteContext(void* context) { return true; } -Bool flushBuffer(void* context) { - NSOpenGLContext *nsContext = (NSOpenGLContext*)context; +Bool flushBuffer(void* nsJContext) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; [nsContext flushBuffer]; @@ -559,14 +594,14 @@ Bool flushBuffer(void* context) { return true; } -void setContextOpacity(void* context, int opacity) { - NSOpenGLContext *nsContext = (NSOpenGLContext*)context; +void setContextOpacity(void* nsJContext, int opacity) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; [nsContext setValues:&opacity forParameter:NSOpenGLCPSurfaceOpacity]; } -void updateContext(void* context) { - NSOpenGLContext *nsContext = (NSOpenGLContext*)context; +void updateContext(void* nsJContext) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; [nsContext update]; @@ -579,8 +614,8 @@ void copyContext(void* destContext, void* srcContext, int mask) { [dst copyAttributesFromContext: src withMask: mask]; } -void* updateContextRegister(void* context, void* view) { - NSOpenGLContext *nsContext = (NSOpenGLContext*)context; +void* updateContextRegister(void* nsJContext, void* view) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; NSView *nsView = (NSView*)view; NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; @@ -590,7 +625,7 @@ void* updateContextRegister(void* context, void* view) { return NULL; } -void updateContextUnregister(void* context, void* view, void* updater) { +void updateContextUnregister(void* updater) { ContextUpdater *contextUpdater = (ContextUpdater *)updater; NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; @@ -610,10 +645,8 @@ void* createPBuffer(int renderTarget, int internalFormat, int width, int height) return pBuffer; } -Bool destroyPBuffer(void* context, void* buffer) { +Bool destroyPBuffer(void* buffer) { /* FIXME: not clear whether we need to perform the clearDrawable below */ - /* FIXME: remove the context argument -- don't need it any more */ - /* NSOpenGLContext *nsContext = (NSOpenGLContext*)context; */ NSOpenGLPixelBuffer *pBuffer = (NSOpenGLPixelBuffer*)buffer; NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; @@ -628,8 +661,8 @@ Bool destroyPBuffer(void* context, void* buffer) { return true; } -void setContextPBuffer(void* context, void* buffer) { - NSOpenGLContext *nsContext = (NSOpenGLContext*)context; +void setContextPBuffer(void* nsJContext, void* buffer) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; NSOpenGLPixelBuffer *pBuffer = (NSOpenGLPixelBuffer*)buffer; NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; @@ -640,8 +673,8 @@ void setContextPBuffer(void* context, void* buffer) { [pool release]; } -void setContextTextureImageToPBuffer(void* context, void* buffer, int colorBuffer) { - NSOpenGLContext *nsContext = (NSOpenGLContext*)context; +void setContextTextureImageToPBuffer(void* nsJContext, void* buffer, int colorBuffer) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; NSOpenGLPixelBuffer *pBuffer = (NSOpenGLPixelBuffer*)buffer; NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; @@ -686,8 +719,8 @@ void* getProcAddress(const char *procname) { return NULL; } -void setSwapInterval(void* context, int interval) { - NSOpenGLContext *nsContext = (NSOpenGLContext*)context; +void setSwapInterval(void* nsJContext, int interval) { + NSOpenGLContext *nsContext = (NSOpenGLContext*)nsJContext; long swapInterval = interval; [nsContext setValues: &swapInterval forParameter: NSOpenGLCPSwapInterval]; } |