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); }