X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=progs%2Fxdemos%2Fpbutil.c;h=ce133d012dc6193de7b82dc4d676065e6c3d1715;hb=3673189326e348eb91e354017703fdfd9d6d8184;hp=0dd4b409f4ae00583a9ed59d950b2f900d22f425;hpb=18a949000cee8f8e63b633b628bbdbc8196fe7de;p=mesa.git diff --git a/progs/xdemos/pbutil.c b/progs/xdemos/pbutil.c index 0dd4b409f4a..ce133d012dc 100644 --- a/progs/xdemos/pbutil.c +++ b/progs/xdemos/pbutil.c @@ -3,61 +3,191 @@ * OpenGL pbuffers utility functions. * * Brian Paul - * April 1997 + * 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 #include #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. + * 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) - char *extensions; + if (fbcSupport == 2) { + return glXChooseFBConfigSGIX(dpy, screen, (int *) attribs, nConfigs); + } +#endif + return NULL; +} + - extensions = (char *) glXQueryServerString(dpy, screen, GLX_EXTENSIONS); - if (!strstr(extensions,"GLX_SGIX_fbconfig")) { - return 0; +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); } - if (!strstr(extensions,"GLX_SGIX_pbuffer")) { - return 0; +#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); } - return 1; -#else - return 0; #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; +} -#ifdef GLX_SGIX_fbconfig +/** + * 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, GLXFBConfigSGIX fbConfig, Bool horizFormat) +PrintFBConfigInfo(Display *dpy, int screen, FBCONFIG config, Bool horizFormat) { - int pbAttribs[] = {GLX_LARGEST_PBUFFER_SGIX, True, - GLX_PRESERVED_CONTENTS_SGIX, False, - None}; - GLXPbufferSGIX pBuffer; + PBUFFER pBuffer; int width=2, height=2; int bufferSize, level, doubleBuffer, stereo, auxBuffers; int redSize, greenSize, blueSize, alphaSize; @@ -67,47 +197,52 @@ PrintFBConfigInfo(Display *dpy, GLXFBConfigSGIX fbConfig, Bool horizFormat) int drawableType, renderType, xRenderable, xVisual, id; int maxWidth, maxHeight, maxPixels; int optWidth, optHeight; + int floatComponents = 0; - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_BUFFER_SIZE, &bufferSize); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_LEVEL, &level); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_DOUBLEBUFFER, &doubleBuffer); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_STEREO, &stereo); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_AUX_BUFFERS, &auxBuffers); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_RED_SIZE, &redSize); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_GREEN_SIZE, &greenSize); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_BLUE_SIZE, &blueSize); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_ALPHA_SIZE, &alphaSize); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_DEPTH_SIZE, &depthSize); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_STENCIL_SIZE, &stencilSize); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_ACCUM_RED_SIZE, &accumRedSize); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_ACCUM_GREEN_SIZE, &accumGreenSize); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_ACCUM_BLUE_SIZE, &accumBlueSize); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_ACCUM_ALPHA_SIZE, &accumAlphaSize); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_SAMPLE_BUFFERS_SGIS, &sampleBuffers); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_SAMPLES_SGIS, &samples); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_DRAWABLE_TYPE_SGIX, &drawableType); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_RENDER_TYPE_SGIX, &renderType); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_X_RENDERABLE_SGIX, &xRenderable); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_X_VISUAL_TYPE_EXT, &xVisual); + /* 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; - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_FBCONFIG_ID_SGIX, &id); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_MAX_PBUFFER_WIDTH_SGIX, - &maxWidth); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_MAX_PBUFFER_HEIGHT_SGIX, - &maxHeight); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_MAX_PBUFFER_PIXELS_SGIX, - &maxPixels); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_OPTIMAL_PBUFFER_WIDTH_SGIX, - &optWidth); - glXGetFBConfigAttribSGIX(dpy, fbConfig, GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX, - &optHeight); + 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 - pBuffer = CreatePbuffer(dpy, fbConfig, width, height, pbAttribs); + /* See if we can create a pbuffer with this config */ + pBuffer = CreatePbuffer(dpy, screen, config, width, height, False, False); if (horizFormat) { - printf("0x%03x ", id); + 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 "); @@ -116,16 +251,17 @@ PrintFBConfigInfo(Display *dpy, GLXFBConfigSGIX fbConfig, Bool horizFormat) 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" : "n", - (renderType & GLX_COLOR_INDEX_BIT_SGIX) ? "y" : "n", - doubleBuffer ? "y" : "n", - stereo ? "y" : "n"); + (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", pBuffer ? "y" : "n"); + printf(" %s %c", pBuffer ? "y" : ".", + ".y"[floatComponents]); printf("\n"); } else { @@ -148,70 +284,140 @@ PrintFBConfigInfo(Display *dpy, GLXFBConfigSGIX fbConfig, Bool horizFormat) printf(" Sample Buffers: %d\n", sampleBuffers); printf(" Samples/Pixel: %d\n", samples); printf(" Drawable Types: "); - if (drawableType & GLX_WINDOW_BIT_SGIX) printf("Window "); - if (drawableType & GLX_PIXMAP_BIT_SGIX) printf("Pixmap "); - if (drawableType & GLX_PBUFFER_BIT_SGIX) printf("PBuffer"); + 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(" Max width: %d\n", maxWidth); - printf(" Max height: %d\n", maxHeight); - printf(" Max pixels: %d\n", maxPixels); - printf(" Optimum width: %d\n", optWidth); - printf(" Optimum height: %d\n", optHeight); - */ + 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) { - glXDestroyGLXPbufferSGIX(dpy, 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 ) +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 pixel buffer attributes as used by - * glXCreateGLXPbufferSGIX(). - * Return: a pixel buffer or None. + * pbAttribs - list of optional pixel buffer attributes + * Return: a Pbuffer or None. */ -GLXPbufferSGIX -CreatePbuffer( Display *dpy, GLXFBConfigSGIX fbConfig, - int width, int height, int *pbAttribs ) +PBUFFER +CreatePbuffer(Display *dpy, int screen, FBCONFIG config, + int width, int height, Bool largest, Bool preserve) { - int (*oldHandler)( Display *, XErrorEvent * ); - GLXPbufferSGIX pBuffer = None; + int (*oldHandler)(Display *, XErrorEvent *); + PBUFFER pBuffer = None; + int pbSupport = QueryPbuffers(dpy, screen); /* Catch X protocol errors with our own error handler */ - oldHandler = XSetErrorHandler( HandleXError ); - + oldHandler = XSetErrorHandler(HandleXError); XErrorFlag = 0; - pBuffer = glXCreateGLXPbufferSGIX(dpy, fbConfig, width, height, pbAttribs); +#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 ); + (void) XSetErrorHandler(oldHandler); /* Return pbuffer (may be None) */ - if (!XErrorFlag && pBuffer!=None) { + if (!XErrorFlag && pBuffer != None) { /*printf("config %d worked!\n", i);*/ return pBuffer; } @@ -221,7 +427,20 @@ CreatePbuffer( Display *dpy, GLXFBConfigSGIX fbConfig, } - -#endif /*GLX_SGIX_fbconfig*/ - - +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 +}