/*
** GLimp_Shutdown
**
** This routine does all OS specific shutdown procedures for the OpenGL
** subsystem. Under OpenGL this means NULLing out the current DC and
** HGLRC, deleting the rendering context, and releasing the DC acquired
** for the window. The state structure is also nulled out.
**
*/
void GLimp_Shutdown( void )
{
if (!ctx || !dpy)
return;
IN_DeactivateMouse();
XAutoRepeatOn(dpy);
if (dpy) {
if (ctx)
qglXDestroyContext(dpy, ctx);
if (win)
XDestroyWindow(dpy, win);
if (vidmode_active)
XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[0]);
XCloseDisplay(dpy);
}
vidmode_active = qfalse;
dpy = NULL;
win = 0;
ctx = NULL;
memset( &glConfig, 0, sizeof( glConfig ) );
memset( &glState, 0, sizeof( glState ) );
QGL_Shutdown();
}
int CRadiantApp::ExitInstance()
{
// TODO: Add your specialized code here and/or call the base class
//::FreeLibrary(g_hOpenGL32);
QGL_Shutdown();
return CWinApp::ExitInstance();
}
/*
** GLimp_Shutdown
**
** This routine does all OS specific shutdown procedures for the OpenGL
** subsystem. Under OpenGL this means NULLing out the current DC and
** HGLRC, deleting the rendering context, and releasing the DC acquired
** for the window. The state structure is also nulled out.
**
*/
void GLimp_Shutdown( void )
{
if (!ctx || !dpy)
return;
IN_DeactivateMouse();
// bk001206 - replaced with H2/Fakk2 solution
// XAutoRepeatOn(dpy);
// autorepeaton = qfalse; // bk001130 - from cvs1.17 (mkv)
if (dpy) {
if (ctx)
qglXDestroyContext(dpy, ctx);
if (win)
XDestroyWindow(dpy, win);
if (vidmode_active)
XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[0]);
XCloseDisplay(dpy);
}
vidmode_active = qfalse;
dpy = NULL;
win = 0;
ctx = NULL;
memset( &glConfig, 0, sizeof( glConfig ) );
memset( &glState, 0, sizeof( glState ) );
QGL_Shutdown();
}
/*
** GLimp_Shutdown
**
** This routine does all OS specific shutdown procedures for the OpenGL
** subsystem. Under OpenGL this means NULLing out the current DC and
** HGLRC, deleting the rendering context, and releasing the DC acquired
** for the window. The state structure is also nulled out.
**
*/
void GLimp_Shutdown( void ) {
#ifdef HAVE_GLES
if (!g_EGLWindowSurface || !dpy)
#else
if ( !ctx || !dpy )
#endif
{
return;
}
IN_DeactivateMouse();
// bk001206 - replaced with H2/Fakk2 solution
// XAutoRepeatOn(dpy);
// autorepeaton = qfalse; // bk001130 - from cvs1.17 (mkv)
if ( dpy ) {
#ifdef HAVE_GLES
eglMakeCurrent( g_EGLDisplay, NULL, NULL, EGL_NO_CONTEXT );
if (g_EGLContext)
eglDestroyContext(g_EGLDisplay, g_EGLContext);
if (g_EGLWindowSurface)
eglDestroySurface(g_EGLDisplay, g_EGLWindowSurface);
eglTerminate(g_EGLDisplay);
#else
if ( ctx ) {
qglXDestroyContext( dpy, ctx );
}
#endif
if ( win ) {
XDestroyWindow( dpy, win );
}
if ( vidmode_active ) {
XF86VidModeSwitchToMode( dpy, scrnum, vidmodes[0] );
}
if ( glConfig.deviceSupportsGamma ) {
XF86VidModeSetGamma( dpy, scrnum, &vidmode_InitialGamma );
}
// NOTE TTimo opening/closing the display should be necessary only once per run
// but it seems QGL_Shutdown gets called in a lot of occasion
// in some cases, this XCloseDisplay is known to raise some X errors
// ( show_bug.cgi?id=33 )
XCloseDisplay( dpy );
}
vidmode_active = qfalse;
dpy = NULL;
win = 0;
#ifdef HAVE_GLES
g_EGLWindowSurface = NULL;
g_EGLContext = NULL;
g_EGLDisplay = NULL;
#else
ctx = NULL;
#endif
memset( &glConfig, 0, sizeof( glConfig ) );
memset( &glState, 0, sizeof( glState ) );
QGL_Shutdown();
}
/*
** GLimp_Shutdown
**
** This routine does all OS specific shutdown procedures for the OpenGL
** subsystem. Under OpenGL this means NULLing out the current DC and
** HGLRC, deleting the rendering context, and releasing the DC acquired
** for the window. The state structure is also nulled out.
**
*/
void GLimp_Shutdown( void )
{
IN_Shutdown();
screen = NULL;
memset( &glConfig, 0, sizeof( glConfig ) );
memset( &glState, 0, sizeof( glState ) );
QGL_Shutdown();
}
/*
===================
GLimp_Shutdown
This routine does all OS specific shutdown procedures for the OpenGL
subsystem.
===================
*/
void GLimp_Shutdown( void ) {
const char *success[] = { "failed", "success" };
int retVal;
common->Printf( "Shutting down OpenGL subsystem\n" );
// set current context to NULL
if ( qwglMakeCurrent ) {
retVal = qwglMakeCurrent( NULL, NULL ) != 0;
common->Printf( "...wglMakeCurrent( NULL, NULL ): %s\n", success[retVal] );
}
// delete HGLRC
if ( win32.hGLRC ) {
retVal = qwglDeleteContext( win32.hGLRC ) != 0;
common->Printf( "...deleting GL context: %s\n", success[retVal] );
win32.hGLRC = NULL;
}
// release DC
if ( win32.hDC ) {
retVal = ReleaseDC( win32.hWnd, win32.hDC ) != 0;
common->Printf( "...releasing DC: %s\n", success[retVal] );
win32.hDC = NULL;
}
// destroy window
if ( win32.hWnd ) {
common->Printf( "...destroying window\n" );
ShowWindow( win32.hWnd, SW_HIDE );
DestroyWindow( win32.hWnd );
win32.hWnd = NULL;
}
// reset display settings
if ( win32.cdsFullscreen ) {
common->Printf( "...resetting display\n" );
ChangeDisplaySettings( 0, 0 );
win32.cdsFullscreen = false;
}
// close the thread so the handle doesn't dangle
if ( win32.renderThreadHandle ) {
common->Printf( "...closing smp thread\n" );
CloseHandle( win32.renderThreadHandle );
win32.renderThreadHandle = NULL;
}
// restore gamma
GLimp_RestoreGamma();
// shutdown QGL subsystem
QGL_Shutdown();
}
static qbool GLW_LoadOpenGL()
{
// only real GL implementations are acceptable
const char* OPENGL_DRIVER_NAME = "opengl32";
// load the driver and bind our function pointers to it
if ( QGL_Init( OPENGL_DRIVER_NAME ) ) {
// create the window and set up the context
if ( GLW_SetMode( (qbool)r_fullscreen->integer ) ) {
return qtrue;
}
}
QGL_Shutdown();
return qfalse;
}
/*
** GLimp_Shutdown
**
** This routine does all OS specific shutdown procedures for the OpenGL
** subsystem.
*/
void GLimp_Shutdown( void )
{
// const char *strings[] = { "soft", "hard" };
const char *success[] = { "failed", "success" };
int retVal;
VID_Printf( PRINT_ALL, "Shutting down OpenGL subsystem\n" );
// shutdown QGL subsystem
QGL_Shutdown();
memset( &glConfig, 0, sizeof( glConfig ) );
memset( &glState, 0, sizeof( glState ) );
}
/*
** GLW_LoadOpenGL
**
** GLimp_win.c internal function that that attempts to load and use
** a specific OpenGL DLL.
*/
static qboolean GLW_LoadOpenGL()
{
char buffer[1024];
qboolean fullscreen;
#ifdef HAVE_GLES
strcpy( buffer, "libGLES_CM.so" );
#else
strcpy( buffer, OPENGL_DRIVER_NAME );
#endif
VID_Printf( PRINT_ALL, "...loading %s: ", buffer );
// load the QGL layer
if ( QGL_Init( buffer ) )
{
#ifdef HAVE_GLES
fullscreen = qtrue;
#else
fullscreen = r_fullscreen->integer;
#endif
// create the window and set up the context
if ( !GLW_StartDriverAndSetMode( buffer, r_mode->integer, fullscreen ) )
{
if (r_mode->integer != 3) {
if ( !GLW_StartDriverAndSetMode( buffer, 3, fullscreen ) ) {
goto fail;
}
} else
goto fail;
}
return qtrue;
}
else
{
VID_Printf( PRINT_ALL, "failed\n" );
}
fail:
QGL_Shutdown();
return qfalse;
}
/*
** GLW_LoadOpenGL
**
** GLimp_win.c internal function that that attempts to load and use
** a specific OpenGL DLL.
*/
static qboolean GLW_LoadOpenGL()
{
char name[1024];
qboolean fullscreen;
strcpy( name, OPENGL_DRIVER_NAME );
ri.Printf( PRINT_ALL, "...loading %s: ", name );
// disable the 3Dfx splash screen and set gamma
// we do this all the time, but it shouldn't hurt anything
// on non-3Dfx stuff
putenv("FX_GLIDE_NO_SPLASH=0");
// Mesa VooDoo hacks
putenv("MESA_GLX_FX=fullscreen\n");
// load the QGL layer
if ( QGL_Init( name ) )
{
fullscreen = (r_fullscreen->integer) ? qtrue : qfalse;
// create the window and set up the context
if ( !GLW_StartDriverAndSetMode( name, r_mode->integer, fullscreen ) )
{
if (r_mode->integer != 3) {
if ( !GLW_StartDriverAndSetMode( name, 3, fullscreen ) ) {
goto fail;
}
} else
goto fail;
}
return qtrue;
}
else
{
ri.Printf( PRINT_ALL, "failed\n" );
}
fail:
QGL_Shutdown();
return qfalse;
}
/*
** GLimp_Shutdown
**
** This routine does all OS specific shutdown procedures for the OpenGL
** subsystem.
*/
void GLimp_Shutdown( void )
{
// FIXME: Brian, we need better fallbacks from partially initialized failures
VID_Printf( PRINT_ALL, "Shutting down OpenGL subsystem\n" );
// Set the gamma back to normal
// GLimp_SetGamma(1.f);
// kill input system (tied to window)
IN_Shutdown();
// shutdown QGL subsystem
GLW_Shutdown();
QGL_Shutdown();
memset( &glConfig, 0, sizeof( glConfig ) );
memset( &glState, 0, sizeof( glState ) );
}
/*
** GLW_LoadOpenGL
**
** GLimp_win.c internal function that that attempts to load and use
** a specific OpenGL DLL.
*/
static qboolean GLW_LoadOpenGL( const char *name ) {
qboolean fullscreen;
ri.Printf( PRINT_ALL, "...loading %s: ", name );
#ifndef HAVE_GLES
// disable the 3Dfx splash screen and set gamma
// we do this all the time, but it shouldn't hurt anything
// on non-3Dfx stuff
putenv( "FX_GLIDE_NO_SPLASH=0" );
// Mesa VooDoo hacks
putenv( "MESA_GLX_FX=fullscreen\n" );
#endif
// load the QGL layer
if ( QGL_Init( name ) ) {
#ifdef PANDORA
fullscreen = 1;
#else
fullscreen = r_fullscreen->integer;
#endif
// create the window and set up the context
if ( !GLW_StartDriverAndSetMode( name, r_mode->integer, fullscreen ) ) {
if ( r_mode->integer != 3 ) {
if ( !GLW_StartDriverAndSetMode( name, 3, fullscreen ) ) {
goto fail;
}
} else {
goto fail;
}
}
return qtrue;
} else
{
ri.Printf( PRINT_ALL, "failed\n" );
}
fail:
QGL_Shutdown();
return qfalse;
}
/*
** GLW_LoadOpenGL
**
** GLimp_win.c internal function that attempts to load and use
** a specific OpenGL DLL.
*/
static qboolean GLW_LoadOpenGL()
{
char buffer[1024];
strlwr( strcpy( buffer, OPENGL_DRIVER_NAME ) );
//
// load the driver and bind our function pointers to it
//
if ( QGL_Init( buffer ) )
{
GLW_CreateWindow(640, 480, 24, 1);
return qtrue;
}
QGL_Shutdown();
return qfalse;
}
/*
===================
GLimp_Shutdown
===================
*/
void GLimp_Shutdown()
{
common->Printf( "Shutting down OpenGL subsystem\n" );
#if SDL_VERSION_ATLEAST(2, 0, 0)
if( context )
{
SDL_GL_DeleteContext( context );
context = NULL;
}
if( window )
{
SDL_DestroyWindow( window );
window = NULL;
}
#endif
QGL_Shutdown();
}
/*
** QGL_Init
**
** This is responsible for binding our qgl function pointers to
** the appropriate GL stuff. In Windows this means doing a
** LoadLibrary and a bunch of calls to GetProcAddress. On other
** operating systems we need to do the right thing, whatever that
** might be.
**
*/
qboolean QGL_Init( const char *dllname )
{
if ( glw_state.OpenGLLib )
QGL_Shutdown();
if ( ( glw_state.OpenGLLib = dlopen( dllname, RTLD_LAZY ) ) == 0 )
{
char fn[MAX_OSPATH];
char *path;
// try basedir next
path = Cvar_Get ("basedir", ".", CVAR_NOSET)->string;
Com_sprintf(fn, MAX_OSPATH, "%s/%s", path, dllname );
if ( ( glw_state.OpenGLLib = dlopen( fn, RTLD_LAZY ) ) == 0 ) {
Com_Printf ( "%s\n", dlerror() );
return false;
}
Com_Printf ("Using %s for OpenGL...", fn);
} else {
Com_Printf ("Using %s for OpenGL...", dllname);
}
#define QGL_FUNC(type,name,params) (q##name) = ( void * )dlsym( glw_state.OpenGLLib, #name ); \
if( !(q##name) ) { Com_Printf( "QGL_Init: Failed to get address for %s\n", #name ); return false; }
#define QGL_EXT(type,name,params) (q##name) = NULL;
#define QGL_GLX(type,name,params) (q##name) = ( void * )dlsym( glw_state.OpenGLLib, #name ); \
if( !(q##name) ) { Com_Printf( "QGL_Init: Failed to get address for %s\n", #name ); return false; }
#define QGL_GLX_EXT(type,name,params) (q##name) = NULL;
#include "../ref_gl/qgl.h"
#undef QGL_GLX_EXT
#undef QGL_GLX
#undef QGL_EXT
#undef QGL_FUNC
return true;
}
/*
** GLimp_Shutdown
**
** This routine does all OS specific shutdown procedures for the OpenGL
** subsystem. Under OpenGL this means NULLing out the current DC and
** HGLRC, deleting the rendering context, and releasing the DC acquired
** for the window. The state structure is also nulled out.
**
*/
void GLimp_Shutdown( void )
{
if (!ctx || !dpy)
return;
IN_DeactivateMouse();
// bk001206 - replaced with H2/Fakk2 solution
// XAutoRepeatOn(dpy);
// autorepeaton = qfalse; // bk001130 - from cvs1.17 (mkv)
if (dpy)
{
if (ctx)
qglXDestroyContext(dpy, ctx);
if (win)
XDestroyWindow(dpy, win);
#ifdef HAVE_XF86DGA
if (vidmode_active)
XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[0]);
if (glConfig.deviceSupportsGamma)
{
XF86VidModeSetGamma(dpy, scrnum, &vidmode_InitialGamma);
}
#endif /* HAVE_XF86DGA */
// NOTE TTimo opening/closing the display should be necessary only once per run
// but it seems QGL_Shutdown gets called in a lot of occasion
// in some cases, this XCloseDisplay is known to raise some X errors
// ( https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=33 )
XCloseDisplay(dpy);
}
vidmode_active = qfalse;
dpy = NULL;
win = 0;
ctx = NULL;
memset( &glConfig, 0, sizeof( glConfig ) );
memset( &glState, 0, sizeof( glState ) );
QGL_Shutdown();
}
/*
** GLW_LoadOpenGL
**
** GLimp_win.c internal function that attempts to load and use
** a specific OpenGL DLL.
*/
static qboolean GLW_LoadOpenGL( )
{
char buffer[1024];
qboolean cdsFullscreen;
Q_strlwr( strcpy( buffer, OPENGL_DRIVER_NAME ) );
//
// load the driver and bind our function pointers to it
//
if ( QGL_Init( buffer ) )
{
cdsFullscreen = (qboolean)r_fullscreen->integer;
// create the window and set up the context
if ( !GLW_StartDriverAndSetMode( r_mode->integer, r_colorbits->integer, cdsFullscreen ) )
{
// if we're on a 24/32-bit desktop and we're going fullscreen on an ICD,
// try it again but with a 16-bit desktop
if ( r_colorbits->integer != 16 ||
cdsFullscreen != qtrue ||
r_mode->integer != 3 )
{
if ( !GLW_StartDriverAndSetMode( 3, 16, qtrue ) )
{
goto fail;
}
}
}
return qtrue;
}
fail:
QGL_Shutdown();
return qfalse;
}
~QglAPI ()
{
QGL_Shutdown(m_qgl);
}
/*
** GLimp_Shutdown
**
** This routine does all OS specific shutdown procedures for the OpenGL
** subsystem.
*/
void GLimp_Shutdown( void ) {
// const char *strings[] = { "soft", "hard" };
const char *success[] = { "failed", "success" };
int retVal;
// FIXME: Brian, we need better fallbacks from partially initialized failures
if ( !qwglMakeCurrent ) {
return;
}
ri.Printf( PRINT_ALL, "Shutting down OpenGL subsystem\n" );
// restore gamma. We do this first because 3Dfx's extension needs a valid OGL subsystem
WG_RestoreGamma();
// delete display lists
GLW_DeleteDefaultLists();
// set current context to NULL
if ( qwglMakeCurrent ) {
retVal = qwglMakeCurrent( NULL, NULL ) != 0;
ri.Printf( PRINT_ALL, "...wglMakeCurrent( NULL, NULL ): %s\n", success[retVal] );
}
// delete HGLRC
if ( glw_state.hGLRC ) {
retVal = qwglDeleteContext( glw_state.hGLRC ) != 0;
ri.Printf( PRINT_ALL, "...deleting GL context: %s\n", success[retVal] );
glw_state.hGLRC = NULL;
}
// release DC
if ( glw_state.hDC ) {
retVal = ReleaseDC( g_wv.hWnd, glw_state.hDC ) != 0;
ri.Printf( PRINT_ALL, "...releasing DC: %s\n", success[retVal] );
glw_state.hDC = NULL;
}
// destroy window
if ( g_wv.hWnd ) {
ri.Printf( PRINT_ALL, "...destroying window\n" );
ShowWindow( g_wv.hWnd, SW_HIDE );
DestroyWindow( g_wv.hWnd );
g_wv.hWnd = NULL;
glw_state.pixelFormatSet = qfalse;
}
// close the r_logFile
if ( glw_state.log_fp ) {
fclose( glw_state.log_fp );
glw_state.log_fp = 0;
}
// reset display settings
if ( glw_state.cdsFullscreen ) {
ri.Printf( PRINT_ALL, "...resetting display\n" );
ChangeDisplaySettings( 0, 0 );
glw_state.cdsFullscreen = qfalse;
}
// shutdown QGL subsystem
QGL_Shutdown();
memset( &glConfig, 0, sizeof( glConfig ) );
memset( &glState, 0, sizeof( glState ) );
}
void GLimp_Shutdown()
{
// FIXME: Brian, we need better fallbacks from partially initialized failures
if ( !qwglMakeCurrent ) {
return;
}
ri.Printf( PRINT_DEVELOPER, "Shutting down OpenGL subsystem\n" );
GLW_RestoreGamma();
const char* success[] = { "failed", "success" };
int retVal;
// set current context to NULL
if ( qwglMakeCurrent )
{
retVal = qwglMakeCurrent( NULL, NULL ) != 0;
ri.Printf( PRINT_DEVELOPER, "...wglMakeCurrent( NULL, NULL ): %s\n", success[retVal] );
}
// delete HGLRC
if ( glw_state.hGLRC )
{
retVal = qwglDeleteContext( glw_state.hGLRC ) != 0;
ri.Printf( PRINT_DEVELOPER, "...deleting GL context: %s\n", success[retVal] );
glw_state.hGLRC = NULL;
}
// release DC
if ( glw_state.hDC )
{
retVal = ReleaseDC( g_wv.hWnd, glw_state.hDC ) != 0;
ri.Printf( PRINT_DEVELOPER, "...releasing DC: %s\n", success[retVal] );
glw_state.hDC = NULL;
}
// destroy window
if ( g_wv.hWnd )
{
ri.Printf( PRINT_DEVELOPER, "...destroying window\n" );
ShowWindow( g_wv.hWnd, SW_HIDE );
DestroyWindow( g_wv.hWnd );
g_wv.hWnd = NULL;
glw_state.pixelFormatSet = qfalse;
}
// reset display settings
if ( glw_state.cdsFullscreen )
{
ri.Printf( PRINT_DEVELOPER, "...resetting display\n" );
ChangeDisplaySettings( 0, 0 );
glw_state.cdsFullscreen = qfalse;
}
// shutdown QGL subsystem
QGL_Shutdown();
memset( &glConfig, 0, sizeof( glConfig ) );
memset( &glState, 0, sizeof( glState ) );
}
/*
** GLW_LoadOpenGL
**
** GLimp_win.c internal function that attempts to load and use
** a specific OpenGL DLL.
*/
static qboolean GLW_LoadOpenGL( const char *drivername )
{
char buffer[1024];
qboolean cdsFullscreen;
Q_strncpyz( buffer, drivername, sizeof(buffer) );
Q_strlwr(buffer);
//
// determine if we're on a standalone driver
//
if ( strstr( buffer, "opengl32" ) != 0 || r_maskMinidriver->integer )
{
glConfig.driverType = GLDRV_ICD;
}
else
{
glConfig.driverType = GLDRV_STANDALONE;
ri.Printf( PRINT_ALL, "...assuming '%s' is a standalone driver\n", drivername );
if ( strstr( buffer, _3DFX_DRIVER_NAME ) )
{
glConfig.driverType = GLDRV_VOODOO;
}
}
// disable the 3Dfx splash screen
_putenv("FX_GLIDE_NO_SPLASH=0");
//
// load the driver and bind our function pointers to it
//
if ( QGL_Init( buffer ) )
{
cdsFullscreen = r_fullscreen->integer;
// create the window and set up the context
if ( !GLW_StartDriverAndSetMode( drivername, r_mode->integer, r_colorbits->integer, cdsFullscreen ) )
{
// if we're on a 24/32-bit desktop and we're going fullscreen on an ICD,
// try it again but with a 16-bit desktop
if ( glConfig.driverType == GLDRV_ICD )
{
if ( r_colorbits->integer != 16 ||
cdsFullscreen != qtrue ||
r_mode->integer != 3 )
{
if ( !GLW_StartDriverAndSetMode( drivername, 3, 16, qtrue ) )
{
goto fail;
}
}
}
else
{
goto fail;
}
}
if ( glConfig.driverType == GLDRV_VOODOO )
{
glConfig.isFullscreen = qtrue;
}
return qtrue;
}
fail:
QGL_Shutdown();
return qfalse;
}