| |
| /* |
| * OpenGL pbuffers utility functions. |
| * |
| * Brian Paul |
| * Original code: April 1997 |
| * Updated on 5 October 2002 |
| * Updated again on 3 January 2005 to use GLX 1.3 functions in preference |
| * to the GLX_SGIX_fbconfig/pbuffer extensions. |
| */ |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include "pbutil.h" |
| |
| |
| /** |
| * Test if we pixel buffers are available for a particular X screen. |
| * Input: dpy - the X display |
| * screen - screen number |
| * Return: 0 = fbconfigs not available. |
| * 1 = fbconfigs are available via GLX 1.3. |
| * 2 = fbconfigs and pbuffers are available via GLX_SGIX_fbconfig |
| */ |
| int |
| QueryFBConfig(Display *dpy, int screen) |
| { |
| #if defined(GLX_VERSION_1_3) |
| { |
| /* GLX 1.3 supports pbuffers */ |
| int glxVersionMajor, glxVersionMinor; |
| if (!glXQueryVersion(dpy, &glxVersionMajor, &glxVersionMinor)) { |
| /* GLX not available! */ |
| return 0; |
| } |
| if (glxVersionMajor * 100 + glxVersionMinor >= 103) { |
| return 1; |
| } |
| /* fall-through */ |
| } |
| #endif |
| |
| /* Try the SGIX extensions */ |
| { |
| char *extensions; |
| extensions = (char *) glXQueryServerString(dpy, screen, GLX_EXTENSIONS); |
| if (extensions && strstr(extensions,"GLX_SGIX_fbconfig")) { |
| return 2; |
| } |
| } |
| |
| return 0; |
| } |
| |
| /** |
| * Test if we pixel buffers are available for a particular X screen. |
| * Input: dpy - the X display |
| * screen - screen number |
| * Return: 0 = pixel buffers not available. |
| * 1 = pixel buffers are available via GLX 1.3. |
| * 2 = pixel buffers are available via GLX_SGIX_fbconfig/pbuffer. |
| */ |
| int |
| QueryPbuffers(Display *dpy, int screen) |
| { |
| int ret; |
| |
| ret = QueryFBConfig(dpy, screen); |
| if (ret == 2) { |
| char *extensions; |
| extensions = (char *) glXQueryServerString(dpy, screen, GLX_EXTENSIONS); |
| if (extensions && strstr(extensions, "GLX_SGIX_pbuffer")) |
| return 2; |
| else |
| return 0; |
| } |
| else |
| return ret; |
| } |
| |
| FBCONFIG * |
| ChooseFBConfig(Display *dpy, int screen, const int attribs[], int *nConfigs) |
| { |
| int fbcSupport = QueryPbuffers(dpy, screen); |
| #if defined(GLX_VERSION_1_3) |
| if (fbcSupport == 1) { |
| return glXChooseFBConfig(dpy, screen, attribs, nConfigs); |
| } |
| #endif |
| #if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer) |
| if (fbcSupport == 2) { |
| return glXChooseFBConfigSGIX(dpy, screen, (int *) attribs, nConfigs); |
| } |
| #endif |
| return NULL; |
| } |
| |
| |
| FBCONFIG * |
| GetAllFBConfigs(Display *dpy, int screen, int *nConfigs) |
| { |
| int fbcSupport = QueryFBConfig(dpy, screen); |
| #if defined(GLX_VERSION_1_3) |
| if (fbcSupport == 1) { |
| return glXGetFBConfigs(dpy, screen, nConfigs); |
| } |
| #endif |
| #if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer) |
| if (fbcSupport == 2) { |
| /* The GLX_SGIX_fbconfig extensions says to pass NULL to get list |
| * of all available configurations. |
| */ |
| return glXChooseFBConfigSGIX(dpy, screen, NULL, nConfigs); |
| } |
| #endif |
| return NULL; |
| } |
| |
| |
| XVisualInfo * |
| GetVisualFromFBConfig(Display *dpy, int screen, FBCONFIG config) |
| { |
| int fbcSupport = QueryFBConfig(dpy, screen); |
| #if defined(GLX_VERSION_1_3) |
| if (fbcSupport == 1) { |
| return glXGetVisualFromFBConfig(dpy, config); |
| } |
| #endif |
| #if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer) |
| if (fbcSupport == 2) { |
| return glXGetVisualFromFBConfigSGIX(dpy, config); |
| } |
| #endif |
| return NULL; |
| } |
| |
| |
| /** |
| * Either use glXGetFBConfigAttrib() or glXGetFBConfigAttribSGIX() |
| * to query an fbconfig attribute. |
| */ |
| static int |
| GetFBConfigAttrib(Display *dpy, int screen, |
| #if defined(GLX_VERSION_1_3) |
| const GLXFBConfig config, |
| #elif defined(GLX_SGIX_fbconfig) |
| const GLXFBConfigSGIX config, |
| #endif |
| int attrib |
| ) |
| { |
| int fbcSupport = QueryFBConfig(dpy, screen); |
| int value = 0; |
| |
| #if defined(GLX_VERSION_1_3) |
| if (fbcSupport == 1) { |
| /* ok */ |
| if (glXGetFBConfigAttrib(dpy, config, attrib, &value) != 0) { |
| value = 0; |
| } |
| return value; |
| } |
| /* fall-through */ |
| #endif |
| |
| #if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer) |
| if (fbcSupport == 2) { |
| if (glXGetFBConfigAttribSGIX(dpy, config, attrib, &value) != 0) { |
| value = 0; |
| } |
| return value; |
| } |
| #endif |
| |
| return value; |
| } |
| |
| |
| |
| /** |
| * Print parameters for a GLXFBConfig to stdout. |
| * Input: dpy - the X display |
| * screen - the X screen number |
| * fbConfig - the fbconfig handle |
| * horizFormat - if true, print in horizontal format |
| */ |
| void |
| PrintFBConfigInfo(Display *dpy, int screen, FBCONFIG config, Bool horizFormat) |
| { |
| PBUFFER pBuffer; |
| int width=2, height=2; |
| int bufferSize, level, doubleBuffer, stereo, auxBuffers; |
| int redSize, greenSize, blueSize, alphaSize; |
| int depthSize, stencilSize; |
| int accumRedSize, accumBlueSize, accumGreenSize, accumAlphaSize; |
| int sampleBuffers, samples; |
| int drawableType, renderType, xRenderable, xVisual, id; |
| int maxWidth, maxHeight, maxPixels; |
| int optWidth, optHeight; |
| int floatComponents = 0; |
| |
| /* do queries using the GLX 1.3 tokens (same as the SGIX tokens) */ |
| bufferSize = GetFBConfigAttrib(dpy, screen, config, GLX_BUFFER_SIZE); |
| level = GetFBConfigAttrib(dpy, screen, config, GLX_LEVEL); |
| doubleBuffer = GetFBConfigAttrib(dpy, screen, config, GLX_DOUBLEBUFFER); |
| stereo = GetFBConfigAttrib(dpy, screen, config, GLX_STEREO); |
| auxBuffers = GetFBConfigAttrib(dpy, screen, config, GLX_AUX_BUFFERS); |
| redSize = GetFBConfigAttrib(dpy, screen, config, GLX_RED_SIZE); |
| greenSize = GetFBConfigAttrib(dpy, screen, config, GLX_GREEN_SIZE); |
| blueSize = GetFBConfigAttrib(dpy, screen, config, GLX_BLUE_SIZE); |
| alphaSize = GetFBConfigAttrib(dpy, screen, config, GLX_ALPHA_SIZE); |
| depthSize = GetFBConfigAttrib(dpy, screen, config, GLX_DEPTH_SIZE); |
| stencilSize = GetFBConfigAttrib(dpy, screen, config, GLX_STENCIL_SIZE); |
| accumRedSize = GetFBConfigAttrib(dpy, screen, config, GLX_ACCUM_RED_SIZE); |
| accumGreenSize = GetFBConfigAttrib(dpy, screen, config, GLX_ACCUM_GREEN_SIZE); |
| accumBlueSize = GetFBConfigAttrib(dpy, screen, config, GLX_ACCUM_BLUE_SIZE); |
| accumAlphaSize = GetFBConfigAttrib(dpy, screen, config, GLX_ACCUM_ALPHA_SIZE); |
| sampleBuffers = GetFBConfigAttrib(dpy, screen, config, GLX_SAMPLE_BUFFERS); |
| samples = GetFBConfigAttrib(dpy, screen, config, GLX_SAMPLES); |
| drawableType = GetFBConfigAttrib(dpy, screen, config, GLX_DRAWABLE_TYPE); |
| renderType = GetFBConfigAttrib(dpy, screen, config, GLX_RENDER_TYPE); |
| xRenderable = GetFBConfigAttrib(dpy, screen, config, GLX_X_RENDERABLE); |
| xVisual = GetFBConfigAttrib(dpy, screen, config, GLX_X_VISUAL_TYPE); |
| if (!xRenderable || !(drawableType & GLX_WINDOW_BIT_SGIX)) |
| xVisual = -1; |
| |
| id = GetFBConfigAttrib(dpy, screen, config, GLX_FBCONFIG_ID); |
| maxWidth = GetFBConfigAttrib(dpy, screen, config, GLX_MAX_PBUFFER_WIDTH); |
| maxHeight = GetFBConfigAttrib(dpy, screen, config, GLX_MAX_PBUFFER_HEIGHT); |
| maxPixels = GetFBConfigAttrib(dpy, screen, config, GLX_MAX_PBUFFER_PIXELS); |
| #if defined(GLX_SGIX_pbuffer) |
| optWidth = GetFBConfigAttrib(dpy, screen, config, GLX_OPTIMAL_PBUFFER_WIDTH_SGIX); |
| optHeight = GetFBConfigAttrib(dpy, screen, config, GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX); |
| #else |
| optWidth = optHeight = 0; |
| #endif |
| #if defined(GLX_NV_float_buffer) |
| floatComponents = GetFBConfigAttrib(dpy, screen, config, GLX_FLOAT_COMPONENTS_NV); |
| #endif |
| |
| /* See if we can create a pbuffer with this config */ |
| pBuffer = CreatePbuffer(dpy, screen, config, width, height, False, False); |
| |
| if (horizFormat) { |
| printf("0x%-9x ", id); |
| if (xVisual==GLX_STATIC_GRAY) printf("StaticGray "); |
| else if (xVisual==GLX_GRAY_SCALE) printf("GrayScale "); |
| else if (xVisual==GLX_STATIC_COLOR) printf("StaticColor "); |
| else if (xVisual==GLX_PSEUDO_COLOR) printf("PseudoColor "); |
| else if (xVisual==GLX_TRUE_COLOR) printf("TrueColor "); |
| else if (xVisual==GLX_DIRECT_COLOR) printf("DirectColor "); |
| else printf(" -none- "); |
| printf(" %3d %3d %s %s %s %2s ", bufferSize, level, |
| (renderType & GLX_RGBA_BIT_SGIX) ? "y" : ".", |
| (renderType & GLX_COLOR_INDEX_BIT_SGIX) ? "y" : ".", |
| doubleBuffer ? "y" : ".", |
| stereo ? "y" : "."); |
| printf("%2d %2d %2d %2d ", redSize, greenSize, blueSize, alphaSize); |
| printf("%2d %2d ", depthSize, stencilSize); |
| printf("%2d %2d %2d %2d", accumRedSize, accumGreenSize, accumBlueSize, |
| accumAlphaSize); |
| printf(" %2d %2d", sampleBuffers, samples); |
| printf(" %s %c", pBuffer ? "y" : ".", |
| ".y"[floatComponents]); |
| printf("\n"); |
| } |
| else { |
| printf("Id 0x%x\n", id); |
| printf(" Buffer Size: %d\n", bufferSize); |
| printf(" Level: %d\n", level); |
| printf(" Double Buffer: %s\n", doubleBuffer ? "yes" : "no"); |
| printf(" Stereo: %s\n", stereo ? "yes" : "no"); |
| printf(" Aux Buffers: %d\n", auxBuffers); |
| printf(" Red Size: %d\n", redSize); |
| printf(" Green Size: %d\n", greenSize); |
| printf(" Blue Size: %d\n", blueSize); |
| printf(" Alpha Size: %d\n", alphaSize); |
| printf(" Depth Size: %d\n", depthSize); |
| printf(" Stencil Size: %d\n", stencilSize); |
| printf(" Accum Red Size: %d\n", accumRedSize); |
| printf(" Accum Green Size: %d\n", accumGreenSize); |
| printf(" Accum Blue Size: %d\n", accumBlueSize); |
| printf(" Accum Alpha Size: %d\n", accumAlphaSize); |
| printf(" Sample Buffers: %d\n", sampleBuffers); |
| printf(" Samples/Pixel: %d\n", samples); |
| printf(" Drawable Types: "); |
| if (drawableType & GLX_WINDOW_BIT) printf("Window "); |
| if (drawableType & GLX_PIXMAP_BIT) printf("Pixmap "); |
| if (drawableType & GLX_PBUFFER_BIT) printf("PBuffer"); |
| printf("\n"); |
| printf(" Render Types: "); |
| if (renderType & GLX_RGBA_BIT_SGIX) printf("RGBA "); |
| if (renderType & GLX_COLOR_INDEX_BIT_SGIX) printf("CI "); |
| printf("\n"); |
| printf(" X Renderable: %s\n", xRenderable ? "yes" : "no"); |
| |
| printf(" Pbuffer: %s\n", pBuffer ? "yes" : "no"); |
| printf(" Max Pbuffer width: %d\n", maxWidth); |
| printf(" Max Pbuffer height: %d\n", maxHeight); |
| printf(" Max Pbuffer pixels: %d\n", maxPixels); |
| printf(" Optimum Pbuffer width: %d\n", optWidth); |
| printf(" Optimum Pbuffer height: %d\n", optHeight); |
| |
| printf(" Float Components: %s\n", floatComponents ? "yes" : "no"); |
| } |
| |
| if (pBuffer) { |
| DestroyPbuffer(dpy, screen, pBuffer); |
| } |
| } |
| |
| |
| |
| GLXContext |
| CreateContext(Display *dpy, int screen, FBCONFIG config) |
| { |
| int fbcSupport = QueryFBConfig(dpy, screen); |
| #if defined(GLX_VERSION_1_3) |
| if (fbcSupport == 1) { |
| /* GLX 1.3 */ |
| GLXContext c; |
| c = glXCreateNewContext(dpy, config, GLX_RGBA_TYPE, NULL, True); |
| if (!c) { |
| /* try indirect */ |
| c = glXCreateNewContext(dpy, config, GLX_RGBA_TYPE, NULL, False); |
| } |
| return c; |
| } |
| #endif |
| #if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer) |
| if (fbcSupport == 2) { |
| GLXContext c; |
| c = glXCreateContextWithConfigSGIX(dpy, config, GLX_RGBA_TYPE_SGIX, NULL, True); |
| if (!c) { |
| c = glXCreateContextWithConfigSGIX(dpy, config, GLX_RGBA_TYPE_SGIX, NULL, False); |
| } |
| return c; |
| } |
| #endif |
| return 0; |
| } |
| |
| |
| void |
| DestroyContext(Display *dpy, GLXContext ctx) |
| { |
| glXDestroyContext(dpy, ctx); |
| } |
| |
| |
| /* This is only used by CreatePbuffer() */ |
| static int XErrorFlag = 0; |
| static int HandleXError(Display *dpy, XErrorEvent *event) |
| { |
| XErrorFlag = 1; |
| return 0; |
| } |
| |
| |
| /** |
| * Create a Pbuffer. Use an X error handler to deal with potential |
| * BadAlloc errors. |
| * |
| * Input: dpy - the X display |
| * fbConfig - an FBConfig as returned by glXChooseFBConfigSGIX(). |
| * width, height - size of pixel buffer to request, in pixels. |
| * pbAttribs - list of optional pixel buffer attributes |
| * Return: a Pbuffer or None. |
| */ |
| PBUFFER |
| CreatePbuffer(Display *dpy, int screen, FBCONFIG config, |
| int width, int height, Bool largest, Bool preserve) |
| { |
| int (*oldHandler)(Display *, XErrorEvent *); |
| PBUFFER pBuffer = None; |
| int pbSupport = QueryPbuffers(dpy, screen); |
| |
| /* Catch X protocol errors with our own error handler */ |
| oldHandler = XSetErrorHandler(HandleXError); |
| XErrorFlag = 0; |
| |
| #if defined(GLX_VERSION_1_3) |
| if (pbSupport == 1) { |
| /* GLX 1.3 */ |
| int attribs[100], i = 0; |
| attribs[i++] = GLX_PBUFFER_WIDTH; |
| attribs[i++] = width; |
| attribs[i++] = GLX_PBUFFER_HEIGHT; |
| attribs[i++] = height; |
| attribs[i++] = GLX_PRESERVED_CONTENTS; |
| attribs[i++] = preserve; |
| attribs[i++] = GLX_LARGEST_PBUFFER; |
| attribs[i++] = largest; |
| attribs[i++] = 0; |
| pBuffer = glXCreatePbuffer(dpy, config, attribs); |
| } |
| else |
| #endif |
| #if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer) |
| if (pbSupport == 2) { |
| int attribs[100], i = 0; |
| attribs[i++] = GLX_PRESERVED_CONTENTS; |
| attribs[i++] = preserve; |
| attribs[i++] = GLX_LARGEST_PBUFFER; |
| attribs[i++] = largest; |
| attribs[i++] = 0; |
| pBuffer = glXCreateGLXPbufferSGIX(dpy, config, width, height, attribs); |
| } |
| else |
| #endif |
| { |
| pBuffer = None; |
| } |
| |
| XSync(dpy, False); |
| /* Restore original X error handler */ |
| (void) XSetErrorHandler(oldHandler); |
| |
| /* Return pbuffer (may be None) */ |
| if (!XErrorFlag && pBuffer != None) { |
| /*printf("config %d worked!\n", i);*/ |
| return pBuffer; |
| } |
| else { |
| return None; |
| } |
| } |
| |
| |
| void |
| DestroyPbuffer(Display *dpy, int screen, PBUFFER pbuffer) |
| { |
| int pbSupport = QueryPbuffers(dpy, screen); |
| #if defined(GLX_VERSION_1_3) |
| if (pbSupport == 1) { |
| glXDestroyPbuffer(dpy, pbuffer); |
| return; |
| } |
| #endif |
| #if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer) |
| if (pbSupport == 2) { |
| glXDestroyGLXPbufferSGIX(dpy, pbuffer); |
| return; |
| } |
| #endif |
| } |