/////////////////////////////////////////////////////////////////////////////// // This function determines if the named OpenGL Extension is supported // Returns 1 or 0 int gltIsExtSupported(const char *extension) { #ifndef OPENGL_ES GLint nNumExtensions; glGetIntegerv(GL_NUM_EXTENSIONS, &nNumExtensions); for(GLint i = 0; i < nNumExtensions; i++) if(strcmp(extension, (const char *)glGetStringi(GL_EXTENSIONS, i)) == 0) return 1; #else GLubyte *extensions = NULL; const GLubyte *start; GLubyte *where, *terminator; where = (GLubyte *) strchr(extension, ' '); if (where || *extension == '\0') return 0; extensions = (GLubyte *)glGetString(GL_EXTENSIONS); start = extensions; for (;;) { where = (GLubyte *) strstr((const char *) start, extension); if (!where) break; terminator = where + strlen(extension); if (where == start || *(where - 1) == ' ') { if (*terminator == ' ' || *terminator == '\0') return 1; } start = terminator; } #endif return 0; }
vector<string> ofGLSupportedExtensions(){ #ifdef TARGET_OPENGLES char* extensions = (char*)glGetString(GL_EXTENSIONS); if(extensions){ string extensions_str = extensions; return ofSplitString(extensions_str," "); }else{ return vector<string>(); } #else int numExtensions=0; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); std::vector<std::string> extensions; for(int i=0;i<numExtensions;i++){ char* extension = (char*)glGetStringi(GL_EXTENSIONS, i); if(extension){ extensions.emplace_back(extension); } } return extensions; #endif }
static void CollectExtensions() { const char *extension; int max = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &max); if (0 == max) { // Try old method to collect extensions const char *supported = (char *)glGetString(GL_EXTENSIONS); if (nullptr != supported) { char *extensions = new char[strlen(supported) + 1]; strcpy(extensions, supported); char *extension = strtok(extensions, " "); while (extension) { m_Extensions.Push(FString(extension)); extension = strtok(nullptr, " "); } delete [] extensions; } } else { // Use modern method to collect extensions for (int i = 0; i < max; i++) { extension = (const char*)glGetStringi(GL_EXTENSIONS, i); m_Extensions.Push(FString(extension)); } } }
void piglit_init(int argc, char **argv) { const char *renderer = (const char *) glGetString(GL_RENDERER); const char *version = (const char *) glGetString(GL_VERSION); const char *vendor = (const char *) glGetString(GL_VENDOR); printf("GL_RENDERER = %s\n", renderer); printf("GL_VERSION = %s\n", version); printf("GL_VENDOR = %s\n", vendor); if (version[0] >= '2') { printf("GL_SHADING_LANGUAGE_VERSION = %s\n", (const char *) glGetString(GL_SHADING_LANGUAGE_VERSION)); } printf("Extensions:\n"); if (version[0] >= '3') { GLint numExt, i; glGetIntegerv(GL_NUM_EXTENSIONS, &numExt); for (i = 0; i < numExt; i++) { printf("%s\n", (const char *) glGetStringi(GL_EXTENSIONS, i)); } } else { const char *ext = (const char *) glGetString(GL_EXTENSIONS); const char *c = ext; for (c = ext; *c; c++) { if (*c == ' ') putchar('\n'); else putchar(*c); } } piglit_report_result(PIGLIT_PASS); }
bool Context::hasExtension(const char *string) { os::log("glws.cpp hasExtension"); if (extensions.empty()) { if (isCoreProfile(profile)) { // Use glGetStringi GLint num_extensions = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions); for (int i = 0; i < num_extensions; ++i) { const char *extension = reinterpret_cast<const char *>(glGetStringi(GL_EXTENSIONS, i)); if (extension) { extensions.insert(extension); } } } else { // Use glGetString const char *begin = reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)); do { const char *end = begin; char c = *end; while (c != '\0' && c != ' ') { ++end; c = *end; } if (end != begin) { extensions.insert(std::string(begin, end)); } if (c == '\0') { break; } begin = end + 1; } while(1); } } return extensions.find(string) != extensions.end(); }
void GLUtils::DebugPrintGLInfo() { const char* vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR)); const char* renderer = reinterpret_cast<const char*>(glGetString(GL_RENDERER)); const char* version = reinterpret_cast<const char*>(glGetString(GL_VERSION)); const char* glslVersion = reinterpret_cast<const char*>(glGetString( GL_SHADING_LANGUAGE_VERSION)); GLint major, minor; glGetIntegerv(GL_MAJOR_VERSION, &major); glGetIntegerv(GL_MINOR_VERSION, &minor); wxLogDebug("Renderer info: %s version %s from %s", renderer, version, vendor); wxLogDebug("GL version major: %s minor: %s", major, minor); wxLogDebug("GLSL version: %s", glslVersion); GLint numExtensions; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); for(int extension = 0; extension < numExtensions; extension++) { wxLogDebug("Extension: %s\n", glGetStringi(GL_EXTENSIONS, extension)); } }
/** Returns a space-separated list of all GL extensions. Used for hardware * reporting. */ const std::string getGLExtensions() { std::string result; if (glGetStringi != NULL) { GLint num_extensions = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions); for (GLint i = 0; i < num_extensions; i++) { const char* extension = (const char*)glGetStringi(GL_EXTENSIONS, i); if(result.size()>0) result += " "; result += extension; } } else { const char* extensions = (const char*) glGetString(GL_EXTENSIONS); result = extensions; } return result; } // getGLExtensions
qboolean GL_CheckForExtension(const char *ext) { #ifdef FEATURE_RENDERER2 int i = 0, exts = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &exts); for (i = 0; i < exts; i++) { if (!Q_stricmp(ext, (char *)glGetStringi(GL_EXTENSIONS, i))) { return qtrue; } } return qfalse; #else const char *ptr = Q_stristr(glConfig.extensions_string, ext); if (ptr == NULL) { return qfalse; } ptr += strlen(ext); return ((*ptr == ' ') || (*ptr == '\0')); // verify it's complete string. #endif }
inline std::string getOpenGLExtensions() { std::string ext; if (Has_GL_Version_3_0||Has_GL_Version_4_0) { int count = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &count); for( int i=0; i<count; ++i ) { ext += std::string((char*)glGetStringi(GL_EXTENSIONS, i)) + " "; VL_CHECK_OGL(); } } else { VL_CHECK(glGetString(GL_EXTENSIONS)); ext = (const char*)glGetString(GL_EXTENSIONS); // make sure also the last extension ends with a space ext.push_back(' '); } return ext; }
bool EnvironmentCore::isExtensionAvailable( const std::string &extName ) { static bool sInitialized = false; static std::set<std::string> sExtensions; if( ! sInitialized ) { GLint loop; GLint numExtensions = 0; glGetIntegerv( GL_NUM_EXTENSIONS, &numExtensions ); for( loop = 0; loop < numExtensions; loop++) { std::string s = (const char *)glGetStringi( GL_EXTENSIONS, loop ); std::transform( s.begin(), s.end(), s.begin(), static_cast<int(*)(int)>( tolower ) ); sExtensions.insert( s ); } sInitialized = true; } // convert to lower case std::string extension = extName; std::transform( extension.begin(), extension.end(), extension.begin(), static_cast<int(*)(int)>( tolower ) ); return sExtensions.count( extension ) > 0; }
bool hasGLExtension(const char* extension) { #if !defined(USE_GLES2) if (glGetStringi != NULL) { GLint numExtensions = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); for (GLint i = 0; i < numExtensions; i++) { const char* foundExtension = (const char*) glGetStringi(GL_EXTENSIONS, i); if (foundExtension && strcmp(foundExtension, extension) == 0) { return true; } } } else #endif { const char* extensions = (const char*) glGetString(GL_EXTENSIONS); static std::vector<std::string> all_extensions; if (all_extensions.empty()) { all_extensions = StringUtils::split(std::string(extensions), ' '); } for (unsigned i = 0; i < all_extensions.size(); i++) { if (all_extensions[i] == extension) { return true; } } } return false; } // hasGLExtension
void GLUtils::dumpGLInfo(bool dumpExtensions) { const GLubyte *renderer = glGetString( GL_RENDERER ); const GLubyte *vendor = glGetString( GL_VENDOR ); const GLubyte *version = glGetString( GL_VERSION ); const GLubyte *glslVersion = glGetString( GL_SHADING_LANGUAGE_VERSION ); GLint major, minor; glGetIntegerv(GL_MAJOR_VERSION, &major); glGetIntegerv(GL_MINOR_VERSION, &minor); printf("GL Vendor : %s\n", vendor); printf("GL Renderer : %s\n", renderer); printf("GL Version : %s\n", version); printf("GL Version : %d.%d\n", major, minor); printf("GLSL Version : %s\n", glslVersion); if( dumpExtensions ) { GLint nExtensions; glGetIntegerv(GL_NUM_EXTENSIONS, &nExtensions); for( int i = 0; i < nExtensions; i++ ) { printf("%s\n", glGetStringi(GL_EXTENSIONS, i)); } } }
void Initialize() { printf("Version Pilote OpenGL : %s\n", glGetString(GL_VERSION)); printf("Type de GPU : %s\n", glGetString(GL_RENDERER)); printf("Fabricant : %s\n", glGetString(GL_VENDOR)); printf("Version GLSL : %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); int numExtensions; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); GLenum error = glewInit(); if (error != GL_NO_ERROR) { // TODO } for (int index = 0; index < numExtensions; ++index) { printf("Extension[%d] : %s\n", index, glGetStringi(GL_EXTENSIONS, index)); } #ifdef _WIN32 // on coupe la synchro vertical pour voir l'effet du delta time wglSwapIntervalEXT(0); #endif basicShader.LoadVertexShader("basic.vs"); basicShader.LoadFragmentShader("basic.fs"); basicShader.Create(); auto program = basicShader.GetProgram(); // UN UBO SERAIT UTILE ICI auto basicProgram = basicShader.GetProgram(); auto blockIndex = glGetUniformBlockIndex(basicProgram, "ViewProj"); GLuint blockBinding = 1; glGenBuffers(1, &g_Camera.UBO); glBindBuffer(GL_UNIFORM_BUFFER, g_Camera.UBO); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(g_Camera.projectionMatrix)); glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(g_Camera.viewMatrix)); glBindBufferBase(GL_UNIFORM_BUFFER, blockBinding, g_Camera.UBO); glBindBuffer(GL_UNIFORM_BUFFER, 0); glUniformBlockBinding(basicProgram, blockIndex, blockBinding); previousTime = glutGet(GLUT_ELAPSED_TIME); InitCube(); glBindVertexArray(g_Cube.VAO); glBindVertexArray(g_Cube.IBO); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, 0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, (void*)iPosSize); // render states par defaut glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_CULL_FACE); }
CStdGLCtx *CStdGL::CreateContext(C4Window * pWindow, C4AbstractApp *pApp) { // safety if (!pWindow) return NULL; // create it CStdGLCtx *pCtx = new CStdGLCtx(); bool first_ctx = !pMainCtx; if (first_ctx) { pMainCtx = pCtx; LogF(" gl: Create first %scontext...", Config.Graphics.DebugOpenGL ? "debug " : ""); } bool success = pCtx->Init(pWindow, pApp); if (Config.Graphics.DebugOpenGL && glDebugMessageCallbackARB) { if (first_ctx) Log(" gl: Setting OpenGLDebugProc callback"); glDebugMessageCallbackARB(&OpenGLDebugProc, nullptr); glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); #ifdef GL_KHR_debug if (GLEW_KHR_debug) glEnable(GL_DEBUG_OUTPUT); #endif } // First context: Log some information about hardware/drivers // Must log after context creation to get valid results if (first_ctx) { const char *gl_vendor = reinterpret_cast<const char *>(glGetString(GL_VENDOR)); const char *gl_renderer = reinterpret_cast<const char *>(glGetString(GL_RENDERER)); const char *gl_version = reinterpret_cast<const char *>(glGetString(GL_VERSION)); LogF("GL %s on %s (%s)", gl_version ? gl_version : "", gl_renderer ? gl_renderer : "", gl_vendor ? gl_vendor : ""); if (Config.Graphics.DebugOpenGL) { // Dump extension list if (glGetStringi) { GLint gl_extension_count = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &gl_extension_count); if (gl_extension_count == 0) { LogSilentF("No available extensions."); } else { LogSilentF("%d available extensions:", gl_extension_count); for (GLint i = 0; i < gl_extension_count; ++i) { const char *gl_extension = (const char*)glGetStringi(GL_EXTENSIONS, i); LogSilentF(" %4d: %s", i, gl_extension); } } } else { const char *gl_extensions = reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)); LogSilentF("GLExt: %s", gl_extensions ? gl_extensions : ""); } } } if (!success) { delete pCtx; Error(" gl: Error creating secondary context!"); return NULL; } // creation selected the new context - switch back to previous context RenderTarget = NULL; pCurrCtx = NULL; // done return pCtx; }
void GL::init() { static bool init = false; const GLubyte* str; if( init ) return; init = true; /* version check */ str = glGetString( GL_VERSION ); parseVersion( ( const char* ) str, &_glmajor, &_glminor ); str = glGetString( GL_SHADING_LANGUAGE_VERSION ); parseVersion( ( const char* ) str, &_glslmajor, &_glslminor ); if( _glmajor < 2 || ( _glmajor == 2 && _glminor == 0 ) ) { std::cerr << "GL Version too old, at least GL 2.1 is needed" << std::endl; std::exit( EXIT_FAILURE ); } if( _glslmajor == 1 && _glslminor < 20 ) { std::cerr << "GLSL Version too old, at least GLSL 1.20 is needed" << std::endl; std::exit( EXIT_FAILURE ); } /* extensions check */ if( _glmajor > 2 ) { int numext; glGetIntegerv( GL_NUM_EXTENSIONS, &numext ); for( int i = 0; i < numext; i++ ) { _extensions.push_back( ( const char* ) glGetStringi( GL_EXTENSIONS, i ) ); } } else { String cvtstr( ( const char* ) glGetString( GL_EXTENSIONS ) ); cvtstr.tokenize( _extensions, ' ' ); } if( existsExtension( "GL_ARB_vertex_array_object" ) || ( _glmajor > 2 || ( _glmajor == 2 && _glminor >= 1 ) ) ) { glGenVertexArrays = ( void (*)( GLsizei, GLuint* ) ) getProcAddress( "glGenVertexArrays" ); glDeleteVertexArrays = ( void (*)( GLsizei, const GLuint* ) ) getProcAddress( "glDeleteVertexArrays" ); glBindVertexArray = ( void (*)( GLuint ) ) getProcAddress( "glBindVertexArray" ); glIsVertexArray = ( GLboolean (*)( GLuint ) ) getProcAddress( "glIsVertexArray" ); } else if( existsExtension( "GL_APPLE_vertex_array_object" ) ) { glGenVertexArrays = ( void (*)( GLsizei, GLuint* ) ) getProcAddress( "glGenVertexArraysAPPLE" ); glDeleteVertexArrays = ( void (*)( GLsizei, const GLuint* ) ) getProcAddress( "glDeleteVertexArraysAPPLE" ); glBindVertexArray = ( void (*)( GLuint ) ) getProcAddress( "glBindVertexArrayAPPLE" ); glIsVertexArray = ( GLboolean (*)( GLuint ) ) getProcAddress( "glIsVertexArrayAPPLE" ); } else { std::cerr << "GL vertex array object extension missing" << std::endl; std::exit( EXIT_FAILURE ); } if( !existsExtension( "GL_ARB_texture_non_power_of_two" ) && _glmajor <= 2 ) { std::cerr << "GL texture non power of two extension missing" << std::endl; std::exit( EXIT_FAILURE ); } if( existsExtension( "GL_EXT_framebuffer_object" ) || existsExtension( "GL_ARB_framebuffer_object" ) || _glmajor > 2 ) { glBindRenderbuffer = ( void (*)( GLenum target, GLuint renderbuffer) ) getProcAddress( "glBindRenderbuffer" ); glDeleteRenderbuffers = ( void (*)( GLsizei n, const GLuint *renderbuffers) ) getProcAddress( "glDeleteRenderbuffers" ); glGenRenderbuffers = ( void (*)( GLsizei n, GLuint *renderbuffers) ) getProcAddress( "glGenRenderbuffers" ); glRenderbufferStorage = ( void (*)( GLenum target, GLenum internalformat, GLsizei width, GLsizei height) ) getProcAddress( "glRenderbufferStorage" ); glBindFramebuffer = ( void (*)( GLenum target, GLuint framebuffer ) ) getProcAddress( "glBindFramebuffer" ); glDeleteFramebuffers = ( void (*)( GLsizei n, const GLuint *framebuffers ) ) getProcAddress( "glDeleteFramebuffers" ); glGenFramebuffers = ( void (*)( GLsizei n, GLuint *framebuffers ) ) getProcAddress( "glGenFramebuffers" ); glFramebufferTexture1D = ( void (*)( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) ) getProcAddress( "glFramebufferTexture1D" ); glFramebufferTexture2D = ( void (*)( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) ) getProcAddress( "glFramebufferTexture2D" ); glFramebufferTexture3D = ( void (*)( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset ) ) getProcAddress( "glFramebufferTexture3D" ); glFramebufferRenderbuffer = ( void (*)( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) ) getProcAddress( "glFramebufferRenderbuffer" ); } else { std::cerr << "GL framebuffer extension missing" << std::endl; std::exit( EXIT_FAILURE ); } }
void LogGraphicsInfo() { #if defined(HAS_GL) || defined(HAS_GLES) const GLubyte *s; s = glGetString(GL_VENDOR); if (s) CLog::Log(LOGNOTICE, "GL_VENDOR = %s", s); else CLog::Log(LOGNOTICE, "GL_VENDOR = NULL"); s = glGetString(GL_RENDERER); if (s) CLog::Log(LOGNOTICE, "GL_RENDERER = %s", s); else CLog::Log(LOGNOTICE, "GL_RENDERER = NULL"); s = glGetString(GL_VERSION); if (s) CLog::Log(LOGNOTICE, "GL_VERSION = %s", s); else CLog::Log(LOGNOTICE, "GL_VERSION = NULL"); s = glGetString(GL_SHADING_LANGUAGE_VERSION); if (s) CLog::Log(LOGNOTICE, "GL_SHADING_LANGUAGE_VERSION = %s", s); else CLog::Log(LOGNOTICE, "GL_SHADING_LANGUAGE_VERSION = NULL"); //GL_NVX_gpu_memory_info extension #define GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX 0x9047 #define GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX 0x9048 #define GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX 0x9049 #define GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX 0x904A #define GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX 0x904B if (CServiceBroker::GetRenderSystem()->IsExtSupported("GL_NVX_gpu_memory_info")) { GLint mem = 0; glGetIntegerv(GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX, &mem); CLog::Log(LOGNOTICE, "GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX = %i", mem); //this seems to be the amount of ram on the videocard glGetIntegerv(GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX, &mem); CLog::Log(LOGNOTICE, "GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX = %i", mem); } std::string extensions; #if defined(HAS_GL) unsigned int renderVersionMajor, renderVersionMinor; CServiceBroker::GetRenderSystem()->GetRenderVersion(renderVersionMajor, renderVersionMinor); if (renderVersionMajor > 3 || (renderVersionMajor == 3 && renderVersionMinor >= 2)) { GLint n; glGetIntegerv(GL_NUM_EXTENSIONS, &n); if (n > 0) { GLint i; for (i = 0; i < n; i++) { extensions += (const char*)glGetStringi(GL_EXTENSIONS, i); extensions += " "; } } } else #endif { extensions += (const char*) glGetString(GL_EXTENSIONS); } if (!extensions.empty()) CLog::Log(LOGNOTICE, "GL_EXTENSIONS = %s", extensions.c_str()); else CLog::Log(LOGNOTICE, "GL_EXTENSIONS = NULL"); #else /* !HAS_GL */ CLog::Log(LOGNOTICE, "Please define LogGraphicsInfo for your chosen graphics library"); #endif /* !HAS_GL */ }
/** * @brief This routine is responsible for initializing the OS specific portions of OpenGL */ void GLimp_Init(void) { r_allowSoftwareGL = ri.Cvar_Get("r_allowSoftwareGL", "0", CVAR_LATCH); r_allowResize = ri.Cvar_Get("r_allowResize", "0", CVAR_ARCHIVE); r_centerWindow = ri.Cvar_Get("r_centerWindow", "0", CVAR_ARCHIVE); if (ri.Cvar_VariableIntegerValue("com_abnormalExit")) { ri.Cvar_Set("r_mode", va("%d", R_MODE_FALLBACK)); ri.Cvar_Set("r_fullscreen", "0"); ri.Cvar_Set("r_centerWindow", "0"); ri.Cvar_Set("com_abnormalExit", "0"); } ri.Sys_GLimpInit(); // Create the window and set up the context if (GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, r_noborder->integer)) { goto success; } // Try again, this time in a platform specific "safe mode" ri.Sys_GLimpSafeInit(); if (GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, qfalse)) { goto success; } // Finally, try the default screen resolution if (r_mode->integer != R_MODE_FALLBACK) { Ren_Print("Setting r_mode %d failed, falling back on r_mode %d\n", r_mode->integer, R_MODE_FALLBACK); if (GLimp_StartDriverAndSetMode(R_MODE_FALLBACK, qfalse, qfalse)) { goto success; } } // Nothing worked, give up Ren_Fatal("GLimp_Init() - could not load OpenGL subsystem\n"); success: //Clear the screen with a black color thanks Glimp_ClearScreen(); #ifdef FEATURE_RENDERER2 if (glConfig.driverType != GLDRV_OPENGL3) { glConfig.driverType = GLDRV_ICD; } #else // This values force the UI to disable driver selection glConfig.driverType = GLDRV_ICD; #endif glConfig.hardwareType = GLHW_GENERIC; // Only using SDL_SetWindowBrightness to determine if hardware gamma is supported glConfig.deviceSupportsGamma = !r_ignorehwgamma->integer && SDL_SetWindowBrightness(main_window, 1.0f) >= 0; // Get extension strings if (glConfig.driverType != GLDRV_OPENGL3) { Q_strncpyz(glConfig.extensions_string, ( char * ) glGetString(GL_EXTENSIONS), sizeof(glConfig.extensions_string)); } #ifndef FEATURE_RENDERER_GLES else { int i = 0, exts = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &exts); glConfig.extensions_string[0] = 0; for (i = 0; i < exts; i++) { if (strlen(glConfig.extensions_string) + 100 >= sizeof(glConfig.extensions_string)) { //Just so we wont error out when there are really a lot of extensions break; } Q_strcat(glConfig.extensions_string, sizeof(glConfig.extensions_string), va("%s ", glGetStringi(GL_EXTENSIONS, i))); } } #endif // FEATURE_RENDERER_GLES // initialize extensions GLimp_SetHardware(); #ifdef FEATURE_RENDERER2 GLimp_InitExtensionsR2(); // renderer2 #else GLimp_InitExtensions(); // vanilla renderer #endif ri.Cvar_Get("r_availableModes", "", CVAR_ROM); // This depends on SDL_INIT_VIDEO, hence having it here ri.IN_Init(); }
static void Init(void) { const GLubyte *extensions; GLboolean hasDebugExtension; extensions = glGetString(GL_EXTENSIONS); checkGlError("glGetString(GL_EXTENSIONS)"); hasDebugExtension = checkExtension(debugExtensionString, extensions); if (GLEW_VERSION_3_0) { GLboolean hasDebugExtension3 = GL_FALSE; GLint i; GLint num_extensions = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions); checkGlError("glGetIntegerv(GL_NUM_EXTENSIONS)"); for (i = 0; i < num_extensions; ++i) { const char *extension; extension = (const char *)glGetStringi(GL_EXTENSIONS, i); checkGlError("glGetStringi(GL_EXTENSIONS, i)"); if (strlen(extension) == 0) { fprintf(stderr, "error: glGetStringi returned empty string\n"); exit(1); } if (strcmp(extension, debugExtensionString) == 0) { hasDebugExtension3 = GL_TRUE; } } if (hasDebugExtension != hasDebugExtension3) { fprintf(stderr, "error: %s not consistently supported by GL3\n", debugExtensionString); exit(1); } } glewInit(); if (hasDebugExtension != glewIsSupported(debugExtensionString)) { fprintf(stderr, "error: %s not consistently supported by GLEW\n", debugExtensionString); exit(1); } if (hasDebugExtension) { switch (debugExtension) { case KHR_DEBUG: debugMessageInsert = khrDebugMessageInsert; pushDebugGroup = khrPushDebugGroup; popDebugGroup = khrPopDebugGroup; objectLabel = glObjectLabel; getObjectLabel = glGetObjectLabel; break; case ARB_DEBUG_OUTPUT: debugMessageInsert = arbDebugMessageInsert; break; case AMD_DEBUG_OUTPUT: debugMessageInsert = amdDebugMessageInsert; break; case EXT_DEBUG_MARKER: debugMessageInsert = extDebugMessageInsert; pushDebugGroup = extPushDebugGroup; popDebugGroup = extPopDebugGroup; break; } } else { fprintf(stderr, "warning: %s not supported\n", debugExtensionString); } debugMessageInsert(-1, __FUNCTION__); pushDebugGroup(-1, __FUNCTION__); glClearColor(0.3, 0.1, 0.3, 1.0); popDebugGroup(); // texture label GLuint texture = 0; glGenTextures(1, &texture); objectLabel(GL_TEXTURE, texture, -1, "texture"); glBindTexture(GL_TEXTURE_2D, texture); glTexImage2D(GL_TEXTURE_2D, 0, 3, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); // framebuffer color attachment label GLuint framebuffer = 0; glGenFramebuffers(1, &framebuffer); glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0); }
void CheckGLExtensions() { #if !PPSSPP_PLATFORM(UWP) // Make sure to only do this once. It's okay to call CheckGLExtensions from wherever. if (extensionsDone) return; extensionsDone = true; memset(&gl_extensions, 0, sizeof(gl_extensions)); gl_extensions.IsCoreContext = useCoreContext; #ifdef USING_GLES2 gl_extensions.IsGLES = true; #endif const char *renderer = (const char *)glGetString(GL_RENDERER); const char *versionStr = (const char *)glGetString(GL_VERSION); const char *glslVersionStr = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION); // Check vendor string to try and guess GPU const char *cvendor = (char *)glGetString(GL_VENDOR); // TODO: move this stuff to gpu_features.cpp if (cvendor) { const std::string vendor = StripSpaces(std::string(cvendor)); if (vendor == "NVIDIA Corporation" || vendor == "Nouveau" || vendor == "nouveau") { gl_extensions.gpuVendor = GPU_VENDOR_NVIDIA; } else if (vendor == "Advanced Micro Devices, Inc." || vendor == "ATI Technologies Inc.") { gl_extensions.gpuVendor = GPU_VENDOR_AMD; } else if (vendor == "Intel" || vendor == "Intel Inc." || vendor == "Intel Corporation" || vendor == "Tungsten Graphics, Inc") { // We'll assume this last one means Intel gl_extensions.gpuVendor = GPU_VENDOR_INTEL; } else if (vendor == "ARM") { gl_extensions.gpuVendor = GPU_VENDOR_ARM; } else if (vendor == "Imagination Technologies") { gl_extensions.gpuVendor = GPU_VENDOR_POWERVR; } else if (vendor == "Qualcomm") { gl_extensions.gpuVendor = GPU_VENDOR_ADRENO; } else if (vendor == "Broadcom") { gl_extensions.gpuVendor = GPU_VENDOR_BROADCOM; // Just for reference: Galaxy Y has renderer == "VideoCore IV HW" } else { gl_extensions.gpuVendor = GPU_VENDOR_UNKNOWN; } } else { gl_extensions.gpuVendor = GPU_VENDOR_UNKNOWN; } ILOG("GPU Vendor : %s ; renderer: %s version str: %s ; GLSL version str: %s", cvendor, renderer ? renderer : "N/A", versionStr ? versionStr : "N/A", glslVersionStr ? glslVersionStr : "N/A"); if (renderer) { strncpy(gl_extensions.model, renderer, sizeof(gl_extensions.model)); gl_extensions.model[sizeof(gl_extensions.model) - 1] = 0; } if (!gl_extensions.IsGLES) { // For desktop GL, grab the version and attempt to parse. char buffer[64] = { 0 }; if (versionStr) { strncpy(buffer, versionStr, 63); } const char *lastNumStart = buffer; int numVer = 0; int len = (int)strlen(buffer); for (int i = 0; i < len && numVer < 3; i++) { if (buffer[i] == '.') { buffer[i] = 0; gl_extensions.ver[numVer++] = strtol(lastNumStart, NULL, 10); i++; lastNumStart = buffer + i; } } if (numVer < 3) gl_extensions.ver[numVer++] = strtol(lastNumStart, NULL, 10); // If the GL version >= 4.3, we know it's a true superset of OpenGL ES 3.0 and can thus enable // all the same modern paths. // Most of it could be enabled on lower GPUs as well, but let's start this way. if (gl_extensions.VersionGEThan(4, 3, 0)) { gl_extensions.GLES3 = true; } } else { // Start by assuming we're at 2.0. gl_extensions.ver[0] = 2; #ifdef USING_GLES2 #ifdef GL_MAJOR_VERSION // Before grabbing the values, reset the error. glGetError(); glGetIntegerv(GL_MAJOR_VERSION, &gl_extensions.ver[0]); glGetIntegerv(GL_MINOR_VERSION, &gl_extensions.ver[1]); // We check error here to detect if these properties were supported. if (glGetError() != GL_NO_ERROR) { // They weren't, reset to GLES 2.0. gl_extensions.ver[0] = 2; gl_extensions.ver[1] = 0; } #endif // If the above didn't give us a version, or gave us a crazy version, fallback. if (gl_extensions.ver[0] < 3 || gl_extensions.ver[0] > 5) { // Try to load GLES 3.0 only if "3.0" found in version // This simple heuristic avoids issues on older devices where you can only call eglGetProcAddress a limited // number of times. Make sure to check for 3.0 in the shader version too to avoid false positives, see #5584. bool gl_3_0_in_string = strstr(versionStr, "3.0") && strstr(glslVersionStr, "3.0"); bool gl_3_1_in_string = strstr(versionStr, "3.1") && strstr(glslVersionStr, "3.1"); // intentionally left out .1 if ((gl_3_0_in_string || gl_3_1_in_string) && gl3stubInit()) { gl_extensions.ver[0] = 3; if (gl_3_1_in_string) { gl_extensions.ver[1] = 1; } gl_extensions.GLES3 = true; // Though, let's ban Mali from the GLES 3 path for now, see #4078 if (strstr(renderer, "Mali") != 0) { gl_extensions.GLES3 = false; } } else { // Just to be safe. gl_extensions.ver[0] = 2; gl_extensions.ver[1] = 0; } } else { // Otherwise, let's trust GL_MAJOR_VERSION. Note that Mali is intentionally not banned here. if (gl_extensions.ver[0] >= 3) { gl_extensions.GLES3 = gl3stubInit(); } } #endif if (gl_extensions.GLES3) { if (gl_extensions.ver[1] >= 1) { ILOG("OpenGL ES 3.1 support detected!\n"); } else { ILOG("OpenGL ES 3.0 support detected!\n"); } } } const char *extString = nullptr; if (gl_extensions.ver[0] >= 3) { // Let's use the new way for OpenGL 3.x+, required in the core profile. GLint numExtensions = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); g_all_gl_extensions = ""; for (GLint i = 0; i < numExtensions; ++i) { g_all_gl_extensions += (const char *)glGetStringi(GL_EXTENSIONS, i); g_all_gl_extensions += " "; } extString = g_all_gl_extensions.c_str(); } else { extString = (const char *)glGetString(GL_EXTENSIONS); if (extString) { g_all_gl_extensions = extString; } else { g_all_gl_extensions = ""; extString = ""; } } #ifdef WIN32 const char *wglString = 0; if (wglGetExtensionsStringEXT) wglString = wglGetExtensionsStringEXT(); if (wglString) { gl_extensions.EXT_swap_control_tear = strstr(wglString, "WGL_EXT_swap_control_tear") != 0; g_all_egl_extensions = wglString; } else { g_all_egl_extensions = ""; } #elif !defined(USING_GLES2) // const char *glXString = glXQueryExtensionString(); // gl_extensions.EXT_swap_control_tear = strstr(glXString, "GLX_EXT_swap_control_tear") != 0; #endif // Check the desktop extension instead of the OES one. They are very similar. // Also explicitly check those ATI devices that claims to support npot gl_extensions.OES_texture_npot = strstr(extString, "GL_ARB_texture_non_power_of_two") != 0 && !(((strncmp(renderer, "ATI RADEON X", 12) == 0) || (strncmp(renderer, "ATI MOBILITY RADEON X", 21) == 0))); gl_extensions.ARB_blend_func_extended = strstr(extString, "GL_ARB_blend_func_extended") != 0; gl_extensions.EXT_blend_func_extended = strstr(extString, "GL_EXT_blend_func_extended") != 0; gl_extensions.ARB_conservative_depth = strstr(extString, "GL_ARB_conservative_depth") != 0; gl_extensions.ARB_shader_image_load_store = (strstr(extString, "GL_ARB_shader_image_load_store") != 0) || (strstr(extString, "GL_EXT_shader_image_load_store") != 0); gl_extensions.EXT_bgra = strstr(extString, "GL_EXT_bgra") != 0; gl_extensions.EXT_gpu_shader4 = strstr(extString, "GL_EXT_gpu_shader4") != 0; gl_extensions.NV_framebuffer_blit = strstr(extString, "GL_NV_framebuffer_blit") != 0; gl_extensions.NV_copy_image = strstr(extString, "GL_NV_copy_image") != 0; gl_extensions.OES_copy_image = strstr(extString, "GL_OES_copy_image") != 0; gl_extensions.EXT_copy_image = strstr(extString, "GL_EXT_copy_image") != 0; gl_extensions.ARB_copy_image = strstr(extString, "GL_ARB_copy_image") != 0; gl_extensions.ARB_vertex_array_object = strstr(extString, "GL_ARB_vertex_array_object") != 0; gl_extensions.ARB_texture_float = strstr(extString, "GL_ARB_texture_float") != 0; if (gl_extensions.IsGLES) { gl_extensions.OES_texture_npot = strstr(extString, "GL_OES_texture_npot") != 0; gl_extensions.OES_packed_depth_stencil = (strstr(extString, "GL_OES_packed_depth_stencil") != 0) || gl_extensions.GLES3; gl_extensions.OES_depth24 = strstr(extString, "GL_OES_depth24") != 0; gl_extensions.OES_depth_texture = strstr(extString, "GL_OES_depth_texture") != 0; gl_extensions.OES_mapbuffer = strstr(extString, "GL_OES_mapbuffer") != 0; gl_extensions.EXT_blend_minmax = strstr(extString, "GL_EXT_blend_minmax") != 0; gl_extensions.EXT_unpack_subimage = strstr(extString, "GL_EXT_unpack_subimage") != 0; gl_extensions.EXT_shader_framebuffer_fetch = strstr(extString, "GL_EXT_shader_framebuffer_fetch") != 0; gl_extensions.NV_shader_framebuffer_fetch = strstr(extString, "GL_NV_shader_framebuffer_fetch") != 0; gl_extensions.ARM_shader_framebuffer_fetch = strstr(extString, "GL_ARM_shader_framebuffer_fetch") != 0; gl_extensions.OES_texture_float = strstr(extString, "GL_OES_texture_float") != 0; gl_extensions.OES_texture_half_float = strstr(extString, "GL_OES_texture_half_float") != 0; #if defined(__ANDROID__) // On Android, incredibly, this is not consistently non-zero! It does seem to have the same value though. // https://twitter.com/ID_AA_Carmack/status/387383037794603008 #ifdef _DEBUG void *invalidAddress = (void *)eglGetProcAddress("InvalidGlCall1"); void *invalidAddress2 = (void *)eglGetProcAddress("AnotherInvalidGlCall2"); DLOG("Addresses returned for invalid extensions: %p %p", invalidAddress, invalidAddress2); #endif // These are all the same. Let's alias. if (!gl_extensions.OES_copy_image) { if (gl_extensions.NV_copy_image) { glCopyImageSubDataOES = (decltype(glCopyImageSubDataOES))eglGetProcAddress("glCopyImageSubDataNV"); } else if (gl_extensions.EXT_copy_image) { glCopyImageSubDataOES = (decltype(glCopyImageSubDataOES))eglGetProcAddress("glCopyImageSubDataEXT"); } } if (gl_extensions.NV_framebuffer_blit) { glBlitFramebufferNV = (PFNGLBLITFRAMEBUFFERNVPROC)eglGetProcAddress("glBlitFramebufferNV"); } gl_extensions.OES_vertex_array_object = strstr(extString, "GL_OES_vertex_array_object") != 0; if (gl_extensions.OES_vertex_array_object) { glGenVertexArraysOES = (PFNGLGENVERTEXARRAYSOESPROC)eglGetProcAddress("glGenVertexArraysOES"); glBindVertexArrayOES = (PFNGLBINDVERTEXARRAYOESPROC)eglGetProcAddress("glBindVertexArrayOES"); glDeleteVertexArraysOES = (PFNGLDELETEVERTEXARRAYSOESPROC)eglGetProcAddress("glDeleteVertexArraysOES"); glIsVertexArrayOES = (PFNGLISVERTEXARRAYOESPROC)eglGetProcAddress("glIsVertexArrayOES"); } // Hm, this should be available on iOS too. gl_extensions.EXT_discard_framebuffer = strstr(extString, "GL_EXT_discard_framebuffer") != 0; if (gl_extensions.EXT_discard_framebuffer) { glDiscardFramebufferEXT = (PFNGLDISCARDFRAMEBUFFEREXTPROC)eglGetProcAddress("glDiscardFramebufferEXT"); } #else gl_extensions.OES_vertex_array_object = false; gl_extensions.EXT_discard_framebuffer = false; #endif } else { // Desktops support minmax and subimage unpack (GL_UNPACK_ROW_LENGTH etc) gl_extensions.EXT_blend_minmax = true; gl_extensions.EXT_unpack_subimage = true; } // GLES 3 subsumes many ES2 extensions. if (gl_extensions.GLES3) { gl_extensions.EXT_unpack_subimage = true; } #if defined(__ANDROID__) if (gl_extensions.OES_mapbuffer) { glMapBuffer = (PFNGLMAPBUFFERPROC)eglGetProcAddress("glMapBufferOES"); } // Look for EGL extensions EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY); const char *eglString = eglQueryString(display, EGL_EXTENSIONS); if (eglString) { g_all_egl_extensions = eglString; gl_extensions.EGL_NV_system_time = strstr(eglString, "EGL_NV_system_time") != 0; gl_extensions.EGL_NV_coverage_sample = strstr(eglString, "EGL_NV_coverage_sample") != 0; if (gl_extensions.EGL_NV_system_time) { eglGetSystemTimeNV = (PFNEGLGETSYSTEMTIMENVPROC)eglGetProcAddress("eglGetSystemTimeNV"); eglGetSystemTimeFrequencyNV = (PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC)eglGetProcAddress("eglGetSystemTimeFrequencyNV"); } } else { g_all_egl_extensions = ""; } #endif // This is probably a waste of time, implementations lie. if (gl_extensions.IsGLES || strstr(extString, "GL_ARB_ES2_compatibility")) { const GLint precisions[6] = { GL_LOW_FLOAT, GL_MEDIUM_FLOAT, GL_HIGH_FLOAT, GL_LOW_INT, GL_MEDIUM_INT, GL_HIGH_INT }; GLint shaderTypes[2] = { GL_VERTEX_SHADER, GL_FRAGMENT_SHADER }; for (int st = 0; st < 2; st++) { for (int p = 0; p < 6; p++) { glGetShaderPrecisionFormat(shaderTypes[st], precisions[p], gl_extensions.range[st][p], &gl_extensions.precision[st][p]); } } } gl_extensions.ARB_framebuffer_object = strstr(extString, "GL_ARB_framebuffer_object") != 0; gl_extensions.EXT_framebuffer_object = strstr(extString, "GL_EXT_framebuffer_object") != 0; gl_extensions.ARB_pixel_buffer_object = strstr(extString, "GL_ARB_pixel_buffer_object") != 0; gl_extensions.NV_pixel_buffer_object = strstr(extString, "GL_NV_pixel_buffer_object") != 0; if (!gl_extensions.IsGLES && gl_extensions.IsCoreContext) { // These are required, and don't need to be specified by the driver (they aren't on Apple.) gl_extensions.ARB_vertex_array_object = true; gl_extensions.ARB_framebuffer_object = true; } #ifdef __APPLE__ if (!gl_extensions.IsGLES && !gl_extensions.IsCoreContext) { // Apple doesn't allow OpenGL 3.x+ in compatibility contexts. gl_extensions.ForceGL2 = true; } #endif ProcessGPUFeatures(); int error = glGetError(); if (error) ELOG("GL error in init: %i", error); #endif }
void caps::initVersion() { glGetIntegerv(GL_MINOR_VERSION, &VersionData.MINOR_VERSION); glGetIntegerv(GL_MAJOR_VERSION, &VersionData.MAJOR_VERSION); this->VersionData.RENDERER = reinterpret_cast<const char *>(glGetString(GL_RENDERER)); this->VersionData.VENDOR = reinterpret_cast<const char *>(glGetString(GL_VENDOR)); this->VersionData.VERSION = reinterpret_cast<const char *>(glGetString(GL_VERSION)); this->VersionData.SHADING_LANGUAGE_VERSION = reinterpret_cast<const char *>(glGetString(GL_SHADING_LANGUAGE_VERSION)); if(this->check(4, 3) || Extensions.KHR_debug) glGetIntegerv(GL_CONTEXT_FLAGS, &VersionData.CONTEXT_FLAGS); if(this->check(3, 0)) glGetIntegerv(GL_NUM_EXTENSIONS, &VersionData.NUM_EXTENSIONS); if(this->check(4, 3)) { glGetIntegerv(GL_NUM_SHADING_LANGUAGE_VERSIONS, &VersionData.NUM_SHADING_LANGUAGE_VERSIONS); for(GLint i = 0; i < VersionData.NUM_SHADING_LANGUAGE_VERSIONS; ++i) { std::string Version((char const*)glGetStringi(GL_SHADING_LANGUAGE_VERSION, i)); if(Version == std::string("100")) VersionData.GLSL100 = true; else if(Version == std::string("110")) VersionData.GLSL110 = true; else if(Version == std::string("120")) VersionData.GLSL120 = true; else if(Version == std::string("130")) VersionData.GLSL130 = true; else if(Version == std::string("140")) VersionData.GLSL140 = true; else if(Version == std::string("150 core")) VersionData.GLSL150Core = true; else if(Version == std::string("150 compatibility")) VersionData.GLSL150Comp = true; else if(Version == std::string("300 es")) VersionData.GLSL330Core = true; else if(Version == std::string("330 core")) VersionData.GLSL330Core = true; else if(Version == std::string("330 compatibility")) VersionData.GLSL330Comp = true; else if(Version == std::string("400 core")) VersionData.GLSL400Core = true; else if(Version == std::string("400 compatibility")) VersionData.GLSL400Comp = true; else if(Version == std::string("410 core")) VersionData.GLSL410Core = true; else if(Version == std::string("410 compatibility")) VersionData.GLSL410Comp = true; else if(Version == std::string("420 core")) VersionData.GLSL420Core = true; else if(Version == std::string("420 compatibility")) VersionData.GLSL420Comp = true; else if(Version == std::string("430 core")) VersionData.GLSL430Core = true; else if(Version == std::string("440 compatibility")) VersionData.GLSL440Comp = true; else if(Version == std::string("440 core")) VersionData.GLSL440Core = true; } } }
void caps::initExtensions() { memset(&ExtensionData, 0, sizeof(ExtensionData)); glGetIntegerv(GL_NUM_EXTENSIONS, &VersionData.NUM_EXTENSIONS); if((this->VersionData.PROFILE == CORE) || (this->VersionData.PROFILE == COMPATIBILITY)) { for (GLint i = 0; i < VersionData.NUM_EXTENSIONS; ++i) { const char* Extension = reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, i)); if(!strcmp("GL_ARB_multitexture", Extension)) { ExtensionData.ARB_multitexture = true; continue; } if(!strcmp("GL_ARB_transpose_matrix", Extension)) { ExtensionData.ARB_transpose_matrix = true; continue; } if(!strcmp("GL_ARB_multisample", Extension)) { ExtensionData.ARB_multisample = true; continue; } if(!strcmp("GL_ARB_texture_env_add", Extension)) { ExtensionData.ARB_texture_env_add = true; continue; } if(!strcmp("GL_ARB_texture_cube_map", Extension)) { ExtensionData.ARB_texture_cube_map = true; continue; } if(!strcmp("GL_ARB_texture_compression", Extension)) { ExtensionData.ARB_texture_compression = true; continue; } if(!strcmp("GL_ARB_texture_border_clamp", Extension)) { ExtensionData.ARB_texture_border_clamp = true; continue; } if(!strcmp("GL_ARB_point_parameters", Extension)) { ExtensionData.ARB_point_parameters = true; continue; } if(!strcmp("GL_ARB_vertex_blend", Extension)) { ExtensionData.ARB_vertex_blend = true; continue; } if(!strcmp("GL_ARB_matrix_palette", Extension)) { ExtensionData.ARB_matrix_palette = true; continue; } if(!strcmp("GL_ARB_texture_env_combine", Extension)) { ExtensionData.ARB_texture_env_combine = true; continue; } if(!strcmp("GL_ARB_texture_env_crossbar", Extension)) { ExtensionData.ARB_texture_env_crossbar = true; continue; } if(!strcmp("GL_ARB_texture_env_dot3", Extension)) { ExtensionData.ARB_texture_env_dot3 = true; continue; } if(!strcmp("GL_ARB_texture_mirrored_repeat", Extension)) { ExtensionData.ARB_texture_mirrored_repeat = true; continue; } if(!strcmp("GL_ARB_depth_texture", Extension)) { ExtensionData.ARB_depth_texture = true; continue; } if(!strcmp("GL_ARB_shadow", Extension)) { ExtensionData.ARB_shadow = true; continue; } if(!strcmp("GL_ARB_shadow_ambient", Extension)) { ExtensionData.ARB_shadow_ambient = true; continue; } if(!strcmp("GL_ARB_window_pos", Extension)) { ExtensionData.ARB_window_pos = true; continue; } if(!strcmp("GL_ARB_vertex_program", Extension)) { ExtensionData.ARB_vertex_program = true; continue; } if(!strcmp("GL_ARB_fragment_program", Extension)) { ExtensionData.ARB_fragment_program = true; continue; } if(!strcmp("GL_ARB_vertex_buffer_object", Extension)) { ExtensionData.ARB_vertex_buffer_object = true; continue; } if(!strcmp("GL_ARB_occlusion_query", Extension)) { ExtensionData.ARB_occlusion_query = true; continue; } if(!strcmp("GL_ARB_shader_objects", Extension)) { ExtensionData.ARB_shader_objects = true; continue; } if(!strcmp("GL_ARB_vertex_shader", Extension)) { ExtensionData.ARB_vertex_shader = true; continue; } if(!strcmp("GL_ARB_fragment_shader", Extension)) { ExtensionData.ARB_fragment_shader = true; continue; } if(!strcmp("GL_ARB_shading_language_100", Extension)) { ExtensionData.ARB_shading_language_100 = true; continue; } if(!strcmp("GL_ARB_texture_non_power_of_two", Extension)) { ExtensionData.ARB_texture_non_power_of_two = true; continue; } if(!strcmp("GL_ARB_point_sprite", Extension)) { ExtensionData.ARB_point_sprite = true; continue; } if(!strcmp("GL_ARB_fragment_program_shadow", Extension)) { ExtensionData.ARB_fragment_program_shadow = true; continue; } if(!strcmp("GL_ARB_draw_buffers", Extension)) { ExtensionData.ARB_draw_buffers = true; continue; } if(!strcmp("GL_ARB_texture_rectangle", Extension)) { ExtensionData.ARB_texture_rectangle = true; continue; } if(!strcmp("GL_ARB_color_buffer_float", Extension)) ExtensionData.ARB_color_buffer_float = true; else if(!strcmp("GL_ARB_half_float_pixel", Extension)) ExtensionData.ARB_half_float_pixel = true; else if(!strcmp("GL_ARB_texture_float", Extension)) ExtensionData.ARB_texture_float = true; else if(!strcmp("GL_ARB_pixel_buffer_object", Extension)) ExtensionData.ARB_pixel_buffer_object = true; else if(!strcmp("GL_ARB_depth_buffer_float", Extension)) ExtensionData.ARB_depth_buffer_float = true; else if(!strcmp("GL_ARB_draw_instanced", Extension)) ExtensionData.ARB_draw_instanced = true; else if(!strcmp("GL_ARB_framebuffer_object", Extension)) ExtensionData.ARB_framebuffer_object = true; else if(!strcmp("GL_ARB_framebuffer_sRGB", Extension)) ExtensionData.ARB_framebuffer_sRGB = true; else if(!strcmp("GL_ARB_geometry_shader4", Extension)) ExtensionData.ARB_geometry_shader4 = true; else if(!strcmp("GL_ARB_half_float_vertex", Extension)) ExtensionData.ARB_half_float_vertex = true; else if(!strcmp("GL_ARB_instanced_arrays", Extension)) ExtensionData.ARB_instanced_arrays = true; else if(!strcmp("GL_ARB_map_buffer_range", Extension)) ExtensionData.ARB_map_buffer_range = true; else if(!strcmp("GL_ARB_texture_buffer_object", Extension)) ExtensionData.ARB_texture_buffer_object = true; else if(!strcmp("GL_ARB_texture_compression_rgtc", Extension)) ExtensionData.ARB_texture_compression_rgtc = true; else if(!strcmp("GL_ARB_texture_rg", Extension)) ExtensionData.ARB_texture_rg = true; else if(!strcmp("GL_ARB_vertex_array_object", Extension)) ExtensionData.ARB_vertex_array_object = true; else if(!strcmp("GL_ARB_uniform_buffer_object", Extension)) ExtensionData.ARB_uniform_buffer_object = true; else if(!strcmp("GL_ARB_compatibility", Extension)) ExtensionData.ARB_compatibility = true; else if(!strcmp("GL_ARB_copy_buffer", Extension)) ExtensionData.ARB_copy_buffer = true; else if(!strcmp("GL_ARB_shader_texture_lod", Extension)) ExtensionData.ARB_shader_texture_lod = true; else if(!strcmp("GL_ARB_depth_clamp", Extension)) ExtensionData.ARB_depth_clamp = true; else if(!strcmp("GL_ARB_draw_elements_base_vertex", Extension)) ExtensionData.ARB_draw_elements_base_vertex = true; else if(!strcmp("GL_ARB_fragment_coord_conventions", Extension)) ExtensionData.ARB_fragment_coord_conventions = true; else if(!strcmp("GL_ARB_provoking_vertex", Extension)) ExtensionData.ARB_provoking_vertex = true; else if(!strcmp("GL_ARB_seamless_cube_map", Extension)) ExtensionData.ARB_seamless_cube_map = true; else if(!strcmp("GL_ARB_sync", Extension)) ExtensionData.ARB_sync = true; else if(!strcmp("GL_ARB_texture_multisample", Extension)) ExtensionData.ARB_texture_multisample = true; else if(!strcmp("GL_ARB_vertex_array_bgra", Extension)) ExtensionData.ARB_vertex_array_bgra = true; else if(!strcmp("GL_ARB_draw_buffers_blend", Extension)) ExtensionData.ARB_draw_buffers_blend = true; else if(!strcmp("GL_ARB_sample_shading", Extension)) ExtensionData.ARB_sample_shading = true; else if(!strcmp("GL_ARB_texture_cube_map_array", Extension)) ExtensionData.ARB_texture_cube_map_array = true; else if(!strcmp("GL_ARB_texture_gather", Extension)) ExtensionData.ARB_texture_gather = true; else if(!strcmp("GL_ARB_texture_query_lod", Extension)) ExtensionData.ARB_texture_query_lod = true; else if(!strcmp("GL_ARB_shading_language_include", Extension)) ExtensionData.ARB_shading_language_include = true; else if(!strcmp("GL_ARB_texture_compression_bptc", Extension)) ExtensionData.ARB_texture_compression_bptc = true; else if(!strcmp("GL_ARB_blend_func_extended", Extension)) ExtensionData.ARB_blend_func_extended = true; else if(!strcmp("GL_ARB_explicit_attrib_location", Extension)) ExtensionData.ARB_explicit_attrib_location = true; else if(!strcmp("GL_ARB_occlusion_query2", Extension)) ExtensionData.ARB_occlusion_query2 = true; else if(!strcmp("GL_ARB_sampler_objects", Extension)) ExtensionData.ARB_sampler_objects = true; else if(!strcmp("GL_ARB_shader_bit_encoding", Extension)) ExtensionData.ARB_shader_bit_encoding = true; else if(!strcmp("GL_ARB_texture_rgb10_a2ui", Extension)) ExtensionData.ARB_texture_rgb10_a2ui = true; else if(!strcmp("GL_ARB_texture_swizzle", Extension)) ExtensionData.ARB_texture_swizzle = true; else if(!strcmp("GL_ARB_timer_query", Extension)) ExtensionData.ARB_timer_query = true; else if(!strcmp("GL_ARB_vertex_type_2_10_10_10_rev", Extension)) ExtensionData.ARB_vertex_type_2_10_10_10_rev = true; else if(!strcmp("GL_ARB_draw_indirect", Extension)) ExtensionData.ARB_draw_indirect = true; else if(!strcmp("GL_ARB_gpu_shader5", Extension)) ExtensionData.ARB_gpu_shader5 = true; else if(!strcmp("GL_ARB_gpu_shader_fp64", Extension)) ExtensionData.ARB_gpu_shader_fp64 = true; else if(!strcmp("GL_ARB_shader_subroutine", Extension)) ExtensionData.ARB_shader_subroutine = true; else if(!strcmp("GL_ARB_tessellation_shader", Extension)) ExtensionData.ARB_tessellation_shader = true; else if(!strcmp("GL_ARB_texture_buffer_object_rgb32", Extension)) ExtensionData.ARB_texture_buffer_object_rgb32 = true; else if(!strcmp("GL_ARB_transform_feedback2", Extension)) ExtensionData.ARB_transform_feedback2 = true; else if(!strcmp("GL_ARB_transform_feedback3", Extension)) ExtensionData.ARB_transform_feedback3 = true; else if(!strcmp("GL_ARB_ES2_compatibility", Extension)) ExtensionData.ARB_ES2_compatibility = true; else if(!strcmp("GL_ARB_get_program_binary", Extension)) ExtensionData.ARB_get_program_binary = true; else if(!strcmp("GL_ARB_separate_shader_objects", Extension)) ExtensionData.ARB_separate_shader_objects = true; else if(!strcmp("GL_ARB_shader_precision", Extension)) ExtensionData.ARB_shader_precision = true; else if(!strcmp("GL_ARB_vertex_attrib_64bit", Extension)) ExtensionData.ARB_vertex_attrib_64bit = true; else if(!strcmp("GL_ARB_viewport_array", Extension)) ExtensionData.ARB_viewport_array = true; else if(!strcmp("GL_ARB_cl_event", Extension)) ExtensionData.ARB_cl_event = true; else if(!strcmp("GL_ARB_debug_output", Extension)) ExtensionData.ARB_debug_output = true; else if(!strcmp("GL_ARB_robustness", Extension)) ExtensionData.ARB_robustness = true; else if(!strcmp("GL_ARB_shader_stencil_export", Extension)) ExtensionData.ARB_shader_stencil_export = true; else if(!strcmp("GL_ARB_base_instance", Extension)) ExtensionData.ARB_base_instance = true; else if(!strcmp("GL_ARB_shading_language_420pack", Extension)) ExtensionData.ARB_shading_language_420pack = true; else if(!strcmp("GL_ARB_transform_feedback_instanced", Extension)) ExtensionData.ARB_transform_feedback_instanced = true; else if(!strcmp("GL_ARB_compressed_texture_pixel_storage", Extension)) ExtensionData.ARB_compressed_texture_pixel_storage = true; else if(!strcmp("GL_ARB_conservative_depth", Extension)) ExtensionData.ARB_conservative_depth = true; else if(!strcmp("GL_ARB_internalformat_query", Extension)) ExtensionData.ARB_internalformat_query = true; else if(!strcmp("GL_ARB_map_buffer_alignment", Extension)) ExtensionData.ARB_map_buffer_alignment = true; else if(!strcmp("GL_ARB_shader_atomic_counters", Extension)) ExtensionData.ARB_shader_atomic_counters = true; else if(!strcmp("GL_ARB_shader_image_load_store", Extension)) ExtensionData.ARB_shader_image_load_store = true; else if(!strcmp("GL_ARB_shading_language_packing", Extension)) ExtensionData.ARB_shading_language_packing = true; else if(!strcmp("GL_ARB_texture_storage", Extension)) ExtensionData.ARB_texture_storage = true; else if(!strcmp("GL_KHR_texture_compression_astc_hdr", Extension)) ExtensionData.KHR_texture_compression_astc_hdr = true; else if(!strcmp("GL_KHR_texture_compression_astc_ldr", Extension)) ExtensionData.KHR_texture_compression_astc_ldr = true; else if(!strcmp("GL_KHR_debug", Extension)) ExtensionData.KHR_debug = true; else if(!strcmp("GL_ARB_arrays_of_arrays", Extension)) ExtensionData.ARB_arrays_of_arrays = true; else if(!strcmp("GL_ARB_clear_buffer_object", Extension)) ExtensionData.ARB_clear_buffer_object = true; else if(!strcmp("GL_ARB_compute_shader", Extension)) ExtensionData.ARB_compute_shader = true; else if(!strcmp("GL_ARB_copy_image", Extension)) ExtensionData.ARB_copy_image = true; else if(!strcmp("GL_ARB_texture_view", Extension)) ExtensionData.ARB_texture_view = true; else if(!strcmp("GL_ARB_vertex_attrib_binding", Extension)) ExtensionData.ARB_vertex_attrib_binding = true; else if(!strcmp("GL_ARB_robustness_isolation", Extension)) ExtensionData.ARB_robustness_isolation = true; else if(!strcmp("GL_ARB_robustness_isolation", Extension)) ExtensionData.ARB_robustness_isolation = true; else if(!strcmp("GL_ARB_ES3_compatibility", Extension)) ExtensionData.ARB_ES3_compatibility = true; else if(!strcmp("GL_ARB_explicit_uniform_location", Extension)) ExtensionData.ARB_explicit_uniform_location = true; else if(!strcmp("GL_ARB_fragment_layer_viewport", Extension)) ExtensionData.ARB_fragment_layer_viewport = true; else if(!strcmp("GL_ARB_framebuffer_no_attachments", Extension)) ExtensionData.ARB_framebuffer_no_attachments = true; else if(!strcmp("GL_ARB_internalformat_query2", Extension)) ExtensionData.ARB_internalformat_query2 = true; else if(!strcmp("GL_ARB_invalidate_subdata", Extension)) ExtensionData.ARB_invalidate_subdata = true; else if(!strcmp("GL_ARB_multi_draw_indirect", Extension)) ExtensionData.ARB_multi_draw_indirect = true; else if(!strcmp("GL_ARB_program_interface_query", Extension)) ExtensionData.ARB_program_interface_query = true; else if(!strcmp("GL_ARB_robust_buffer_access_behavior", Extension)) ExtensionData.ARB_robust_buffer_access_behavior = true; else if(!strcmp("GL_ARB_shader_image_size", Extension)) ExtensionData.ARB_shader_image_size = true; else if(!strcmp("GL_ARB_shader_storage_buffer_object", Extension)) ExtensionData.ARB_shader_storage_buffer_object = true; else if(!strcmp("GL_ARB_stencil_texturing", Extension)) ExtensionData.ARB_stencil_texturing = true; else if(!strcmp("GL_ARB_texture_buffer_range", Extension)) ExtensionData.ARB_texture_buffer_range = true; else if(!strcmp("GL_ARB_texture_query_levels", Extension)) ExtensionData.ARB_texture_query_levels = true; else if(!strcmp("GL_ARB_texture_storage_multisample", Extension)) ExtensionData.ARB_texture_storage_multisample = true; else if(!strcmp("GL_ARB_buffer_storage", Extension)) ExtensionData.ARB_buffer_storage = true; else if(!strcmp("GL_ARB_clear_texture", Extension)) ExtensionData.ARB_clear_texture = true; else if(!strcmp("GL_ARB_enhanced_layouts", Extension)) ExtensionData.ARB_enhanced_layouts = true; else if(!strcmp("GL_ARB_multi_bind", Extension)) ExtensionData.ARB_multi_bind = true; else if(!strcmp("GL_ARB_query_buffer_object", Extension)) ExtensionData.ARB_query_buffer_object = true; else if(!strcmp("GL_ARB_texture_mirror_clamp_to_edge", Extension)) ExtensionData.ARB_texture_mirror_clamp_to_edge = true; else if(!strcmp("GL_ARB_texture_stencil8", Extension)) ExtensionData.ARB_texture_stencil8 = true; else if(!strcmp("GL_ARB_vertex_type_10f_11f_11f_rev", Extension)) ExtensionData.ARB_vertex_type_10f_11f_11f_rev = true; else if(!strcmp("GL_ARB_bindless_texture", Extension)) ExtensionData.ARB_bindless_texture = true; else if(!strcmp("GL_ARB_compute_variable_group_size", Extension)) ExtensionData.ARB_compute_variable_group_size = true; else if(!strcmp("GL_ARB_indirect_parameters", Extension)) ExtensionData.ARB_indirect_parameters = true; else if(!strcmp("GL_ARB_seamless_cubemap_per_texture", Extension)) ExtensionData.ARB_seamless_cubemap_per_texture = true; else if(!strcmp("GL_ARB_shader_draw_parameters", Extension)) ExtensionData.ARB_shader_draw_parameters = true; else if(!strcmp("GL_ARB_shader_group_vote", Extension)) ExtensionData.ARB_shader_group_vote = true; else if(!strcmp("GL_ARB_sparse_texture", Extension)) ExtensionData.ARB_sparse_texture = true; // EXT if(!strcmp("GL_EXT_texture_compression_s3tc", Extension)) { ExtensionData.EXT_texture_compression_s3tc = true; continue; } if(!strcmp("GL_EXT_texture_compression_latc", Extension)) { ExtensionData.EXT_texture_compression_latc = true; continue; } if(!strcmp("GL_EXT_transform_feedback", Extension)) { ExtensionData.EXT_transform_feedback = true; continue; } if(!strcmp("GL_EXT_direct_state_access", Extension)) { ExtensionData.EXT_direct_state_access = true; continue; } if(!strcmp("GL_EXT_texture_filter_anisotropic", Extension)) { ExtensionData.EXT_texture_filter_anisotropic = true; continue; } if(!strcmp("GL_EXT_texture_compression_s3tc", Extension)) { ExtensionData.EXT_texture_compression_s3tc = true; continue; } if(!strcmp("GL_EXT_texture_array", Extension)) { ExtensionData.EXT_texture_array = true; continue; } if(!strcmp("GL_EXT_texture_snorm", Extension)) { ExtensionData.EXT_texture_snorm = true; continue; } if(!strcmp("GL_EXT_texture_sRGB_decode", Extension)) { ExtensionData.EXT_texture_sRGB_decode = true; continue; } if(!strcmp("GL_EXT_framebuffer_multisample_blit_scaled", Extension)) { ExtensionData.EXT_framebuffer_multisample_blit_scaled = true; continue; } if(!strcmp("GL_EXT_shader_integer_mix", Extension)) { ExtensionData.EXT_shader_integer_mix = true; continue; } // NV if(!strcmp("GL_NV_explicit_multisample", Extension)) { ExtensionData.NV_explicit_multisample = true; continue; } if(!strcmp("GL_NV_shader_buffer_load", Extension)) { ExtensionData.NV_shader_buffer_load = true; continue; } if(!strcmp("GL_NV_vertex_buffer_unified_memory", Extension)) { ExtensionData.NV_vertex_buffer_unified_memory = true; continue; } if(!strcmp("GL_NV_shader_buffer_store", Extension)) { ExtensionData.NV_shader_buffer_store = true; continue; } if(!strcmp("GL_NV_bindless_multi_draw_indirect", Extension)) { ExtensionData.NV_bindless_multi_draw_indirect = true; continue; } if(!strcmp("GL_NV_blend_equation_advanced", Extension)) { ExtensionData.NV_blend_equation_advanced = true; continue; } if(!strcmp("GL_NV_deep_texture3D", Extension)) { ExtensionData.NV_deep_texture3D = true; continue; } // AMD if(!strcmp("GL_ATI_texture_compression_3dc", Extension)) { ExtensionData.ATI_texture_compression_3dc = true; continue; } if(!strcmp("GL_AMD_depth_clamp_separate", Extension)) { ExtensionData.AMD_depth_clamp_separate = true; continue; } if(!strcmp("GL_AMD_stencil_operation_extended", Extension)) { ExtensionData.AMD_stencil_operation_extended = true; continue; } if(!strcmp("GL_AMD_vertex_shader_viewport_index", Extension)) { ExtensionData.AMD_vertex_shader_viewport_index = true; continue; } if(!strcmp("GL_AMD_vertex_shader_layer", Extension)) { ExtensionData.AMD_vertex_shader_layer = true; continue; } if(!strcmp("GL_AMD_shader_trinary_minmax", Extension)) { ExtensionData.AMD_shader_trinary_minmax = true; continue; } if(!strcmp("GL_AMD_interleaved_elements", Extension)) { ExtensionData.AMD_interleaved_elements = true; continue; } if(!strcmp("GL_AMD_shader_atomic_counter_ops", Extension)) { ExtensionData.AMD_shader_atomic_counter_ops = true; continue; } } } }
void Initialize() { printf("Version Pilote OpenGL : %s\n", glGetString(GL_VERSION)); printf("Type de GPU : %s\n", glGetString(GL_RENDERER)); printf("Fabricant : %s\n", glGetString(GL_VENDOR)); printf("Version GLSL : %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); int numExtensions; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); GLenum error = glewInit(); if (error != GL_NO_ERROR) { // TODO } #if LIST_EXTENSIONS for (int index = 0; index < numExtensions; ++index) { printf("Extension[%d] : %s\n", index, glGetStringi(GL_EXTENSIONS, index)); } #endif #ifdef _WIN32 // on coupe la synchro vertical pour voir l'effet du delta time wglSwapIntervalEXT(0); #endif // render states par defaut glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_CULL_FACE); // AntTweakBar TwInit(TW_OPENGL, NULL); // ou TW_OPENGL_CORE selon le cas de figure objTweakBar = TwNewBar("Multiple Point Lights"); TwAddVarRW(objTweakBar, "Num Point Lights", TW_TYPE_UINT32, &g_NumPointLights, ""); TwAddButton(objTweakBar, "Quitter", &ExitCallbackTw, nullptr, ""); // Objets OpenGL glGenBuffers(1, &g_Camera.UBO); glBindBuffer(GL_UNIFORM_BUFFER, g_Camera.UBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::mat4) * 2, nullptr, GL_STREAM_DRAW); glGenBuffers(1, &PointLight::UBO); glBindBuffer(GL_UNIFORM_BUFFER, PointLight::UBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(PointLight) * MAX_POINT_LIGHTS, nullptr, GL_STREAM_DRAW); glGenBuffers(1, &Material::UBO); glBindBuffer(GL_UNIFORM_BUFFER, Material::UBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(Material), &g_ShinyMaterial, GL_STATIC_DRAW); error = glGetError(); assert(error == GL_NO_ERROR); g_AmbientShader.LoadVertexShader("ambient.vs"); g_AmbientShader.LoadFragmentShader("ambient.fs"); g_AmbientShader.Create(); auto program = g_AmbientShader.GetProgram(); glBindBufferBase(GL_UNIFORM_BUFFER, 0, g_Camera.UBO); auto blockIndex = glGetUniformBlockIndex(program, "ViewProj"); glUniformBlockBinding(program, blockIndex, 0); error = glGetError(); assert(error == GL_NO_ERROR); g_BlinnPhongShader.LoadVertexShader("blinnPhong.vs"); g_BlinnPhongShader.LoadFragmentShader("blinnPhong.fs"); g_BlinnPhongShader.Create(); program = g_BlinnPhongShader.GetProgram(); //glBindBufferBase(GL_UNIFORM_BUFFER, 0, g_Camera.UBO); // deja bound blockIndex = glGetUniformBlockIndex(program, "ViewProj"); glUniformBlockBinding(program, blockIndex, 0); glBindBufferBase(GL_UNIFORM_BUFFER, 1, PointLight::UBO); blockIndex = glGetUniformBlockIndex(program, "Lights"); glUniformBlockBinding(program, blockIndex, 1); glBindBufferBase(GL_UNIFORM_BUFFER, 2, Material::UBO); blockIndex = glGetUniformBlockIndex(program, "Material"); glUniformBlockBinding(program, blockIndex, 2); // Setup error = glGetError(); assert(error == GL_NO_ERROR); previousTime = glutGet(GLUT_ELAPSED_TIME); LoadMesh(g_WallMesh, g_Room); LoadAndCreateTextureRGBA("wall_color_map.jpg", g_Walls.textures[Walls::gWallTexture]); glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gWallTexture]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); LoadAndCreateTextureRGBA("floor_color_map.jpg", g_Walls.textures[Walls::gFloorTexture]); glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gFloorTexture]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); LoadAndCreateTextureRGBA("ceiling_color_map.jpg", g_Walls.textures[Walls::gCeilingTexture]); glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gCeilingTexture]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); const std::string inputFile = "sphere.obj"; LoadOBJ(g_SphereMesh, inputFile); g_Spheres.resize(g_NumPointLights); for (uint32_t index = 0; index < g_NumPointLights; ++index) { g_Spheres[index].initialize(index); } error = glGetError(); assert(error == GL_NO_ERROR); }
bool CRenderSystemGL::InitRenderSystem() { m_bVSync = false; m_bVsyncInit = false; m_maxTextureSize = 2048; m_renderCaps = 0; // Get the GL version number m_RenderVersionMajor = 0; m_RenderVersionMinor = 0; const char* ver = (const char*)glGetString(GL_VERSION); if (ver != 0) { sscanf(ver, "%d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor); m_RenderVersion = ver; } m_RenderExtensions = " "; if (m_RenderVersionMajor > 3 || (m_RenderVersionMajor == 3 && m_RenderVersionMinor >= 2)) { GLint n; glGetIntegerv(GL_NUM_EXTENSIONS, &n); if (n > 0) { GLint i; for (i = 0; i < n; i++) { m_RenderExtensions += (const char*)glGetStringi(GL_EXTENSIONS, i); m_RenderExtensions += " "; } } } else { m_RenderExtensions += (const char*) glGetString(GL_EXTENSIONS); } m_RenderExtensions += " "; if (IsExtSupported("GL_ARB_shading_language_100")) { ver = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION); if (ver) { sscanf(ver, "%d.%d", &m_glslMajor, &m_glslMinor); } else { m_glslMajor = 1; m_glslMinor = 0; } } LogGraphicsInfo(); // Get our driver vendor and renderer const char* tmpVendor = (const char*) glGetString(GL_VENDOR); m_RenderVendor.clear(); if (tmpVendor != NULL) m_RenderVendor = tmpVendor; const char* tmpRenderer = (const char*) glGetString(GL_RENDERER); m_RenderRenderer.clear(); if (tmpRenderer != NULL) m_RenderRenderer = tmpRenderer; // grab our capabilities if (IsExtSupported("GL_EXT_texture_compression_s3tc")) m_renderCaps |= RENDER_CAPS_DXT; if (IsExtSupported("GL_ARB_texture_non_power_of_two")) { m_renderCaps |= RENDER_CAPS_NPOT; if (m_renderCaps & RENDER_CAPS_DXT) m_renderCaps |= RENDER_CAPS_DXT_NPOT; } //Check OpenGL quirks and revert m_renderCaps as needed CheckOpenGLQuirks(); m_bRenderCreated = true; if (m_RenderVersionMajor > 3 || (m_RenderVersionMajor == 3 && m_RenderVersionMinor >= 2)) { glGenVertexArrays(1, &m_vertexArray); glBindVertexArray(m_vertexArray); } InitialiseShader(); return true; }
static void write_opengl_info(std::ostream &out) { out << "OpenGL version " << glGetString(GL_VERSION); out << ", running on " << glGetString(GL_VENDOR); out << " " << glGetString(GL_RENDERER) << "\n"; out << "Available extensions:" << "\n"; { out << "Shading language version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << "\n"; GLint numext = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &numext); for (int i = 0; i < numext; ++i) { out << " " << glGetStringi(GL_EXTENSIONS, i) << "\n"; } } out << "\nImplementation Limits:\n"; // first, clear all OpenGL error flags dump_and_clear_opengl_errors(out); #define DUMP_GL_VALUE(name) dump_opengl_value(out, #name, name, 1) #define DUMP_GL_VALUE2(name) dump_opengl_value(out, #name, name, 2) DUMP_GL_VALUE(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS); DUMP_GL_VALUE(GL_MAX_CUBE_MAP_TEXTURE_SIZE); DUMP_GL_VALUE(GL_MAX_DRAW_BUFFERS); DUMP_GL_VALUE(GL_MAX_ELEMENTS_INDICES); DUMP_GL_VALUE(GL_MAX_ELEMENTS_VERTICES); DUMP_GL_VALUE(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS); DUMP_GL_VALUE(GL_MAX_TEXTURE_IMAGE_UNITS); DUMP_GL_VALUE(GL_MAX_TEXTURE_LOD_BIAS); DUMP_GL_VALUE(GL_MAX_TEXTURE_SIZE); DUMP_GL_VALUE(GL_MAX_VERTEX_ATTRIBS); DUMP_GL_VALUE(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS); DUMP_GL_VALUE(GL_MAX_VERTEX_UNIFORM_COMPONENTS); DUMP_GL_VALUE(GL_NUM_COMPRESSED_TEXTURE_FORMATS); DUMP_GL_VALUE(GL_SAMPLE_BUFFERS); DUMP_GL_VALUE(GL_SAMPLES); DUMP_GL_VALUE2(GL_ALIASED_LINE_WIDTH_RANGE); DUMP_GL_VALUE2(GL_MAX_VIEWPORT_DIMS); DUMP_GL_VALUE2(GL_SMOOTH_LINE_WIDTH_RANGE); DUMP_GL_VALUE2(GL_SMOOTH_POINT_SIZE_RANGE); #undef DUMP_GL_VALUE #undef DUMP_GL_VALUE2 // enumerate compressed texture formats { dump_and_clear_opengl_errors(out); out << "\nCompressed texture formats:\n"; GLint nformats; GLint formats[128]; // XXX 128 should be enough, right? glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &nformats); GLenum err = glGetError(); if (err != GL_NO_ERROR) { out << "Get NUM_COMPRESSED_TEXTURE_FORMATS failed\n"; dump_and_clear_opengl_errors(out, err); } else { assert(nformats >= 0 && nformats < int(COUNTOF(formats))); glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats); err = glGetError(); if (err != GL_NO_ERROR) { out << "Get COMPRESSED_TEXTURE_FORMATS failed\n"; dump_and_clear_opengl_errors(out, err); } else { for (int i = 0; i < nformats; ++i) { out << stringf(" %0{x#}\n", unsigned(formats[i])); } } } } // one last time dump_and_clear_opengl_errors(out); }
void SDLWindow::initializeOpenGL() { // Set Attributes SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 2); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 2); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 2); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 2); SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 0); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0); SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 0); SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 0); SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 0); SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 0); SDL_GL_SetAttribute(SDL_GL_STEREO, 0); #if not defined(__linux__) SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 32); #endif // not defined(__linux__) SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1); SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, 0); #if defined(CONTEXT_MAJOR_VERSION) && defined(CONTEXT_MINOR_VERSION) SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, CONTEXT_MAJOR_VERSION); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, CONTEXT_MINOR_VERSION); #endif // defined(CONTEXT_MAJOR_VERSION) && defined(CONTEXT_MINOR_VERSION) SDL_GL_SetAttribute(SDL_GL_CONTEXT_EGL, 0); SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG | SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG | SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG | SDL_GL_CONTEXT_RESET_ISOLATION_FLAG); SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 0); SDL_GL_SetAttribute(SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, 0); // Create Window m_sdlWindow = SDL_CreateWindow(m_title.c_str(), m_xOrigin, m_yOrigin, m_xSize, m_ySize, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI); if (m_sdlWindow == NULL) { printf("SDL_CreateWindow Error: %s\n", SDL_GetError()); assert(m_sdlWindow != NULL); } #if defined(CONTEXT_MAJOR_VERSION) && defined(CONTEXT_MINOR_VERSION) // Create Context m_sdlContext = SDL_GL_CreateContext(m_sdlWindow); if (m_sdlContext == NULL) { printf("SDL_GL_CreateContext Error: %s\n", SDL_GetError()); assert(m_sdlContext != NULL); } else { std::cout << "OpenGL context: " << CONTEXT_MAJOR_VERSION << "." << CONTEXT_MINOR_VERSION << std::endl; } #else // Create Context const int major[] = { 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 2 }; const int minor[] = { 5, 4, 3, 2, 1, 0, 3, 2, 1, 0, 0 }; int index = 0; for (index = 0; index < 11; ++index) { SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major[index]); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor[index]); m_sdlGlContext = SDL_GL_CreateContext(m_sdlWindow); if (m_sdlGlContext != NULL) { break; } } if (m_sdlGlContext == NULL) { printf("SDL_GL_CreateContext Error: %s\n", SDL_GetError()); assert(m_sdlGlContext != NULL); } else { std::cout << "OpenGL context: " << major[index] << "." << minor[index] << std::endl; } #endif // defined(CONTEXT_MAJOR_VERSION) && defined(CONTEXT_MINOR_VERSION) // Set Context to Current SDL_GL_MakeCurrent(m_sdlWindow, m_sdlGlContext); // Log relevant information std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl; std::cout << "OpenGL GLEXT version: " << GL_GLEXT_VERSION << std::endl; std::cout << "OpenGL GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl; std::cout << "OpenGL Renderer: " << glGetString(GL_RENDERER) << std::endl; std::cout << "OpenGL Vendor: " << glGetString(GL_VENDOR) << std::endl; GLint extensionsCount; glGetIntegerv(GL_NUM_EXTENSIONS, &extensionsCount); std::cout << "OpenGL Extensions: " << extensionsCount << std::endl; #if not defined(__APPLE__) && not defined(__linux__) // TODO Fix this for unsupported platforms for (GLint i = 0; i < extensionsCount; ++i) { std::cout << glGetStringi(GL_EXTENSIONS, i) << std::endl; } #endif // defined(__APPLE__) && not defined(__linux__) int videoDrivers = SDL_GetNumVideoDrivers(); std::cout << "Video Drivers: " << videoDrivers << std::endl; const std::string currentVideoDriver(SDL_GetCurrentVideoDriver()); for (int i = 0; i < videoDrivers; ++i) { const std::string videoDriver(SDL_GetVideoDriver(i)); std::cout << "Video Driver " << i << ": " << videoDriver; if (currentVideoDriver == videoDriver) { std::cout << " [Current]"; } std::cout << std::endl; } int renderDrivers = SDL_GetNumRenderDrivers(); std::cout << "Render Drivers: " << renderDrivers << std::endl; SDL_RendererInfo info; for (int i = 0; i < renderDrivers; ++i) { SDL_GetRenderDriverInfo(i, &info); std::cout << "Render Driver " << i << ": " << info.name; bool isSoftware = info.flags & SDL_RENDERER_SOFTWARE; bool isHardware = info.flags & SDL_RENDERER_ACCELERATED; bool isVSyncEnabled = info.flags & SDL_RENDERER_PRESENTVSYNC; bool isTargetTexture = info.flags & SDL_RENDERER_TARGETTEXTURE; std::cout << " ["; if (isSoftware) std::cout << "SW"; if (isHardware) std::cout << "HW"; if (isVSyncEnabled) std::cout << ", VS"; if (isTargetTexture) std::cout << ", TT"; std::cout << "]" << std::endl; } }
void gl_features() { int major, minor; gl_version(major, minor); if (major > 0) { std::vector<std::string> gl_exts; if (major >= 3) { LOAD_FUNC1(glGetStringi); GLint num_exts; glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts); gl_exts.resize(num_exts); for (GLint i = 0; i < num_exts; ++ i) { gl_exts[i] = reinterpret_cast<char const *>(glGetStringi(GL_EXTENSIONS, i)); } } else { GLubyte const * str = glGetString(GL_EXTENSIONS); if (str != NULL) { gl_exts = split(reinterpret_cast<char const *>(str)); } } gl_exts.erase(std::remove(gl_exts.begin(), gl_exts.end(), ""), gl_exts.end()); #ifdef GLLOADER_GLES for (std::vector<std::string>::iterator iter = gl_exts.begin(); iter != gl_exts.end(); ++ iter) { if (0 == iter->find("GL_")) { *iter = "GLES_" + iter->substr(3); } } #endif features_.insert(features_.end(), gl_exts.begin(), gl_exts.end()); int const ver_code = major * 10 + minor; #ifndef GLLOADER_GLES if (ver_code >= 10) { features_.push_back("GL_VERSION_1_0"); } if (ver_code >= 11) { features_.push_back("GL_VERSION_1_1"); } if (ver_code >= 12) { features_.push_back("GL_VERSION_1_2"); } if (ver_code >= 13) { features_.push_back("GL_VERSION_1_3"); } if (ver_code >= 14) { features_.push_back("GL_VERSION_1_4"); } if (ver_code >= 15) { features_.push_back("GL_VERSION_1_5"); } if (ver_code >= 20) { features_.push_back("GL_VERSION_2_0"); } if (ver_code >= 21) { features_.push_back("GL_VERSION_2_1"); } if (ver_code >= 30) { features_.push_back("GL_VERSION_3_0"); } if (ver_code >= 31) { features_.push_back("GL_VERSION_3_1"); } if (ver_code >= 32) { features_.push_back("GL_VERSION_3_2"); } if (ver_code >= 33) { features_.push_back("GL_VERSION_3_3"); } if (ver_code >= 40) { features_.push_back("GL_VERSION_4_0"); } if (ver_code >= 41) { features_.push_back("GL_VERSION_4_1"); } if (ver_code >= 42) { features_.push_back("GL_VERSION_4_2"); } if (ver_code >= 43) { features_.push_back("GL_VERSION_4_3"); } if (ver_code >= 44) { features_.push_back("GL_VERSION_4_4"); } #else if (ver_code >= 10) { features_.push_back("GLES_VERSION_1_0"); } if (ver_code >= 11) { features_.push_back("GLES_VERSION_1_1"); } if (ver_code >= 20) { features_.push_back("GLES_VERSION_2_0"); } if (ver_code >= 30) { features_.push_back("GLES_VERSION_3_0"); } #endif } }
void RE_InitOpenGl(void) { //Clear the screen with a black color thanks Glimp_ClearScreen(); glConfig.driverType = GLDRV_ICD; glConfig.hardwareType = GLHW_GENERIC; // Get extension strings #ifndef FEATURE_RENDERER2 Q_strncpyz(glConfig.extensions_string, ( char * ) glGetString(GL_EXTENSIONS), sizeof(glConfig.extensions_string)); #else { int i = 0, exts = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &exts); glConfig.extensions_string[0] = 0; for (i = 0; i < exts; i++) { if (strlen(glConfig.extensions_string) + 100 >= sizeof(glConfig.extensions_string)) { //Just so we wont error out when there are really a lot of extensions break; } Q_strcat(glConfig.extensions_string, sizeof(glConfig.extensions_string), va("%s ", glGetStringi(GL_EXTENSIONS, i))); } } #endif // initialize extensions #ifdef FEATURE_RENDERER2 GLimp_InitExtensionsR2(); // renderer2 #else GLimp_InitExtensions(); // vanilla renderer #endif }
bool RendererLegacy::PrintDebugInfo(std::ostream &out) { out << "OpenGL version " << glGetString(GL_VERSION); out << ", running on " << glGetString(GL_VENDOR); out << " " << glGetString(GL_RENDERER) << "\n"; out << "GLEW version " << glewGetString(GLEW_VERSION) << "\n"; if (glewIsSupported("GL_VERSION_2_0")) out << "Shading language version: " << glGetString(GL_SHADING_LANGUAGE_VERSION_ARB) << "\n"; out << "Available extensions:" << "\n"; GLint numext = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &numext); if (glewIsSupported("GL_VERSION_3_0")) { for (int i = 0; i < numext; ++i) { out << " " << glGetStringi(GL_EXTENSIONS, i) << "\n"; } } else { out << " "; std::istringstream ext(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS))); std::copy( std::istream_iterator<std::string>(ext), std::istream_iterator<std::string>(), std::ostream_iterator<std::string>(out, "\n ")); } out << "\nImplementation Limits:\n"; // first, clear all OpenGL error flags while (glGetError() != GL_NO_ERROR) {} #define DUMP_GL_VALUE(name) dump_opengl_value(out, #name, name, 1) #define DUMP_GL_VALUE2(name) dump_opengl_value(out, #name, name, 2) DUMP_GL_VALUE(GL_MAX_3D_TEXTURE_SIZE); DUMP_GL_VALUE(GL_MAX_ATTRIB_STACK_DEPTH); DUMP_GL_VALUE(GL_MAX_CLIENT_ATTRIB_STACK_DEPTH); DUMP_GL_VALUE(GL_MAX_CLIP_PLANES); DUMP_GL_VALUE(GL_MAX_COLOR_ATTACHMENTS_EXT); DUMP_GL_VALUE(GL_MAX_COLOR_MATRIX_STACK_DEPTH); DUMP_GL_VALUE(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS); DUMP_GL_VALUE(GL_MAX_CUBE_MAP_TEXTURE_SIZE); DUMP_GL_VALUE(GL_MAX_DRAW_BUFFERS); DUMP_GL_VALUE(GL_MAX_ELEMENTS_INDICES); DUMP_GL_VALUE(GL_MAX_ELEMENTS_VERTICES); DUMP_GL_VALUE(GL_MAX_EVAL_ORDER); DUMP_GL_VALUE(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS); DUMP_GL_VALUE(GL_MAX_LIGHTS); DUMP_GL_VALUE(GL_MAX_LIST_NESTING); DUMP_GL_VALUE(GL_MAX_MODELVIEW_STACK_DEPTH); DUMP_GL_VALUE(GL_MAX_NAME_STACK_DEPTH); DUMP_GL_VALUE(GL_MAX_PIXEL_MAP_TABLE); DUMP_GL_VALUE(GL_MAX_PROJECTION_STACK_DEPTH); DUMP_GL_VALUE(GL_MAX_RENDERBUFFER_SIZE_EXT); DUMP_GL_VALUE(GL_MAX_SAMPLES_EXT); DUMP_GL_VALUE(GL_MAX_TEXTURE_COORDS); DUMP_GL_VALUE(GL_MAX_TEXTURE_IMAGE_UNITS); DUMP_GL_VALUE(GL_MAX_TEXTURE_LOD_BIAS); DUMP_GL_VALUE(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT); DUMP_GL_VALUE(GL_MAX_TEXTURE_SIZE); DUMP_GL_VALUE(GL_MAX_TEXTURE_STACK_DEPTH); DUMP_GL_VALUE(GL_MAX_TEXTURE_UNITS); DUMP_GL_VALUE(GL_MAX_VARYING_FLOATS); DUMP_GL_VALUE(GL_MAX_VERTEX_ATTRIBS); DUMP_GL_VALUE(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS); DUMP_GL_VALUE(GL_MAX_VERTEX_UNIFORM_COMPONENTS); DUMP_GL_VALUE(GL_NUM_COMPRESSED_TEXTURE_FORMATS); DUMP_GL_VALUE(GL_SAMPLE_BUFFERS); DUMP_GL_VALUE(GL_SAMPLES); DUMP_GL_VALUE2(GL_ALIASED_LINE_WIDTH_RANGE); DUMP_GL_VALUE2(GL_ALIASED_POINT_SIZE_RANGE); DUMP_GL_VALUE2(GL_MAX_VIEWPORT_DIMS); DUMP_GL_VALUE2(GL_SMOOTH_LINE_WIDTH_RANGE); DUMP_GL_VALUE2(GL_SMOOTH_POINT_SIZE_RANGE); #undef DUMP_GL_VALUE #undef DUMP_GL_VALUE2 return true; }
void GLPlatform::detect(OpenGLPlatformInterface platformInterface) { m_platformInterface = platformInterface; m_vendor = (const char*)glGetString(GL_VENDOR); m_renderer = (const char*)glGetString(GL_RENDERER); m_version = (const char*)glGetString(GL_VERSION); // Parse the OpenGL version const QList<QByteArray> versionTokens = m_version.split(' '); if (versionTokens.count() > 0) { const QByteArray version = QByteArray(m_version); m_glVersion = parseVersionString(version); if (platformInterface == EglPlatformInterface) { // only EGL can have OpenGLES, GLX is OpenGL only if (version.startsWith("OpenGL ES")) { // from GLES 2: "Returns a version or release number of the form OpenGL<space>ES<space><version number><space><vendor-specific information>." // from GLES 3: "Returns a version or release number." and "The version number uses one of these forms: major_number.minor_number major_number.minor_number.release_number" m_gles = true; } } } if (!isGLES() && m_glVersion >= kVersionNumber(3, 0)) { int count; glGetIntegerv(GL_NUM_EXTENSIONS, &count); for (int i = 0; i < count; i++) { const char *name = (const char *) glGetStringi(GL_EXTENSIONS, i); m_extensions.insert(name); } } else { const QByteArray extensions = (const char *) glGetString(GL_EXTENSIONS); m_extensions = QSet<QByteArray>::fromList(extensions.split(' ')); } // Parse the Mesa version const int mesaIndex = versionTokens.indexOf("Mesa"); if (mesaIndex != -1) { const QByteArray version = versionTokens.at(mesaIndex + 1); m_mesaVersion = parseVersionString(version); } if (platformInterface == EglPlatformInterface) { if (isGLES()) { m_supportsGLSL = true; m_textureNPOT = true; } else { m_supportsGLSL = m_extensions.contains("GL_ARB_shader_objects") && m_extensions.contains("GL_ARB_fragment_shader") && m_extensions.contains("GL_ARB_vertex_shader"); m_textureNPOT = m_extensions.contains("GL_ARB_texture_non_power_of_two"); } } else if (platformInterface == GlxPlatformInterface) { m_supportsGLSL = m_extensions.contains("GL_ARB_shader_objects") && m_extensions.contains("GL_ARB_fragment_shader") && m_extensions.contains("GL_ARB_vertex_shader"); m_textureNPOT = m_extensions.contains("GL_ARB_texture_non_power_of_two"); } m_serverVersion = getXServerVersion(); m_kernelVersion = getKernelVersion(); m_glslVersion = 0; m_glsl_version.clear(); if (m_supportsGLSL) { // Parse the GLSL version m_glsl_version = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION); m_glslVersion = parseVersionString(m_glsl_version); } m_chipset = QByteArrayLiteral("Unknown"); m_preferBufferSubData = false; // Mesa classic drivers // ==================================================== // Radeon if (m_renderer.startsWith("Mesa DRI R")) { // Sample renderer string: Mesa DRI R600 (RV740 94B3) 20090101 x86/MMX/SSE2 TCL DRI2 const QList<QByteArray> tokens = m_renderer.split(' '); const QByteArray chipClass = tokens.at(2); m_chipset = tokens.at(3).mid(1, -1); // Strip the leading '(' if (chipClass == "R100") // Vendor: Tungsten Graphics, Inc. m_driver = Driver_R100; else if (chipClass == "R200") // Vendor: Tungsten Graphics, Inc. m_driver = Driver_R200; else if (chipClass == "R300") // Vendor: DRI R300 Project m_driver = Driver_R300C; else if (chipClass == "R600") // Vendor: Advanced Micro Devices, Inc. m_driver = Driver_R600C; m_chipClass = detectRadeonClass(m_chipset); } // Intel else if (m_renderer.contains("Intel")) { // Vendor: Tungsten Graphics, Inc. // Sample renderer string: Mesa DRI Mobile Intel® GM45 Express Chipset GEM 20100328 2010Q1 QByteArray chipset; if (m_renderer.startsWith("Intel(R) Integrated Graphics Device")) chipset = "IGD"; else chipset = m_renderer; m_driver = Driver_Intel; m_chipClass = detectIntelClass(chipset); } // Gallium drivers // ==================================================== else if (m_renderer.contains("Gallium")) { // Sample renderer string: Gallium 0.4 on AMD RV740 const QList<QByteArray> tokens = m_renderer.split(' '); m_galliumVersion = parseVersionString(tokens.at(1)); m_chipset = (tokens.at(3) == "AMD" || tokens.at(3) == "ATI") ? tokens.at(4) : tokens.at(3); // R300G if (m_vendor == QByteArrayLiteral("X.Org R300 Project")) { m_chipClass = detectRadeonClass(m_chipset); m_driver = Driver_R300G; } // R600G else if (m_vendor == "X.Org" && (m_renderer.contains("R6") || m_renderer.contains("R7") || m_renderer.contains("RV6") || m_renderer.contains("RV7") || m_renderer.contains("RS780") || m_renderer.contains("RS880") || m_renderer.contains("CEDAR") || m_renderer.contains("REDWOOD") || m_renderer.contains("JUNIPER") || m_renderer.contains("CYPRESS") || m_renderer.contains("HEMLOCK") || m_renderer.contains("PALM") || m_renderer.contains("EVERGREEN") || m_renderer.contains("SUMO") || m_renderer.contains("SUMO2") || m_renderer.contains("BARTS") || m_renderer.contains("TURKS") || m_renderer.contains("CAICOS") || m_renderer.contains("CAYMAN"))) { m_chipClass = detectRadeonClass(m_chipset); m_driver = Driver_R600G; } // Nouveau else if (m_vendor == "nouveau") { m_chipClass = detectNVidiaClass(m_chipset); m_driver = Driver_Nouveau; } // softpipe else if (m_vendor == "VMware, Inc." && m_chipset == "softpipe" ) { m_driver = Driver_Softpipe; } // llvmpipe else if (m_vendor == "VMware, Inc." && m_chipset == "llvmpipe") { m_driver = Driver_Llvmpipe; } // SVGA3D else if (m_vendor == "VMware, Inc." && m_chipset.contains("SVGA3D")) { m_driver = Driver_VMware; } } // Properietary drivers // ==================================================== else if (m_vendor == "ATI Technologies Inc.") { m_chipClass = detectRadeonClass(m_renderer); m_driver = Driver_Catalyst; if (versionTokens.count() > 1 && versionTokens.at(2)[0] == '(') m_driverVersion = parseVersionString(versionTokens.at(1)); else if (versionTokens.count() > 0) m_driverVersion = parseVersionString(versionTokens.at(0)); else m_driverVersion = 0; } else if (m_vendor == "NVIDIA Corporation") { m_chipClass = detectNVidiaClass(m_renderer); m_driver = Driver_NVidia; int index = versionTokens.indexOf("NVIDIA"); if (versionTokens.count() > index) m_driverVersion = parseVersionString(versionTokens.at(index + 1)); else m_driverVersion = 0; } else if (m_renderer == "Software Rasterizer") { m_driver = Driver_Swrast; } // Virtual Hardware // ==================================================== else if (m_vendor == "Humper" && m_renderer == "Chromium") { // Virtual Box m_driver = Driver_VirtualBox; const int index = versionTokens.indexOf("Chromium"); if (versionTokens.count() > index) m_driverVersion = parseVersionString(versionTokens.at(index + 1)); else m_driverVersion = 0; } // Driver/GPU specific features // ==================================================== if (isRadeon()) { // R200 technically has a programmable pipeline, but since it's SM 1.4, // it's too limited to to be of any practical value to us. if (m_chipClass < R300) m_supportsGLSL = false; m_limitedGLSL = false; m_limitedNPOT = false; if (m_chipClass < R600) { if (driver() == Driver_Catalyst) m_textureNPOT = m_limitedNPOT = false; // Software fallback else if (driver() == Driver_R300G) m_limitedNPOT = m_textureNPOT; m_limitedGLSL = m_supportsGLSL; } if (m_chipClass < R300) { // fallback to XRender for R100 and R200 m_recommendedCompositor = XRenderCompositing; } else if (m_chipClass < R600) { // XRender due to NPOT limitations not supported by KWin's shaders m_recommendedCompositor = XRenderCompositing; } else { m_recommendedCompositor = OpenGL2Compositing; } if (driver() == Driver_R600G || (driver() == Driver_R600C && m_renderer.contains("DRI2"))) { m_looseBinding = true; } } if (isNvidia()) { if (m_driver == Driver_NVidia && m_chipClass < NV40) m_supportsGLSL = false; // High likelihood of software emulation if (m_driver == Driver_NVidia) { m_looseBinding = true; m_preferBufferSubData = true; } if (m_chipClass < NV40) { m_recommendedCompositor = XRenderCompositing; } else { m_recommendedCompositor = OpenGL2Compositing; } m_limitedNPOT = m_textureNPOT && m_chipClass < NV40; m_limitedGLSL = m_supportsGLSL && m_chipClass < G80; } if (isIntel()) { if (m_chipClass < I915) m_supportsGLSL = false; m_limitedGLSL = m_supportsGLSL && m_chipClass < I965; // see https://bugs.freedesktop.org/show_bug.cgi?id=80349#c1 m_looseBinding = false; if (m_chipClass < I915) { m_recommendedCompositor = XRenderCompositing; } else { m_recommendedCompositor = OpenGL2Compositing; } } if (isMesaDriver() && platformInterface == EglPlatformInterface) { // According to the reference implementation in // mesa/demos/src/egl/opengles1/texture_from_pixmap // the mesa egl implementation does not require a strict binding (so far). m_looseBinding = true; } if (isSoftwareEmulation()) { if (m_driver < Driver_Llvmpipe) { // we recommend XRender m_recommendedCompositor = XRenderCompositing; // Software emulation does not provide GLSL m_limitedGLSL = m_supportsGLSL = false; } else { // llvmpipe does support GLSL m_recommendedCompositor = OpenGL2Compositing; m_limitedGLSL = false; m_supportsGLSL = true; } } if (m_chipClass == UnknownChipClass && m_driver == Driver_Unknown) { // we don't know the hardware. Let's be optimistic and assume OpenGL compatible hardware m_recommendedCompositor = OpenGL2Compositing; m_supportsGLSL = true; } if (isVirtualBox()) { m_virtualMachine = true; m_recommendedCompositor = OpenGL2Compositing; } if (isVMware()) { m_virtualMachine = true; m_recommendedCompositor = OpenGL2Compositing; } // and force back to shader supported on gles, we wouldn't have got a context if not supported if (isGLES()) { m_supportsGLSL = true; m_limitedGLSL = false; } }
/* =============== GLimp_Init This routine is responsible for initializing the OS specific portions of OpenGL =============== */ bool GLimp_Init() { glConfig.driverType = GLDRV_ICD; r_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM ); r_allowResize = ri.Cvar_Get( "r_allowResize", "0", 0 ); r_centerWindow = ri.Cvar_Get( "r_centerWindow", "0", 0 ); r_displayIndex = ri.Cvar_Get( "r_displayIndex", "0", 0 ); ri.Cmd_AddCommand( "minimize", GLimp_Minimize ); if ( ri.Cvar_VariableIntegerValue( "com_abnormalExit" ) ) { ri.Cvar_Set( "r_mode", va( "%d", R_MODE_FALLBACK ) ); ri.Cvar_Set( "r_fullscreen", "0" ); ri.Cvar_Set( "r_centerWindow", "0" ); ri.Cvar_Set( "com_abnormalExit", "0" ); } // Create the window and set up the context if ( GLimp_StartDriverAndSetMode( r_mode->integer, r_fullscreen->integer, false ) ) { goto success; } // Finally, try the default screen resolution if ( r_mode->integer != R_MODE_FALLBACK ) { ri.Printf( PRINT_ALL, "Setting r_mode %d failed, falling back on r_mode %d\n", r_mode->integer, R_MODE_FALLBACK ); if ( GLimp_StartDriverAndSetMode( R_MODE_FALLBACK, false, false ) ) { goto success; } } // Nothing worked, give up SDL_QuitSubSystem( SDL_INIT_VIDEO ); return false; success: // These values force the UI to disable driver selection glConfig.hardwareType = GLHW_GENERIC; // get our config strings Q_strncpyz( glConfig.vendor_string, ( char * ) glGetString( GL_VENDOR ), sizeof( glConfig.vendor_string ) ); Q_strncpyz( glConfig.renderer_string, ( char * ) glGetString( GL_RENDERER ), sizeof( glConfig.renderer_string ) ); if ( *glConfig.renderer_string && glConfig.renderer_string[ strlen( glConfig.renderer_string ) - 1 ] == '\n' ) { glConfig.renderer_string[ strlen( glConfig.renderer_string ) - 1 ] = 0; } Q_strncpyz( glConfig.version_string, ( char * ) glGetString( GL_VERSION ), sizeof( glConfig.version_string ) ); if ( glConfig.driverType == GLDRV_OPENGL3 ) { GLint numExts, i; glGetIntegerv( GL_NUM_EXTENSIONS, &numExts ); glConfig.extensions_string[ 0 ] = '\0'; for ( i = 0; i < numExts; ++i ) Q_strcat( glConfig.extensions_string, sizeof( glConfig.extensions_string ), ( char * ) glGetStringi( GL_EXTENSIONS, i ) ); } else { Q_strncpyz( glConfig.extensions_string, ( char * ) glGetString( GL_EXTENSIONS ), sizeof( glConfig.extensions_string ) ); } if ( Q_stristr( glConfig.renderer_string, "mesa" ) || Q_stristr( glConfig.renderer_string, "gallium" ) || Q_stristr( glConfig.vendor_string, "nouveau" ) || Q_stristr( glConfig.vendor_string, "mesa" ) ) { // suckage glConfig.driverType = GLDRV_MESA; } if ( Q_stristr( glConfig.renderer_string, "geforce" ) ) { if ( Q_stristr( glConfig.renderer_string, "8400" ) || Q_stristr( glConfig.renderer_string, "8500" ) || Q_stristr( glConfig.renderer_string, "8600" ) || Q_stristr( glConfig.renderer_string, "8800" ) || Q_stristr( glConfig.renderer_string, "9500" ) || Q_stristr( glConfig.renderer_string, "9600" ) || Q_stristr( glConfig.renderer_string, "9800" ) || Q_stristr( glConfig.renderer_string, "gts 240" ) || Q_stristr( glConfig.renderer_string, "gts 250" ) || Q_stristr( glConfig.renderer_string, "gtx 260" ) || Q_stristr( glConfig.renderer_string, "gtx 275" ) || Q_stristr( glConfig.renderer_string, "gtx 280" ) || Q_stristr( glConfig.renderer_string, "gtx 285" ) || Q_stristr( glConfig.renderer_string, "gtx 295" ) || Q_stristr( glConfig.renderer_string, "gt 320" ) || Q_stristr( glConfig.renderer_string, "gt 330" ) || Q_stristr( glConfig.renderer_string, "gt 340" ) || Q_stristr( glConfig.renderer_string, "gt 415" ) || Q_stristr( glConfig.renderer_string, "gt 420" ) || Q_stristr( glConfig.renderer_string, "gt 425" ) || Q_stristr( glConfig.renderer_string, "gt 430" ) || Q_stristr( glConfig.renderer_string, "gt 435" ) || Q_stristr( glConfig.renderer_string, "gt 440" ) || Q_stristr( glConfig.renderer_string, "gt 520" ) || Q_stristr( glConfig.renderer_string, "gt 525" ) || Q_stristr( glConfig.renderer_string, "gt 540" ) || Q_stristr( glConfig.renderer_string, "gt 550" ) || Q_stristr( glConfig.renderer_string, "gt 555" ) || Q_stristr( glConfig.renderer_string, "gts 450" ) || Q_stristr( glConfig.renderer_string, "gtx 460" ) || Q_stristr( glConfig.renderer_string, "gtx 470" ) || Q_stristr( glConfig.renderer_string, "gtx 480" ) || Q_stristr( glConfig.renderer_string, "gtx 485" ) || Q_stristr( glConfig.renderer_string, "gtx 560" ) || Q_stristr( glConfig.renderer_string, "gtx 570" ) || Q_stristr( glConfig.renderer_string, "gtx 580" ) || Q_stristr( glConfig.renderer_string, "gtx 590" ) ) { glConfig.hardwareType = GLHW_NV_DX10; } } else if ( Q_stristr( glConfig.renderer_string, "quadro fx" ) ) { if ( Q_stristr( glConfig.renderer_string, "3600" ) ) { glConfig.hardwareType = GLHW_NV_DX10; } } else if ( Q_stristr( glConfig.renderer_string, "gallium" ) && Q_stristr( glConfig.renderer_string, " amd " ) ) { // anything prior to R600 is listed as ATI. glConfig.hardwareType = GLHW_ATI_DX10; } else if ( Q_stristr( glConfig.renderer_string, "rv770" ) || Q_stristr( glConfig.renderer_string, "eah4850" ) || Q_stristr( glConfig.renderer_string, "eah4870" ) || // previous three are too specific? Q_stristr( glConfig.renderer_string, "radeon hd" ) ) { glConfig.hardwareType = GLHW_ATI_DX10; } else if ( Q_stristr( glConfig.renderer_string, "radeon" ) ) { glConfig.hardwareType = GLHW_ATI; } reportDriverType( false ); reportHardwareType( false ); { // allow overriding where the user really does know better cvar_t *forceGL; glDriverType_t driverType = GLDRV_UNKNOWN; glHardwareType_t hardwareType = GLHW_UNKNOWN; forceGL = ri.Cvar_Get( "r_glForceDriver", "", CVAR_LATCH ); if ( !Q_stricmp( forceGL->string, "icd" )) { driverType = GLDRV_ICD; } else if ( !Q_stricmp( forceGL->string, "standalone" )) { driverType = GLDRV_STANDALONE; } else if ( !Q_stricmp( forceGL->string, "opengl3" )) { driverType = GLDRV_OPENGL3; } else if ( !Q_stricmp( forceGL->string, "mesa" )) { driverType = GLDRV_MESA; } forceGL = ri.Cvar_Get( "r_glForceHardware", "", CVAR_LATCH ); if ( !Q_stricmp( forceGL->string, "generic" )) { hardwareType = GLHW_GENERIC; } else if ( !Q_stricmp( forceGL->string, "ati" )) { hardwareType = GLHW_ATI; } else if ( !Q_stricmp( forceGL->string, "atidx10" ) || !Q_stricmp( forceGL->string, "radeonhd" )) { hardwareType = GLHW_ATI_DX10; } else if ( !Q_stricmp( forceGL->string, "nvdx10" )) { hardwareType = GLHW_NV_DX10; } if ( driverType != GLDRV_UNKNOWN ) { glConfig.driverType = driverType; reportDriverType( true ); } if ( hardwareType != GLHW_UNKNOWN ) { glConfig.hardwareType = hardwareType; reportHardwareType( true ); } } // initialize extensions GLimp_InitExtensions(); ri.Cvar_Get( "r_availableModes", "", CVAR_ROM ); // This depends on SDL_INIT_VIDEO, hence having it here ri.IN_Init( window ); return true; }