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; }
/* CENTRY */ int GLUTAPIENTRY glutGet(GLenum param) { Window win, root; int x, y, value; unsigned int width, height, border, depth; switch (param) { case GLUT_INIT_WINDOW_X: return __glutInitX; case GLUT_INIT_WINDOW_Y: return __glutInitY; case GLUT_INIT_WINDOW_WIDTH: return __glutInitWidth; case GLUT_INIT_WINDOW_HEIGHT: return __glutInitHeight; case GLUT_INIT_DISPLAY_MODE: return __glutDisplayMode; case GLUT_WINDOW_X: XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win, __glutRoot, 0, 0, &x, &y, &win); return x; case GLUT_WINDOW_Y: XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win, __glutRoot, 0, 0, &x, &y, &win); return y; case GLUT_WINDOW_WIDTH: if (!__glutCurrentWindow->reshape) { XGetGeometry(__glutDisplay, __glutCurrentWindow->win, &root, &x, &y, &width, &height, &border, &depth); return width; } return __glutCurrentWindow->width; case GLUT_WINDOW_HEIGHT: if (!__glutCurrentWindow->reshape) { XGetGeometry(__glutDisplay, __glutCurrentWindow->win, &root, &x, &y, &width, &height, &border, &depth); return height; } return __glutCurrentWindow->height; #ifdef __OS2__ #define GET_CONFIG(attrib) \ { if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) \ glXGetConfig( __glutCurrentWindow->vis, attrib, &value); \ else \ glXGetConfig(__glutCurrentWindow->overlay->vis, attrib, &value); \ } \ #else #define GET_CONFIG(attrib) { \ if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { \ glXGetConfig(__glutDisplay, __glutCurrentWindow->vis, \ attrib, &value); \ } else { \ glXGetConfig(__glutDisplay, __glutCurrentWindow->overlay->vis, \ attrib, &value); \ } \ } #endif case GLUT_WINDOW_BUFFER_SIZE: GET_CONFIG(GLX_BUFFER_SIZE); return value; case GLUT_WINDOW_STENCIL_SIZE: GET_CONFIG(GLX_STENCIL_SIZE); return value; case GLUT_WINDOW_DEPTH_SIZE: GET_CONFIG(GLX_DEPTH_SIZE); return value; case GLUT_WINDOW_RED_SIZE: GET_CONFIG(GLX_RED_SIZE); return value; case GLUT_WINDOW_GREEN_SIZE: GET_CONFIG(GLX_GREEN_SIZE); return value; case GLUT_WINDOW_BLUE_SIZE: GET_CONFIG(GLX_BLUE_SIZE); return value; case GLUT_WINDOW_ALPHA_SIZE: GET_CONFIG(GLX_ALPHA_SIZE); return value; case GLUT_WINDOW_ACCUM_RED_SIZE: GET_CONFIG(GLX_ACCUM_RED_SIZE); return value; case GLUT_WINDOW_ACCUM_GREEN_SIZE: GET_CONFIG(GLX_ACCUM_GREEN_SIZE); return value; case GLUT_WINDOW_ACCUM_BLUE_SIZE: GET_CONFIG(GLX_ACCUM_BLUE_SIZE); return value; case GLUT_WINDOW_ACCUM_ALPHA_SIZE: GET_CONFIG(GLX_ACCUM_ALPHA_SIZE); return value; case GLUT_WINDOW_DOUBLEBUFFER: GET_CONFIG(GLX_DOUBLEBUFFER); return value; case GLUT_WINDOW_RGBA: GET_CONFIG(GLX_RGBA); return value; case GLUT_WINDOW_COLORMAP_SIZE: GET_CONFIG(GLX_RGBA); if (value) { return 0; } else { #if defined(_WIN32) || defined(__OS2__) /* KLUDGE: we always assume 256 colors in CI mode on Win32 */ return 256; #else if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { return __glutCurrentWindow->vis->visual->map_entries; } else { return __glutCurrentWindow->overlay->vis->visual->map_entries; } #endif /* _WIN32 */ } case GLUT_WINDOW_PARENT: return __glutCurrentWindow->parent ? __glutCurrentWindow->parent->num + 1 : 0; case GLUT_WINDOW_NUM_CHILDREN: { int num = 0; GLUTwindow *children = __glutCurrentWindow->children; while (children) { num++; children = children->siblings; } return num; } case GLUT_WINDOW_NUM_SAMPLES: #if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample) if (__glutIsSupportedByGLX("GLX_SGIS_multisample")) { GET_CONFIG(GLX_SAMPLES_SGIS); return value; } else { return 0; } #else /* Independent of GLX server support, multisampling not supported by GLX client-side. */ return 0; #endif case GLUT_WINDOW_STEREO: GET_CONFIG(GLX_STEREO); return value; case GLUT_WINDOW_CURSOR: return __glutCurrentWindow->cursor; case GLUT_SCREEN_WIDTH: return DisplayWidth(__glutDisplay, __glutScreen); case GLUT_SCREEN_HEIGHT: return DisplayHeight(__glutDisplay, __glutScreen); case GLUT_SCREEN_WIDTH_MM: return DisplayWidthMM(__glutDisplay, __glutScreen); case GLUT_SCREEN_HEIGHT_MM: return DisplayHeightMM(__glutDisplay, __glutScreen); case GLUT_MENU_NUM_ITEMS: return __glutCurrentMenu->num; case GLUT_DISPLAY_MODE_POSSIBLE: { XVisualInfo *vi; Bool dummy, visAlloced; void *fbc; #if defined(_WIN32) /* Our fake glXChooseVisual (which is called by __glutDetermineVisual) needs an HDC to work with, so grab one from the "root" window. */ XHDC = GetDC(GetDesktopWindow()); #endif vi = __glutDetermineWindowVisual(&dummy, &visAlloced, &fbc); #if defined(_WIN32) ReleaseDC(GetDesktopWindow(), XHDC); #endif if (vi) { if (visAlloced) XFree(vi); return 1; } return 0; } case GLUT_ELAPSED_TIME: { #ifdef OLD_VMS struct timeval6 elapsed, beginning, now; #else struct timeval elapsed, beginning, now; #endif __glutInitTime(&beginning); GETTIMEOFDAY(&now); TIMEDELTA(elapsed, now, beginning); /* Return elapsed milliseconds. */ #if defined(__vms) && ( __VMS_VER < 70000000 ) return (int) (elapsed.val / TICKS_PER_MILLISECOND); #else return (int) ((elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000)); #endif } case GLUT_WINDOW_FORMAT_ID: #if defined(__OS2__) return wglGetPixelFormat(__glutCurrentWindow->hdc); #elif defined(_WIN32) return GetPixelFormat(__glutCurrentWindow->hdc); #else if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { return (int) __glutCurrentWindow->vis->visualid; } else { return (int) __glutCurrentWindow->overlay->vis->visualid; } #endif default: __glutWarning("invalid glutGet parameter: %d", param); return -1; } }
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); }
/* CENTRY */ int APIENTRY glutVideoResizeGet(GLenum param) { #if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize) if (canVideoResize < 0) { canVideoResize = __glutIsSupportedByGLX("GLX_SGIX_video_resize"); if (canVideoResize) { #if __sgi /* This is a hack because IRIX 6.2, 6.3, and some 6.4 versions were released with GLX_SGIX_video_resize being advertised by the X server though the video resize extension is not actually supported. We try to determine if the libGL.so we are using actually has a video resize entrypoint before we try to use the feature. */ void (*func) (void); void *glxDso = dlopen("libGL.so", RTLD_LAZY); func = (void (*)(void)) dlsym(glxDso, "glXQueryChannelDeltasSGIX"); if (!func) { canVideoResize = 0; } else #endif { char *channelString; int (*handler) (Display *, XErrorEvent *); channelString = getenv("GLUT_VIDEO_RESIZE_CHANNEL"); videoResizeChannel = channelString ? atoi(channelString) : 0; /* Work around another annoying problem with SGI's GLX_SGIX_video_resize implementation. Early IRIX 6.4 OpenGL's advertise the extension and have the video resize API, but an XSGIvc X protocol errors result trying to use the API. Set up an error handler to intercept what would otherwise be a fatal error. If an error was recieved, do not report that video resize is possible. */ handler = XSetErrorHandler(catchXSGIvcErrors); errorCaught = 0; glXQueryChannelDeltasSGIX(__glutDisplay, __glutScreen, videoResizeChannel, &dx, &dy, &dw, &dh); /* glXQueryChannelDeltasSGIX is an inherent X server round-trip so we know we will have gotten either the correct reply or and error by this time. */ XSetErrorHandler(handler); /* Still yet another work around. In IRIX 6.4 betas, glXQueryChannelDeltasSGIX will return as if it succeeded, but the values are filled with junk. Watch to make sure the delta variables really make sense. */ if (errorCaught || dx < 0 || dy < 0 || dw < 0 || dh < 0 || dx > 2048 || dy > 2048 || dw > 2048 || dh > 2048) { canVideoResize = 0; } } } } #endif /* GLX_SGIX_video_resize */ switch (param) { case GLUT_VIDEO_RESIZE_POSSIBLE: return canVideoResize; case GLUT_VIDEO_RESIZE_IN_USE: return videoResizeInUse; case GLUT_VIDEO_RESIZE_X_DELTA: return dx; case GLUT_VIDEO_RESIZE_Y_DELTA: return dy; case GLUT_VIDEO_RESIZE_WIDTH_DELTA: return dw; case GLUT_VIDEO_RESIZE_HEIGHT_DELTA: return dh; case GLUT_VIDEO_RESIZE_X: case GLUT_VIDEO_RESIZE_Y: case GLUT_VIDEO_RESIZE_WIDTH: case GLUT_VIDEO_RESIZE_HEIGHT: #if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize) if (videoResizeInUse) { int x, y, width, height; glXQueryChannelRectSGIX(__glutDisplay, __glutScreen, videoResizeChannel, &x, &y, &width, &height); switch (param) { case GLUT_VIDEO_RESIZE_X: return x; case GLUT_VIDEO_RESIZE_Y: return y; case GLUT_VIDEO_RESIZE_WIDTH: return width; case GLUT_VIDEO_RESIZE_HEIGHT: return height; } } #endif return -1; default: __glutWarning("invalid glutVideoResizeGet parameter: %d", param); return -1; } }
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); }