static void GLW_AttemptFSAA()
{
static const float ar[] = { 0, 0 };
// ignore r_xyzbits vars - FSAA requires 32-bit color, and anyone using it is implicitly on decent HW
static int anAttributes[] = {
WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
WGL_COLOR_BITS_ARB, 32,
WGL_ALPHA_BITS_ARB, 0,
WGL_DEPTH_BITS_ARB, 24,
WGL_STENCIL_BITS_ARB, 8,
WGL_SAMPLE_BUFFERS_ARB, GL_TRUE,
WGL_SAMPLES_ARB, 4,
0, 0
};
qwglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)qwglGetProcAddress( "wglChoosePixelFormatARB" );
if (!r_ext_multisample->integer || !qwglChoosePixelFormatARB) {
glDisable(GL_MULTISAMPLE_ARB);
return;
}
int iPFD;
UINT cPFD;
anAttributes[19] = r_ext_multisample->integer; // !!! UGH
if (!qwglChoosePixelFormatARB(glw_state.hDC, anAttributes, ar, 1, &iPFD, &cPFD) || !cPFD)
return;
// now bounce the ENTIRE f*****g subsystem thanks to WGL stupidity
// we can't use GLimp_Shutdown() for this, because that does CDS poking that we don't want
assert( glw_state.hGLRC && glw_state.hDC && g_wv.hWnd );
qwglMakeCurrent( glw_state.hDC, NULL );
if ( glw_state.hGLRC ) {
qwglDeleteContext( glw_state.hGLRC );
glw_state.hGLRC = NULL;
}
if ( glw_state.hDC ) {
ReleaseDC( g_wv.hWnd, glw_state.hDC );
glw_state.hDC = NULL;
}
if ( g_wv.hWnd ) {
DestroyWindow( g_wv.hWnd );
g_wv.hWnd = NULL;
}
ri.Printf( PRINT_ALL, "...enabling FSAA\n" );
glw_state.nPendingPF = iPFD;
glw_state.pixelFormatSet = qfalse;
GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, glConfig.colorBits );
glw_state.nPendingPF = 0;
glEnable(GL_MULTISAMPLE_ARB);
}
/*
** 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_Init
This is the platform specific OpenGL initialization function. It
is responsible for loading OpenGL, initializing it,
creating a window of the appropriate size, doing
fullscreen manipulations, etc. Its overall responsibility is
to make sure that a functional OpenGL subsystem is operating
when it returns to the ref.
If there is any failure, the renderer will revert back to safe
parameters and try again.
===================
*/
bool GLimp_Init( glimpParms_t parms )
{
const char* driverName;
HDC hDC;
cmdSystem->AddCommand( "testSwapBuffers", GLimp_TestSwapBuffers, CMD_FL_SYSTEM, "Times swapbuffer options" );
common->Printf( "Initializing OpenGL subsystem with multisamples:%i stereo:%i fullscreen:%i\n",
parms.multiSamples, parms.stereo, parms.fullScreen );
// check our desktop attributes
hDC = GetDC( GetDesktopWindow() );
win32.desktopBitsPixel = GetDeviceCaps( hDC, BITSPIXEL );
win32.desktopWidth = GetDeviceCaps( hDC, HORZRES );
win32.desktopHeight = GetDeviceCaps( hDC, VERTRES );
ReleaseDC( GetDesktopWindow(), hDC );
// we can't run in a window unless it is 32 bpp
if( win32.desktopBitsPixel < 32 && parms.fullScreen <= 0 )
{
common->Printf( "^3Windowed mode requires 32 bit desktop depth^0\n" );
return false;
}
// save the hardware gamma so it can be
// restored on exit
GLimp_SaveGamma();
// create our window classes if we haven't already
GLW_CreateWindowClasses();
// this will load the dll and set all our qgl* function pointers,
// but doesn't create a window
// r_glDriver is only intended for using instrumented OpenGL
// dlls. Normal users should never have to use it, and it is
// not archived.
driverName = r_glDriver.GetString()[0] ? r_glDriver.GetString() : "opengl32";
if( !QGL_Init( driverName ) )
{
common->Printf( "^3GLimp_Init() could not load r_glDriver \"%s\"^0\n", driverName );
return false;
}
// getting the wgl extensions involves creating a fake window to get a context,
// which is pretty disgusting, and seems to mess with the AGP VAR allocation
GLW_GetWGLExtensionsWithFakeWindow();
// Optionally ChangeDisplaySettings to get a different fullscreen resolution.
if( !GLW_ChangeDislaySettingsIfNeeded( parms ) )
{
GLimp_Shutdown();
return false;
}
// try to create a window with the correct pixel format
// and init the renderer context
if( !GLW_CreateWindow( parms ) )
{
GLimp_Shutdown();
return false;
}
glConfig.isFullscreen = parms.fullScreen;
glConfig.isStereoPixelFormat = parms.stereo;
glConfig.nativeScreenWidth = parms.width;
glConfig.nativeScreenHeight = parms.height;
glConfig.multisamples = parms.multiSamples;
glConfig.pixelAspect = 1.0f; // FIXME: some monitor modes may be distorted
// should side-by-side stereo modes be consider aspect 0.5?
// get the screen size, which may not be reliable...
// If we use the windowDC, I get my 30" monitor, even though the window is
// on a 27" monitor, so get a dedicated DC for the full screen device name.
const idStr deviceName = GetDeviceName( Max( 0, parms.fullScreen - 1 ) );
HDC deviceDC = CreateDC( deviceName.c_str(), deviceName.c_str(), NULL, NULL );
const int mmWide = GetDeviceCaps( win32.hDC, HORZSIZE );
DeleteDC( deviceDC );
if( mmWide == 0 )
{
glConfig.physicalScreenWidthInCentimeters = 100.0f;
}
else
{
glConfig.physicalScreenWidthInCentimeters = 0.1f * mmWide;
}
// wglSwapinterval, etc
GLW_CheckWGLExtensions( win32.hDC );
// check logging
GLimp_EnableLogging( ( r_logFile.GetInteger() != 0 ) );
return true;
}
static qbool GLW_SetMode( qbool cdsFullscreen )
{
HDC hDC = GetDC( GetDesktopWindow() );
glw_state.desktopBPP = GetDeviceCaps( hDC, BITSPIXEL );
glw_state.desktopWidth = GetDeviceCaps( hDC, HORZRES );
glw_state.desktopHeight = GetDeviceCaps( hDC, VERTRES );
ReleaseDC( GetDesktopWindow(), hDC );
glInfo.isFullscreen = cdsFullscreen;
if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect ) ) {
if (!glInfo.isFullscreen)
{
Cvar_SetValue( "vid_xpos", 0 );
Cvar_SetValue( "vid_ypos", 0 );
}
glConfig.vidWidth = glw_state.desktopWidth;
glConfig.vidHeight = glw_state.desktopHeight;
glConfig.windowAspect = (float)glConfig.vidWidth / glConfig.vidHeight;
cdsFullscreen = qfalse;
}
//ri.Printf( PRINT_DEVELOPER, "...setting mode %dx%d %s\n", glConfig.vidWidth, glConfig.vidHeight, cdsFullscreen ? "FS" : "W" );
DEVMODE dm;
memset( &dm, 0, sizeof( dm ) );
dm.dmSize = sizeof( dm );
if (cdsFullscreen != glw_state.cdsFullscreen) {
if (cdsFullscreen) {
dm.dmPelsWidth = glConfig.vidWidth;
dm.dmPelsHeight = glConfig.vidHeight;
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
if ( r_displayRefresh->integer ) {
dm.dmDisplayFrequency = r_displayRefresh->integer;
dm.dmFields |= DM_DISPLAYFREQUENCY;
}
if ( r_colorbits->integer ) {
dm.dmBitsPerPel = r_colorbits->integer;
dm.dmFields |= DM_BITSPERPEL;
}
glInfo.isFullscreen = qtrue;
glw_state.cdsFullscreen = qtrue;
if (!GLW_Fullscreen( dm )) {
glInfo.isFullscreen = qfalse;
glw_state.cdsFullscreen = qfalse;
}
}
else
{
ChangeDisplaySettings( 0, 0 );
glw_state.cdsFullscreen = qfalse;
}
}
if (!GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, glConfig.colorBits ))
return qfalse;
if (EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &dm ))
glInfo.displayFrequency = dm.dmDisplayFrequency;
GLW_AttemptFSAA();
return qtrue;
}
/*
** GLW_SetMode
*/
static rserr_t GLW_SetMode( const char *drivername,
int mode,
int colorbits,
qboolean cdsFullscreen )
{
HDC hDC;
const char *win_fs[] = { "W", "FS" };
int cdsRet;
DEVMODE dm;
//
// print out informational messages
//
ri.Printf( PRINT_ALL, "...setting mode %d:", mode );
if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) )
{
ri.Printf( PRINT_ALL, " invalid mode\n" );
return RSERR_INVALID_MODE;
}
ri.Printf( PRINT_ALL, " %d %d %s\n", glConfig.vidWidth, glConfig.vidHeight, win_fs[cdsFullscreen] );
//
// check our desktop attributes
//
hDC = GetDC( GetDesktopWindow() );
glw_state.desktopBitsPixel = GetDeviceCaps( hDC, BITSPIXEL );
glw_state.desktopWidth = GetDeviceCaps( hDC, HORZRES );
glw_state.desktopHeight = GetDeviceCaps( hDC, VERTRES );
ReleaseDC( GetDesktopWindow(), hDC );
//
// verify desktop bit depth
//
if ( glConfig.driverType != GLDRV_VOODOO )
{
if ( glw_state.desktopBitsPixel < 15 || glw_state.desktopBitsPixel == 24 )
{
if ( colorbits == 0 || ( !cdsFullscreen && colorbits >= 15 ) )
{
if ( MessageBox( NULL,
"It is highly unlikely that a correct\n"
"windowed display can be initialized with\n"
"the current desktop display depth. Select\n"
"'OK' to try anyway. Press 'Cancel' if you\n"
"have a 3Dfx Voodoo, Voodoo-2, or Voodoo Rush\n"
"3D accelerator installed, or if you otherwise\n"
"wish to quit.",
"Low Desktop Color Depth",
MB_OKCANCEL | MB_ICONEXCLAMATION ) != IDOK )
{
return RSERR_INVALID_MODE;
}
}
}
}
// do a CDS if needed
if ( cdsFullscreen )
{
memset( &dm, 0, sizeof( dm ) );
dm.dmSize = sizeof( dm );
dm.dmPelsWidth = glConfig.vidWidth;
dm.dmPelsHeight = glConfig.vidHeight;
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
if ( r_displayRefresh->integer != 0 )
{
dm.dmDisplayFrequency = r_displayRefresh->integer;
dm.dmFields |= DM_DISPLAYFREQUENCY;
}
// try to change color depth if possible
if ( colorbits != 0 )
{
if ( glw_state.allowdisplaydepthchange )
{
dm.dmBitsPerPel = colorbits;
dm.dmFields |= DM_BITSPERPEL;
ri.Printf( PRINT_ALL, "...using colorsbits of %d\n", colorbits );
}
else
{
ri.Printf( PRINT_ALL, "WARNING:...changing depth not supported on Win95 < pre-OSR 2.x\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...using desktop display depth of %d\n", glw_state.desktopBitsPixel );
}
//
// if we're already in fullscreen then just create the window
//
if ( glw_state.cdsFullscreen )
{
ri.Printf( PRINT_ALL, "...already fullscreen, avoiding redundant CDS\n" );
if ( !GLW_CreateWindow ( drivername, glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue ) )
{
ri.Printf( PRINT_ALL, "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
return RSERR_INVALID_MODE;
}
}
//
// need to call CDS
//
else
{
ri.Printf( PRINT_ALL, "...calling CDS: " );
// try setting the exact mode requested, because some drivers don't report
// the low res modes in EnumDisplaySettings, but still work
if ( ( cdsRet = ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) ) == DISP_CHANGE_SUCCESSFUL )
{
ri.Printf( PRINT_ALL, "ok\n" );
if ( !GLW_CreateWindow ( drivername, glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue) )
{
ri.Printf( PRINT_ALL, "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
return RSERR_INVALID_MODE;
}
glw_state.cdsFullscreen = qtrue;
}
else
{
//
// the exact mode failed, so scan EnumDisplaySettings for the next largest mode
//
DEVMODE devmode;
int modeNum;
ri.Printf( PRINT_ALL, "failed, " );
PrintCDSError( cdsRet );
ri.Printf( PRINT_ALL, "...trying next higher resolution:" );
// we could do a better matching job here...
for ( modeNum = 0 ; ; modeNum++ ) {
if ( !EnumDisplaySettings( NULL, modeNum, &devmode ) ) {
modeNum = -1;
break;
}
if ( devmode.dmPelsWidth >= glConfig.vidWidth
&& devmode.dmPelsHeight >= glConfig.vidHeight
&& devmode.dmBitsPerPel >= 15 ) {
break;
}
}
if ( modeNum != -1 && ( cdsRet = ChangeDisplaySettings( &devmode, CDS_FULLSCREEN ) ) == DISP_CHANGE_SUCCESSFUL )
{
ri.Printf( PRINT_ALL, " ok\n" );
if ( !GLW_CreateWindow( drivername, glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue) )
{
ri.Printf( PRINT_ALL, "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
return RSERR_INVALID_MODE;
}
glw_state.cdsFullscreen = qtrue;
}
else
{
ri.Printf( PRINT_ALL, " failed, " );
PrintCDSError( cdsRet );
ri.Printf( PRINT_ALL, "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
glw_state.cdsFullscreen = qfalse;
glConfig.isFullscreen = qfalse;
if ( !GLW_CreateWindow( drivername, glConfig.vidWidth, glConfig.vidHeight, colorbits, qfalse) )
{
return RSERR_INVALID_MODE;
}
return RSERR_INVALID_FULLSCREEN;
}
}
}
}
else
{
if ( glw_state.cdsFullscreen )
{
ChangeDisplaySettings( 0, 0 );
}
glw_state.cdsFullscreen = qfalse;
if ( !GLW_CreateWindow( drivername, glConfig.vidWidth, glConfig.vidHeight, colorbits, qfalse ) )
{
return RSERR_INVALID_MODE;
}
}
//
// success, now check display frequency, although this won't be valid on Voodoo(2)
//
memset( &dm, 0, sizeof( dm ) );
dm.dmSize = sizeof( dm );
if ( EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &dm ) )
{
glConfig.displayFrequency = dm.dmDisplayFrequency;
}
// NOTE: this is overridden later on standalone 3Dfx drivers
glConfig.isFullscreen = cdsFullscreen;
return RSERR_OK;
}
rserr_t GLimp_SetMode( int mode, int colorbits, bool fullscreen ) {
const char* win_fs[] = { "W", "FS" };
//
// print out informational messages
//
common->Printf( "...setting mode %d:", mode );
if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) ) {
common->Printf( " invalid mode\n" );
return RSERR_INVALID_MODE;
}
common->Printf( " %d %d %s\n", glConfig.vidWidth, glConfig.vidHeight, win_fs[ fullscreen ] );
//
// check our desktop attributes
//
HDC hDC = GetDC( GetDesktopWindow() );
desktopBitsPixel = GetDeviceCaps( hDC, BITSPIXEL );
desktopWidth = GetDeviceCaps( hDC, HORZRES );
desktopHeight = GetDeviceCaps( hDC, VERTRES );
ReleaseDC( GetDesktopWindow(), hDC );
//
// verify desktop bit depth
//
if ( desktopBitsPixel < 15 || desktopBitsPixel == 24 ) {
if ( colorbits == 0 || ( !cdsFullscreen && colorbits >= 15 ) ) {
if ( MessageBox( NULL,
"It is highly unlikely that a correct\n"
"windowed display can be initialized with\n"
"the current desktop display depth. Select\n"
"'OK' to try anyway. Press 'Cancel' if you otherwise\n"
"wish to quit.",
"Low Desktop Color Depth",
MB_OKCANCEL | MB_ICONEXCLAMATION ) != IDOK ) {
return RSERR_INVALID_MODE;
}
}
}
DEVMODE dm;
// do a CDS if needed
if ( fullscreen ) {
Com_Memset( &dm, 0, sizeof ( dm ) );
dm.dmSize = sizeof ( dm );
dm.dmPelsWidth = glConfig.vidWidth;
dm.dmPelsHeight = glConfig.vidHeight;
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
if ( r_displayRefresh->integer != 0 ) {
dm.dmDisplayFrequency = r_displayRefresh->integer;
dm.dmFields |= DM_DISPLAYFREQUENCY;
}
// try to change color depth if possible
if ( colorbits != 0 ) {
dm.dmBitsPerPel = colorbits;
dm.dmFields |= DM_BITSPERPEL;
common->Printf( "...using colorsbits of %d\n", colorbits );
} else {
common->Printf( "...using desktop display depth of %d\n", desktopBitsPixel );
}
//
// If we're already in fullscreen then just create the window.
//
if ( cdsFullscreen ) {
common->Printf( "...already fullscreen, avoiding redundant CDS\n" );
if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, true ) ) {
common->Printf( "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
cdsFullscreen = false;
return RSERR_INVALID_MODE;
}
}
//
// need to call CDS
//
else {
common->Printf( "...calling CDS: " );
// try setting the exact mode requested, because some drivers don't report
// the low res modes in EnumDisplaySettings, but still work
int cdsRet = ChangeDisplaySettings( &dm, CDS_FULLSCREEN );
if ( cdsRet == DISP_CHANGE_SUCCESSFUL ) {
common->Printf( "ok\n" );
if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, true ) ) {
common->Printf( "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
return RSERR_INVALID_MODE;
}
cdsFullscreen = true;
} else {
common->Printf( "failed, " );
PrintCDSError( cdsRet );
//
// the exact mode failed, so scan EnumDisplaySettings for the next largest mode
//
common->Printf( "...trying next higher resolution:" );
// we could do a better matching job here...
DEVMODE devmode;
int modeNum;
for ( modeNum = 0;; modeNum++ ) {
if ( !EnumDisplaySettings( NULL, modeNum, &devmode ) ) {
modeNum = -1;
break;
}
if ( devmode.dmPelsWidth >= glConfig.vidWidth &&
devmode.dmPelsHeight >= glConfig.vidHeight &&
devmode.dmBitsPerPel >= 15 ) {
break;
}
}
if ( modeNum != -1 ) {
cdsRet = ChangeDisplaySettings( &devmode, CDS_FULLSCREEN );
}
if ( modeNum != -1 && cdsRet == DISP_CHANGE_SUCCESSFUL ) {
common->Printf( " ok\n" );
if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, true ) ) {
common->Printf( "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
return RSERR_INVALID_MODE;
}
cdsFullscreen = true;
} else {
common->Printf( " failed, " );
PrintCDSError( cdsRet );
common->Printf( "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
cdsFullscreen = false;
glConfig.isFullscreen = false;
if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, false ) ) {
return RSERR_INVALID_MODE;
}
return RSERR_INVALID_FULLSCREEN;
}
}
}
} else {
if ( cdsFullscreen ) {
ChangeDisplaySettings( 0, 0 );
}
cdsFullscreen = false;
if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, false ) ) {
return RSERR_INVALID_MODE;
}
}
//
// success, now check display frequency
//
Com_Memset( &dm, 0, sizeof ( dm ) );
dm.dmSize = sizeof ( dm );
if ( EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &dm ) ) {
glConfig.displayFrequency = dm.dmDisplayFrequency;
}
glConfig.isFullscreen = fullscreen;
return RSERR_OK;
}
/*
===================
GLimp_Init
This is the platform specific OpenGL initialization function. It
is responsible for loading OpenGL, initializing it,
creating a window of the appropriate size, doing
fullscreen manipulations, etc. Its overall responsibility is
to make sure that a functional OpenGL subsystem is operating
when it returns to the ref.
If there is any failure, the renderer will revert back to safe
parameters and try again.
===================
*/
bool GLimp_Init( glimpParms_t parms ) {
const char *driverName;
HDC hDC;
common->Printf( "Initializing OpenGL subsystem\n" );
// check our desktop attributes
hDC = GetDC( GetDesktopWindow() );
win32.desktopBitsPixel = GetDeviceCaps( hDC, BITSPIXEL );
win32.desktopWidth = GetDeviceCaps( hDC, HORZRES );
win32.desktopHeight = GetDeviceCaps( hDC, VERTRES );
ReleaseDC( GetDesktopWindow(), hDC );
// we can't run in a window unless it is 32 bpp
if ( win32.desktopBitsPixel < 32 && !parms.fullScreen ) {
common->Printf("^3Windowed mode requires 32 bit desktop depth^0\n");
return false;
}
// save the hardware gamma so it can be
// restored on exit
GLimp_SaveGamma();
// create our window classes if we haven't already
GLW_CreateWindowClasses();
// this will load the dll and set all our qgl* function pointers,
// but doesn't create a window
// r_glDriver is only intended for using instrumented OpenGL
// dlls. Normal users should never have to use it, and it is
// not archived.
driverName = r_glDriver.GetString()[0] ? r_glDriver.GetString() : "opengl32";
if ( !QGL_Init( driverName ) ) {
common->Printf( "^3GLimp_Init() could not load r_glDriver \"%s\"^0\n", driverName );
return false;
}
// getting the wgl extensions involves creating a fake window to get a context,
// which is pretty disgusting, and seems to mess with the AGP VAR allocation
GLW_GetWGLExtensionsWithFakeWindow();
// try to change to fullscreen
if ( parms.fullScreen ) {
if ( !GLW_SetFullScreen( parms ) ) {
GLimp_Shutdown();
return false;
}
}
// try to create a window with the correct pixel format
// and init the renderer context
if ( !GLW_CreateWindow( parms ) ) {
GLimp_Shutdown();
return false;
}
// wglSwapinterval, etc
GLW_CheckWGLExtensions( win32.hDC );
// check logging
GLimp_EnableLogging( ( r_logFile.GetInteger() != 0 ) );
return true;
}
/*
** GLW_SetMode
*/
static rserr_t GLW_SetMode( int mode,
int colorbits,
qboolean cdsFullscreen )
{
HDC hDC;
const char *win_fs[] = { "W", "FS" };
int cdsRet;
DEVMODE dm;
//
// print out informational messages
//
ri.Printf( PRINT_ALL, "...setting mode %d:", mode );
if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) )
{
ri.Printf( PRINT_ALL, " invalid mode\n" );
return RSERR_INVALID_MODE;
}
ri.Printf( PRINT_ALL, " %d %d %s\n", glConfig.vidWidth, glConfig.vidHeight, win_fs[cdsFullscreen] );
//
// check our desktop attributes
//
hDC = GetDC( GetDesktopWindow() );
glw_state.desktopBitsPixel = GetDeviceCaps( hDC, BITSPIXEL );
glw_state.desktopWidth = GetDeviceCaps( hDC, HORZRES );
glw_state.desktopHeight = GetDeviceCaps( hDC, VERTRES );
ReleaseDC( GetDesktopWindow(), hDC );
//
// verify desktop bit depth
//
if ( glw_state.desktopBitsPixel < 15 || glw_state.desktopBitsPixel == 24 )
{
if ( colorbits == 0 || ( !cdsFullscreen && colorbits >= 15 ) )
{
// since I can't be bothered trying to mess around with asian codepages and MBCS stuff for a windows
// error box that'll only appear if something's seriously f****d then I'm going to fallback to
// english text when these would otherwise be used...
//
char sErrorHead[1024]; // ott
extern qboolean Language_IsAsian(void);
Q_strncpyz(sErrorHead, Language_IsAsian() ? "Low Desktop Color Depth" : SP_GetStringTextString("CON_TEXT_LOW_DESKTOP_COLOUR_DEPTH"), sizeof(sErrorHead) );
const char *psErrorBody = Language_IsAsian() ?
"It is highly unlikely that a correct windowed\n"
"display can be initialized with the current\n"
"desktop display depth. Select 'OK' to try\n"
"anyway. Select 'Cancel' to try a fullscreen\n"
"mode instead."
:
SP_GetStringTextString("CON_TEXT_TRY_ANYWAY");
if ( MessageBox( NULL,
psErrorBody,
sErrorHead,
MB_OKCANCEL | MB_ICONEXCLAMATION ) != IDOK )
{
return RSERR_INVALID_MODE;
}
}
}
// do a CDS if needed
if ( cdsFullscreen )
{
memset( &dm, 0, sizeof( dm ) );
dm.dmSize = sizeof( dm );
dm.dmPelsWidth = glConfig.vidWidth;
dm.dmPelsHeight = glConfig.vidHeight;
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
if ( r_displayRefresh->integer != 0 )
{
dm.dmDisplayFrequency = r_displayRefresh->integer;
dm.dmFields |= DM_DISPLAYFREQUENCY;
}
// try to change color depth if possible
if ( colorbits != 0 )
{
if ( glw_state.allowdisplaydepthchange )
{
dm.dmBitsPerPel = colorbits;
dm.dmFields |= DM_BITSPERPEL;
ri.Printf( PRINT_ALL, "...using colorsbits of %d\n", colorbits );
}
else
{
ri.Printf( PRINT_ALL, "WARNING:...changing depth not supported on Win95 < pre-OSR 2.x\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...using desktop display depth of %d\n", glw_state.desktopBitsPixel );
}
//
// if we're already in fullscreen then just create the window
//
if ( glw_state.cdsFullscreen )
{
ri.Printf( PRINT_ALL, "...already fullscreen, avoiding redundant CDS\n" );
if ( !GLW_CreateWindow ( glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue ) )
{
ri.Printf( PRINT_ALL, "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
return RSERR_INVALID_MODE;
}
}
//
// need to call CDS
//
else
{
ri.Printf( PRINT_ALL, "...calling CDS: " );
// try setting the exact mode requested, because some drivers don't report
// the low res modes in EnumDisplaySettings, but still work
if ( ( cdsRet = ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) ) == DISP_CHANGE_SUCCESSFUL )
{
ri.Printf( PRINT_ALL, "ok\n" );
if ( !GLW_CreateWindow ( glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue) )
{
ri.Printf( PRINT_ALL, "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
return RSERR_INVALID_MODE;
}
glw_state.cdsFullscreen = qtrue;
}
else
{
//
// the exact mode failed, so scan EnumDisplaySettings for the next largest mode
//
DEVMODE devmode;
int modeNum;
ri.Printf( PRINT_ALL, "failed, " );
PrintCDSError( cdsRet );
ri.Printf( PRINT_ALL, "...trying next higher resolution:" );
// we could do a better matching job here...
for ( modeNum = 0 ; ; modeNum++ ) {
if ( !EnumDisplaySettings( NULL, modeNum, &devmode ) ) {
modeNum = -1;
break;
}
if ( devmode.dmPelsWidth >= glConfig.vidWidth
&& devmode.dmPelsHeight >= glConfig.vidHeight
&& devmode.dmBitsPerPel >= 15 ) {
break;
}
}
if ( modeNum != -1 && ( cdsRet = ChangeDisplaySettings( &devmode, CDS_FULLSCREEN ) ) == DISP_CHANGE_SUCCESSFUL )
{
ri.Printf( PRINT_ALL, " ok\n" );
if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue) )
{
ri.Printf( PRINT_ALL, "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
return RSERR_INVALID_MODE;
}
glw_state.cdsFullscreen = qtrue;
}
else
{
ri.Printf( PRINT_ALL, " failed, " );
PrintCDSError( cdsRet );
ri.Printf( PRINT_ALL, "...restoring display settings\n" );
ChangeDisplaySettings( 0, 0 );
/* jfm: i took out the following code to allow fallback to mode 3, with this code it goes half windowed and just doesn't work.
glw_state.cdsFullscreen = qfalse;
glConfig.isFullscreen = qfalse;
if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, qfalse) )
{
return RSERR_INVALID_MODE;
}
*/
return RSERR_INVALID_FULLSCREEN;
}
}
}
}
else
{
if ( glw_state.cdsFullscreen )
{
ChangeDisplaySettings( 0, 0 );
}
glw_state.cdsFullscreen = qfalse;
if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, qfalse ) )
{
return RSERR_INVALID_MODE;
}
}
//
// success, now check display frequency, although this won't be valid on Voodoo(2)
//
memset( &dm, 0, sizeof( dm ) );
dm.dmSize = sizeof( dm );
if ( EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &dm ) )
{
glConfig.displayFrequency = dm.dmDisplayFrequency;
}
// NOTE: this is overridden later on standalone 3Dfx drivers
glConfig.isFullscreen = cdsFullscreen;
return RSERR_OK;
}