447 lines
14 KiB
C
447 lines
14 KiB
C
|
|
/*
|
|
* 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
|
|
}
|