diff options
| -rw-r--r-- | make/stub_includes/opengl/GL/glxext.h | 10 | ||||
| -rw-r--r-- | src/jogl/classes/jogamp/opengl/GLXExtensions.java | 37 | ||||
| -rw-r--r-- | src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java | 49 | ||||
| -rw-r--r-- | src/test-native/contextRetargetDrawable01.c | 154 | ||||
| -rw-r--r-- | src/test-native/contextRetargetDrawable02.c | 382 | ||||
| -rw-r--r-- | src/test-native/glExtensionsListGL2.c | 2 | ||||
| -rw-r--r-- | src/test-native/glExtensionsListGL3.c | 25 | ||||
| -rwxr-xr-x | src/test-native/make.sh | 2 | ||||
| -rw-r--r-- | src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/GearsES2.java | 3 | ||||
| -rw-r--r-- | src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/RedSquareES2.java | 3 |
10 files changed, 642 insertions, 25 deletions
diff --git a/make/stub_includes/opengl/GL/glxext.h b/make/stub_includes/opengl/GL/glxext.h index 06dbb271b..3d85521b9 100644 --- a/make/stub_includes/opengl/GL/glxext.h +++ b/make/stub_includes/opengl/GL/glxext.h @@ -439,6 +439,16 @@ typedef GLXContext ( * PFNGLXCREATECONTEXTATTRIBSARBPROC) (Display *dpy, GLXFBCo #define GLX_EXT_visual_info 1 #endif +#ifndef GLX_MESA_swap_control +#define GLX_MESA_swap_control 1 +#ifdef GLX_GLXEXT_PROTOTYPES +extern int glXSwapIntervalMESA(unsigned int interval); +extern int glXGetSwapIntervalMESA(void); +#endif /* GLX_GLXEXT_PROTOTYPES */ +typedef int ( * PFNGLXSWAPINTERVALMESAPROC)(unsigned int interval); +typedef int ( * PFNGLXGETSWAPINTERVALMESAPROC)(void); +#endif + #ifndef GLX_SGI_swap_control #define GLX_SGI_swap_control 1 #ifdef GLX_GLXEXT_PROTOTYPES diff --git a/src/jogl/classes/jogamp/opengl/GLXExtensions.java b/src/jogl/classes/jogamp/opengl/GLXExtensions.java new file mode 100644 index 000000000..36c6c4665 --- /dev/null +++ b/src/jogl/classes/jogamp/opengl/GLXExtensions.java @@ -0,0 +1,37 @@ +/** + * Copyright 2012 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: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions 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. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ +package jogamp.opengl; + +/** + * Class holding GLX/WGL/.. extension strings, commonly used by JOGL's implementation. + */ +public class GLXExtensions { + public static final String GLX_MESA_swap_control = "GLX_MESA_swap_control"; + public static final String GLX_SGI_swap_control = "GLX_SGI_swap_control"; + public static final String GLX_NV_swap_group = "GLX_NV_swap_group"; +} diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java index e1330eb52..72ddd2693 100644 --- a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java +++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java @@ -53,10 +53,10 @@ import javax.media.opengl.GLContext; import javax.media.opengl.GLException; import javax.media.opengl.GLProfile; -import jogamp.nativewindow.x11.X11Lib; import jogamp.nativewindow.x11.X11Util; import jogamp.opengl.GLContextImpl; import jogamp.opengl.GLDrawableImpl; +import jogamp.opengl.GLXExtensions; import com.jogamp.common.nio.Buffers; import com.jogamp.common.util.VersionNumber; @@ -72,7 +72,8 @@ public abstract class X11GLXContext extends GLContextImpl { // Table that holds the addresses of the native C-language entry points for // GLX extension functions. private GLXExtProcAddressTable glXExtProcAddressTable; - private int hasSwapIntervalSGI = 0; + /** 1 MESA, 2 SGI, 0 undefined, -1 none */ + private int hasSwapInterval = 0; private int hasSwapGroupNV = 0; // This indicates whether the context we have created is indirect @@ -101,7 +102,7 @@ public abstract class X11GLXContext extends GLContextImpl { protected void resetStates() { // no inner state _glXExt=null; glXExtProcAddressTable = null; - hasSwapIntervalSGI = 0; + hasSwapInterval = 0; hasSwapGroupNV = 0; isDirect = false; glXServerVersion = null; @@ -155,8 +156,10 @@ public abstract class X11GLXContext extends GLContextImpl { try { if ( isGLXVersionGreaterEqualOneThree() ) { + // System.err.println(getThreadName() +": X11GLXContext.makeCurrent: obj " + toHexString(hashCode()) + " / ctx "+toHexString(contextHandle)+": ctx "+toHexString(ctx)+", [write "+toHexString(writeDrawable)+", read "+toHexString(readDrawable)+"] - switch"); res = GLX.glXMakeContextCurrent(dpy, writeDrawable, readDrawable, ctx); } else if ( writeDrawable == readDrawable ) { + // System.err.println(getThreadName() +": X11GLXContext.makeCurrent: obj " + toHexString(hashCode()) + " / ctx "+toHexString(contextHandle)+": ctx "+toHexString(ctx)+", [write "+toHexString(writeDrawable)+"] - switch"); res = GLX.glXMakeCurrent(dpy, writeDrawable, ctx); } else { // should not happen due to 'isGLReadDrawableAvailable()' query in GLContextImpl @@ -513,20 +516,36 @@ public abstract class X11GLXContext extends GLContextImpl { @Override protected boolean setSwapIntervalImpl(int interval) { - X11GLXGraphicsConfiguration config = (X11GLXGraphicsConfiguration)drawable.getNativeSurface().getGraphicsConfiguration(); - GLCapabilitiesImmutable glCaps = (GLCapabilitiesImmutable) config.getChosenCapabilities(); - if(!glCaps.isOnscreen()) { return false; } + if( !drawable.getChosenGLCapabilities().isOnscreen() ) { return false; } - GLXExt glXExt = getGLXExt(); - if(0==hasSwapIntervalSGI) { + final GLXExt glXExt = getGLXExt(); + if(0==hasSwapInterval) { try { - hasSwapIntervalSGI = glXExt.isExtensionAvailable("GLX_SGI_swap_control")?1:-1; - } catch (Throwable t) { hasSwapIntervalSGI=1; } - } - if (hasSwapIntervalSGI>0) { + /** Same impl. .. + if( glXExt.isExtensionAvailable(GLXExtensions.GLX_MESA_swap_control) ) { + if(DEBUG) { System.err.println("X11GLXContext.setSwapInterval using: "+GLXExtensions.GLX_MESA_swap_control); } + hasSwapInterval = 1; + } else */ + if ( glXExt.isExtensionAvailable(GLXExtensions.GLX_SGI_swap_control) ) { + if(DEBUG) { System.err.println("X11GLXContext.setSwapInterval using: "+GLXExtensions.GLX_SGI_swap_control); } + hasSwapInterval = 2; + } else { + hasSwapInterval = -1; + } + } catch (Throwable t) { hasSwapInterval=-1; } + } + /* try { + switch( hasSwapInterval ) { + case 1: + return 0 == glXExt.glXSwapIntervalMESA(interval); + case 2: + return 0 == glXExt.glXSwapIntervalSGI(interval); + } + } catch (Throwable t) { hasSwapInterval = -1; } */ + if (2 == hasSwapInterval) { try { return 0 == glXExt.glXSwapIntervalSGI(interval); - } catch (Throwable t) { hasSwapIntervalSGI=-1; } + } catch (Throwable t) { hasSwapInterval=-1; } } return false; } @@ -534,10 +553,10 @@ public abstract class X11GLXContext extends GLContextImpl { private final int initSwapGroupImpl(GLXExt glXExt) { if(0==hasSwapGroupNV) { try { - hasSwapGroupNV = glXExt.isExtensionAvailable("GLX_NV_swap_group")?1:-1; + hasSwapGroupNV = glXExt.isExtensionAvailable(GLXExtensions.GLX_NV_swap_group)?1:-1; } catch (Throwable t) { hasSwapGroupNV=1; } if(DEBUG) { - System.err.println("initSwapGroupImpl: hasSwapGroupNV: "+hasSwapGroupNV); + System.err.println("initSwapGroupImpl: "+GLXExtensions.GLX_NV_swap_group+": "+hasSwapGroupNV); } } return hasSwapGroupNV; diff --git a/src/test-native/contextRetargetDrawable01.c b/src/test-native/contextRetargetDrawable01.c new file mode 100644 index 000000000..bad6c661f --- /dev/null +++ b/src/test-native/contextRetargetDrawable01.c @@ -0,0 +1,154 @@ +/** + * compile with: gcc -o contextRetargetDrawable01 contextRetargetDrawable01.c -lX11 -lGL + */ + +#include <stdio.h> +#include <unistd.h> +#include <X11/X.h> +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#include <GL/glx.h> +#include <GL/gl.h> + +static PFNGLXSWAPINTERVALSGIPROC _glXSwapIntervalSGI = NULL; + +static void testRetarget(); + +static const char * msg = "contextRetargetDrawable01"; + +static const useconds_t demodelay = 2 * 1000 * 1000; + +int main(int nargs, char **vargs) { + _glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC) glXGetProcAddressARB("glXSwapIntervalSGI"); + if(NULL == _glXSwapIntervalSGI) { + fprintf(stderr, "No glXSwapIntervalSGI avail, bail out\n"); + return 1; + } + testRetarget(); + return 0; +} + +static void createGLWin(Display *dpy, int width, int height, Window *rWin, GLXContext *rCtx); +static void useGL(Display *dpy, Window win, GLXContext ctx, int width, int height, float c, int swapInterval); + +static void testRetarget() { + int major, minor; + Display *disp1; + Window win1; + GLXContext ctx1; + + Display *disp2; + Window win2; + GLXContext ctx2; + + fprintf(stderr, "%s: Create #1\n", msg); + disp1 = XOpenDisplay(NULL); + createGLWin(disp1, 200, 200, &win1, &ctx1); + + fprintf(stderr, "%s: Create #2\n", msg); + disp2 = disp1; + // disp2 = XOpenDisplay(NULL); + createGLWin(disp2, 300, 300, &win2, &ctx2); + + fprintf(stderr, "%s: Use #1.1\n", msg); + useGL(disp1, win1, ctx1, 200, 200, 0.0f, 1); // OK + + fprintf(stderr, "%s: Use #1.2\n", msg); + useGL(disp2, win2, ctx2, 300, 300, 1.0f, 1); // OK + + usleep( demodelay ); + + fprintf(stderr, "%s: Retarget Drawable\n", msg); + { + Window _win = win2; + win2 = win1; + win1 = _win; + } + + fprintf(stderr, "%s: Use #2.1\n", msg); + useGL(disp1, win1, ctx1, 200, 200, 0.0f, 0); // no setSwapInterval - OK + + fprintf(stderr, "%s: Use #2.2\n", msg); + useGL(disp2, win2, ctx2, 300, 300, 1.0f, 0); // no setSwapInterval - OK + + usleep( demodelay ); + + fprintf(stderr, "%s: Use #3.1\n", msg); + useGL(disp1, win1, ctx1, 200, 200, 0.1f, 1); // setSwapInterval - crash on Mesa 8.0.4 DRI2 + + fprintf(stderr, "%s: Use #3.2\n", msg); + useGL(disp2, win2, ctx2, 300, 300, 0.9f, 1); // setSwapInterval - crash on Mesa 8.0.4 DRI2 + + fprintf(stderr, "%s: Success - no bug\n", msg); + + usleep( demodelay ); + + fprintf(stderr, "%s: Destroy #1.0\n", msg); + glXMakeContextCurrent(disp1, 0, 0, 0); + glXDestroyContext(disp1, ctx1); + if( disp1 != disp2 ) { + XCloseDisplay(disp1); + } + fprintf(stderr, "%s: Destroy #1.X\n", msg); + + fprintf(stderr, "%s: Destroy #2.0\n", msg); + glXMakeContextCurrent(disp2, 0, 0, 0); + glXDestroyContext(disp2, ctx2); + XCloseDisplay(disp2); + fprintf(stderr, "%s: Destroy #2.X\n", msg); + + fprintf(stderr, "%s: Exit - OK\n", msg); +} + +static void useGL(Display *dpy, Window win, GLXContext ctx, int width, int height, float c, int swapInterval) +{ + glXMakeContextCurrent(dpy, win, win, ctx); + glViewport(0, 0, width, height); + if(0 < swapInterval) { + fprintf(stderr, "%s: glXSwapIntervalSGI(1)\n", msg); + _glXSwapIntervalSGI(1); // offending op after retargeting drawable + } + fprintf(stderr, "GL_VENDOR: %s\n", glGetString(GL_VENDOR)); + fprintf(stderr, "GL_VERSION: %s\n", glGetString(GL_VERSION)); + fprintf(stderr, "GL_RENDERER: %s\n", glGetString(GL_RENDERER)); + glClearColor(c, c, c, 0.0f); + glClearDepth(1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glXSwapBuffers(dpy, win); + glXMakeContextCurrent(dpy, 0, 0, 0); +} + +/* attributes for a double buffered visual in RGBA format with at least + * 4 bits per color and a 16 bit depth buffer */ +static int attrListDbl[] = { GLX_RGBA, GLX_DOUBLEBUFFER, + GLX_RED_SIZE, 4, + GLX_GREEN_SIZE, 4, + GLX_BLUE_SIZE, 4, + GLX_DEPTH_SIZE, 16, + None }; + +static void createGLWin(Display *dpy, int width, int height, Window *rWin, GLXContext *rCtx) +{ + int screen = DefaultScreen(dpy); + XVisualInfo *vi = glXChooseVisual(dpy, screen, attrListDbl); + Colormap cmap; + XSetWindowAttributes attr; + + /* create a GLX context */ + *rCtx = glXCreateContext(dpy, vi, 0, GL_TRUE); + + /* create a color map */ + cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen), vi->visual, AllocNone); + attr.colormap = cmap; + attr.border_pixel = 0; + + /* create a window in window mode*/ + attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask | + StructureNotifyMask; + *rWin = XCreateWindow(dpy, RootWindow(dpy, vi->screen), + 0, 0, width, height, 0, vi->depth, InputOutput, vi->visual, + CWBorderPixel | CWColormap | CWEventMask, &attr); + + XMapRaised(dpy, *rWin); +} + diff --git a/src/test-native/contextRetargetDrawable02.c b/src/test-native/contextRetargetDrawable02.c new file mode 100644 index 000000000..3d0807b78 --- /dev/null +++ b/src/test-native/contextRetargetDrawable02.c @@ -0,0 +1,382 @@ +/** + * compile with: gcc -o contextRetargetDrawable02 contextRetargetDrawable02.c -lX11 -lGL + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <errno.h> +#include <X11/X.h> +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#include <GL/glx.h> +#include <GL/gl.h> + +typedef int bool; +#define true 1 +#define false 0 + +static PFNGLXSWAPINTERVALSGIPROC _glXSwapIntervalSGI = NULL; + +static void testRetarget(bool reverse); + +static const char * msg = "contextRetargetDrawable01"; + +static const useconds_t demodelay = 2 * 1000 * 1000; + +int main(int nargs, char **vargs) { + _glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC) glXGetProcAddressARB("glXSwapIntervalSGI"); + if(NULL == _glXSwapIntervalSGI) { + fprintf(stderr, "No glXSwapIntervalSGI avail, bail out\n"); + return 1; + } + testRetarget(false); + return 0; +} + +static void createGLWin(Display *dpy, int width, int height, Window *rWin, GLXContext *rCtx); +static void useGL(Display *dpy, Window win, GLXContext ctx, int width, int height, float c, int swapInterval); + +static void testRetarget(bool reverse) { + int major, minor; + Display *disp1; + Window win1; + GLXContext ctx1; + + Display *disp2; + Window win2; + GLXContext ctx2; + + fprintf(stderr, "%s: Create #1\n", msg); + disp1 = XOpenDisplay(NULL); + createGLWin(disp1, 200, 200, &win1, &ctx1); + + fprintf(stderr, "%s: Create #2\n", msg); + disp2 = disp1; + // disp2 = XOpenDisplay(NULL); + createGLWin(disp2, 300, 300, &win2, &ctx2); + + fprintf(stderr, "%s: Use #1.1\n", msg); + useGL(disp1, win1, ctx1, 200, 200, 0.0f, 1); // OK + + fprintf(stderr, "%s: Use #1.2\n", msg); + useGL(disp2, win2, ctx2, 300, 300, 1.0f, 1); // OK + + usleep( demodelay ); + + fprintf(stderr, "%s: Retarget Drawable\n", msg); + { + GLXContext _ctx = ctx2; + ctx2 = ctx1; + ctx1 = _ctx; + } + + /** + if(reverse) { + fprintf(stderr, "%s: Use #2.2\n", msg); + useGL(disp2, win2, ctx2, 300, 300, 1.0f, 0); // no setSwapInterval - OK + + fprintf(stderr, "%s: Use #2.1\n", msg); + useGL(disp1, win1, ctx1, 200, 200, 0.0f, 0); // no setSwapInterval - OK + } else { + fprintf(stderr, "%s: Use #2.1\n", msg); + useGL(disp1, win1, ctx1, 200, 200, 0.0f, 0); // no setSwapInterval - OK + + fprintf(stderr, "%s: Use #2.2\n", msg); + useGL(disp2, win2, ctx2, 300, 300, 1.0f, 0); // no setSwapInterval - OK + } + usleep( demodelay ); */ + + if(reverse) { + fprintf(stderr, "%s: Use #3.2\n", msg); + useGL(disp2, win2, ctx2, 300, 300, 0.9f, 1); // setSwapInterval - crash on Mesa 8.0.4 DRI2 + + fprintf(stderr, "%s: Use #3.1\n", msg); + useGL(disp1, win1, ctx1, 200, 200, 0.1f, 1); // setSwapInterval - crash on Mesa 8.0.4 DRI2 + } else { + fprintf(stderr, "%s: Use #3.1\n", msg); + useGL(disp1, win1, ctx1, 200, 200, 0.1f, 1); // setSwapInterval - crash on Mesa 8.0.4 DRI2 + + fprintf(stderr, "%s: Use #3.2\n", msg); + useGL(disp2, win2, ctx2, 300, 300, 0.9f, 1); // setSwapInterval - crash on Mesa 8.0.4 DRI2 + } + fprintf(stderr, "%s: Success - no bug\n", msg); + usleep( demodelay ); + + fprintf(stderr, "%s: Destroy #1.0\n", msg); + glXMakeContextCurrent(disp1, 0, 0, 0); + glXDestroyContext(disp1, ctx1); + if( disp1 != disp2 ) { + XCloseDisplay(disp1); + } + fprintf(stderr, "%s: Destroy #1.X\n", msg); + + fprintf(stderr, "%s: Destroy #2.0\n", msg); + glXMakeContextCurrent(disp2, 0, 0, 0); + glXDestroyContext(disp2, ctx2); + XCloseDisplay(disp2); + fprintf(stderr, "%s: Destroy #2.X\n", msg); + + fprintf(stderr, "%s: Exit - OK\n", msg); +} + +static void useGL(Display *dpy, Window win, GLXContext ctx, int width, int height, float c, int swapInterval) +{ + glXMakeContextCurrent(dpy, win, win, ctx); + glViewport(0, 0, width, height); + if(0 < swapInterval) { + fprintf(stderr, "%s: glXSwapIntervalSGI(1)\n", msg); + _glXSwapIntervalSGI(1); // offending op after retargeting drawable + } + fprintf(stderr, "GL_VENDOR: %s\n", glGetString(GL_VENDOR)); + fprintf(stderr, "GL_VERSION: %s\n", glGetString(GL_VERSION)); + fprintf(stderr, "GL_RENDERER: %s\n", glGetString(GL_RENDERER)); + glClearColor(c, c, c, 0.0f); + glClearDepth(1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glXSwapBuffers(dpy, win); + glXMakeContextCurrent(dpy, 0, 0, 0); +} + +static volatile bool ctxErrorOccurred = false; +static int ctxErrorHandler( Display *dpy, XErrorEvent *e ) +{ + const char * errnoStr = strerror(errno); + char errCodeStr[80]; + char reqCodeStr[80]; + + snprintf(errCodeStr, sizeof(errCodeStr), "%d", e->request_code); + XGetErrorDatabaseText(dpy, "XRequest", errCodeStr, "Unknown", reqCodeStr, sizeof(reqCodeStr)); + XGetErrorText(dpy, e->error_code, errCodeStr, sizeof(errCodeStr)); + + fprintf(stderr, "X11 Error: %d - %s, dpy %p, id %x, # %d: %d:%d %s\n", + e->error_code, errCodeStr, e->display, (int)e->resourceid, (int)e->serial, + (int)e->request_code, (int)e->minor_code, reqCodeStr); + fflush(stderr); + + ctxErrorOccurred = true; + return 0; +} + +/* attributes for a double buffered visual in RGBA format with at least + * 8 bits per color and a 16 bit depth buffer */ +static int visual_attribs[] = { + GLX_X_RENDERABLE , True, + GLX_DRAWABLE_TYPE , GLX_WINDOW_BIT, + GLX_RENDER_TYPE , GLX_RGBA_BIT, + GLX_RED_SIZE , 8, + GLX_GREEN_SIZE , 8, + GLX_BLUE_SIZE , 8, + GLX_DEPTH_SIZE , 16, + GLX_DOUBLEBUFFER , True, + GLX_STEREO , False, + GLX_TRANSPARENT_TYPE, GLX_NONE, + //GLX_SAMPLE_BUFFERS , 1, + //GLX_SAMPLES , 4, + None }; + +static int context_attribs[] = { + GLX_CONTEXT_MAJOR_VERSION_ARB, 3, + GLX_CONTEXT_MINOR_VERSION_ARB, 0, + GLX_RENDER_TYPE , GLX_RGBA_TYPE, + GLX_CONTEXT_FLAGS_ARB , 0, + // GLX_CONTEXT_FLAGS_ARB , GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, + // GLX_CONTEXT_PROFILE_MASK_ARB , GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, + None }; + +static bool isExtensionSupported(const char *extList, const char *extension); + +static void createGLWin(Display *dpy, int width, int height, Window *rWin, GLXContext *rCtx) +{ + int glx_major, glx_minor; + + // FBConfigs were added in GLX version 1.3. + if ( !glXQueryVersion( dpy, &glx_major, &glx_minor ) || + ( ( glx_major == 1 ) && ( glx_minor < 3 ) ) || ( glx_major < 1 ) ) + { + printf( "Invalid GLX version" ); + exit(1); + } + + int fbcount; + GLXFBConfig *fbc = glXChooseFBConfig( dpy, DefaultScreen( dpy ), + visual_attribs, &fbcount ); + if ( !fbc || 0 == fbcount ) + { + printf( "Failed to retrieve a framebuffer config\n" ); + exit(1); + } + printf( "Found %d matching FB configs.\n", fbcount ); + + GLXFBConfig bestFbc = fbc[ 0 ]; + int bestFbcID = 0; + if( 0 != glXGetFBConfigAttrib( dpy, bestFbc, GLX_FBCONFIG_ID, &bestFbcID ) ) { + printf( "Invalid FBConfigID\n" ); + exit(1); + } + printf( "Chosen FBConfigID = 0x%x\n", bestFbcID); + + XVisualInfo *vi = glXGetVisualFromFBConfig( dpy, bestFbc ); + printf( "Chosen visual ID = 0x%x\n", (int) vi->visualid ); + + XSetWindowAttributes swa; + Colormap cmap; + swa.colormap = cmap = XCreateColormap( dpy, + RootWindow( dpy, vi->screen ), + vi->visual, AllocNone ); + swa.background_pixmap = None ; + swa.border_pixel = 0; + swa.event_mask = StructureNotifyMask; + + printf( "Creating window\n" ); + Window win = XCreateWindow( dpy, RootWindow( dpy, vi->screen ), + 0, 0, width, height, 0, vi->depth, InputOutput, + vi->visual, + CWBorderPixel|CWColormap|CWEventMask, &swa ); + if ( !win ) + { + printf( "Failed to create window.\n" ); + exit(1); + } + + // Done with the visual info data + XFree( vi ); + + XStoreName( dpy, win, "GL Window" ); + + XMapWindow( dpy, win ); + + *rWin = win; + + GLXContext ctx0 = glXCreateNewContext( dpy, bestFbc, GLX_RGBA_TYPE, 0, True ); + if( !ctx0 ) { + printf( "Failed to create intermediate old OpenGL context\n" ); + exit(1); + } + glXMakeContextCurrent(dpy, win, win, ctx0); + + + // Get the default screen's GLX extension list + const char *glxExts01 = glXQueryExtensionsString( dpy, + DefaultScreen( dpy ) ); + const char *glxExts02 = glXGetClientString( dpy, GLX_EXTENSIONS); + const char *glxExts03 = glXQueryServerString( dpy, DefaultScreen( dpy ), GLX_EXTENSIONS); + + // NOTE: It is not necessary to create or make current to a context before + // calling glXGetProcAddressARB + PFNGLXCREATECONTEXTATTRIBSARBPROC _glXCreateContextAttribsARB = 0; + _glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC) + glXGetProcAddressARB( (const GLubyte *) "glXCreateContextAttribsARB" ); + + // Check for the GLX_ARB_create_context extension string and the function. + // If either is not present, use GLX 1.3 context creation method. + bool isGLX_ARB_create_contextAvail = isExtensionSupported( glxExts01, "GLX_ARB_create_context" ) || + isExtensionSupported( glxExts02, "GLX_ARB_create_context" ) || + isExtensionSupported( glxExts03, "GLX_ARB_create_context" ); + + glXMakeContextCurrent(dpy, 0, 0, 0); + + GLXContext ctx = 0; + + // Install an X error handler so the application won't exit if GL 3.0 + // context allocation fails. + // + // Note this error handler is global. All display connections in all threads + // of a process use the same error handler, so be sure to guard against other + // threads issuing X commands while this code is running. + int (*oldHandler)(Display*, XErrorEvent*) = + XSetErrorHandler(&ctxErrorHandler); + + if ( !isGLX_ARB_create_contextAvail || !_glXCreateContextAttribsARB ) + { + printf( "glXCreateContextAttribsARB() not found (ext %d, func %p)" + " ... using old-style GLX context\n", isGLX_ARB_create_contextAvail, _glXCreateContextAttribsARB ); + printf( "extensions 01: %s\n", glxExts01); + printf( "extensions 02: %s\n", glxExts02); + printf( "extensions 03: %s\n", glxExts03); + ctx = ctx0; + } + + // If it does, try to get a GL 3.0 context! + else + { + printf( "Creating context\n" ); + XSync( dpy, False ); + ctxErrorOccurred = false; + ctx = _glXCreateContextAttribsARB( dpy, bestFbc, 0, True, context_attribs ); + XSync( dpy, False ); + + if ( !ctxErrorOccurred && ctx ) { + printf( "Created GL 3.0 context\n" ); + glXDestroyContext(dpy, ctx0); // get rid of old ctx + } else + { + // Couldn't create GL 3.0 context. Fall back to old-style 2.x context. + // When a context version below 3.0 is requested, implementations will + // return the newest context version compatible with OpenGL versions less + // than version 3.0. + // GLX_CONTEXT_MAJOR_VERSION_ARB = 1 + context_attribs[1] = 1; + // GLX_CONTEXT_MINOR_VERSION_ARB = 0 + context_attribs[3] = 0; + + printf( "Failed to create GL 3.0 context (err %d, ctx %p)" + " ... using old-style GLX context\n", ctxErrorOccurred, (void*)ctx ); + ctx = ctx0; + + ctxErrorOccurred = false; + } + } + + // Sync to ensure any errors generated are processed. + XSync( dpy, False ); + + // Restore the original error handler + XSetErrorHandler( oldHandler ); + + if ( ctxErrorOccurred || !ctx ) + { + printf( "Failed to create an OpenGL context\n" ); + exit(1); + } + + XFree( fbc ); + + *rCtx = ctx; +} + +// Helper to check for extension string presence. Adapted from: +// http://www.opengl.org/resources/features/OGLextensions/ +static bool isExtensionSupported(const char *extList, const char *extension) +{ + + const char *start; + const char *where, *terminator; + + /* Extension names should not have spaces. */ + where = strchr(extension, ' '); + if ( where || *extension == '\0' ) + return false; + + /* It takes a bit of care to be fool-proof about parsing the + OpenGL extensions string. Don't be fooled by sub-strings, + etc. */ + for ( start = extList; ; ) { + where = strstr( start, extension ); + + if ( !where ) + break; + + terminator = where + strlen( extension ); + + if ( where == start || *(where - 1) == ' ' ) + if ( *terminator == ' ' || *terminator == '\0' ) + return true; + + start = terminator; + } + + return false; +} + diff --git a/src/test-native/glExtensionsListGL2.c b/src/test-native/glExtensionsListGL2.c index 89815e9c0..ea47b8c69 100644 --- a/src/test-native/glExtensionsListGL2.c +++ b/src/test-native/glExtensionsListGL2.c @@ -77,6 +77,8 @@ void useGL(Display *dpy, Window win, GLXContext ctx, int width, int height) glXMakeCurrent(dpy, win, ctx); fprintf(stderr, "GL_VENDOR: %s\n", glGetString(GL_VENDOR)); + fprintf(stderr, "GL_VERSION: %s\n", glGetString(GL_VERSION)); + fprintf(stderr, "GL_RENDERER: %s\n", glGetString(GL_RENDERER)); glGetIntegerv(GL_NUM_EXTENSIONS, &n); fprintf(stderr, "GL_NUM_EXTENSIONS: %d\n", n); diff --git a/src/test-native/glExtensionsListGL3.c b/src/test-native/glExtensionsListGL3.c index c531577e8..5875c10bc 100644 --- a/src/test-native/glExtensionsListGL3.c +++ b/src/test-native/glExtensionsListGL3.c @@ -59,6 +59,8 @@ void dumpGLExtension() { int i, n; fprintf(stderr, "GL_VENDOR: %s\n", glGetString(GL_VENDOR)); + fprintf(stderr, "GL_VERSION: %s\n", glGetString(GL_VERSION)); + fprintf(stderr, "GL_RENDERER: %s\n", glGetString(GL_RENDERER)); glGetIntegerv(GL_NUM_EXTENSIONS, &n); fprintf(stderr, "GL_NUM_EXTENSIONS: %d\n", n); @@ -153,9 +155,6 @@ int main (int argc, char ** argv) GLXFBConfig bestFbc = fbc[ best_fbc ]; - // Be sure to free the FBConfig list allocated by glXChooseFBConfig() - XFree( fbc ); - // Get a visual XVisualInfo *vi = glXGetVisualFromFBConfig( display, bestFbc ); printf( "Chosen visual ID = 0x%x\n", (int) vi->visualid ); @@ -190,8 +189,9 @@ int main (int argc, char ** argv) XMapWindow( display, win ); // Get the default screen's GLX extension list - const char *glxExts = glXQueryExtensionsString( display, - DefaultScreen( display ) ); + const char *glxExts01 = glXQueryExtensionsString( display, DefaultScreen( display ) ); + const char *glxExts02 = glXGetClientString( display, GLX_EXTENSIONS); + const char *glxExts03 = glXQueryServerString( display, DefaultScreen( display ), GLX_EXTENSIONS); // NOTE: It is not necessary to create or make current to a context before // calling glXGetProcAddressARB @@ -213,11 +213,16 @@ int main (int argc, char ** argv) // Check for the GLX_ARB_create_context extension string and the function. // If either is not present, use GLX 1.3 context creation method. - if ( !isExtensionSupported( glxExts, "GLX_ARB_create_context" ) || - !glXCreateContextAttribsARB ) + bool isGLX_ARB_create_contextAvail = isExtensionSupported( glxExts01, "GLX_ARB_create_context" ) || + isExtensionSupported( glxExts02, "GLX_ARB_create_context" ) || + isExtensionSupported( glxExts03, "GLX_ARB_create_context" ); + if ( !isGLX_ARB_create_contextAvail || !glXCreateContextAttribsARB ) { printf( "glXCreateContextAttribsARB() not found" " ... using old-style GLX context\n" ); + printf( "extensions 01: %s\n", glxExts01); + printf( "extensions 02: %s\n", glxExts02); + printf( "extensions 03: %s\n", glxExts03); ctx = glXCreateNewContext( display, bestFbc, GLX_RGBA_TYPE, 0, True ); } @@ -229,7 +234,8 @@ int main (int argc, char ** argv) GLX_CONTEXT_MAJOR_VERSION_ARB, 3, GLX_CONTEXT_MINOR_VERSION_ARB, 0, GLX_RENDER_TYPE , GLX_RGBA_TYPE, - GLX_CONTEXT_FLAGS_ARB , GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, + // GLX_CONTEXT_FLAGS_ARB , GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, + // GLX_CONTEXT_PROFILE_MASK_ARB , GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB None }; @@ -261,6 +267,9 @@ int main (int argc, char ** argv) } } + // Be sure to free the FBConfig list allocated by glXChooseFBConfig() + XFree( fbc ); + // Sync to ensure any errors generated are processed. XSync( display, False ); diff --git a/src/test-native/make.sh b/src/test-native/make.sh index 20bd49e4a..269f09c35 100755 --- a/src/test-native/make.sh +++ b/src/test-native/make.sh @@ -4,3 +4,5 @@ gcc -o displayMultiple01 displayMultiple01.c -lX11 -lGL gcc -o displayMultiple02 displayMultiple02.c -lX11 -lGL gcc -o glExtensionsListGL2 glExtensionsListGL2.c -lX11 -lGL gcc -o glExtensionsListGL3 glExtensionsListGL3.c -lX11 -lGL +gcc -o contextRetargetDrawable01 contextRetargetDrawable01.c -lX11 -lGL +gcc -o contextRetargetDrawable02 contextRetargetDrawable02.c -lX11 -lGL diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/GearsES2.java b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/GearsES2.java index d991e7635..47feb60e2 100644 --- a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/GearsES2.java +++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/GearsES2.java @@ -194,7 +194,8 @@ public class GearsES2 implements GLEventListener { } public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) { - System.err.println(Thread.currentThread()+" GearsES2.reshape "+x+"/"+y+" "+width+"x"+height+", swapInterval "+swapInterval); + System.err.println(Thread.currentThread()+" GearsES2.reshape "+x+"/"+y+" "+width+"x"+height+", swapInterval "+swapInterval+", drawable 0x"+Long.toHexString(drawable.getHandle())); + // Thread.dumpStack(); GL2ES2 gl = drawable.getGL().getGL2ES2(); if(-1 != swapInterval) { diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/RedSquareES2.java b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/RedSquareES2.java index 9629d2102..fea1d752e 100644 --- a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/RedSquareES2.java +++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/RedSquareES2.java @@ -160,7 +160,8 @@ public class RedSquareES2 implements GLEventListener { } public void reshape(GLAutoDrawable glad, int x, int y, int width, int height) { - System.err.println(Thread.currentThread()+" RedSquareES2.reshape "+x+"/"+y+" "+width+"x"+height+", swapInterval "+swapInterval); + System.err.println(Thread.currentThread()+" RedSquareES2.reshape "+x+"/"+y+" "+width+"x"+height+", swapInterval "+swapInterval+", drawable 0x"+Long.toHexString(glad.getHandle())); + // Thread.dumpStack(); GL2ES2 gl = glad.getGL().getGL2ES2(); if(-1 != swapInterval) { |