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