/* 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; } }
void GLUTAPIENTRY glutInit(int *argcp, char **argv) { char *display = NULL; char *str, *geometry = NULL; #ifdef OLD_VMS struct timeval6 unused; #else struct timeval unused; #endif int i; if (__glutDisplay) { __glutWarning("glutInit being called a second time."); return; } /* Determine temporary program name. */ str = strrchr(argv[0], '/'); if (str == NULL) { __glutProgramName = argv[0]; } else { __glutProgramName = str + 1; } /* Make private copy of command line arguments. */ __glutArgc = *argcp; __glutArgv = (char **) malloc(__glutArgc * sizeof(char *)); if (!__glutArgv) __glutFatalError("out of memory."); for (i = 0; i < __glutArgc; i++) { __glutArgv[i] = __glutStrdup(argv[i]); if (!__glutArgv[i]) __glutFatalError("out of memory."); } /* determine permanent program name */ str = strrchr(__glutArgv[0], '/'); if (str == NULL) { __glutProgramName = __glutArgv[0]; } else { __glutProgramName = str + 1; } /* parse arguments for standard options */ for (i = 1; i < __glutArgc; i++) { if (!strcmp(__glutArgv[i], "-display")) { #if defined(_WIN32) __glutWarning("-display option not supported by Win32 GLUT."); #endif if (++i >= __glutArgc) { __glutFatalError( "follow -display option with X display name."); } display = __glutArgv[i]; removeArgs(argcp, &argv[1], 2); } else if (!strcmp(__glutArgv[i], "-geometry")) { if (++i >= __glutArgc) { __glutFatalError( "follow -geometry option with geometry parameter."); } geometry = __glutArgv[i]; removeArgs(argcp, &argv[1], 2); } else if (!strcmp(__glutArgv[i], "-direct")) { #if defined(_WIN32) __glutWarning("-direct option not supported by Win32 GLUT."); #endif if (!__glutTryDirect) __glutFatalError( "cannot force both direct and indirect rendering."); __glutForceDirect = GL_TRUE; removeArgs(argcp, &argv[1], 1); } else if (!strcmp(__glutArgv[i], "-indirect")) { #if defined(_WIN32) __glutWarning("-indirect option not supported by Win32 GLUT."); #endif if (__glutForceDirect) __glutFatalError( "cannot force both direct and indirect rendering."); __glutTryDirect = GL_FALSE; removeArgs(argcp, &argv[1], 1); } else if (!strcmp(__glutArgv[i], "-iconic")) { __glutIconic = GL_TRUE; removeArgs(argcp, &argv[1], 1); } else if (!strcmp(__glutArgv[i], "-gldebug")) { __glutDebug = GL_TRUE; removeArgs(argcp, &argv[1], 1); } else if (!strcmp(__glutArgv[i], "-sync")) { #if defined(_WIN32) __glutWarning("-sync option not supported by Win32 GLUT."); #endif synchronize = GL_TRUE; removeArgs(argcp, &argv[1], 1); } else { /* Once unknown option encountered, stop command line processing. */ break; } } #if defined(__OS2__) __glutOpenOS2Connection(display); #elif defined(_WIN32) __glutOpenWin32Connection(display); #else __glutOpenXConnection(display); #endif if (geometry) { int flags, x, y, width, height; /* Fix bogus "{width|height} may be used before set" warning */ width = 0; height = 0; flags = XParseGeometry(geometry, &x, &y, (unsigned int *) &width, (unsigned int *) &height); if (WidthValue & flags) { /* Careful because X does not allow zero or negative width windows */ if (width > 0) __glutInitWidth = width; } if (HeightValue & flags) { /* Careful because X does not allow zero or negative height windows */ if (height > 0) __glutInitHeight = height; } glutInitWindowSize(__glutInitWidth, __glutInitHeight); if (XValue & flags) { if (XNegative & flags) x = DisplayWidth(__glutDisplay, __glutScreen) + x - __glutSizeHints.width; /* Play safe: reject negative X locations */ if (x >= 0) __glutInitX = x; } if (YValue & flags) { if (YNegative & flags) y = DisplayHeight(__glutDisplay, __glutScreen) + y - __glutSizeHints.height; /* Play safe: reject negative Y locations */ if (y >= 0) __glutInitY = y; } glutInitWindowPosition(__glutInitX, __glutInitY); } __glutInitTime(&unused); /* check if GLUT_FPS env var is set */ { const char *fps = getenv("GLUT_FPS"); if (fps) { sscanf(fps, "%d", &__glutFPS); if (__glutFPS <= 0) __glutFPS = 5000; /* 5000 milliseconds */ } } }