// Dialog procedure. BOOL APIENTRY AboutDlgProc(HWND hDlg, UINT message, UINT wParam, LONG lParam) { switch (message) { // Initialize the dialog box case WM_INITDIALOG: { int i; GLenum glError; // glGetString demo SetDlgItemText(hDlg, IDC_OPENGL_VENDOR, (LPCSTR)glGetString(GL_VENDOR)); SetDlgItemText(hDlg, IDC_OPENGL_RENDERER, (LPCSTR)glGetString(GL_RENDERER)); SetDlgItemText(hDlg, IDC_OPENGL_VERSION, (LPCSTR)glGetString(GL_VERSION)); SetDlgItemText(hDlg, IDC_OPENGL_EXTENSIONS, (LPCSTR)glGetString(GL_EXTENSIONS)); // gluGetString demo SetDlgItemText(hDlg, IDC_GLU_VERSION, (LPCSTR)gluGetString(GLU_VERSION)); SetDlgItemText(hDlg, IDC_GLU_EXTENSIONS, (LPCSTR)gluGetString(GLU_EXTENSIONS)); // Display any recent error messages i = 0; do { glError = glGetError(); SetDlgItemText(hDlg, IDC_ERROR1 + i, (LPCSTR)gluErrorString(glError)); i++; } while (i < 6 && glError != GL_NO_ERROR); return (TRUE); } break; // Process command messages case WM_COMMAND: { // Validate and Make the changes if (LOWORD(wParam) == IDOK) EndDialog(hDlg, TRUE); } break; // Closed from sysbox case WM_CLOSE: EndDialog(hDlg, TRUE); break; } return FALSE; }
// Fonction principale int main(int argc, char **argv) { // Initialisation de la GLUT glutInit(&argc, argv); // Choix de double buffer glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB); // Position de la fenêtre glutInitWindowPosition (fenetreX, fenetreY); // Taille de la fenêtre glutInitWindowSize (fenetreLargeur,fenetreHauteur); // Création de la fenêtre GLUT glutCreateWindow (argv[0]); // informations sur les versions OpenGL et GLU utilisées printf("Version OpenGL, OS:%s\n",glGetString(GL_VERSION)); printf("Vendeur:%s\n",glGetString(GL_VENDOR)); printf("Renderer:%s\n",glGetString(GL_RENDERER)); printf("Version GLU:%s\n",gluGetString(GLU_VERSION)); printf("Extensions GLU:%s\n\n",gluGetString(GLU_EXTENSIONS)); // Initialisation init(); // Fonction callback d'affichage glutDisplayFunc(display); // Fonction callback de redimensionnement. glutReshapeFunc(reshape); // Fonction callback d'animation glutIdleFunc(cameraAutoRotation); // On key pressed //glutKeyboardFunc(keyPressed); //glutSpecialFunc(keyPressed); // Initialisation du menu et de ses sous-menus. initMenu(); // Lancement de la boucle glutMainLoop(); // Fin de programme return 0; }
InfoView::InfoView() : BGroupView(B_TRANSLATE("Information"), B_HORIZONTAL) { BStringView* rendererView = new BStringView(NULL, (const char*)glGetString(GL_RENDERER)); rendererView->SetExplicitAlignment(kLabelAlignment); rendererView->SetFont(be_bold_font); BStringView* vendorNameView = new BStringView(NULL, (const char*)glGetString(GL_VENDOR)); vendorNameView->SetExplicitAlignment(kLabelAlignment); BStringView* glVersionView = new BStringView(NULL, (const char*)glGetString(GL_VERSION)); glVersionView->SetExplicitAlignment(kLabelAlignment); BString apiString("GLU "); apiString << (const char*)gluGetString(GLU_VERSION); apiString << ", GLUT "; apiString << (int32)GLUT_API_VERSION; BStringView* apiVersionView = new BStringView(NULL, apiString.String()); apiVersionView->SetExplicitAlignment(kLabelAlignment); BLayoutBuilder::Group<>(this) .AddGroup(B_VERTICAL, 0) .Add(rendererView) .Add(vendorNameView) .Add(glVersionView) .Add(apiVersionView) .End(); }
static int tolua_glu_gluGetString00(lua_State* tolua_S) { #ifndef TOLUA_RELEASE tolua_Error tolua_err; if ( !tolua_isnumber(tolua_S,1,0,&tolua_err) || !tolua_isnoobj(tolua_S,2,&tolua_err) ) goto tolua_lerror; else #endif { int name = (( int) tolua_tonumber(tolua_S,1,0)); { unsigned const char* tolua_ret = ( unsigned const char*) gluGetString(name); tolua_pushstring(tolua_S,(const char*)tolua_ret); } } return 1; #ifndef TOLUA_RELEASE tolua_lerror: tolua_error(tolua_S,"#ferror in function 'gluGetString'.",&tolua_err); return 0; #endif }
int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(300, 300); glutInitWindowPosition(100, 100); glutCreateWindow("OpenGL Version"); #pragma region show version string const GLubyte* name = glGetString(GL_VENDOR); //返回负责当前OpenGL实现厂商的名字 const GLubyte* biaoshifu = glGetString(GL_RENDERER); //返回一个渲染器标识符,通常是个硬件平台 const GLubyte* OpenGLVersion = glGetString(GL_VERSION); //返回当前OpenGL实现的版本号 const GLubyte* gluVersion = gluGetString(GLU_VERSION); //返回当前GLU工具库版本 printf("OpenGL实现厂商的名字:%s\n", name); printf("渲染器标识符:%s\n", biaoshifu); printf("OpenGL实现的版本号:%s\n", OpenGLVersion); printf("OGLU工具库版本:%s\n", gluVersion); #pragma endregion show version string glutDisplayFunc(renderScene); glutReshapeFunc(changeSize); glutMainLoop(); return 0; }
int main() { if (execute) { // This needs an active GL context, so not executed, but serves // as a link test. (void) glGetString(GL_VERSION); (void) gluGetString(GLU_VERSION); } std::cout << "version=" << #if defined GL_VERSION_2_1 "2.1" #elif defined GL_VERSION_2_0 "2.0" #elif defined GL_VERSION_1_5 "1.5" #elif defined GL_VERSION_1_4 "1.4" #elif defined GL_VERSION_1_3 "1.3" #elif defined GL_VERSION_1_2 "1.2" #elif defined GL_VERSION_1_1 "1.1" #elif defined GL_VERSION_1_0 "1.0" #else "unknown" #endif << std::endl; return 0; }
std::string OGLInspector::GetGluVersion() { #ifndef GLU_VERSION_1_1 return "1.0"; #else return (char*)(gluGetString(GLU_VERSION)); #endif }
std::string OGLInspector::GetGluExtensions() { #ifndef GLU_VERSION_1_1 return ""; #else return (char*)(gluGetString(GLU_EXTENSIONS)); #endif }
static void hugsprim_gluGetString_0(HugsStackPtr hugs_root) { HsWord32 arg1; HsPtr res1; arg1 = hugs->getWord32(); res1 = gluGetString(arg1); hugs->putPtr(res1); hugs->returnIO(hugs_root,1); }
void ShaderManager::checkUniformError( void ) { GLenum error = glGetError(); if (error != GL_NO_ERROR) { Log::ErrorFmt(getClassName(), "Uniform Error, #%d %s", error, gluGetString(error)); } }
static void screenInfo( Display *dpy, int scrnum, QString &infotext ) { const char *serverVendor = glXQueryServerString( dpy, scrnum, GLX_VENDOR ); const char *serverVersion = glXQueryServerString( dpy, scrnum, GLX_VERSION ); const char *serverExtensions = glXQueryServerString( dpy, scrnum, GLX_EXTENSIONS ); const char *clientVendor = glXGetClientString( dpy, GLX_VENDOR ); const char *clientVersion = glXGetClientString( dpy, GLX_VERSION ); const char *clientExtensions = glXGetClientString( dpy, GLX_EXTENSIONS ); const char *glxExtensions = glXQueryExtensionsString( dpy, scrnum ); const char *glVendor = (const char *) glGetString( GL_VENDOR ); const char *glRenderer = (const char *) glGetString( GL_RENDERER ); const char *glVersion = (const char *) glGetString( GL_VERSION ); const char *glExtensions = (const char *) glGetString( GL_EXTENSIONS ); const char *gluVersion = (const char *) gluGetString( (GLenum) GLU_VERSION ); const char *gluExtensions = (const char *) gluGetString( (GLenum) GLU_EXTENSIONS ); infotext.sprintf( "%sServer GLX vendor string: %s\n", infotext.ascii(), serverVendor ); infotext.sprintf( "%sServer GLX version string: %s\n", infotext.ascii(), serverVersion ); infotext.sprintf( "%sServer GLX extensions:\n", infotext.ascii() ); infotext += QString( serverExtensions ).replace( ' ', '\n' ) + "\n\n"; infotext.sprintf( "%sClient GLX vendor string: %s\n", infotext.ascii(), clientVendor ); infotext.sprintf( "%sClient GLX version string: %s\n", infotext.ascii(), clientVersion ); infotext.sprintf( "%sClient GLX extensions:\n", infotext.ascii() ); infotext += QString( clientExtensions ).replace( ' ', '\n' ) + "\n\n"; infotext.sprintf( "%sGLX extensions:\n", infotext.ascii() ); infotext += QString( glxExtensions ).replace( ' ', '\n' ) + "\n\n"; infotext.sprintf( "%sOpenGL vendor string: %s\n", infotext.ascii(), glVendor ); infotext.sprintf( "%sOpenGL renderer string: %s\n", infotext.ascii(), glRenderer ); infotext.sprintf( "%sOpenGL version string: %s\n", infotext.ascii(), glVersion ); infotext.sprintf( "%sOpenGL extensions:\n", infotext.ascii() ); infotext += QString( glExtensions ).replace( ' ', '\n' ) + "\n\n"; infotext.sprintf( "%sGLU version: %s\n", infotext.ascii(), gluVersion ); infotext.sprintf( "%sGLU extensions:\n", infotext.ascii() ); infotext += QString( gluExtensions ).replace( ' ', '\n' ) + "\n\n"; }
void CoreInit(void (GLUTCALLBACK *drawFunc)(void),int argc,char **argv) { glutInit(&argc, (char**)argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH); glutInitWindowSize(SCREEN_SIZE_X, SCREEN_SIZE_Y); glutInitWindowPosition(0, 0); glutCreateWindow("Title"); glutDisplayFunc(drawFunc); glutIdleFunc(drawFunc); glutReshapeFunc(&CoreReshape); glutSpecialFunc(&CorekeyDown1Static); glutSpecialUpFunc(&CorekeyUp1Static); glutKeyboardFunc(&CorekeyDown2Static); glutKeyboardUpFunc(&CorekeyUp2Static); glutMotionFunc(&CoreMouseMotionStatic); glutPassiveMotionFunc(&CoreMouseMotionStatic); glutMouseFunc (&CoreMouseButtonStatic); glewInit(); std::cout << "GL_VERSION: " << glGetString(GL_VERSION) << std::endl; //std::cout << "GL_EXTENSIONS: " << glGetString(GL_EXTENSIONS) << std::endl; std::cout << "GL_RENDERER: " << glGetString(GL_RENDERER) << std::endl; std::cout << "GL_VENDOR: " << glGetString(GL_VENDOR) << std::endl; std::cout << "GLU_VERSION: " << gluGetString(GLU_VERSION) << std::endl; //std::cout << "GLU_EXTENSIONS: " << gluGetString(GLU_EXTENSIONS) << std::endl; std::cout << "GLUT_API_VERSION: " << GLUT_API_VERSION << std::endl; int res[16]; #ifndef MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS #define MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS 0x8E81 #endif #ifndef MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS #define MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS 0x8E82 #endif glGetIntegerv(MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS,res); printf("MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS %d\n",res[0]); glGetIntegerv(MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS,res); printf("MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS %d\n",res[0]); wglSwapIntervalEXT(0); //glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, GL_FALSE);CHECK_GL_ERROR(); //glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, GL_FALSE);CHECK_GL_ERROR(); glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);CHECK_GL_ERROR(); glClearDepth(1.0); // Enables Clearing Of The Depth Buffer glDepthFunc(GL_LESS); // The Type Of Depth Test To Do glEnable(GL_DEPTH_TEST); // Enables Depth Testing glShadeModel(GL_SMOOTH); // Enables Smooth Color Shading glEnable(GL_CULL_FACE); glCullFace (GL_FRONT); }
// set the error message void VRML_LAYER::SetGLError( GLenum errorID ) { error = ""; error = (const char*)gluGetString( errorID ); if( error.empty() ) { std::ostringstream ostr; ostr << "Unknown OpenGL error: " << errorID; error = ostr.str(); } }
void DVRClipper::initialize(DVRVolume *volume) { if(volume == NULL) return; // get clip objects DVRClipObjectsPtr clipObjects = DVRVOLUME_PARAMETER(volume, DVRClipObjects); if(clipObjects == NullFC) return; if(!hasTesselatorSupport) { // check for glu tesselator support hasTesselatorSupport = (atof((char*)gluGetString(GLU_VERSION)) >= 1.2); if(!hasTesselatorSupport) return; } if(myTess == NULL) { myTess = gluNewTess(); // registering callback functions for glu tesselator... gluTessCallback(myTess, GLU_TESS_COMBINE_DATA, (GLvoid (CALLBACK *)()) vertexCombineCallback); gluTessCallback(myTess, GLU_TESS_VERTEX_DATA, (GLvoid (CALLBACK *)()) vertexCallback); gluTessCallback(myTess, GLU_TESS_BEGIN_DATA, (GLvoid (CALLBACK *)()) beginCallback); gluTessCallback(myTess, GLU_TESS_END_DATA, (GLvoid (CALLBACK *)()) endCallback); gluTessCallback(myTess, GLU_TESS_ERROR, (GLvoid (CALLBACK *)()) errorCallback); } }
int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_MULTISAMPLE); glutInitWindowPosition(520, 10); glutInitWindowSize(WIDTH, HEIGHT); window1 = glutCreateWindow("shadow sample"); GLenum err = glewInit(); if(err != GLEW_OK){ std::cout << "fail" << std::endl; return -1; } //multisample, is this realized by the fixed pipeline? I need to //rewrite it in a shader with fbo maybe. GLint bufs, samples; glGetIntegerv(GL_SAMPLE_BUFFERS, &bufs); glGetIntegerv(GL_SAMPLES, &samples); glEnable(GL_MULTISAMPLE); //show some info const GLubyte *name = glGetString(GL_VENDOR); const GLubyte *renderer = glGetString(GL_RENDERER); const GLubyte *version = glGetString(GL_VERSION); const GLubyte *gluversion = gluGetString(GLU_VERSION); std::cout << "++++++++++++++++++++++++++++" << std::endl << "+ GL_VENDOR: " << name << std::endl << "+ GL_RENDERER: " << renderer << std::endl << "+ GL_VERSION: " << version << std::endl << "+ GLU_VERSION: " << gluversion << std::endl << "++++++++++++++++++++++++++++" << std::endl; init(); glutDisplayFunc(display); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(keyboarddown); glutKeyboardUpFunc(keyboardup); glutReshapeFunc(reshape); glutIdleFunc(idle); //openwin2(); glutMainLoop(); glDeleteVertexArrays(1, &box_vao); glDeleteBuffers(1, &vertexID); return 0; }
static struct once { once() { // Initialize GLEW glewExperimental= GL_TRUE; GLenum err = glewInit (); if (GLEW_OK != err) { // Problem: glewInit failed, something is seriously wrong. std::cerr << "<gate/render/window.cpp> says: Error: " << glewGetErrorString (err) << std::endl; std::exit(1); } // Print some infos about user's OpenGL implementation if(0) { std::cout << "OpenGL Version String: " << glGetString (GL_VERSION) << std::endl; std::cout << "GLU Version String: " << gluGetString (GLU_VERSION) << std::endl; std::cout << "GLEW Version String: " << glewGetString (GLEW_VERSION) <<std::endl; } }} _2;
int main(int argc, char** argv) { // 返回负责当前OpenGL实现厂商的名字 const GLubyte* name = glGetString(GL_VENDOR); // 返回一个渲染器标识符,通常是个硬件平台 const GLubyte* renderID = glGetString(GL_RENDERER); // 返回当前OpenGL实现的版本号 const GLubyte* OpenGLVersion = glGetString(GL_VERSION); // 返回当前GLU工具库版本 const GLubyte* gluVersion = gluGetString(GLU_VERSION); printf("OpenGL实现厂商的名字:%s\n", name); printf("渲染器标识符:%s\n", renderID); printf("OpenGL实现的版本号:%s\n", OpenGLVersion); printf("GLU工具库版本:%s\n", gluVersion); return 0; }
/* GetString (name) -> string */ static int luaglu_get_string(lua_State *L) { GLenum e; const GLubyte *str; /* test argument type */ if(!lua_isstring(L, 1)) luaL_error(L, "incorrect argument to function 'glu.GetString'"); /* get string parameter */ e = luaglu_get_gl_enum(L, 1); /* test argument */ if(e == LUAGL_ENUM_ERROR) luaL_error(L, "incorrect string argument to function 'glu.GetString'"); /* call opengl function */ str = gluGetString(e); lua_pushstring(L, (const char*)str); return 1; }
void showSystemInfo_plat(){ //opengl version query //see: http://www.opengl.org/wiki/GlGetString const GLubyte* s_gl_vendor = glGetString(GL_VENDOR); const GLubyte* s_gl_renderer = glGetString(GL_RENDERER); const GLubyte* s_gl_version =glGetString(GL_VERSION); const GLubyte* s_glu_version= gluGetString(GLU_VERSION); cout<<endl; cout<<"OpenGL vendor: "<<s_gl_vendor<<endl; cout<<"GPU:"<<s_gl_renderer<<endl; cout<<"OpenGL version: "<<s_gl_version<<endl; cout<<"GLU version: "<<s_glu_version<<endl; //see if support opengl 2.0 if (glewIsSupported("GL_VERSION_2_0")) cout<<"support openGL 2.0!"<<endl; else { cout<<"not support openGL 2.0!"<<endl; assert(false); } //GLSL version const GLubyte* s= glGetString(GL_SHADING_LANGUAGE_VERSION); cout<<s<<endl; cout<<endl; }
/* GetString (name) -> string */ static int luaglu_get_string(lua_State *L) { lua_pushstring(L, (char*)gluGetString(luaglu_get_gl_enum(L, 1))); return 1; }
static PyObject* opengl_init( PyObject* self, PyObject* args ) { GL_ERROR_CHECK("top of opengl_init"); printf( " vendor : %s\n", glGetString( GL_VENDOR ) ); printf( " renderer : %s\n", glGetString( GL_RENDERER ) ); printf( " version : %s\n", glGetString( GL_VERSION ) ); printf( "glu version : %s\n", gluGetString( GLU_VERSION ) ); /*printf( "extensions : %s\n", glGetString( GL_EXTENSIONS ) );*/ glewExperimental=GL_TRUE; GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ printf("Error: %s\n", glewGetErrorString(err)); } printf("Status: Using GLEW %s\n", glewGetString(GLEW_VERSION)); if (glewIsSupported("GLX_SGI_swap_control")) { /* It is safe to use the ARB_vertex_program extension here. */ printf("GLX_SGI_swap_control supported!\n"); //glXSwapIntervalSGI(1); } else { printf("No GLX_SGI_swap_control support.\n"); } if (glewIsSupported("GLX_SGI_video_sync")) { /* It is safe to use the ARB_vertex_program extension here. */ printf("GLX_SGI_video_sync supported!\n"); //glXSwapIntervalSGI(1); int retraceCount; glXGetVideoSyncSGI(&retraceCount); glXWaitVideoSyncSGI(2, (retraceCount+1)%2, &retraceCount); } else { printf("GLX_SGI_video_sync support.\n"); int c; //__glewXWaitVideoSyncSGI(5,0,&c); } glEnable( GL_VERTEX_ARRAY ); /* on mac, we expect that to fail; must be enabled as client state instead, */ if(glGetError() != GL_NO_ERROR) { glEnableClientState( GL_VERTEX_ARRAY ); GL_ERROR_CHECK( "enable client gl_vertex_array" ); } glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glEnable( GL_DEPTH_TEST ); glDepthFunc( GL_ALWAYS ); glClearDepth( 0.0 ); GL_ERROR_CHECK( "end of opengl_init" ); //glEnable( GL_POLYGON_SMOOTH ); Py_INCREF( Py_None ); return Py_None; }
/****************************************************************************** *############################################################################* *# Screen functions #* *############################################################################* ******************************************************************************/ void openglInit() { /*setting up OpenGL*/ screen_w = 10; screen_h = 10; global_screenratio = 1.0; glViewport(0, 0, 10, 10); glMatrixMode(GL_PROJECTION); glLoadIdentity(); vp_wrel = vp_hrel = FALSE; vp_top = vp_left = 0; vp_width = vp_height = 10; glClearColor(0.0f, 0.0f, 0.0f, 1.0f); wireframe2d = FALSE; wireframe3d = FALSE; shading = GL_SMOOTH; lighting = TRUE; texture2d = TRUE; texture3d = TRUE; glFrontFace(GL_CCW); glCullFace(GL_BACK); glDepthFunc(GL_LEQUAL); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); global_forceblend = FALSE; glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); glHint(GL_FOG_HINT, GL_FASTEST); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, TRUE); curcount = 0; count = 0; fog = FALSE; fogdensity = 0.0; fogcolor[0] = 0.5; fogcolor[1] = 0.5; fogcolor[2] = 0.5; fogcolor[3] = 1.0; /*core declaration*/ MOD_ID = coreDeclareModule("opengl", NULL, NULL, shellCallback, NULL, NULL, NULL); FUNC_WIREFRAME = coreDeclareShellFunction(MOD_ID, "wireframe", VAR_VOID, 2, VAR_INT, VAR_INT); FUNC_FOG = coreDeclareShellFunction(MOD_ID, "fog", VAR_VOID, 1, VAR_INT); FUNC_LIGHTING = coreDeclareShellFunction(MOD_ID, "lighting", VAR_VOID, 2, VAR_INT, VAR_INT); FUNC_TEXTURE = coreDeclareShellFunction(MOD_ID, "texture", VAR_VOID, 2, VAR_INT, VAR_INT); FUNC_COUNT = coreDeclareShellFunction(MOD_ID, "count", VAR_INT, 0); /*OpenGL info*/ shellPrintf(LEVEL_INFO, " -> OpenGL version: %s", (const char*)glGetString(GL_VERSION)); shellPrintf(LEVEL_INFO, " -> OpenGL vendor: %s", (const char*)glGetString(GL_VENDOR)); shellPrintf(LEVEL_INFO, " -> OpenGL renderer: %s", (const char*)glGetString(GL_RENDERER)); shellPrintf(LEVEL_DEBUG, " -> OpenGL extensions: %s", (const char*)glGetString(GL_EXTENSIONS)); /*GLU info*/ shellPrintf(LEVEL_INFO, " -> GLU version: %s", (const char*)gluGetString(GLU_VERSION)); shellPrintf(LEVEL_DEBUG, " -> GLU extensions: %s", (const char*)gluGetString(GLU_EXTENSIONS)); }
static void print_screen_info(Display *dpy, int scrnum, Bool allowDirect, GLboolean limits) { Window win; int attribSingle[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, None }; int attribDouble[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_DOUBLEBUFFER, None }; XSetWindowAttributes attr; unsigned long mask; Window root; GLXContext ctx; XVisualInfo *visinfo; int width = 100, height = 100; root = RootWindow(dpy, scrnum); visinfo = glXChooseVisual(dpy, scrnum, attribSingle); if (!visinfo) { visinfo = glXChooseVisual(dpy, scrnum, attribDouble); if (!visinfo) { fprintf(stderr, "Error: couldn't find RGB GLX visual\n"); return; } } attr.background_pixel = 0; attr.border_pixel = 0; attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone); attr.event_mask = StructureNotifyMask | ExposureMask; mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; win = XCreateWindow(dpy, root, 0, 0, width, height, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr); ctx = glXCreateContext( dpy, visinfo, NULL, allowDirect ); if (!ctx) { fprintf(stderr, "Error: glXCreateContext failed\n"); XDestroyWindow(dpy, win); return; } if (glXMakeCurrent(dpy, win, ctx)) { const char *serverVendor = glXQueryServerString(dpy, scrnum, GLX_VENDOR); const char *serverVersion = glXQueryServerString(dpy, scrnum, GLX_VERSION); const char *serverExtensions = glXQueryServerString(dpy, scrnum, GLX_EXTENSIONS); const char *clientVendor = glXGetClientString(dpy, GLX_VENDOR); const char *clientVersion = glXGetClientString(dpy, GLX_VERSION); const char *clientExtensions = glXGetClientString(dpy, GLX_EXTENSIONS); const char *glxExtensions = glXQueryExtensionsString(dpy, scrnum); const char *glVendor = (const char *) glGetString(GL_VENDOR); const char *glRenderer = (const char *) glGetString(GL_RENDERER); const char *glVersion = (const char *) glGetString(GL_VERSION); const char *glExtensions = (const char *) glGetString(GL_EXTENSIONS); int glxVersionMajor; int glxVersionMinor; char *displayName = NULL; char *colon = NULL, *period = NULL; #ifdef DO_GLU const char *gluVersion = (const char *) gluGetString(GLU_VERSION); const char *gluExtensions = (const char *) gluGetString(GLU_EXTENSIONS); #endif if (! glXQueryVersion( dpy, & glxVersionMajor, & glxVersionMinor )) { fprintf(stderr, "Error: glXQueryVersion failed\n"); exit(1); } /* Strip the screen number from the display name, if present. */ if (!(displayName = (char *) malloc(strlen(DisplayString(dpy)) + 1))) { fprintf(stderr, "Error: malloc() failed\n"); exit(1); } strcpy(displayName, DisplayString(dpy)); colon = strrchr(displayName, ':'); if (colon) { period = strchr(colon, '.'); if (period) *period = '\0'; } printf("display: %s screen: %d\n", displayName, scrnum); free(displayName); printf("direct rendering: %s\n", glXIsDirect(dpy, ctx) ? "Yes" : "No"); printf("server glx vendor string: %s\n", serverVendor); printf("server glx version string: %s\n", serverVersion); printf("server glx extensions:\n"); print_extension_list(serverExtensions); printf("client glx vendor string: %s\n", clientVendor); printf("client glx version string: %s\n", clientVersion); printf("client glx extensions:\n"); print_extension_list(clientExtensions); printf("GLX version: %u.%u\n", glxVersionMajor, glxVersionMinor); printf("GLX extensions:\n"); print_extension_list(glxExtensions); printf("OpenGL vendor string: %s\n", glVendor); printf("OpenGL renderer string: %s\n", glRenderer); printf("OpenGL version string: %s\n", glVersion); printf("OpenGL extensions:\n"); print_extension_list(glExtensions); if (limits) print_limits(); #ifdef DO_GLU printf("glu version: %s\n", gluVersion); printf("glu extensions:\n"); print_extension_list(gluExtensions); #endif } else { fprintf(stderr, "Error: glXMakeCurrent failed\n"); } glXDestroyContext(dpy, ctx); XDestroyWindow(dpy, win); }
void SettingsDialog::setup() { FXVerticalFrame* vframe; FXHorizontalFrame* hframe; FXMatrix* matrix; FXLabel* label; FXFontDesc fontdescription = getApp()->getNormalFont()->getFontDesc(); fontdescription.weight = FXFont::DemiBold; thickfont=new FXFont(getApp(), fontdescription); thickfont->create(); FXGLVisual* glvisual = static_cast<FXGLVisual*>(canvas->getVisual()); canvas->makeCurrent(); setTitle(tr("OpenGL Information")); hframe = new FXHorizontalFrame(this, LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH); new FXButton(hframe, tr("Close"), nullptr, this, ID_ACCEPT,FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|BUTTON_DEFAULT|BUTTON_INITIAL,0,0,0,0,20,20,2,2); new FXButton(hframe, tr("Save"), nullptr, this, ID_SAVE,FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT,0,0,0,0,20,20,2,2); FXTabBook* tabbook = new FXTabBook(this,nullptr,0,LAYOUT_FILL_X|LAYOUT_FILL_Y,0,0,0,0); new FXTabItem(tabbook, tr(" Display Mode ")); matrix = new FXMatrix(tabbook,2,MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED|FRAME_THICK); label = new FXLabel(matrix, tr("Hardware-accelerated:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, tr(PRINT_YESNO(glvisual->isAccelerated())), nullptr, LABEL_NORMAL); label = new FXLabel(matrix, tr("Double Buffering:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, tr(PRINT_YESNO(glvisual->isDoubleBuffer())), nullptr, LABEL_NORMAL); label = new FXLabel(matrix, tr("Stereo View:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, tr(PRINT_YESNO(glvisual->isStereo())), nullptr, LABEL_NORMAL); label = new FXLabel(matrix, tr("Buffer-swap by copy:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, tr(PRINT_YESNO(glvisual->isBufferSwapCopy())), nullptr, LABEL_NORMAL); label = new FXLabel(matrix, tr("Color Depth:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%d",glvisual->getActualRedSize()+glvisual->getActualGreenSize()+glvisual->getActualBlueSize()+glvisual->getActualAlphaSize()),NULL,LABEL_NORMAL); label = new FXLabel(matrix, tr("Depth Buffer Size:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%d",glvisual->getActualDepthSize()), nullptr, LABEL_NORMAL); label = new FXLabel(matrix, tr("Stencil Buffer Size:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%d",glvisual->getActualStencilSize()), nullptr, LABEL_NORMAL); label = new FXLabel(matrix, tr("RGBA:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix,FXString::value("%d-%d-%d-%d",glvisual->getActualRedSize(),glvisual->getActualGreenSize(),glvisual->getActualBlueSize(),glvisual->getActualAlphaSize()),NULL,LABEL_NORMAL); label = new FXLabel(matrix, tr("Accum RGBA:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix,FXString::value("%d-%d-%d-%d",glvisual->getActualAccumRedSize(),glvisual->getActualAccumGreenSize(),glvisual->getActualAccumBlueSize(),glvisual->getActualAccumAlphaSize()),NULL,LABEL_NORMAL); label = new FXLabel(matrix,tr("Multi Sample:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix,FXString::value("%dx", glvisual->getActualMultiSamples()), nullptr, LABEL_NORMAL); new FXTabItem(tabbook,tr(" Limits ")); matrix = new FXMatrix(tabbook, 2, MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED|FRAME_THICK); GLint intvals[2] = {0, 0}; glGetIntegerv(GL_MAX_VIEWPORT_DIMS, intvals); label = new FXLabel(matrix,tr("Viewport Size:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%d x %d", intvals[0], intvals[1])); GLint intval(0); glGetIntegerv(GL_MAX_TEXTURE_SIZE, &intval); label = new FXLabel(matrix,tr("Texture Size:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%d", intval)); #if defined(GL_MAX_TEXTURE_UNITS) glGetIntegerv(GL_MAX_TEXTURE_UNITS, &intval); label = new FXLabel(matrix, tr("Texture Units:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%d", intval)); #endif glGetIntegerv(GL_MAX_LIGHTS, &intval); label = new FXLabel(matrix,tr("Lights:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%d", intval)); glGetIntegerv(GL_MAX_CLIP_PLANES, &intval); label = new FXLabel(matrix,tr("Clipping Planes:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%d", intval)); glGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH, &intval); label = new FXLabel(matrix,tr("Modelview Stack:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%d", intval)); glGetIntegerv(GL_MAX_PROJECTION_STACK_DEPTH, &intval); label = new FXLabel(matrix,tr("Projection Stack:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%d", intval)); glGetIntegerv(GL_MAX_ATTRIB_STACK_DEPTH, &intval); label = new FXLabel(matrix, tr("Attribute Stack:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%d", intval)); label = new FXLabel(matrix, tr("Vertex Attributes:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); #if defined(GL_MAX_VERTEX_ATTRIBS) glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &intval); new FXLabel(matrix, FXString::value("%d", intval)); #else new FXLabel(matrix,"-"); #endif label = new FXLabel(matrix, tr("Vertex Uniform Components:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); #if defined(GL_MAX_VERTEX_UNIFORM_COMPONENTS) glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &intval); new FXLabel(matrix, FXString::value("%d", intval)); #else new FXLabel(matrix, "-"); #endif label = new FXLabel(matrix, tr("Fragment Uniform Components:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); #if defined(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS) glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &intval); new FXLabel(matrix, FXString::value("%d", intval)); #else new FXLabel(matrix, "-"); #endif new FXTabItem(tabbook, tr(" Extensions ")); vframe = new FXVerticalFrame(tabbook, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED|FRAME_THICK); vframe = new FXVerticalFrame(vframe, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, 0,0,0,0,0,0,0,0); extensionlist = new FXList(vframe, nullptr, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y|HSCROLLING_OFF); // Get OpenGL extensions char* tmp = (char*)glGetString(GL_EXTENSIONS); if (tmp) { char* text = strdup(tmp); char* token = strtok(text, " "); while(token) { extensionlist->appendItem(token); token = strtok(nullptr, " "); } free(text); } extensionlist->setSortFunc(FXList::ascending); extensionlist->sortItems(); // Get GLU extensions #ifdef GLU_VERSION_1_1 tmp = (char*)gluGetString(GLU_EXTENSIONS); if (tmp) { char* text = strdup(tmp); char* token = strtok(text, " "); while (token != nullptr) { extensionlist->appendItem(token); token = strtok(nullptr, " "); } free(text); } #endif new FXTabItem(tabbook, tr(" Driver ")); matrix = new FXMatrix(tabbook, 2, MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED|FRAME_THICK); label = new FXLabel(matrix, tr("Vendor:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%s",glGetString(GL_VENDOR)), nullptr, LABEL_NORMAL); label = new FXLabel(matrix, tr("Renderer:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%s",glGetString(GL_RENDERER)), nullptr, LABEL_NORMAL); label = new FXLabel(matrix, tr("GL Version:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%s",glGetString(GL_VERSION)), nullptr, LABEL_NORMAL); label = new FXLabel(matrix, tr("GLU Version:"), nullptr, LABEL_NORMAL|LAYOUT_RIGHT); label->setFont(thickfont); new FXLabel(matrix, FXString::value("%s", gluGetString(GLU_VERSION)), nullptr, LABEL_NORMAL); canvas->makeNonCurrent(); }
static Q3ListViewItem *get_gl_info(Display *dpy, int scrnum, Bool allowDirect,Q3ListViewItem *l1, Q3ListViewItem *after) { Window win; int attribSingle[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, None }; int attribDouble[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_DOUBLEBUFFER, None }; XSetWindowAttributes attr; unsigned long mask; Window root; GLXContext ctx; XVisualInfo *visinfo; int width = 100, height = 100; Q3ListViewItem *result = after; root = RootWindow(dpy, scrnum); visinfo = glXChooseVisual(dpy, scrnum, attribSingle); if (!visinfo) { visinfo = glXChooseVisual(dpy, scrnum, attribDouble); if (!visinfo) { kDebug() << "Error: couldn't find RGB GLX visual\n"; return result; } } attr.background_pixel = 0; attr.border_pixel = 0; attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone); attr.event_mask = StructureNotifyMask | ExposureMask; mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; win = XCreateWindow(dpy, root, 0, 0, width, height, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr); ctx = glXCreateContext( dpy, visinfo, NULL, allowDirect ); if (!ctx) { kDebug() << "Error: glXCreateContext failed\n"; XDestroyWindow(dpy, win); return result; } if (glXMakeCurrent(dpy, win, ctx)) { gli.serverVendor = glXQueryServerString(dpy, scrnum, GLX_VENDOR); gli.serverVersion = glXQueryServerString(dpy, scrnum, GLX_VERSION); gli.serverExtensions = glXQueryServerString(dpy, scrnum, GLX_EXTENSIONS); gli.clientVendor = glXGetClientString(dpy, GLX_VENDOR); gli.clientVersion = glXGetClientString(dpy, GLX_VERSION); gli.clientExtensions = glXGetClientString(dpy, GLX_EXTENSIONS); gli.glxExtensions = glXQueryExtensionsString(dpy, scrnum); gli.glVendor = (const char *) glGetString(GL_VENDOR); gli.glRenderer = (const char *) glGetString(GL_RENDERER); gli.glVersion = (const char *) glGetString(GL_VERSION); gli.glExtensions = (const char *) glGetString(GL_EXTENSIONS); gli.displayName = NULL; #ifdef KCMGL_DO_GLU gli.gluVersion = (const char *) gluGetString(GLU_VERSION); gli.gluExtensions = (const char *) gluGetString(GLU_EXTENSIONS); #endif IsDirect = glXIsDirect(dpy, ctx); result = print_screen_info(l1, after); } else { kDebug() << "Error: glXMakeCurrent failed\n"; glXDestroyContext(dpy, ctx); } glXDestroyContext(dpy, ctx); XDestroyWindow(dpy, win); return result; }
// Save OpenGL info to a file FXbool SettingsDialog::saveInformation(const FXString& filename) { FILE* fp = std::fopen(filename.text(),"w"); if (fp) { FXGLVisual *glvisual = static_cast<FXGLVisual*>(canvas->getVisual()); canvas->makeCurrent(); std::fprintf(fp,"Driver Information\n"); std::fprintf(fp,"------------------\n"); std::fprintf(fp,"\n"); std::fprintf(fp," Vendor: %s\n", glGetString(GL_VENDOR)); std::fprintf(fp," Renderer: %s\n", glGetString(GL_RENDERER)); std::fprintf(fp," GL Version: %s\n", glGetString(GL_VERSION)); std::fprintf(fp," GLU Version: %s\n", gluGetString(GLU_VERSION)); std::fprintf(fp,"\n"); std::fprintf(fp,"Implementation Limits\n"); std::fprintf(fp,"---------------------\n"); std::fprintf(fp,"\n"); GLint intval(0); GLint intvals[2] = {0, 0}; glGetIntegerv(GL_MAX_VIEWPORT_DIMS, intvals); std::fprintf(fp," Viewport Size: %d x %d\n", intvals[0], intvals[1]); glGetIntegerv(GL_MAX_TEXTURE_SIZE, &intval); std::fprintf(fp," Texture Size: %d\n", intval); #if defined(GL_MAX_TEXTURE_UNITS) glGetIntegerv(GL_MAX_TEXTURE_UNITS, &intval); std::fprintf(fp," Texture Units: %d\n", intval); #endif glGetIntegerv(GL_MAX_LIGHTS, &intval); std::fprintf(fp," Lights: %d\n", intval); glGetIntegerv(GL_MAX_CLIP_PLANES, &intval); std::fprintf(fp," Clipping Planes: %d\n", intval); glGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH,&intval); std::fprintf(fp," Modelview Stack: %d\n", intval); glGetIntegerv(GL_MAX_PROJECTION_STACK_DEPTH,&intval); std::fprintf(fp," Projection Stack: %d\n", intval); glGetIntegerv(GL_MAX_ATTRIB_STACK_DEPTH,&intval); std::fprintf(fp," Attribute Stack: %d\n", intval); #if defined(GL_MAX_VERTEX_ATTRIBS) glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &intval); std::fprintf(fp," Vertex Attributes: %d\n", intval); #else std::fprintf(fp," Vertex Attributes: -\n"); #endif #if defined(GL_MAX_VERTEX_UNIFORM_COMPONENTS) glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &intval); std::fprintf(fp," Vertex Uniform Components: %d\n", intval); #else std::fprintf(fp," Vertex Uniform Components: -\n"); #endif #if defined(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS) glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &intval); std::fprintf(fp," Fragment Uniform Components: %d\n", intval); #else std::fprintf(fp," Fragment Uniform Components: -\n"); #endif std::fprintf(fp,"\n"); std::fprintf(fp,"Display Mode\n"); std::fprintf(fp,"------------\n"); std::fprintf(fp,"\n"); std::fprintf(fp," Hardware Accelerated: %s\n", PRINT_YESNO(glvisual->isAccelerated())); std::fprintf(fp," Double Buffering: %s\n", PRINT_YESNO(glvisual->isDoubleBuffer())); std::fprintf(fp," Stereo View: %s\n", PRINT_YESNO(glvisual->isStereo())); std::fprintf(fp," Buffer-swap by copy: %s\n", PRINT_YESNO(glvisual->isBufferSwapCopy())); std::fprintf(fp," Color Depth: %d\n", glvisual->getActualRedSize()+glvisual->getActualGreenSize()+glvisual->getActualBlueSize()+glvisual->getActualAlphaSize()); std::fprintf(fp," Depth Buffer Size: %d\n", glvisual->getActualDepthSize()); std::fprintf(fp," Stencil Buffer Size: %d\n", glvisual->getActualStencilSize()); std::fprintf(fp," RGBA: %d-%d-%d-%d\n", glvisual->getActualRedSize(), glvisual->getActualGreenSize(), glvisual->getActualBlueSize(), glvisual->getActualAlphaSize()); std::fprintf(fp," Accum RGBA: %d-%d-%d-%d\n", glvisual->getActualAccumRedSize(), glvisual->getActualAccumGreenSize(), glvisual->getActualAccumBlueSize(), glvisual->getActualAccumAlphaSize()); std::fprintf(fp," Multi Sample: %d\n", glvisual->getActualMultiSamples()); std::fprintf(fp,"\n"); std::fprintf(fp,"Available Extensions\n"); std::fprintf(fp,"--------------------\n"); std::fprintf(fp,"\n"); for (FXint i=0; i < extensionlist->getNumItems(); i++) { std::fprintf(fp, " %s\n", extensionlist->getItemText(i).text()); } canvas->makeNonCurrent(); std::fclose(fp); return true; } return false; }
void glu_getstring( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { plhs[0]=mxCreateString((const char *)gluGetString((GLenum)mxGetScalar(prhs[0]))); }
void COpenGLExtensionHandler::initExtensions(bool stencilBuffer) { const f32 ver = (f32)atof((c8*)glGetString(GL_VERSION)); Version = core::floor32(ver)*100+(s32)(ver-floor(ver)); if ( Version >= 102) os::Printer::log("OpenGL driver version is 1.2 or better.", ELL_INFORMATION); else os::Printer::log("OpenGL driver version is not 1.2 or better.", ELL_WARNING); const GLubyte* t = glGetString(GL_EXTENSIONS); // os::Printer::log((const c8*)t, ELL_INFORMATION); #ifdef GLU_VERSION_1_3 const GLubyte* gluVersion = gluGetString(GLU_VERSION); if (gluVersion[0]>1 || gluVersion[3]>2) { for (u32 i=0; i<IRR_OpenGL_Feature_Count; ++i) FeatureAvailable[i] = gluCheckExtension((const GLubyte*)OpenGLFeatureStrings[i], t); } else #endif { s32 len = (s32)strlen((const char*)t); c8 *str = new c8[len+1]; c8* p = str; for (s32 i=0; i<len; ++i) { str[i] = (char)t[i]; if (str[i] == ' ') { str[i] = 0; for (u32 i=0; i<IRR_OpenGL_Feature_Count; ++i) if (strstr(p, OpenGLFeatureStrings[i])) FeatureAvailable[i] = true; p = p + strlen(p) + 1; } } delete [] str; } MultiTextureExtension = FeatureAvailable[IRR_ARB_multitexture]; MultiSamplingExtension = FeatureAvailable[IRR_ARB_multisample]; AnisotropyExtension = FeatureAvailable[IRR_EXT_texture_filter_anisotropic]; SeparateStencilExtension = FeatureAvailable[IRR_ATI_separate_stencil]; TextureCompressionExtension = FeatureAvailable[IRR_ARB_texture_compression]; PackedDepthStencilExtension = FeatureAvailable[IRR_EXT_packed_depth_stencil]; SeparateSpecularColorExtension = FeatureAvailable[IRR_EXT_separate_specular_color]; StencilBuffer=stencilBuffer; #ifdef _IRR_WINDOWS_API_ // get multitexturing function pointers pGlActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress("glActiveTextureARB"); pGlClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) wglGetProcAddress("glClientActiveTextureARB"); // get fragment and vertex program function pointers pGlGenProgramsARB = (PFNGLGENPROGRAMSARBPROC) wglGetProcAddress("glGenProgramsARB"); pGlBindProgramARB = (PFNGLBINDPROGRAMARBPROC) wglGetProcAddress("glBindProgramARB"); pGlProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC) wglGetProcAddress("glProgramStringARB"); pGlDeleteProgramsARB = (PFNGLDELETEPROGRAMSNVPROC) wglGetProcAddress("glDeleteProgramsARB"); pGlProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) wglGetProcAddress("glProgramLocalParameter4fvARB"); pGlCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) wglGetProcAddress("glCreateShaderObjectARB"); pGlShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) wglGetProcAddress("glShaderSourceARB"); pGlCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) wglGetProcAddress("glCompileShaderARB"); pGlCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) wglGetProcAddress("glCreateProgramObjectARB"); pGlAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) wglGetProcAddress("glAttachObjectARB"); pGlLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) wglGetProcAddress("glLinkProgramARB"); pGlUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) wglGetProcAddress("glUseProgramObjectARB"); pGlDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) wglGetProcAddress("glDeleteObjectARB"); pGlGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) wglGetProcAddress("glGetInfoLogARB"); pGlGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC) wglGetProcAddress("glGetObjectParameterivARB"); pGlGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) wglGetProcAddress("glGetUniformLocationARB"); pGlUniform4fvARB = (PFNGLUNIFORM4FVARBPROC) wglGetProcAddress("glUniform4fvARB"); pGlUniform1ivARB = (PFNGLUNIFORM1IVARBPROC) wglGetProcAddress("glUniform1ivARB"); pGlUniform1fvARB = (PFNGLUNIFORM1FVARBPROC) wglGetProcAddress("glUniform1fvARB"); pGlUniform2fvARB = (PFNGLUNIFORM2FVARBPROC) wglGetProcAddress("glUniform2fvARB"); pGlUniform3fvARB = (PFNGLUNIFORM3FVARBPROC) wglGetProcAddress("glUniform3fvARB"); pGlUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC) wglGetProcAddress("glUniformMatrix2fvARB"); pGlUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC) wglGetProcAddress("glUniformMatrix3fvARB"); pGlUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC) wglGetProcAddress("glUniformMatrix4fvARB"); pGlGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC) wglGetProcAddress("glGetActiveUniformARB"); // get point parameter extension pGlPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC) wglGetProcAddress("glPointParameterfARB"); pGlPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC) wglGetProcAddress("glPointParameterfvARB"); // get stencil extension pGlStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) wglGetProcAddress("glStencilFuncSeparate"); pGlStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) wglGetProcAddress("glStencilOpSeparate"); pGlStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC) wglGetProcAddress("glStencilFuncSeparateATI"); pGlStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC) wglGetProcAddress("glStencilOpSeparateATI"); // compressed textures #ifdef PFNGLCOMPRESSEDTEXIMAGE2DPROC pGlCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) wglGetProcAddress("glCompressedTexImage2D"); #endif // FrameBufferObjects pGlBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) wglGetProcAddress("glBindFramebufferEXT"); pGlDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC) wglGetProcAddress("glDeleteFramebuffersEXT"); pGlGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) wglGetProcAddress("glGenFramebuffersEXT"); pGlCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) wglGetProcAddress("glCheckFramebufferStatusEXT"); pGlFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) wglGetProcAddress("glFramebufferTexture2DEXT"); pGlBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC) wglGetProcAddress("glBindRenderbufferEXT"); pGlDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC) wglGetProcAddress("glDeleteRenderbuffersEXT"); pGlGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC) wglGetProcAddress("glGenRenderbuffersEXT"); pGlRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC) wglGetProcAddress("glRenderbufferStorageEXT"); pGlFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) wglGetProcAddress("glFramebufferRenderbufferEXT"); // vsync extension wglSwapIntervalEXT = (PFNWGLSWAPINTERVALFARPROC)wglGetProcAddress( "wglSwapIntervalEXT" ); #elif defined(_IRR_USE_LINUX_DEVICE_) || defined (_IRR_USE_SDL_DEVICE_) #ifdef _IRR_OPENGL_USE_EXTPOINTER_ #ifdef _IRR_USE_SDL_DEVICE_ #define IRR_OGL_LOAD_EXTENSION(x) SDL_GL_GetProcAddress(reinterpret_cast<const char*>(x)) #else // Accessing the correct function is quite complex // All libraries should support the ARB version, however // since GLX 1.4 the non-ARB version is the official one // So we have to check the runtime environment and // choose the proper symbol // In case you still have problems please enable the // next line by uncommenting it // #define _IRR_GETPROCADDRESS_WORKAROUND_ #ifndef _IRR_GETPROCADDRESS_WORKAROUND_ __GLXextFuncPtr (*IRR_OGL_LOAD_EXTENSION)(const GLubyte*)=0; #ifdef GLX_VERSION_1_4 int major,minor; glXQueryVersion(glXGetCurrentDisplay(), &major, &minor); if ((major>1) || (minor>3)) IRR_OGL_LOAD_EXTENSION=glXGetProcAddress; else #endif IRR_OGL_LOAD_EXTENSION=glXGetProcAddressARB; #else #define IRR_OGL_LOAD_EXTENSION glXGetProcAddressARB #endif #endif pGlActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glActiveTextureARB")); pGlClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glClientActiveTextureARB")); // get fragment and vertex program function pointers pGlGenProgramsARB = (PFNGLGENPROGRAMSARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGenProgramsARB")); pGlBindProgramARB = (PFNGLBINDPROGRAMARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glBindProgramARB")); pGlProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glProgramStringARB")); pGlDeleteProgramsARB = (PFNGLDELETEPROGRAMSNVPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glDeleteProgramsARB")); pGlProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glProgramLocalParameter4fvARB")); pGlCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glCreateShaderObjectARB")); pGlShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glShaderSourceARB")); pGlCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glCompileShaderARB")); pGlCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glCreateProgramObjectARB")); pGlAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glAttachObjectARB")); pGlLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glLinkProgramARB")); pGlUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUseProgramObjectARB")); pGlDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glDeleteObjectARB")); pGlGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGetInfoLogARB")); pGlGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGetObjectParameterivARB")); pGlGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGetUniformLocationARB")); pGlUniform4fvARB = (PFNGLUNIFORM4FVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform4fvARB")); pGlUniform1ivARB = (PFNGLUNIFORM1IVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform1ivARB")); pGlUniform1fvARB = (PFNGLUNIFORM1FVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform1fvARB")); pGlUniform2fvARB = (PFNGLUNIFORM2FVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform2fvARB")); pGlUniform3fvARB = (PFNGLUNIFORM3FVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform3fvARB")); pGlUniform4fvARB = (PFNGLUNIFORM4FVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniform4fvARB")); pGlUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniformMatrix2fvARB")); pGlUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniformMatrix3fvARB")); pGlUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glUniformMatrix4fvARB")); pGlGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGetActiveUniformARB")); // get point parameter extension pGlPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glPointParameterfARB")); pGlPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glPointParameterfvARB")); // get stencil extension pGlStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glStencilFuncSeparate")); pGlStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glStencilOpSeparate")); pGlStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glStencilFuncSeparateATI")); pGlStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glStencilOpSeparateATI")); // compressed textures #ifdef PFNGLCOMPRESSEDTEXIMAGE2DPROC pGlCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glCompressedTexImage2D")); #endif #if defined(GLX_SGI_swap_control) && !defined(_IRR_USE_SDL_DEVICE_) // get vsync extension glxSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glXSwapIntervalSGI")); #endif // FrameBufferObjects pGlBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glBindFramebufferEXT")); pGlDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glDeleteFramebuffersEXT")); pGlGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGenFramebuffersEXT")); pGlCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glCheckFramebufferStatusEXT")); pGlFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glFramebufferTexture2DEXT")); pGlBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glBindRenderbufferEXT")); pGlDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glDeleteRenderbuffersEXT")); pGlGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glGenRenderbuffersEXT")); pGlRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glRenderbufferStorageEXT")); pGlFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) IRR_OGL_LOAD_EXTENSION(reinterpret_cast<const GLubyte*>("glFramebufferRenderbufferEXT")); #endif // _IRR_OPENGL_USE_EXTPOINTER_ #endif // _IRR_WINDOWS_API_ // set some properties glGetIntegerv(GL_MAX_TEXTURE_UNITS, &MaxTextureUnits); glGetIntegerv(GL_MAX_LIGHTS, &MaxLights); glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &MaxAnisotropy); #ifdef _IRR_OPENGL_USE_EXTPOINTER_ if (!pGlActiveTextureARB || !pGlClientActiveTextureARB) { MultiTextureExtension = false; os::Printer::log("Failed to load OpenGL's multitexture extension, proceeding without.", ELL_WARNING); } else #endif if (MaxTextureUnits < 2) { MultiTextureExtension = false; os::Printer::log("Warning: OpenGL device only has one texture unit. Disabling multitexturing.", ELL_WARNING); } MaxTextureUnits = core::min_((u32)MaxTextureUnits,MATERIAL_MAX_TEXTURES); glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &MaxIndices); }
int main (int argc, char** argv) { GLenum err; GLContext ctx; /* ---------------------------------------------------------------------- */ /* parse arguments */ if (GL_TRUE == ParseArgs(argc-1, argv+1)) { #if defined(_WIN32) fprintf(stderr, "Usage: visualinfo [-a] [-s] [-h] [-pf <id>]\n"); fprintf(stderr, " -a: show all visuals\n"); fprintf(stderr, " -s: display to stdout instead of visualinfo.txt\n"); fprintf(stderr, " -pf <id>: use given pixelformat\n"); fprintf(stderr, " -h: this screen\n"); #else fprintf(stderr, "Usage: visualinfo [-h] [-display <display>] [-visual <id>]\n"); fprintf(stderr, " -h: this screen\n"); fprintf(stderr, " -display <display>: use given display\n"); fprintf(stderr, " -visual <id>: use given visual\n"); #endif return 1; } /* ---------------------------------------------------------------------- */ /* create OpenGL rendering context */ InitContext(&ctx); if (GL_TRUE == CreateContext(&ctx)) { fprintf(stderr, "Error: CreateContext failed\n"); DestroyContext(&ctx); return 1; } /* ---------------------------------------------------------------------- */ /* initialize GLEW */ glewExperimental = GL_TRUE; #ifdef GLEW_MX err = glewContextInit(glewGetContext()); # ifdef _WIN32 err = err || wglewContextInit(wglewGetContext()); # elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) err = err || glxewContextInit(glxewGetContext()); # endif #else err = glewInit(); #endif if (GLEW_OK != err) { fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err)); DestroyContext(&ctx); return 1; } /* ---------------------------------------------------------------------- */ /* open file */ #if defined(_WIN32) if (!displaystdout) file = fopen("visualinfo.txt", "w"); if (file == NULL) file = stdout; #else file = stdout; #endif /* ---------------------------------------------------------------------- */ /* output header information */ /* OpenGL extensions */ fprintf(file, "OpenGL vendor string: %s\n", glGetString(GL_VENDOR)); fprintf(file, "OpenGL renderer string: %s\n", glGetString(GL_RENDERER)); fprintf(file, "OpenGL version string: %s\n", glGetString(GL_VERSION)); fprintf(file, "OpenGL extensions (GL_): \n"); PrintExtensions((char*)glGetString(GL_EXTENSIONS)); /* GLU extensions */ fprintf(file, "GLU version string: %s\n", gluGetString(GLU_VERSION)); fprintf(file, "GLU extensions (GLU_): \n"); PrintExtensions((char*)gluGetString(GLU_EXTENSIONS)); /* ---------------------------------------------------------------------- */ /* extensions string */ #if defined(_WIN32) /* WGL extensions */ if (WGLEW_ARB_extensions_string || WGLEW_EXT_extensions_string) { fprintf(file, "WGL extensions (WGL_): \n"); PrintExtensions(wglGetExtensionsStringARB ? (char*)wglGetExtensionsStringARB(ctx.dc) : (char*)wglGetExtensionsStringEXT()); } #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX) #else /* GLX extensions */ fprintf(file, "GLX extensions (GLX_): \n"); PrintExtensions(glXQueryExtensionsString(glXGetCurrentDisplay(), DefaultScreen(glXGetCurrentDisplay()))); #endif /* ---------------------------------------------------------------------- */ /* enumerate all the formats */ VisualInfo(&ctx); /* ---------------------------------------------------------------------- */ /* release resources */ DestroyContext(&ctx); if (file != stdout) fclose(file); return 0; }
//=========================================================================== // DG_Init // 'mode' is either DGL_MODE_WINDOW or DGL_MODE_FULLSCREEN. If 'bpp' is // zero, the current display color depth is used. //=========================================================================== int DG_Init(int width, int height, int bpp, int mode) { boolean fullscreen = (mode == DGL_MODE_FULLSCREEN); char *token, *extbuf; const SDL_VideoInfo *info = NULL; Con_Message("DG_Init: OpenGL.\n"); // Are we in range here? /* if(!fullscreen) { if(width > GetSystemMetrics(SM_CXSCREEN)) width = GetSystemMetrics(SM_CXSCREEN); if(height > GetSystemMetrics(SM_CYSCREEN)) height = GetSystemMetrics(SM_CYSCREEN); } */ info = SDL_GetVideoInfo(); screenBits = info->vfmt->BitsPerPixel; screenWidth = width; screenHeight = height; windowed = !fullscreen; allowCompression = true; verbose = ArgExists("-verbose"); // Set GL attributes. We want at least 5 bits per color and a 16 // bit depth buffer. Plus double buffering, of course. SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); /* if(fullscreen) { if(!fullscreenMode(screenWidth, screenHeight, bpp)) { Con_Error("drOpenGL.Init: Resolution change failed (%d x %d).\n", screenWidth, screenHeight); } } else { windowedMode(screenWidth, screenHeight); } */ if(!initOpenGL()) { Con_Error("drOpenGL.Init: OpenGL init failed.\n"); } // Clear the buffers. DG_Clear(DGL_COLOR_BUFFER_BIT | DGL_DEPTH_BUFFER_BIT); token = (char *) glGetString(GL_EXTENSIONS); extbuf = malloc(strlen(token) + 1); strcpy(extbuf, token); // Check the maximum texture size. glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTexSize); initExtensions(); if(firstTimeInit) { firstTimeInit = DGL_FALSE; // Print some OpenGL information (console must be initialized by now). Con_Message("OpenGL information:\n"); Con_Message(" Vendor: %s\n", glGetString(GL_VENDOR)); Con_Message(" Renderer: %s\n", glGetString(GL_RENDERER)); Con_Message(" Version: %s\n", glGetString(GL_VERSION)); Con_Message(" Extensions:\n"); // Show the list of GL extensions. token = strtok(extbuf, " "); while(token) { Con_Message(" "); // Indent. if(verbose) { // Show full names. Con_Message("%s\n", token); } else { // Two on one line, clamp to 30 characters. Con_Message("%-30.30s", token); token = strtok(NULL, " "); if(token) Con_Message(" %-30.30s", token); Con_Message("\n"); } token = strtok(NULL, " "); } Con_Message(" GLU Version: %s\n", gluGetString(GLU_VERSION)); glGetIntegerv(GL_MAX_TEXTURE_UNITS, &maxTexUnits); #ifndef USE_MULTITEXTURE maxTexUnits = 1; #endif // But sir, we are simple people; two units is enough. if(maxTexUnits > 2) maxTexUnits = 2; Con_Message(" Texture units: %i\n", maxTexUnits); Con_Message(" Maximum texture size: %i\n", maxTexSize); if(extAniso) { glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAniso); Con_Message(" Maximum anisotropy: %g\n", maxAniso); } //if(!noArrays) Con_Message(" Using vertex arrays.\n"); } free(extbuf); // Decide whether vertex arrays should be done manually or with real // OpenGL calls. InitArrays(); if(ArgCheck("-dumptextures")) { dumpTextures = DGL_TRUE; Con_Message(" Dumping textures (mipmap level zero).\n"); } if(extAniso && ArgExists("-anifilter")) { useAnisotropic = DGL_TRUE; Con_Message(" Using anisotropic texture filtering.\n"); } return DGL_OK; }