static XVisualInfo *
getVisualInfoCI(unsigned int mode)
{
#if POKA
static int bufSizeList[] =
{16, 12, 8, 4, 2, 1, 0};
XVisualInfo *vi;
int list[32];
int i, n = 0;
/* Should not be looking at display mode mask if
__glutDisplayString is non-NULL. */
assert(!__glutDisplayString);
list[n++] = GLX_BUFFER_SIZE;
list[n++] = 1;
if (GLUT_WIND_IS_DOUBLE(mode)) {
list[n++] = GLX_DOUBLEBUFFER;
}
if (GLUT_WIND_IS_STEREO(mode)) {
list[n++] = GLX_STEREO;
}
if (GLUT_WIND_HAS_DEPTH(mode)) {
list[n++] = GLX_DEPTH_SIZE;
list[n++] = 1;
}
if (GLUT_WIND_HAS_STENCIL(mode)) {
list[n++] = GLX_STENCIL_SIZE;
list[n++] = 1;
}
list[n] = (int) None; /* terminate list */
/* glXChooseVisual specify GLX_BUFFER_SIZE prefers the
"smallest index buffer of at least the specified size".
This would be reasonable if GLUT allowed the user to
specify the required buffe size, but GLUT's display mode
is too simplistic (easy to use?). GLUT should try to find
the "largest". So start with a large buffer size and
shrink until we find a matching one that exists. */
for (i = 0; bufSizeList[i]; i++) {
/* XXX Assumes list[1] is where GLX_BUFFER_SIZE parameter
is. */
list[1] = bufSizeList[i];
vi = glXChooseVisual(__glutDisplay,
__glutScreen, list);
if (vi)
return vi;
}
return NULL;
#else
return
glXChooseVisual(mode);
#endif
}
static int
checkOverlayAcceptability(XVisualInfo * vi, unsigned int mode)
{
int value;
/* Must support OpenGL. */
glXGetConfig(__glutDisplay, vi, GLX_USE_GL, &value);
if (!value)
return 1;
/* Must be color index. */
glXGetConfig(__glutDisplay, vi, GLX_RGBA, &value);
if (value)
return 1;
/* Must match single/double buffering request. */
glXGetConfig(__glutDisplay, vi, GLX_DOUBLEBUFFER, &value);
if (GLUT_WIND_IS_DOUBLE(mode) != (value != 0))
return 1;
/* Must match mono/stereo request. */
glXGetConfig(__glutDisplay, vi, GLX_STEREO, &value);
if (GLUT_WIND_IS_STEREO(mode) != (value != 0))
return 1;
/* Alpha and accumulation buffers incompatible with color
index. */
if (GLUT_WIND_HAS_ALPHA(mode) || GLUT_WIND_HAS_ACCUM(mode))
return 1;
/* Look for depth buffer if requested. */
glXGetConfig(__glutDisplay, vi, GLX_DEPTH_SIZE, &value);
if (GLUT_WIND_HAS_DEPTH(mode) && (value <= 0))
return 1;
/* Look for stencil buffer if requested. */
glXGetConfig(__glutDisplay, vi, GLX_STENCIL_SIZE, &value);
if (GLUT_WIND_HAS_STENCIL(mode) && (value <= 0))
return 1;
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
/* XXX Multisampled overlay color index?? Pretty unlikely. */
/* Look for multisampling if requested. */
if (__glutIsSupportedByGLX("GLX_SGIS_multisample"))
glXGetConfig(__glutDisplay, vi, GLX_SAMPLES_SGIS, &value);
else
value = 0;
if (GLUT_WIND_IS_MULTISAMPLE(mode) && (value <= 0))
return 1;
#endif
return 0;
}
static XVisualInfo *
getVisualInfoRGB(unsigned int mode)
{
#if POKA
int list[32];
int n = 0;
/* Should not be looking at display mode mask if
__glutDisplayString is non-NULL. */
assert(!__glutDisplayString);
/* XXX Would a caching mechanism to minize the calls to
glXChooseVisual? You'd have to reference count
XVisualInfo* pointers. Would also have to properly
interact with glutInitDisplayString. */
list[n++] = GLX_RGBA;
list[n++] = GLX_RED_SIZE;
list[n++] = 1;
list[n++] = GLX_GREEN_SIZE;
list[n++] = 1;
list[n++] = GLX_BLUE_SIZE;
list[n++] = 1;
if (GLUT_WIND_HAS_ALPHA(mode)) {
list[n++] = GLX_ALPHA_SIZE;
list[n++] = 1;
}
if (GLUT_WIND_IS_DOUBLE(mode)) {
list[n++] = GLX_DOUBLEBUFFER;
}
if (GLUT_WIND_IS_STEREO(mode)) {
list[n++] = GLX_STEREO;
}
if (GLUT_WIND_HAS_DEPTH(mode)) {
list[n++] = GLX_DEPTH_SIZE;
list[n++] = 1;
}
if (GLUT_WIND_HAS_STENCIL(mode)) {
list[n++] = GLX_STENCIL_SIZE;
list[n++] = 1;
}
if (GLUT_WIND_HAS_ACCUM(mode)) {
list[n++] = GLX_ACCUM_RED_SIZE;
list[n++] = 1;
list[n++] = GLX_ACCUM_GREEN_SIZE;
list[n++] = 1;
list[n++] = GLX_ACCUM_BLUE_SIZE;
list[n++] = 1;
if (GLUT_WIND_HAS_ALPHA(mode)) {
list[n++] = GLX_ACCUM_ALPHA_SIZE;
list[n++] = 1;
}
}
#if defined(GLX_VERSION_1_1) && (defined(GLX_SGIS_multisample) || defined(GLX_ARB_multisample))
if (GLUT_WIND_IS_MULTISAMPLE(mode)) {
if (!__glutIsSupportedByGLX("GLX_SGIS_multisample") &&
!__glutIsSupportedByGLX("GLX_ARB_multisample"))
return NULL;
#if defined(GLX_ARB_multisample)
list[n++] = GLX_SAMPLES_ARB;
#elif defined(GLX_SGIS_multisample)
list[n++] = GLX_SAMPLES_SGIS;
#endif
/* XXX Is 4 a reasonable minimum acceptable number of
samples? */
list[n++] = 4;
}
#endif
list[n] = (int) None; /* terminate list */
return glXChooseVisual(__glutDisplay,
__glutScreen, list);
#else /* POKA */
return
glXChooseVisual(mode);
#endif
}
static XVisualInfo *
getVisualInfoRGB(unsigned int mode)
{
int list[32];
int n = 0;
/* Should not be looking at display mode mask if
__glutDisplayString is non-NULL. */
assert(!__glutDisplayString);
/* XXX Would a caching mechanism to minize the calls to
glXChooseVisual? You'd have to reference count
XVisualInfo* pointers. Would also have to properly
interact with glutInitDisplayString. */
list[n++] = GLX_RGBA;
list[n++] = GLX_RED_SIZE;
list[n++] = 1;
list[n++] = GLX_GREEN_SIZE;
list[n++] = 1;
list[n++] = GLX_BLUE_SIZE;
list[n++] = 1;
if (GLUT_WIND_HAS_ALPHA(mode)) {
list[n++] = GLX_ALPHA_SIZE;
list[n++] = 1;
}
if (GLUT_WIND_IS_DOUBLE(mode)) {
list[n++] = GLX_DOUBLEBUFFER;
}
if (GLUT_WIND_IS_STEREO(mode)) {
list[n++] = GLX_STEREO;
}
if (GLUT_WIND_HAS_DEPTH(mode)) {
list[n++] = GLX_DEPTH_SIZE;
list[n++] = 1;
}
if (GLUT_WIND_HAS_STENCIL(mode)) {
list[n++] = GLX_STENCIL_SIZE;
list[n++] = 1;
}
if (GLUT_WIND_HAS_ACCUM(mode)) {
list[n++] = GLX_ACCUM_RED_SIZE;
list[n++] = 1;
list[n++] = GLX_ACCUM_GREEN_SIZE;
list[n++] = 1;
list[n++] = GLX_ACCUM_BLUE_SIZE;
list[n++] = 1;
if (GLUT_WIND_HAS_ALPHA(mode)) {
list[n++] = GLX_ACCUM_ALPHA_SIZE;
list[n++] = 1;
}
}
/* GLX_SAMPLES_SGIS has the same value as GLX_SAMPLES_ARB. */
# ifndef GLX_SAMPLES_ARB
# define GLX_SAMPLES_ARB 100001
# endif
if (GLUT_WIND_IS_MULTISAMPLE(mode)) {
if (
#ifdef _WIN32
!has_WGL_ARB_multisample
#else
!__glutIsSupportedByGLX("GLX_SGIS_multisample") &&
!__glutIsSupportedByGLX("GLX_ARB_multisample")
#endif
) {
return NULL;
}
/* Accept either the SGIS or ARB GLX multisample extensions. */
list[n++] = GLX_SAMPLES_ARB;
list[n++] = 2;
}
list[n] = (int) None; /* terminate list */
return glXChooseVisual(__glutDisplay,
__glutScreen, list);
}
static XVisualInfo *
getVisualInfoRGB(unsigned int mode)
{
int list[32];
int n = 0;
/* XXX Would a caching mechanism to minize the calls to
glXChooseVisual? You'd have to reference count
XVisualInfo* pointers. */
list[n++] = GLX_RGBA;
list[n++] = GLX_RED_SIZE;
list[n++] = 1;
list[n++] = GLX_GREEN_SIZE;
list[n++] = 1;
list[n++] = GLX_BLUE_SIZE;
list[n++] = 1;
if (GLUT_WIND_HAS_ALPHA(mode)) {
list[n++] = GLX_ALPHA_SIZE;
list[n++] = 1;
}
if (GLUT_WIND_IS_DOUBLE(mode)) {
list[n++] = GLX_DOUBLEBUFFER;
}
if (GLUT_WIND_IS_STEREO(mode)) {
list[n++] = GLX_STEREO;
}
if (GLUT_WIND_HAS_DEPTH(mode)) {
list[n++] = GLX_DEPTH_SIZE;
list[n++] = 1;
}
if (GLUT_WIND_HAS_STENCIL(mode)) {
list[n++] = GLX_STENCIL_SIZE;
list[n++] = 1;
}
if (GLUT_WIND_HAS_ACCUM(mode)) {
list[n++] = GLX_ACCUM_RED_SIZE;
list[n++] = 1;
list[n++] = GLX_ACCUM_GREEN_SIZE;
list[n++] = 1;
list[n++] = GLX_ACCUM_BLUE_SIZE;
list[n++] = 1;
if (GLUT_WIND_HAS_ALPHA(mode)) {
list[n++] = GLX_ACCUM_ALPHA_SIZE;
list[n++] = 1;
}
}
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
if (GLUT_WIND_IS_MULTISAMPLE(mode)) {
if (!__glutIsSupportedByGLX("GLX_SGIS_multisample"))
return NULL;
list[n++] = GLX_SAMPLES_SGIS;
/* XXX Is 4 a reasonable minimum acceptable number of
samples? */
list[n++] = 4;
}
#endif
list[n] = (int) None; /* terminate list */
return glXChooseVisual(__glutDisplay,
__glutScreen, list);
}
