/*
** GLimp_SetMode
*/
rserr_t GLimp_SetMode( int *pwidth, int *pheight, int mode, qboolean fullscreen )
{
int width, height;
const char *win_fs[] = { "W", "FS" };
Com_Printf ( "Initializing OpenGL display\n");
Com_Printf ("...setting mode %d:", mode );
if ( !R_GetModeInfo( &width, &height, mode ) )
{
Com_Printf ( " invalid mode\n" );
return rserr_invalid_mode;
}
Com_Printf ( " %d %d %s\n", width, height, win_fs[fullscreen] );
// destroy the existing window
if (glw_state.hWnd)
GLimp_Shutdown ();
// do a CDS if needed
if ( fullscreen )
{
if (GLimp_SetFSMode(&width, &height))
{
*pwidth = width;
*pheight = height;
if (!VID_CreateWindow (width, height, true)) {
Com_Printf("...restoring display settings\n");
ChangeDisplaySettings( 0, 0 );
gl_state.fullscreen = false;
return rserr_invalid_mode;
}
EnumDisplaySettings (NULL, ENUM_CURRENT_SETTINGS, &fullScreenMode);
gl_state.fullscreen = true;
return rserr_ok;
}
}
*pwidth = width;
*pheight = height;
Com_Printf ( "...setting windowed mode\n" );
if (gl_state.fullscreen)
{
ChangeDisplaySettings( 0, 0 );
gl_state.fullscreen = false;
}
if (!VID_CreateWindow (width, height, false))
return rserr_invalid_mode;
return (fullscreen) ? rserr_invalid_fullscreen : rserr_ok;
}
/*
** SWimp_InitGraphics
**
** This initializes the software refresh's implementation specific
** graphics subsystem. In the case of Windows it creates DIB or
** DDRAW surfaces.
**
** The necessary width and height parameters are grabbed from
** vid.width and vid.height.
*/
static qboolean SWimp_InitGraphics( qboolean fullscreen )
{
// free resources in use
SWimp_Shutdown ();
// create a new window
VID_CreateWindow (vid.width, vid.height, WINDOW_STYLE);
// initialize the appropriate subsystem
if ( !fullscreen )
{
if ( !DIB_Init( &vid.buffer, &vid.rowbytes ) )
{
vid.buffer = 0;
vid.rowbytes = 0;
return false;
}
}
else
{
if ( !DDRAW_Init( &vid.buffer, &vid.rowbytes ) )
{
vid.buffer = 0;
vid.rowbytes = 0;
return false;
}
}
return true;
}
/*
** GLimp_SetMode
*/
rserr_t GLimp_SetMode( int x, int y, int width, int height, int displayFrequency,
qboolean fullscreen, qboolean wideScreen )
{
const char *win_fs[] = { "W", "FS" };
// check whether we can toggle fullscreen without a vid_restart
if( glw_state.hWnd ) {
if( glConfig.width == width && glConfig.height == height && fullscreen != glConfig.fullScreen ) {
glConfig.fullScreen = VID_SetFullscreenMode( displayFrequency, fullscreen );
if( glConfig.fullScreen == fullscreen ) {
VID_SetWindowSize( fullscreen );
return rserr_ok;
}
return rserr_restart_required;
}
}
ri.Com_Printf( "Initializing OpenGL display\n" );
ri.Com_Printf( "...setting mode:" );
// disable fullscreen if rendering to a parent window
if( glw_state.parenthWnd ) {
RECT parentWindowRect;
fullscreen = qfalse;
wideScreen = qfalse;
GetWindowRect( glw_state.parenthWnd, &parentWindowRect );
width = parentWindowRect.right - parentWindowRect.left;
height = parentWindowRect.bottom - parentWindowRect.top;
}
ri.Com_Printf( " %d %d %s\n", width, height, win_fs[fullscreen] );
// destroy the existing window
if( glw_state.hWnd )
{
GLimp_Shutdown();
}
glw_state.win_x = x;
glw_state.win_y = y;
glConfig.width = width;
glConfig.height = height;
glConfig.wideScreen = wideScreen;
glConfig.fullScreen = VID_SetFullscreenMode( displayFrequency, fullscreen );
if( !VID_CreateWindow() ) {
return rserr_invalid_mode;
}
return ( fullscreen == glConfig.fullScreen ? rserr_ok : rserr_invalid_fullscreen );
}
rserr_t R_ChangeDisplaySettings( int width, int height, qboolean fullscreen )
{
#ifdef XASH_SDL
SDL_DisplayMode displayMode;
SDL_GetCurrentDisplayMode(0, &displayMode);
R_SaveVideoMode( width, height );
// check our desktop attributes
glw_state.desktopBitsPixel = SDL_BITSPERPIXEL(displayMode.format);
glw_state.desktopWidth = displayMode.w;
glw_state.desktopHeight = displayMode.h;
glState.fullScreen = fullscreen;
// check for 4:3 or 5:4
if( width * 3 != height * 4 && width * 4 != height * 5 )
glState.wideScreen = true;
else glState.wideScreen = false;
if(!host.hWnd)
{
if( !VID_CreateWindow( width, height, fullscreen ) )
return rserr_invalid_mode;
}
else if( fullscreen )
{
SDL_DisplayMode want, got;
want.w = width;
want.h = height;
want.driverdata = NULL;
want.format = want.refresh_rate = 0; // don't care
if( !SDL_GetClosestDisplayMode(0, &want, &got) )
return rserr_invalid_mode;
MsgDev(D_NOTE, "Got closest display mode: %ix%i@%i\n", got.w, got.h, got.refresh_rate);
if( ( SDL_GetWindowFlags(host.hWnd) & SDL_WINDOW_FULLSCREEN ) == SDL_WINDOW_FULLSCREEN)
if( SDL_SetWindowFullscreen(host.hWnd, 0) == -1 )
return rserr_invalid_fullscreen;
if( SDL_SetWindowDisplayMode(host.hWnd, &got) )
return rserr_invalid_mode;
if( SDL_SetWindowFullscreen(host.hWnd, SDL_WINDOW_FULLSCREEN) == -1 )
return rserr_invalid_fullscreen;
R_ChangeDisplaySettingsFast( got.w, got.h );
}
else
{
if( SDL_SetWindowFullscreen(host.hWnd, 0) )
return rserr_invalid_fullscreen;
SDL_SetWindowSize(host.hWnd, width, height);
R_ChangeDisplaySettingsFast( width, height );
}
#endif // XASH_SDL
return rserr_ok;
}
/*
** GLimp_SetMode
*/
int GLimp_SetMode( int mode, qboolean fullscreen )
{
int width, height;
const char *win_fs[] = { "W", "FS" };
qboolean wideScreen;
// disable fullscreen if rendering to a parent window
if( glw_state.parenthWnd )
{
fullscreen = qfalse;
}
Com_Printf( "Initializing OpenGL display\n" );
Com_Printf( "...setting mode %d:", mode );
if( !VID_GetModeInfo( &width, &height, &wideScreen, mode ) )
{
Com_Printf( " invalid mode\n" );
return rserr_invalid_mode;
}
Com_Printf( " %d %d %s\n", width, height, win_fs[fullscreen] );
// destroy the existing window
if( glw_state.hWnd )
{
GLimp_Shutdown();
}
glState.width = width;
glState.height = height;
glState.wideScreen = wideScreen;
glState.fullScreen = fullscreen;
// do a CDS if needed
if( fullscreen )
{
DEVMODE dm;
Com_Printf( "...attempting fullscreen\n" );
memset( &dm, 0, sizeof( dm ) );
dm.dmSize = sizeof( dm );
dm.dmPelsWidth = width;
dm.dmPelsHeight = height;
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
if( r_colorbits->integer != 0 )
{
dm.dmBitsPerPel = r_colorbits->integer;
dm.dmFields |= DM_BITSPERPEL;
Com_Printf( "...using r_bitdepth of %d\n", dm.dmBitsPerPel );
}
else
{
HDC hdc = GetDC( NULL );
int bitspixel = GetDeviceCaps( hdc, BITSPIXEL );
Com_Printf( "...using desktop display depth of %d\n", bitspixel );
ReleaseDC( 0, hdc );
}
if( vid_displayfrequency->integer > 0 )
{
dm.dmFields |= DM_DISPLAYFREQUENCY;
dm.dmDisplayFrequency = vid_displayfrequency->integer;
Com_Printf( "...using display frequency %i\n", dm.dmDisplayFrequency );
}
Com_Printf( "...calling CDS: " );
if( ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) == DISP_CHANGE_SUCCESSFUL )
{
Com_Printf( "ok\n" );
if( !VID_CreateWindow( &glState.width, &glState.height, qtrue ) )
return rserr_invalid_mode;
return rserr_ok;
}
else
{
Com_Printf( "failed\n" );
Com_Printf( "...calling CDS assuming dual monitors:" );
dm.dmPelsWidth = width * 2;
dm.dmPelsHeight = height;
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
if( r_colorbits->integer != 0 )
{
dm.dmBitsPerPel = r_colorbits->integer;
dm.dmFields |= DM_BITSPERPEL;
Com_Printf( "...using r_bitdepth of %d\n", dm.dmBitsPerPel );
}
if( vid_displayfrequency->integer > 0 )
{
dm.dmFields |= DM_DISPLAYFREQUENCY;
dm.dmDisplayFrequency = vid_displayfrequency->integer;
Com_Printf( "...using display frequency %i\n", dm.dmDisplayFrequency );
}
/*
** our first CDS failed, so maybe we're running on some weird dual monitor
** system
*/
if( ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) != DISP_CHANGE_SUCCESSFUL )
{
Com_Printf( " failed\n" );
Com_Printf( "...setting windowed mode\n" );
ChangeDisplaySettings( 0, 0 );
glState.fullScreen = qfalse;
if( !VID_CreateWindow( &glState.width, &glState.height, qfalse ) )
return rserr_invalid_mode;
return rserr_invalid_fullscreen;
}
else
{
Com_Printf( " ok\n" );
if( !VID_CreateWindow( &glState.width, &glState.height, qtrue ) )
return rserr_invalid_mode;
return rserr_ok;
}
}
}
else
{
Com_Printf( "...setting windowed mode\n" );
ChangeDisplaySettings( 0, 0 );
if( !VID_CreateWindow( &glState.width, &glState.height, qfalse ) )
return rserr_invalid_mode;
}
return rserr_ok;
}
/*
** GLimp_SetMode
*/
rserr_t GLimp_SetMode( int *pwidth, int *pheight, int mode, qboolean fullscreen )
{
int width, height;
const char *win_fs[] = { "W", "FS" };
ri.Con_Printf( PRINT_ALL, "Initializing OpenGL display\n");
ri.Con_Printf (PRINT_ALL, "...setting mode %d:", mode );
if ( !ri.Vid_GetModeInfo( &width, &height, mode ) )
{
ri.Con_Printf( PRINT_ALL, " invalid mode\n" );
return rserr_invalid_mode;
}
ri.Con_Printf( PRINT_ALL, " %d %d %s\n", width, height, win_fs[fullscreen] );
// destroy the existing window
if (glw_state.hWnd)
{
GLimp_Shutdown ();
}
// do a CDS if needed
if ( fullscreen )
{
DEVMODE dm;
ri.Con_Printf( PRINT_ALL, "...attempting fullscreen\n" );
memset( &dm, 0, sizeof( dm ) );
dm.dmSize = sizeof( dm );
dm.dmPelsWidth = width;
dm.dmPelsHeight = height;
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
if ( gl_bitdepth->value != 0 )
{
dm.dmBitsPerPel = gl_bitdepth->value;
dm.dmFields |= DM_BITSPERPEL;
ri.Con_Printf( PRINT_ALL, "...using gl_bitdepth of %d\n", ( int ) gl_bitdepth->value );
}
else
{
HDC hdc = GetDC( NULL );
int bitspixel = GetDeviceCaps( hdc, BITSPIXEL );
ri.Con_Printf( PRINT_ALL, "...using desktop display depth of %d\n", bitspixel );
ReleaseDC( 0, hdc );
}
ri.Con_Printf( PRINT_ALL, "...calling CDS: " );
if ( ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) == DISP_CHANGE_SUCCESSFUL )
{
*pwidth = width;
*pheight = height;
gl_state.fullscreen = true;
ri.Con_Printf( PRINT_ALL, "ok\n" );
if ( !VID_CreateWindow (width, height, true) )
return rserr_invalid_mode;
return rserr_ok;
}
else
{
*pwidth = width;
*pheight = height;
ri.Con_Printf( PRINT_ALL, "failed\n" );
ri.Con_Printf( PRINT_ALL, "...calling CDS assuming dual monitors:" );
dm.dmPelsWidth = width * 2;
dm.dmPelsHeight = height;
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
if ( gl_bitdepth->value != 0 )
{
dm.dmBitsPerPel = gl_bitdepth->value;
dm.dmFields |= DM_BITSPERPEL;
}
/*
** our first CDS failed, so maybe we're running on some weird dual monitor
** system
*/
if ( ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) != DISP_CHANGE_SUCCESSFUL )
{
ri.Con_Printf( PRINT_ALL, " failed\n" );
ri.Con_Printf( PRINT_ALL, "...setting windowed mode\n" );
ChangeDisplaySettings( 0, 0 );
*pwidth = width;
*pheight = height;
gl_state.fullscreen = false;
if ( !VID_CreateWindow (width, height, false) )
return rserr_invalid_mode;
return rserr_invalid_fullscreen;
}
else
{
ri.Con_Printf( PRINT_ALL, " ok\n" );
if ( !VID_CreateWindow (width, height, true) )
return rserr_invalid_mode;
gl_state.fullscreen = true;
return rserr_ok;
}
}
}
else
{
ri.Con_Printf( PRINT_ALL, "...setting windowed mode\n" );
ChangeDisplaySettings( 0, 0 );
*pwidth = width;
*pheight = height;
gl_state.fullscreen = false;
if ( !VID_CreateWindow (width, height, false) )
return rserr_invalid_mode;
}
return rserr_ok;
}
qboolean VID_CreateWindow( int width, int height, qboolean fullscreen )
{
#ifdef XASH_SDL
static string wndname;
Uint32 wndFlags = SDL_WINDOW_MOUSE_FOCUS | SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
Q_strncpy( wndname, GI->title, sizeof( wndname ));
host.hWnd = SDL_CreateWindow(wndname, r_xpos->integer,
r_ypos->integer, width, height, wndFlags);
if( !host.hWnd )
{
MsgDev( D_ERROR, "VID_CreateWindow: couldn't create '%s': %s\n", wndname, SDL_GetError());
// remove MSAA, if it present, because
// window creating may fail on GLX visual choose
if( gl_msaa->integer )
{
Cvar_Set("gl_msaa", "0");
GL_SetupAttributes(); // re-choose attributes
// try again
return VID_CreateWindow( width, height, fullscreen );
}
return false;
}
if( fullscreen )
{
SDL_DisplayMode want, got;
want.w = width;
want.h = height;
want.driverdata = NULL;
want.format = want.refresh_rate = 0; // don't care
if( !SDL_GetClosestDisplayMode(0, &want, &got) )
return false;
MsgDev(D_NOTE, "Got closest display mode: %ix%i@%i\n", got.w, got.h, got.refresh_rate);
if( SDL_SetWindowDisplayMode(host.hWnd, &got) == -1 )
return false;
if( SDL_SetWindowFullscreen(host.hWnd, SDL_WINDOW_FULLSCREEN) == -1 )
return false;
}
host.window_center_x = width / 2;
host.window_center_y = height / 2;
SDL_ShowWindow( host.hWnd );
#else
host.hWnd = 1; //fake window
host.window_center_x = width / 2;
host.window_center_y = height / 2;
#endif
if( !glw_state.initialized )
{
if( !GL_CreateContext( ) )
{
return false;
}
VID_StartupGamma();
}
else
{
if( !GL_UpdateContext( ))
return false;
}
return true;
}
