/**
* @brief This routine is responsible for initializing the OS specific portions of OpenGL
* @param[in,out] glConfig
* @param[in] context
*/
void GLimp_Init(glconfig_t *glConfig, windowContext_t *context)
{
SDL_version compiled;
SDL_version linked;
SDL_VERSION(&compiled);
SDL_GetVersion(&linked);
Com_Printf("SDL build version %d.%d.%d - link version %d.%d.%d.\n", compiled.major, compiled.minor, compiled.patch, linked.major, linked.minor, linked.patch);
GLimp_InitCvars();
if (Cvar_VariableIntegerValue("com_abnormalExit"))
{
Cvar_Set("r_mode", va("%d", R_MODE_FALLBACK));
Cvar_Set("r_fullscreen", "0");
Cvar_Set("r_centerWindow", "0");
Cvar_Set("com_abnormalExit", "0");
}
Sys_GLimpInit();
// Create the window and set up the context
if (GLimp_StartDriverAndSetMode(glConfig, r_mode->integer, (qboolean) !!r_fullscreen->integer, (qboolean) !!r_noBorder->integer, context))
{
goto success;
}
// Try again, this time in a platform specific "safe mode"
Sys_GLimpSafeInit();
if (GLimp_StartDriverAndSetMode(glConfig, r_mode->integer, (qboolean) !!r_fullscreen->integer, qfalse, context))
{
goto success;
}
// Finally, try the default screen resolution
if (r_mode->integer != R_MODE_FALLBACK)
{
Com_Printf("Setting r_mode %d failed, falling back on r_mode %d\n", r_mode->integer, R_MODE_FALLBACK);
if (GLimp_StartDriverAndSetMode(glConfig, R_MODE_FALLBACK, qfalse, qfalse, context))
{
goto success;
}
}
// Nothing worked, give up
Com_Error(ERR_VID_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n");
success:
// Only using SDL_SetWindowBrightness to determine if hardware gamma is supported
glConfig->deviceSupportsGamma = !r_ignorehwgamma->integer && SDL_SetWindowBrightness(main_window, 1.0f) >= 0;
re.InitOpenGL();
Cvar_Get("r_availableModes", "", CVAR_ROM);
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init();
}
/*
===============
GLimp_Init
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_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
//r_allowResize = ri.Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE );
Sys_GLimpInit( );
#ifdef SDL_VIDEO_DRIVER_X11
XInitThreads( );
#endif
// create the window and set up the context
if( GLimp_StartDriverAndSetMode( ) )
goto success;
// Try again, this time in a platform specific "safe mode"
Sys_GLimpSafeInit( );
if( GLimp_StartDriverAndSetMode( ) )
goto success;
// Finally, try the default screen resolution
//if( GLimp_StartDriverAndSetMode( qtrue, r_fullscreen->integer ) )
// goto success;
// Nothing worked, give up
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
success:
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = (SDL_SetWindowBrightness( window, 1.0f ) == 0)?1:0;//FIXME: Use SDL_SetWindowGammaRamp with NULL instead?
// Mysteriously, if you use an NVidia graphics card and multiple monitors,
// SDL_SetGamma will incorrectly return false... the first time; ask
// again and you get the correct answer. This is a suspected driver bug, see
// http://bugzilla.icculus.org/show_bug.cgi?id=4316
//glConfig.deviceSupportsGamma = SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0;
// get our config strings
Q_strncpyz( glConfig.vendor_string, (char *) qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, (char *) qglGetString (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 *) qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, (char *) qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
// initialize extensions
GLimp_InitExtensions( );
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init( );
}
/*
===============
GLimp_Init
This routine is responsible for initializing the OS specific portions
of OpenGL
===============
*/
void GLimp_Init(void)
{
qboolean success = qtrue;
r_sdlDriver = ri.Cvar_Get("r_sdlDriver", "", CVAR_ROM);
// Sys_GLimpInit();
// create the window and set up the context
if(!GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer))
{
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, r_fullscreen->integer))
success = qfalse;
}
else
success = qfalse;
}
if(!success)
ri.Error(ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n");
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_DEFAULT;
glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = !!(SDL_SetGamma(1.0f, 1.0f, 1.0f) >= 0);
// get our config strings
Q_strncpyz(glConfig.vendor_string, "Microsoft", sizeof(glConfig.vendor_string));
Q_strncpyz(glConfig.renderer_string, "D3D", 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, "10.0", sizeof(glConfig.version_string));
Q_strncpyz(glConfig.extensions_string, "None", sizeof(glConfig.extensions_string));
ri.Cvar_Get("r_availableModes", "", CVAR_ROM);
// This depends on SDL_INIT_VIDEO, hence having it here
ri.IN_Init();
}
/*
===============
GLimp_Init
This routine is responsible for initializing the OS specific portions
of OpenGL
===============
*/
void GLimp_Init( void )
{
qboolean success = qtrue;
r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
Sys_GLimpInit( );
// create the window and set up the context
if( !GLimp_StartDriverAndSetMode( qfalse, r_fullscreen->integer ) )
{
if( !GLimp_StartDriverAndSetMode( qtrue, r_fullscreen->integer ) )
success = qfalse;
}
if( !success )
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = !!( SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0 );
// get our config strings
Q_strncpyz( glConfig.vendor_string, (char *) qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, (char *) qglGetString (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 *) qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, (char *) qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
// initialize extensions
GLimp_InitExtensions( );
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init( );
}
void GLimp_Init( void ) {
if (SDLvidscreen)
return;
if( !GLimp_StartDriverAndSetMode( r_mode->integer, r_fullscreen->integer , qfalse) )
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
// Hardware gamma is not supported in recent Linux/SDL.
glConfig.deviceSupportsGamma = qfalse;
Q_strncpyz(glConfig.vendor_string, (char *) qglGetString(GL_VENDOR), sizeof(glConfig.vendor_string));
Q_strncpyz(glConfig.renderer_string, (char *) qglGetString(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 *) qglGetString(GL_VERSION), sizeof(glConfig.version_string));
glConfig.extensions_string = (char *)qglGetString(GL_EXTENSIONS);
GLimp_InitExtensions();
glConfig.stereoEnabled = qfalse;
IN_Init();
return;
}
window_t WIN_Init( const windowDesc_t *windowDesc, glconfig_t *glConfig )
{
Cmd_AddCommand("modelist", R_ModeList_f);
Cmd_AddCommand("minimize", GLimp_Minimize);
r_sdlDriver = Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
// Window cvars
r_fullscreen = Cvar_Get( "r_fullscreen", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_noborder = Cvar_Get( "r_noborder", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_centerWindow = Cvar_Get( "r_centerWindow", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_customwidth = Cvar_Get( "r_customwidth", "1600", CVAR_ARCHIVE|CVAR_LATCH );
r_customheight = Cvar_Get( "r_customheight", "1024", CVAR_ARCHIVE|CVAR_LATCH );
r_swapInterval = Cvar_Get( "r_swapInterval", "0", CVAR_ARCHIVE );
r_stereo = Cvar_Get( "r_stereo", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_mode = Cvar_Get( "r_mode", "4", CVAR_ARCHIVE|CVAR_LATCH );
r_displayRefresh = Cvar_Get( "r_displayRefresh", "0", CVAR_LATCH );
Cvar_CheckRange( r_displayRefresh, 0, 240, qtrue );
// Window render surface cvars
r_stencilbits = Cvar_Get( "r_stencilbits", "8", CVAR_ARCHIVE|CVAR_LATCH );
r_depthbits = Cvar_Get( "r_depthbits", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_colorbits = Cvar_Get( "r_colorbits", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_ignorehwgamma = Cvar_Get( "r_ignorehwgamma", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_ext_multisample = Cvar_Get( "r_ext_multisample", "0", CVAR_ARCHIVE|CVAR_LATCH );
// Create the window and set up the context
if(!GLimp_StartDriverAndSetMode( glConfig, windowDesc, r_mode->integer,
(qboolean)r_fullscreen->integer, (qboolean)r_noborder->integer ))
{
if( r_mode->integer != R_MODE_FALLBACK )
{
Com_Printf( "Setting r_mode %d failed, falling back on r_mode %d\n", r_mode->integer, R_MODE_FALLBACK );
if (!GLimp_StartDriverAndSetMode( glConfig, windowDesc, R_MODE_FALLBACK, qfalse, qfalse ))
{
// Nothing worked, give up
Com_Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
}
}
}
glConfig->deviceSupportsGamma =
(qboolean)(!r_ignorehwgamma->integer && SDL_SetWindowBrightness( screen, 1.0f ) >= 0);
Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init( screen );
// window_t is only really useful for Windows if the renderer wants to create a D3D context.
window_t window = {};
window.api = windowDesc->api;
#if defined(_WIN32)
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
if ( SDL_GetWindowWMInfo(screen, &info) )
{
switch(info.subsystem) {
case SDL_SYSWM_WINDOWS:
window.handle = info.info.win.window;
break;
default:
break;
}
}
#endif
return window;
}
/*
===============
GLimp_Init
This routine is responsible for initializing the OS specific portions
of OpenGL
===============
*/
void GLimp_Init( void )
{
ri->Printf( PRINT_DEVELOPER, "Glimp_Init( )\n" );
r_allowSoftwareGL = ri->Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_sdlDriver = ri->Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
r_allowResize = ri->Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE | CVAR_LATCH );
r_centerWindow = ri->Cvar_Get( "r_centerWindow", "0", CVAR_ARCHIVE | CVAR_LATCH );
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 != 0), (r_noborder->integer != 0)))
goto success;
// Try again, this time in a platform specific "safe mode"
ri->Sys_GLimpSafeInit( );
if(GLimp_StartDriverAndSetMode(r_mode->integer, (r_fullscreen->integer != 0), 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
ri->Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
success:
// These values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
// Only using SDL_SetWindowBrightness to determine if hardware gamma is supported
glConfig.deviceSupportsGamma = !r_ignorehwgamma->integer &&
SDL_SetWindowBrightness( SDL_window, 1.0f ) >= 0;
// get our config strings
Q_strncpyz( glConfig.vendor_string, (char *) qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, (char *) qglGetString (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 *) qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, (char *) qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
// initialize extensions
GLimp_InitExtensions( );
ri->Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
ri->IN_Init( SDL_window );
}
/*
===============
GLimp_Init
This routine is responsible for initializing the OS specific portions
of Direct3D
===============
*/
void GLimp_Init( void )
{
qboolean success = qtrue;
//glConfig.driverType = GLDRV_DEFAULT;
r_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
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" );
}
#if 0 //def WIN32 || __WIN64__
if ( !SDL_VIDEODRIVER_externallySet )
{
// It's a little bit weird having in_mouse control the
// video driver, but from ioq3's point of view they're
// virtually the same except for the mouse input anyway
if ( ri.Cvar_VariableIntegerValue( "in_mouse" ) == -1 )
{
// Use the windib SDL backend, which is closest to
// the behaviour of idq3 with in_mouse set to -1
_putenv( "SDL_VIDEODRIVER=windib" );
}
else
{
// Use the DirectX SDL backend
_putenv( "SDL_VIDEODRIVER=directx" );
}
}
#endif
// create the window and set up the context
if ( !GLimp_StartDriverAndSetMode( r_mode->integer, r_fullscreen->integer, qfalse ) )
{
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, r_fullscreen->integer, qfalse ) )
{
success = qfalse;
}
}
else
{
success = qfalse;
}
}
if ( !success )
{
ri.Error( ERR_FATAL, "GLimp_Init() - could not load Direct3D subsystem\n" );
}
// This values force the UI to disable driver selection
glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = !!( SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0 );
// get our config strings
Q_strncpyz( glConfig.vendor_string, "Microsoft", sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, "D3D", 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, "10.0", sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, "None", sizeof( glConfig.extensions_string ) );
// initialize extensions
GLimp_InitExtensions();
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
ri.IN_Init();
}
/*
===============
GLimp_Init
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_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
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_SetEnv( "SDL_VIDEO_CENTERED", r_centerWindow->integer ? "1" : "" );
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 )
{
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, qfalse, qfalse))
goto success;
}
// Nothing worked, give up
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
success:
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0;
// Mysteriously, if you use an NVidia graphics card and multiple monitors,
// SDL_SetGamma will incorrectly return false... the first time; ask
// again and you get the correct answer. This is a suspected driver bug, see
// http://bugzilla.icculus.org/show_bug.cgi?id=4316
glConfig.deviceSupportsGamma = SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0;
if ( -1 == r_ignorehwgamma->integer)
glConfig.deviceSupportsGamma = 1;
if ( 1 == r_ignorehwgamma->integer)
glConfig.deviceSupportsGamma = 0;
// get our config strings
Q_strncpyz( glConfig.vendor_string, (char *) qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, (char *) qglGetString (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 *) qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, (char *) qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
// initialize extensions
GLimp_InitExtensions( );
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
ri.IN_Init( );
}
void GLimp_Init( void )
{
ri->Cvar_Get( "r_restartOnResize", "1", CVAR_ARCHIVE );
ri->Cvar_Get( "r_resizeDelay", "1000", CVAR_ARCHIVE );
r_allowSoftwareGL = ri->Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_sdlDriver = ri->Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
r_allowResize = ri->Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE );
/* if( Cvar_VariableIntegerValue( "com_abnormalExit" ) )
{
Cvar_Set( "r_mode", va( "%d", R_MODE_FALLBACK ) );
Cvar_Set( "r_picmap", "1" );
Cvar_Set( "r_texturebits", "0" );
Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
Cvar_Set( "r_fullscreen", "0" );
Cvar_Set( "r_centerWindow", "0" );
Cvar_Set( "com_abnormalExit", "0" );
}*/
// Create the window and set up the context
if(GLimp_StartDriverAndSetMode(r_mode->integer, (qboolean)r_fullscreen->integer, (qboolean)r_noborder->integer))
goto success;
// Try again, this time in a platform specific "safe mode"
/* 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 )
{
Com_Printf( "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
Com_Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
success:
// This values force the UI to disable driver selection
// glConfig.driverType = GLDRV_ICD;
// glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = (qboolean)(!r_ignorehwgamma->integer &&
SDL_SetWindowBrightness( screen, 1.0f ) >= 0);
// get our config strings
glConfig.vendor_string = (const char *) qglGetString (GL_VENDOR);
glConfig.renderer_string = (const char *) qglGetString (GL_RENDERER);
glConfig.version_string = (const char *) qglGetString (GL_VERSION);
glConfig.extensions_string = (const char *) qglGetString (GL_EXTENSIONS);
// OpenGL driver constants
qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.maxTextureSize );
// stubbed or broken drivers may have reported 0...
if ( glConfig.maxTextureSize <= 0 )
{
glConfig.maxTextureSize = 0;
}
// initialize extensions
GLimp_InitExtensions( );
ri->Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
ri->IN_Init( screen );
}
/*
===============
GLimp_Init
This routine is responsible for initializing the OS specific portions
of OpenGL
===============
*/
void GLimp_Init(void)
{
qboolean success = qtrue;
glConfig.driverType = GLDRV_DEFAULT;
r_sdlDriver = ri.Cvar_Get("r_sdlDriver", "", CVAR_ROM);
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");
}
//Sys_SetEnv("SDL_VIDEO_CENTERED", r_centerWindow->integer ? "1" : "");
//Sys_GLimpInit();
#if 0 //defined(WIN32)
if(!SDL_VIDEODRIVER_externallySet)
{
// It's a little bit weird having in_mouse control the
// video driver, but from ioq3's point of view they're
// virtually the same except for the mouse input anyway
if(ri.Cvar_VariableIntegerValue("in_mouse") == -1)
{
// Use the windib SDL backend, which is closest to
// the behaviour of idq3 with in_mouse set to -1
_putenv("SDL_VIDEODRIVER=windib");
}
else
{
// Use the DirectX SDL backend
_putenv("SDL_VIDEODRIVER=directx");
}
}
#endif
// Create the window and set up the context
if(GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, qfalse))
goto success;
// Try again, this time in a platform specific "safe mode"
//Sys_GLimpSafeInit();
#if 0 //defined(WIN32)
if(!SDL_VIDEODRIVER_externallySet)
{
// Here, we want to let SDL decide what do to unless
// explicitly requested otherwise
_putenv("SDL_VIDEODRIVER=");
}
#endif
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)
{
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, qfalse, qfalse))
goto success;
}
// Nothing worked, give up
ri.Error(ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n");
success:
// This values force the UI to disable driver selection
glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = SDL_SetGamma(1.0f, 1.0f, 1.0f) >= 0;
// Mysteriously, if you use an NVidia graphics card and multiple monitors,
// SDL_SetGamma will incorrectly return false... the first time; ask
// again and you get the correct answer. This is a suspected driver bug, see
// http://bugzilla.icculus.org/show_bug.cgi?id=4316
glConfig.deviceSupportsGamma = SDL_SetGamma(1.0f, 1.0f, 1.0f) >= 0;
// 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)
{
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, "rv770"))
{
glConfig.hardwareType = GLHW_ATI_DX10;
}
else if(Q_stristr(glConfig.renderer_string, "radeon hd"))
{
glConfig.hardwareType = GLHW_ATI_DX10;
}
else if(Q_stristr(glConfig.renderer_string, "eah4850") || Q_stristr(glConfig.renderer_string, "eah4870"))
{
glConfig.hardwareType = GLHW_ATI_DX10;
}
else if(Q_stristr(glConfig.renderer_string, "radeon"))
{
glConfig.hardwareType = GLHW_ATI;
}
// initialize extensions
GLimp_InitExtensions();
ri.Cvar_Get("r_availableModes", "", CVAR_ROM);
// This depends on SDL_INIT_VIDEO, hence having it here
ri.IN_Init();
}
void GLimp_Init( void )
{
ri.Cvar_Get( "r_restartOnResize", "1", CVAR_ARCHIVE );
ri.Cvar_Get( "r_resizeDelay", "1000", CVAR_ARCHIVE );
r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
r_allowResize = ri.Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE );
r_centerWindow = ri.Cvar_Get( "r_centerWindow", "0", CVAR_ARCHIVE );
r_noborder = ri.Cvar_Get( "r_noborder", "0", CVAR_ARCHIVE );
/* if( Cvar_VariableIntegerValue( "com_abnormalExit" ) )
{
Cvar_Set( "r_mode", va( "%d", R_MODE_FALLBACK ) );
Cvar_Set( "r_picmap", "1" );
Cvar_Set( "r_texturebits", "0" );
Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
Cvar_Set( "r_fullscreen", "0" );
Cvar_Set( "r_centerWindow", "0" );
Cvar_Set( "com_abnormalExit", "0" );
}*/
Sys_SetEnv( "SDL_VIDEO_CENTERED", r_centerWindow->integer ? "1" : "" );
// Create the window and set up the context
if(GLimp_StartDriverAndSetMode(r_mode->integer, (qboolean)r_fullscreen->integer, (qboolean)r_noborder->integer))
goto success;
// Try again, this time in a platform specific "safe mode"
/* 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 )
{
Com_Printf( "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
Com_Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
success:
// This values force the UI to disable driver selection
// glConfig.driverType = GLDRV_ICD;
// glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = (qboolean)(SDL_SetGamma( screen, 1.0f, 1.0f, 1.0f ) >= 0);
// Mysteriously, if you use an NVidia graphics card and multiple monitors,
// SDL_SetGamma will incorrectly return false... the first time; ask
// again and you get the correct answer. This is a suspected driver bug, see
// http://bugzilla.icculus.org/show_bug.cgi?id=4316
glConfig.deviceSupportsGamma = (qboolean)(SDL_SetGamma( screen, 1.0f, 1.0f, 1.0f ) >= 0);
if ( -1 == r_ignorehwgamma->integer)
glConfig.deviceSupportsGamma = qtrue;
if ( 1 == r_ignorehwgamma->integer)
glConfig.deviceSupportsGamma = qfalse;
// get our config strings
/* Q_strncpyz( glConfig.vendor_string, (char *) qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, (char *) qglGetString (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 *) qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, (char *) qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );*/
glConfig.vendor_string = (const char *) qglGetString (GL_VENDOR);
glConfig.renderer_string = (const char *) qglGetString (GL_RENDERER);
glConfig.version_string = (const char *) qglGetString (GL_VERSION);
glConfig.extensions_string = (const char *) qglGetString (GL_EXTENSIONS);
// OpenGL driver constants
qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.maxTextureSize );
// stubbed or broken drivers may have reported 0...
if ( glConfig.maxTextureSize <= 0 )
{
glConfig.maxTextureSize = 0;
}
// initialize extensions
GLimp_InitExtensions( );
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
ri.IN_Init( screen );
}
/*
===============
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;
}
/*
===============
GLimp_Init
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_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
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_width", va( "%d", R_FAILSAFE_WIDTH ) );
ri.Cvar_Set( "r_height", va( "%d", R_FAILSAFE_HEIGHT ) );
ri.Cvar_Set( "r_fullscreen", "0" );
ri.Cvar_Set( "r_centerWindow", "0" );
ri.Cvar_Set( "com_abnormalExit", "0" );
}
ri.Sys_SetEnv( "SDL_VIDEO_CENTERED", r_centerWindow->integer ? "1" : "" );
ri.Sys_GLimpInit( );
// Create the window and set up the context
if( GLimp_StartDriverAndSetMode( qfalse, r_fullscreen->integer, r_noborder->integer ) )
goto success;
// Try again, this time in a platform specific "safe mode"
ri.Sys_GLimpSafeInit( );
if( GLimp_StartDriverAndSetMode( qfalse, r_fullscreen->integer, qfalse ) )
goto success;
// Finally, try the default screen resolution
if( GLimp_StartDriverAndSetMode( qtrue, r_fullscreen->integer, qfalse ) )
goto success;
// Nothing worked, give up
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
success:
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
// Remove call to SDL_SetGamma for Mac OS X
// It causes a crash, but is apparently fixed in SDL2
// somewhere upstream in ioq3. For more details, see
// http://www.ioquake.org/forums/viewtopic.php?f=12&t=1928
#ifndef MACOS_X
glConfig.deviceSupportsGamma = SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0;
#endif
// Mysteriously, if you use an NVidia graphics card and multiple monitors,
// SDL_SetGamma will incorrectly return false... the first time; ask
// again and you get the correct answer. This is a suspected driver bug, see
// http://bugzilla.icculus.org/show_bug.cgi?id=4316
#ifndef MACOS_X
glConfig.deviceSupportsGamma = SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0;
#endif
if ( -1 == r_ignorehwgamma->integer)
glConfig.deviceSupportsGamma = 1;
if ( 1 == r_ignorehwgamma->integer)
glConfig.deviceSupportsGamma = 0;
// get our config strings
Q_strncpyz( glConfig.vendor_string, (char *) qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, (char *) qglGetString (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 *) qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, (char *) qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
// initialize extensions
GLimp_InitExtensions( );
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
ri.IN_Init( );
}
/**
* @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();
}
