/*
===============
GLimp_SetMode
===============
*/
static int GLimp_SetMode(int mode, bool fullscreen, bool noborder)
{
const char *glstring;
int perChannelColorBits;
int colorBits, depthBits, stencilBits;
int samples;
int i = 0;
SDL_Surface *icon = NULL;
Uint32 flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
SDL_DisplayMode desktopMode;
int display = 0;
int x = SDL_WINDOWPOS_UNDEFINED, y = SDL_WINDOWPOS_UNDEFINED;
ri->Printf( PRINT_ALL, "Initializing OpenGL display\n");
if ( r_allowResize->integer )
flags |= SDL_WINDOW_RESIZABLE;
#ifdef USE_ICON
icon = SDL_CreateRGBSurfaceFrom(
(void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
#endif
// If a window exists, note its display index
if( SDL_window != NULL )
display = SDL_GetWindowDisplayIndex( SDL_window );
if( SDL_GetDesktopDisplayMode( display, &desktopMode ) == 0 )
{
displayAspect = (float)desktopMode.w / (float)desktopMode.h;
ri.Printf( PRINT_ALL, "Display aspect: %.3f\n", displayAspect );
}
else
{
Com_Memset( &desktopMode, 0, sizeof( SDL_DisplayMode ) );
ri.Printf( PRINT_ALL,
"Cannot determine display aspect, assuming 1.333\n" );
}
ri->Printf (PRINT_ALL, "...setting mode %d:", mode );
if (mode == -2)
{
// use desktop video resolution
if( desktopMode.h > 0 )
{
glConfig.vidWidth = desktopMode.w;
glConfig.vidHeight = desktopMode.h;
}
else
{
glConfig.vidWidth = 640;
glConfig.vidHeight = 480;
ri->Printf( PRINT_ALL,
"Cannot determine display resolution, assuming 640x480\n" );
}
glConfig.windowAspect = (float)glConfig.vidWidth / (float)glConfig.vidHeight;
}
else 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\n", glConfig.vidWidth, glConfig.vidHeight);
// Center window
if( r_centerWindow->integer && !fullscreen )
{
x = ( desktopMode.w / 2 ) - ( glConfig.vidWidth / 2 );
y = ( desktopMode.h / 2 ) - ( glConfig.vidHeight / 2 );
}
// Destroy existing state if it exists
if( SDL_glContext != NULL )
{
SDL_GL_DeleteContext( SDL_glContext );
SDL_glContext = NULL;
}
if( SDL_window != NULL )
{
SDL_GetWindowPosition( SDL_window, &x, &y );
ri->Printf( PRINT_DEVELOPER, "Existing window at %dx%d before being destroyed\n", x, y );
SDL_DestroyWindow( SDL_window );
SDL_window = NULL;
}
if( fullscreen )
{
flags |= SDL_WINDOW_FULLSCREEN;
glConfig.isFullscreen = qtrue;
}
else
{
if( noborder )
flags |= SDL_WINDOW_BORDERLESS;
glConfig.isFullscreen = false;
}
colorBits = r_colorbits->value;
if ((!colorBits) || (colorBits >= 32))
colorBits = 24;
if (!r_depthbits->value)
depthBits = 24;
else
depthBits = r_depthbits->value;
stencilBits = r_stencilbits->value;
samples = r_ext_multisample->value;
for (i = 0; i < 16; i++)
{
int testColorBits, testDepthBits, testStencilBits;
// 0 - default
// 1 - minus colorBits
// 2 - minus depthBits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2 :
if (colorBits == 24)
colorBits = 16;
break;
case 1 :
if (depthBits == 24)
depthBits = 16;
else if (depthBits == 16)
depthBits = 8;
case 3 :
if (stencilBits == 24)
stencilBits = 16;
else if (stencilBits == 16)
stencilBits = 8;
}
}
testColorBits = colorBits;
testDepthBits = depthBits;
testStencilBits = stencilBits;
if ((i % 4) == 3)
{ // reduce colorBits
if (testColorBits == 24)
testColorBits = 16;
}
if ((i % 4) == 2)
{ // reduce depthBits
if (testDepthBits == 24)
testDepthBits = 16;
else if (testDepthBits == 16)
testDepthBits = 8;
}
if ((i % 4) == 1)
{ // reduce stencilBits
if (testStencilBits == 24)
testStencilBits = 16;
else if (testStencilBits == 16)
testStencilBits = 8;
else
testStencilBits = 0;
}
if (testColorBits == 24)
perChannelColorBits = 8;
else
perChannelColorBits = 4;
#ifdef __sgi /* Fix for SGIs grabbing too many bits of color */
if (perChannelColorBits == 4)
perChannelColorBits = 0; /* Use minimum size for 16-bit color */
/* Need alpha or else SGIs choose 36+ bit RGB mode */
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 1);
#endif
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, testDepthBits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, testStencilBits );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );
if(r_stereoEnabled->integer)
{
glConfig.stereoEnabled = true;
SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
}
else
{
glConfig.stereoEnabled = false;
SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
#if 0 // if multisampling is enabled on X11, this causes create window to fail.
// If not allowing software GL, demand accelerated
if( !r_allowSoftwareGL->integer )
SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
#endif
if( ( SDL_window = SDL_CreateWindow( CLIENT_WINDOW_TITLE, x, y,
glConfig.vidWidth, glConfig.vidHeight, flags ) ) == 0 )
{
ri->Printf( PRINT_DEVELOPER, "SDL_CreateWindow failed: %s\n", SDL_GetError( ) );
continue;
}
if( fullscreen )
{
SDL_DisplayMode mode;
switch( testColorBits )
{
case 16:
mode.format = SDL_PIXELFORMAT_RGB565;
break;
case 24:
mode.format = SDL_PIXELFORMAT_RGB24;
break;
default:
ri.Printf( PRINT_DEVELOPER, "testColorBits is %d, can't fullscreen\n", testColorBits );
continue;
}
mode.w = glConfig.vidWidth;
mode.h = glConfig.vidHeight;
mode.refresh_rate = glConfig.displayFrequency = ri->Cvar_VariableIntegerValue( "r_displayRefresh" );
mode.driverdata = NULL;
if( SDL_SetWindowDisplayMode( SDL_window, &mode ) < 0 )
{
ri.Printf( PRINT_DEVELOPER, "SDL_SetWindowDisplayMode failed: %s\n", SDL_GetError( ) );
continue;
}
}
SDL_SetWindowIcon( SDL_window, icon );
if( ( SDL_glContext = SDL_GL_CreateContext( SDL_window ) ) == NULL )
{
ri->Printf( PRINT_DEVELOPER, "SDL_GL_CreateContext failed: %s\n", SDL_GetError( ) );
continue;
}
SDL_GL_SetSwapInterval( r_swapInterval->integer );
glConfig.colorBits = testColorBits;
glConfig.depthBits = testDepthBits;
glConfig.stencilBits = testStencilBits;
ri->Printf( PRINT_ALL, "Using %d color bits, %d depth, %d stencil display.\n",
glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits );
break;
}
SDL_FreeSurface( icon );
if( !SDL_window )
{
ri->Printf( PRINT_ALL, "Couldn't get a visual\n" );
return RSERR_INVALID_MODE;
}
GLimp_DetectAvailableModes();
glstring = (char *) qglGetString (GL_RENDERER);
ri->Printf( PRINT_ALL, "GL_RENDERER: %s\n", glstring );
return RSERR_OK;
}
/*
===============
GLimp_SetMode
===============
*/
static rserr_t GLimp_SetMode(glconfig_t *glConfig, const windowDesc_t *windowDesc, const char *windowTitle, int mode, qboolean fullscreen, qboolean noborder)
{
int perChannelColorBits;
int colorBits, depthBits, stencilBits;
int samples;
int i = 0;
SDL_Surface *icon = NULL;
Uint32 flags = SDL_WINDOW_SHOWN;
SDL_DisplayMode desktopMode;
int display = 0;
int x = SDL_WINDOWPOS_UNDEFINED, y = SDL_WINDOWPOS_UNDEFINED;
if ( windowDesc->api == GRAPHICS_API_OPENGL )
{
flags |= SDL_WINDOW_OPENGL;
}
Com_Printf( "Initializing display\n");
icon = SDL_CreateRGBSurfaceFrom(
(void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
// If a window exists, note its display index
if( screen != NULL )
display = SDL_GetWindowDisplayIndex( screen );
if( SDL_GetDesktopDisplayMode( display, &desktopMode ) == 0 )
{
displayAspect = (float)desktopMode.w / (float)desktopMode.h;
Com_Printf( "Display aspect: %.3f\n", displayAspect );
}
else
{
Com_Memset( &desktopMode, 0, sizeof( SDL_DisplayMode ) );
Com_Printf( "Cannot determine display aspect, assuming 1.333\n" );
}
Com_Printf( "...setting mode %d:", mode );
if (mode == -2)
{
// use desktop video resolution
if( desktopMode.h > 0 )
{
glConfig->vidWidth = desktopMode.w;
glConfig->vidHeight = desktopMode.h;
}
else
{
glConfig->vidWidth = 640;
glConfig->vidHeight = 480;
Com_Printf( "Cannot determine display resolution, assuming 640x480\n" );
}
//glConfig.windowAspect = (float)glConfig.vidWidth / (float)glConfig.vidHeight;
}
else if ( !R_GetModeInfo( &glConfig->vidWidth, &glConfig->vidHeight, /*&glConfig.windowAspect,*/ mode ) )
{
Com_Printf( " invalid mode\n" );
SDL_FreeSurface( icon );
return RSERR_INVALID_MODE;
}
Com_Printf( " %d %d\n", glConfig->vidWidth, glConfig->vidHeight);
// Center window
if( r_centerWindow->integer && !fullscreen )
{
x = ( desktopMode.w / 2 ) - ( glConfig->vidWidth / 2 );
y = ( desktopMode.h / 2 ) - ( glConfig->vidHeight / 2 );
}
// Destroy existing state if it exists
if( opengl_context != NULL )
{
SDL_GL_DeleteContext( opengl_context );
opengl_context = NULL;
}
if( screen != NULL )
{
SDL_GetWindowPosition( screen, &x, &y );
Com_DPrintf( "Existing window at %dx%d before being destroyed\n", x, y );
SDL_DestroyWindow( screen );
screen = NULL;
}
if( fullscreen )
{
flags |= SDL_WINDOW_FULLSCREEN;
glConfig->isFullscreen = qtrue;
}
else
{
if( noborder )
flags |= SDL_WINDOW_BORDERLESS;
glConfig->isFullscreen = qfalse;
}
colorBits = r_colorbits->integer;
if ((!colorBits) || (colorBits >= 32))
colorBits = 24;
if (!r_depthbits->integer)
depthBits = 24;
else
depthBits = r_depthbits->integer;
stencilBits = r_stencilbits->integer;
samples = r_ext_multisample->integer;
if ( windowDesc->api == GRAPHICS_API_OPENGL )
{
for (i = 0; i < 16; i++)
{
int testColorBits, testDepthBits, testStencilBits;
// 0 - default
// 1 - minus colorBits
// 2 - minus depthBits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2 :
if (colorBits == 24)
colorBits = 16;
break;
case 1 :
if (depthBits == 24)
depthBits = 16;
else if (depthBits == 16)
depthBits = 8;
case 3 :
if (stencilBits == 24)
stencilBits = 16;
else if (stencilBits == 16)
stencilBits = 8;
}
}
testColorBits = colorBits;
testDepthBits = depthBits;
testStencilBits = stencilBits;
if ((i % 4) == 3)
{ // reduce colorBits
if (testColorBits == 24)
testColorBits = 16;
}
if ((i % 4) == 2)
{ // reduce depthBits
if (testDepthBits == 24)
testDepthBits = 16;
else if (testDepthBits == 16)
testDepthBits = 8;
}
if ((i % 4) == 1)
{ // reduce stencilBits
if (testStencilBits == 24)
testStencilBits = 16;
else if (testStencilBits == 16)
testStencilBits = 8;
else
testStencilBits = 0;
}
if (testColorBits == 24)
perChannelColorBits = 8;
else
perChannelColorBits = 4;
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, testDepthBits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, testStencilBits );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );
if ( windowDesc->gl.majorVersion )
{
int compactVersion = windowDesc->gl.majorVersion * 100 + windowDesc->gl.minorVersion * 10;
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, windowDesc->gl.majorVersion );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, windowDesc->gl.minorVersion );
if ( windowDesc->gl.profile == GLPROFILE_ES || compactVersion >= 320 )
{
int profile;
switch ( windowDesc->gl.profile )
{
default:
case GLPROFILE_COMPATIBILITY:
profile = SDL_GL_CONTEXT_PROFILE_COMPATIBILITY;
break;
case GLPROFILE_CORE:
profile = SDL_GL_CONTEXT_PROFILE_CORE;
break;
case GLPROFILE_ES:
profile = SDL_GL_CONTEXT_PROFILE_ES;
break;
}
SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, profile );
}
}
if ( windowDesc->gl.contextFlags & GLCONTEXT_DEBUG )
{
SDL_GL_SetAttribute( SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG );
}
if(r_stereo->integer)
{
glConfig->stereoEnabled = qtrue;
SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
}
else
{
glConfig->stereoEnabled = qfalse;
SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
if( ( screen = SDL_CreateWindow( windowTitle, x, y,
glConfig->vidWidth, glConfig->vidHeight, flags ) ) == NULL )
{
Com_DPrintf( "SDL_CreateWindow failed: %s\n", SDL_GetError( ) );
continue;
}
#ifndef MACOS_X
SDL_SetWindowIcon( screen, icon );
#endif
if( fullscreen )
{
SDL_DisplayMode mode;
switch( testColorBits )
{
case 16: mode.format = SDL_PIXELFORMAT_RGB565; break;
case 24: mode.format = SDL_PIXELFORMAT_RGB24; break;
default: Com_DPrintf( "testColorBits is %d, can't fullscreen\n", testColorBits ); continue;
}
mode.w = glConfig->vidWidth;
mode.h = glConfig->vidHeight;
mode.refresh_rate = glConfig->displayFrequency = r_displayRefresh->integer;
mode.driverdata = NULL;
if( SDL_SetWindowDisplayMode( screen, &mode ) < 0 )
{
Com_DPrintf( "SDL_SetWindowDisplayMode failed: %s\n", SDL_GetError( ) );
continue;
}
}
if( ( opengl_context = SDL_GL_CreateContext( screen ) ) == NULL )
{
Com_Printf( "SDL_GL_CreateContext failed: %s\n", SDL_GetError( ) );
continue;
}
SDL_GL_SetSwapInterval( r_swapInterval->integer );
glConfig->colorBits = testColorBits;
glConfig->depthBits = testDepthBits;
glConfig->stencilBits = testStencilBits;
Com_Printf( "Using %d color bits, %d depth, %d stencil display.\n",
glConfig->colorBits, glConfig->depthBits, glConfig->stencilBits );
break;
}
}
else
{
// Just create a regular window
if( ( screen = SDL_CreateWindow( windowTitle, x, y,
glConfig->vidWidth, glConfig->vidHeight, flags ) ) == NULL )
{
Com_DPrintf( "SDL_CreateWindow failed: %s\n", SDL_GetError( ) );
}
else
{
#ifndef MACOS_X
SDL_SetWindowIcon( screen, icon );
#endif
if( fullscreen )
{
if( SDL_SetWindowDisplayMode( screen, NULL ) < 0 )
{
Com_DPrintf( "SDL_SetWindowDisplayMode failed: %s\n", SDL_GetError( ) );
}
}
}
}
SDL_FreeSurface( icon );
if (!GLimp_DetectAvailableModes())
{
return RSERR_UNKNOWN;
}
return RSERR_OK;
}
/*
===============
GLimp_SetMode
===============
*/
static int GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder)
{
const char* glstring;
int sdlcolorbits;
int colorbits, depthbits, stencilbits;
int tcolorbits, tdepthbits, tstencilbits;
int samples;
int i = 0;
SDL_Surface *vidscreen = NULL;
Uint32 flags = SDL_OPENGL;
ri.Printf( PRINT_ALL, "Initializing OpenGL display\n");
if ( r_allowResize->integer )
flags |= SDL_RESIZABLE;
if( videoInfo == NULL )
{
static SDL_VideoInfo sVideoInfo;
static SDL_PixelFormat sPixelFormat;
videoInfo = SDL_GetVideoInfo( );
// Take a copy of the videoInfo
Com_Memcpy( &sPixelFormat, videoInfo->vfmt, sizeof( SDL_PixelFormat ) );
sPixelFormat.palette = NULL; // Should already be the case
Com_Memcpy( &sVideoInfo, videoInfo, sizeof( SDL_VideoInfo ) );
sVideoInfo.vfmt = &sPixelFormat;
videoInfo = &sVideoInfo;
if( videoInfo->current_h > 0 )
{
// Guess the display aspect ratio through the desktop resolution
// by assuming (relatively safely) that it is set at or close to
// the display's native aspect ratio
displayAspect = (float)videoInfo->current_w / (float)videoInfo->current_h;
ri.Printf( PRINT_ALL, "Estimated display aspect: %.3f\n", displayAspect );
#ifdef __ANDROID__
R_SetNativeModeInfo( videoInfo->current_w, videoInfo->current_h );
#endif
}
else
{
ri.Printf( PRINT_ALL,
"Cannot estimate display aspect, assuming 1.333\n" );
}
}
ri.Printf (PRINT_ALL, "...setting mode %d:", mode );
if (mode == -2)
{
// use desktop video resolution
if( videoInfo->current_h > 0 )
{
glConfig.vidWidth = videoInfo->current_w;
glConfig.vidHeight = videoInfo->current_h;
}
else
{
glConfig.vidWidth = 640;
glConfig.vidHeight = 480;
ri.Printf( PRINT_ALL,
"Cannot determine display resolution, assuming 640x480\n" );
}
glConfig.windowAspect = (float)glConfig.vidWidth / (float)glConfig.vidHeight;
}
else 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\n", glConfig.vidWidth, glConfig.vidHeight);
if (fullscreen)
{
flags |= SDL_FULLSCREEN;
glConfig.isFullscreen = qtrue;
}
else
{
if (noborder)
flags |= SDL_NOFRAME;
glConfig.isFullscreen = qfalse;
}
colorbits = r_colorbits->value;
if ((!colorbits) || (colorbits >= 32))
colorbits = 24;
if (!r_depthbits->value)
depthbits = 24;
else
depthbits = r_depthbits->value;
stencilbits = r_stencilbits->value;
samples = r_ext_multisample->value;
for (i = 0; i < 16; i++)
{
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2 :
if (colorbits == 24)
colorbits = 16;
break;
case 1 :
if (depthbits == 24)
depthbits = 16;
else if (depthbits == 16)
depthbits = 8;
case 3 :
if (stencilbits == 24)
stencilbits = 16;
else if (stencilbits == 16)
stencilbits = 8;
}
}
tcolorbits = colorbits;
tdepthbits = depthbits;
tstencilbits = stencilbits;
if ((i % 4) == 3)
{ // reduce colorbits
if (tcolorbits == 24)
tcolorbits = 16;
}
if ((i % 4) == 2)
{ // reduce depthbits
if (tdepthbits == 24)
tdepthbits = 16;
else if (tdepthbits == 16)
tdepthbits = 8;
}
if ((i % 4) == 1)
{ // reduce stencilbits
if (tstencilbits == 24)
tstencilbits = 16;
else if (tstencilbits == 16)
tstencilbits = 8;
else
tstencilbits = 0;
}
sdlcolorbits = 4;
if (tcolorbits == 24)
sdlcolorbits = 8;
#ifdef __sgi /* Fix for SGIs grabbing too many bits of color */
if (sdlcolorbits == 4)
sdlcolorbits = 0; /* Use minimum size for 16-bit color */
/* Need alpha or else SGIs choose 36+ bit RGB mode */
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 1);
#endif
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, tdepthbits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, tstencilbits );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );
if(r_stereoEnabled->integer)
{
glConfig.stereoEnabled = qtrue;
SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
}
else
{
glConfig.stereoEnabled = qfalse;
SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
#if 0 // See http://bugzilla.icculus.org/show_bug.cgi?id=3526
// If not allowing software GL, demand accelerated
if( !r_allowSoftwareGL->integer )
{
if( SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 ) < 0 )
{
ri.Printf( PRINT_ALL, "Unable to guarantee accelerated "
"visual with libSDL < 1.2.10\n" );
}
}
#endif
if( SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, r_swapInterval->integer ) < 0 )
ri.Printf( PRINT_ALL, "r_swapInterval requires libSDL >= 1.2.10\n" );
#ifdef USE_ICON
{
SDL_Surface *icon = SDL_CreateRGBSurfaceFrom(
(void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
SDL_WM_SetIcon( icon, NULL );
SDL_FreeSurface( icon );
}
#endif
SDL_WM_SetCaption(CLIENT_WINDOW_TITLE, CLIENT_WINDOW_MIN_TITLE);
SDL_ShowCursor(0);
if (!(vidscreen = SDL_SetVideoMode(glConfig.vidWidth, glConfig.vidHeight, colorbits, flags)))
{
ri.Printf( PRINT_DEVELOPER, "SDL_SetVideoMode failed: %s\n", SDL_GetError( ) );
continue;
}
opengl_context = GLimp_GetCurrentContext();
ri.Printf( PRINT_ALL, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
sdlcolorbits, sdlcolorbits, sdlcolorbits, tdepthbits, tstencilbits);
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
GLimp_DetectAvailableModes();
if (!vidscreen)
{
ri.Printf( PRINT_ALL, "Couldn't get a visual\n" );
return RSERR_INVALID_MODE;
}
screen = vidscreen;
glstring = (char *) qglGetString (GL_RENDERER);
ri.Printf( PRINT_ALL, "GL_RENDERER: %s\n", glstring );
return RSERR_OK;
}
/*
===============
GLimp_SetMode
===============
*/
static int GLimp_SetMode( int mode, int fullscreen, int noborder )
{
int sdlcolorbits;
int colorbits, depthbits, stencilbits;
int tcolorbits, tdepthbits, tstencilbits;
int i = 0;
SDL_Surface *vidscreen = NULL;
Uint32 flags = 0;
const SDL_VideoInfo *videoInfo;
ri.Printf( PRINT_ALL, "Initializing Direct3D display\n" );
if ( r_allowResize->integer )
{
flags |= SDL_RESIZABLE;
}
if ( displayAspect == 0.0f )
{
#if !SDL_VERSION_ATLEAST(1, 2, 10)
// 1.2.10 is needed to get the desktop resolution
displayAspect = 4.0f / 3.0f;
#else
// Guess the display aspect ratio through the desktop resolution
// by assuming (relatively safely) that it is set at or close to
// the display's native aspect ratio
videoInfo = SDL_GetVideoInfo();
displayAspect = ( float ) videoInfo->current_w / ( float ) videoInfo->current_h;
#endif
ri.Printf( PRINT_ALL, "Estimated display aspect: %.3f\n", displayAspect );
}
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\n", glConfig.vidWidth, glConfig.vidHeight );
if ( fullscreen )
{
flags |= SDL_FULLSCREEN;
glConfig.isFullscreen = qtrue;
}
else
{
glConfig.isFullscreen = qfalse;
}
if ( !r_colorbits->value )
{
colorbits = 24;
}
else
{
colorbits = r_colorbits->value;
}
if ( !r_depthbits->value )
{
depthbits = 24;
}
else
{
depthbits = r_depthbits->value;
}
stencilbits = r_stencilbits->value;
for ( i = 0; i < 16; i++ )
{
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ( ( i % 4 ) == 0 && i )
{
// one pass, reduce
switch ( i / 4 )
{
case 2:
if ( colorbits == 24 )
{
colorbits = 16;
}
break;
case 1:
if ( depthbits == 24 )
{
depthbits = 16;
}
else if ( depthbits == 16 )
{
depthbits = 8;
}
case 3:
if ( stencilbits == 24 )
{
stencilbits = 16;
}
else if ( stencilbits == 16 )
{
stencilbits = 8;
}
}
}
tcolorbits = colorbits;
tdepthbits = depthbits;
tstencilbits = stencilbits;
if ( ( i % 4 ) == 3 )
{
// reduce colorbits
if ( tcolorbits == 24 )
{
tcolorbits = 16;
}
}
if ( ( i % 4 ) == 2 )
{
// reduce depthbits
if ( tdepthbits == 24 )
{
tdepthbits = 16;
}
else if ( tdepthbits == 16 )
{
tdepthbits = 8;
}
}
if ( ( i % 4 ) == 1 )
{
// reduce stencilbits
if ( tstencilbits == 24 )
{
tstencilbits = 16;
}
else if ( tstencilbits == 16 )
{
tstencilbits = 8;
}
else
{
tstencilbits = 0;
}
}
sdlcolorbits = 4;
if ( tcolorbits == 24 )
{
sdlcolorbits = 8;
}
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, tdepthbits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, tstencilbits );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
if ( SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, r_swapInterval->integer ) < 0 )
{
ri.Printf( PRINT_ALL, "r_swapInterval requires libSDL >= 1.2.10\n" );
}
#ifdef USE_ICON
{
SDL_Surface *icon = SDL_CreateRGBSurfaceFrom( ( void * ) CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
SDL_WM_SetIcon( icon, NULL );
SDL_FreeSurface( icon );
}
#endif
SDL_WM_SetCaption( CLIENT_WINDOW_TITLE, CLIENT_WINDOW_MIN_TITLE );
SDL_ShowCursor( 0 );
if ( !( vidscreen = SDL_SetVideoMode( glConfig.vidWidth, glConfig.vidHeight, colorbits, flags ) ) )
{
ri.Printf( PRINT_DEVELOPER, "SDL_SetVideoMode failed: %s\n", SDL_GetError() );
continue;
}
//GLimp_GetCurrentContext();
ri.Printf( PRINT_ALL, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
sdlcolorbits, sdlcolorbits, sdlcolorbits, tdepthbits, tstencilbits );
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
GLimp_DetectAvailableModes();
if ( !vidscreen )
{
ri.Printf( PRINT_ALL, "Couldn't get a visual\n" );
return RSERR_INVALID_MODE;
}
screen = vidscreen;
//glstring = (char *)qglGetString(GL_RENDERER);
//ri.Printf(PRINT_ALL, "GL_RENDERER: %s\n", glstring);
return RSERR_OK;
}
/**
* @brief GLimp_SetMode
* @param[in,out] glConfig
* @param[in] mode
* @param[in] fullscreen
* @param[in] noborder
* @param[in] context
* @return
*/
static int GLimp_SetMode(glconfig_t *glConfig, int mode, qboolean fullscreen, qboolean noborder, windowContext_t *context)
{
int perChannelColorBits;
int colorBits, depthBits, stencilBits;
int samples;
int i = 0;
SDL_Surface *icon = NULL;
SDL_DisplayMode desktopMode;
int display = 0;
int x = SDL_WINDOWPOS_UNDEFINED, y = SDL_WINDOWPOS_UNDEFINED;
Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_INPUT_GRABBED;
Com_Printf("Initializing OpenGL display\n");
if (r_allowResize->integer && !fullscreen)
{
flags |= SDL_WINDOW_RESIZABLE;
}
icon = SDL_CreateRGBSurfaceFrom(
(void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
// If a window exists, note its display index
if (main_window != NULL)
{
display = SDL_GetWindowDisplayIndex(main_window);
}
if (SDL_GetDesktopDisplayMode(display, &desktopMode) == 0)
{
displayAspect = (double)desktopMode.w / (double)desktopMode.h;
Com_Printf("Estimated display aspect: %.3f\n", displayAspect);
}
else
{
Com_Memset(&desktopMode, 0, sizeof(SDL_DisplayMode));
Com_Printf("Cannot estimate display aspect, assuming 1.333\n");
}
Com_Printf("...setting mode %d: ", mode);
if (mode == -2)
{
// use desktop video resolution
if (desktopMode.h > 0)
{
glConfig->vidWidth = desktopMode.w;
glConfig->vidHeight = desktopMode.h;
}
else
{
glConfig->vidWidth = 640;
glConfig->vidHeight = 480;
Com_Printf("Cannot determine display resolution, assuming 640x480\n");
}
glConfig->windowAspect = (float)glConfig->vidWidth / (float)glConfig->vidHeight;
}
else if (!GLimp_GetModeInfo(&glConfig->vidWidth, &glConfig->vidHeight, &glConfig->windowAspect, mode))
{
Com_Printf("invalid mode\n");
return RSERR_INVALID_MODE;
}
Com_Printf("%dx%d\n", glConfig->vidWidth, glConfig->vidHeight);
// Center window
if (r_centerWindow->integer && !fullscreen)
{
x = (desktopMode.w / 2) - (glConfig->vidWidth / 2);
y = (desktopMode.h / 2) - (glConfig->vidHeight / 2);
}
// Destroy existing state if it exists
if (SDL_glContext != NULL)
{
SDL_GL_DeleteContext(SDL_glContext);
SDL_glContext = NULL;
}
if (main_window != NULL)
{
SDL_GetWindowPosition(main_window, &x, &y);
Com_Printf(S_COLOR_YELLOW "Existing window at %dx%d before being destroyed\n", x, y);
SDL_DestroyWindow(main_window);
main_window = NULL;
}
if (fullscreen)
{
if (r_mode->integer == -2)
{
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
}
else
{
flags |= SDL_WINDOW_FULLSCREEN;
}
glConfig->isFullscreen = qtrue;
}
else
{
if (noborder)
{
flags |= SDL_WINDOW_BORDERLESS;
}
glConfig->isFullscreen = qfalse;
}
colorBits = r_colorbits->integer;
if ((!colorBits) || (colorBits >= 32))
{
colorBits = 24;
}
if (r_depthbits->value == 0.f)
{
depthBits = 24;
}
else
{
depthBits = r_depthbits->integer;
}
stencilBits = r_stencilbits->integer;
samples = r_ext_multisample->integer;
for (i = 0; i < 16; i++)
{
int testColorBits, testDepthBits, testStencilBits;
// 0 - default
// 1 - minus colorBits
// 2 - minus depthBits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2:
if (colorBits == 24)
{
colorBits = 16;
}
break;
case 1:
if (depthBits == 32)
{
depthBits = 24;
}
else if (depthBits == 24)
{
depthBits = 16;
}
else if (depthBits == 16)
{
depthBits = 8;
}
case 3: // fall through
if (stencilBits == 24)
{
stencilBits = 16;
}
else if (stencilBits == 16)
{
stencilBits = 8;
}
}
}
testColorBits = colorBits;
testDepthBits = depthBits;
testStencilBits = stencilBits;
if ((i % 4) == 3) // reduce colorbits
{
if (testColorBits == 24)
{
testColorBits = 16;
}
}
if ((i % 4) == 2) // reduce depthbits
{
if (testDepthBits == 24)
{
testDepthBits = 16;
}
else if (testDepthBits == 16)
{
testDepthBits = 8;
}
}
if ((i % 4) == 1) // reduce stencilbits
{
if (testStencilBits == 24)
{
testStencilBits = 16;
}
else if (testStencilBits == 16)
{
testStencilBits = 8;
}
else
{
testStencilBits = 0;
}
}
if (testColorBits == 24)
{
perChannelColorBits = 8;
}
else
{
perChannelColorBits = 4;
}
#ifdef __sgi // Fix for SGIs grabbing too many bits of color
if (perChannelColorBits == 4)
{
perChannelColorBits = 0; /* Use minimum size for 16-bit color */
}
// Need alpha or else SGIs choose 36+ bit RGB mode
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 1);
#endif
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, perChannelColorBits);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, perChannelColorBits);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, perChannelColorBits);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, testDepthBits);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, testStencilBits);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, samples);
// SDL2 uses opengl by default, if we want opengl es we need to set this attribute
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_EGL, 1);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// If not allowing software GL, demand accelerated
if (!r_allowSoftwareGL->integer)
{
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
}
main_window = SDL_CreateWindow(CLIENT_WINDOW_TITLE, x, y, glConfig->vidWidth, glConfig->vidHeight, flags | SDL_WINDOW_SHOWN);
if (!main_window)
{
Com_Printf("SDL_CreateWindow failed: %s\n", SDL_GetError());
continue;
}
if (fullscreen)
{
SDL_DisplayMode modefullScreen;
switch (testColorBits)
{
case 16: modefullScreen.format = SDL_PIXELFORMAT_RGB565; break;
case 24: modefullScreen.format = SDL_PIXELFORMAT_RGB24; break;
default: Com_Printf("SDL_SetWindowDisplayMode failed: testColorBits is %d, can't fullscreen\n", testColorBits); continue;
}
modefullScreen.w = glConfig->vidWidth;
modefullScreen.h = glConfig->vidHeight;
modefullScreen.refresh_rate = glConfig->displayFrequency = r_displayRefresh->integer;
modefullScreen.driverdata = NULL;
if (SDL_SetWindowDisplayMode(main_window, &modefullScreen) < 0)
{
Com_Printf("SDL_SetWindowDisplayMode failed: %s\n", SDL_GetError());
continue;
}
}
SDL_SetWindowIcon(main_window, icon);
if (context && context->versionMajor > 0)
{
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, context->versionMajor);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, context->versionMinor);
switch (context->context)
{
case GL_CONTEXT_COMP:
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
break;
case GL_CONTEXT_CORE:
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
break;
case GL_CONTEXT_EGL:
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
break;
case GL_CONTEXT_DEFAULT:
default:
break;
}
}
if ((SDL_glContext = SDL_GL_CreateContext(main_window)) == NULL)
{
Com_Printf("SDL_GL_CreateContext failed: %s\n", SDL_GetError());
continue;
}
if (SDL_GL_MakeCurrent(main_window, SDL_glContext) < 0)
{
Com_Printf("SDL_GL_MakeCurrent failed: %s\n", SDL_GetError());
}
if (SDL_GL_SetSwapInterval(r_swapInterval->integer) == -1)
{
Com_Printf("SDL_GL_SetSwapInterval failed: %s\n", SDL_GetError());
}
glConfig->colorBits = testColorBits;
glConfig->depthBits = testDepthBits;
glConfig->stencilBits = testStencilBits;
Com_Printf("Using %d color bits, %d depth, %d stencil display.\n",
glConfig->colorBits, glConfig->depthBits, glConfig->stencilBits);
break;
}
GLimp_DetectAvailableModes();
if (!main_window) //|| !main_renderer)
{
Com_Printf("Couldn't get a visual\n");
return RSERR_INVALID_MODE;
}
if (!re.InitOpenGLSubSystem())
{
Com_Printf("Too old openGL driver or hardware");
return RSERR_OLD_GL;
}
SDL_FreeSurface(icon);
return RSERR_OK;
}
/*
===============
GLimp_SetMode
===============
*/
static int GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder)
{
const char *glstring;
int sdlcolorbits;
int colorbits, depthbits, stencilbits;
int tcolorbits, tdepthbits, tstencilbits;
int i = 0;
SDL_Surface *vidscreen = NULL;
Uint32 flags = SDL_OPENGL;
GLenum glewResult;
ri.Printf(PRINT_ALL, "Initializing OpenGL display\n");
if(r_allowResize->integer)
flags |= SDL_RESIZABLE;
if(videoInfo == NULL)
{
static SDL_VideoInfo sVideoInfo;
static SDL_PixelFormat sPixelFormat;
videoInfo = SDL_GetVideoInfo();
// Take a copy of the videoInfo
Com_Memcpy(&sPixelFormat, videoInfo->vfmt, sizeof(SDL_PixelFormat));
sPixelFormat.palette = NULL; // Should already be the case
Com_Memcpy(&sVideoInfo, videoInfo, sizeof(SDL_VideoInfo));
sVideoInfo.vfmt = &sPixelFormat;
videoInfo = &sVideoInfo;
if(videoInfo->current_h > 0)
{
// Guess the display aspect ratio through the desktop resolution
// by assuming (relatively safely) that it is set at or close to
// the display's native aspect ratio
displayAspect = (float)videoInfo->current_w / (float)videoInfo->current_h;
ri.Printf(PRINT_ALL, "Estimated display aspect: %.3f\n", displayAspect);
}
else
{
ri.Printf(PRINT_ALL, "Cannot estimate display aspect, assuming 1.333\n");
}
}
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\n", glConfig.vidWidth, glConfig.vidHeight);
if(fullscreen)
{
flags |= SDL_FULLSCREEN;
glConfig.isFullscreen = qtrue;
}
else
{
if(noborder)
flags |= SDL_NOFRAME;
glConfig.isFullscreen = qfalse;
}
colorbits = r_colorbits->value;
if((!colorbits) || (colorbits >= 32))
colorbits = 24;
if(!r_depthbits->value)
depthbits = 24;
else
depthbits = r_depthbits->value;
stencilbits = r_stencilbits->value;
for(i = 0; i < 16; i++)
{
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2:
if(colorbits == 24)
colorbits = 16;
break;
case 1:
if(depthbits == 24)
depthbits = 16;
else if(depthbits == 16)
depthbits = 8;
case 3:
if(stencilbits == 24)
stencilbits = 16;
else if(stencilbits == 16)
stencilbits = 8;
}
}
tcolorbits = colorbits;
tdepthbits = depthbits;
tstencilbits = stencilbits;
if((i % 4) == 3)
{ // reduce colorbits
if(tcolorbits == 24)
tcolorbits = 16;
}
if((i % 4) == 2)
{ // reduce depthbits
if(tdepthbits == 24)
tdepthbits = 16;
else if(tdepthbits == 16)
tdepthbits = 8;
}
if((i % 4) == 1)
{ // reduce stencilbits
if(tstencilbits == 24)
tstencilbits = 16;
else if(tstencilbits == 16)
tstencilbits = 8;
else
tstencilbits = 0;
}
sdlcolorbits = 4;
if(tcolorbits == 24)
sdlcolorbits = 8;
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, sdlcolorbits);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, sdlcolorbits);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, sdlcolorbits);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, tdepthbits);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, tstencilbits);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
if(SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, r_swapInterval->integer) < 0)
ri.Printf(PRINT_ALL, "r_swapInterval requires libSDL >= 1.2.10\n");
#ifdef USE_ICON
{
SDL_Surface *icon = SDL_CreateRGBSurfaceFrom((void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
SDL_WM_SetIcon(icon, NULL);
SDL_FreeSurface(icon);
}
#endif
SDL_WM_SetCaption(CLIENT_WINDOW_TITLE, CLIENT_WINDOW_MIN_TITLE);
SDL_ShowCursor(0);
if(!(vidscreen = SDL_SetVideoMode(glConfig.vidWidth, glConfig.vidHeight, colorbits, flags)))
{
ri.Printf(PRINT_DEVELOPER, "SDL_SetVideoMode failed: %s\n", SDL_GetError());
continue;
}
ri.Printf(PRINT_ALL, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
sdlcolorbits, sdlcolorbits, sdlcolorbits, tdepthbits, tstencilbits);
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
glewResult = glewInit();
if(GLEW_OK != glewResult)
{
// glewInit failed, something is seriously wrong
ri.Error(ERR_FATAL, "GLW_StartOpenGL() - could not load OpenGL subsystem: %s", glewGetErrorString(glewResult));
}
else
{
ri.Printf(PRINT_ALL, "Using GLEW %s\n", glewGetString(GLEW_VERSION));
}
GLimp_InitOpenGL3xContext();
GLimp_DetectAvailableModes();
if(!vidscreen)
{
ri.Printf(PRINT_ALL, "Couldn't get a visual\n");
return RSERR_INVALID_MODE;
}
screen = vidscreen;
glstring = (char *)glGetString(GL_RENDERER);
ri.Printf(PRINT_ALL, "GL_RENDERER: %s\n", glstring);
return RSERR_OK;
}
/*
===============
GLimp_SetMode
===============
*/
static rserr_t GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder)
{
const char *glstring;
int perChannelColorBits;
int colorBits, depthBits, stencilBits;
int samples;
int i = 0;
SDL_Surface *icon = NULL;
Uint32 flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
SDL_DisplayMode desktopMode;
int display = 0;
int x = 0, y = 0;
Com_Printf( "Initializing OpenGL display\n");
if ( r_allowResize->integer )
flags |= SDL_WINDOW_RESIZABLE;
/*icon = SDL_CreateRGBSurfaceFrom(
(void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);*/
// If a window exists, note its display index
if( screen != NULL )
display = SDL_GetWindowDisplayIndex( screen );
if( SDL_GetDesktopDisplayMode( display, &desktopMode ) == 0 )
{
displayAspect = (float)desktopMode.w / (float)desktopMode.h;
Com_Printf( "Display aspect: %.3f\n", displayAspect );
}
else
{
Com_Memset( &desktopMode, 0, sizeof( SDL_DisplayMode ) );
Com_Printf( "Cannot determine display aspect, assuming 1.333\n" );
}
Com_Printf( "...setting mode %d:", mode );
if (mode == -2)
{
// use desktop video resolution
if( desktopMode.h > 0 )
{
glConfig.vidWidth = desktopMode.w;
glConfig.vidHeight = desktopMode.h;
}
else
{
glConfig.vidWidth = 640;
glConfig.vidHeight = 480;
Com_Printf( "Cannot determine display resolution, assuming 640x480\n" );
}
//glConfig.windowAspect = (float)glConfig.vidWidth / (float)glConfig.vidHeight;
}
else if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, /*&glConfig.windowAspect,*/ mode ) )
{
Com_Printf( " invalid mode\n" );
return RSERR_INVALID_MODE;
}
Com_Printf( " %d %d\n", glConfig.vidWidth, glConfig.vidHeight);
// Center window
if( r_centerWindow->integer && !fullscreen )
{
x = ( desktopMode.w / 2 ) - ( glConfig.vidWidth / 2 );
y = ( desktopMode.h / 2 ) - ( glConfig.vidHeight / 2 );
}
// Destroy existing state if it exists
if( opengl_context != NULL )
{
SDL_GL_DeleteContext( opengl_context );
opengl_context = NULL;
}
if( screen != NULL )
{
SDL_GetWindowPosition( screen, &x, &y );
ri.Printf( PRINT_DEVELOPER, "Existing window at %dx%d before being destroyed\n", x, y );
SDL_DestroyWindow( screen );
screen = NULL;
}
if( fullscreen )
{
flags |= SDL_WINDOW_FULLSCREEN;
glConfig.isFullscreen = qtrue;
}
else
{
if( noborder )
flags |= SDL_WINDOW_BORDERLESS;
glConfig.isFullscreen = qfalse;
}
colorBits = r_colorbits->value;
if ((!colorBits) || (colorBits >= 32))
colorBits = 24;
if (!r_depthbits->value)
depthBits = 24;
else
depthBits = r_depthbits->value;
stencilBits = r_stencilbits->value;
//samples = r_ext_multisample->value;
for (i = 0; i < 16; i++)
{
int testColorBits, testDepthBits, testStencilBits;
// 0 - default
// 1 - minus colorBits
// 2 - minus depthBits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2 :
if (colorBits == 24)
colorBits = 16;
break;
case 1 :
if (depthBits == 24)
depthBits = 16;
else if (depthBits == 16)
depthBits = 8;
case 3 :
if (stencilBits == 24)
stencilBits = 16;
else if (stencilBits == 16)
stencilBits = 8;
}
}
testColorBits = colorBits;
testDepthBits = depthBits;
testStencilBits = stencilBits;
if ((i % 4) == 3)
{ // reduce colorBits
if (testColorBits == 24)
testColorBits = 16;
}
if ((i % 4) == 2)
{ // reduce depthBits
if (testDepthBits == 24)
testDepthBits = 16;
else if (testDepthBits == 16)
testDepthBits = 8;
}
if ((i % 4) == 1)
{ // reduce stencilBits
if (testStencilBits == 24)
testStencilBits = 16;
else if (testStencilBits == 16)
testStencilBits = 8;
else
testStencilBits = 0;
}
if (testColorBits == 24)
perChannelColorBits = 8;
else
perChannelColorBits = 4;
#ifdef __sgi /* Fix for SGIs grabbing too many bits of color */
if (perChannelColorBits == 4)
perChannelColorBits = 0; /* Use minimum size for 16-bit color */
/* Need alpha or else SGIs choose 36+ bit RGB mode */
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 1);
#endif
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, testDepthBits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, testStencilBits );
/*SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );*/
if(r_stereo->integer)
{
glConfig.stereoEnabled = qtrue;
SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
}
else
{
glConfig.stereoEnabled = qfalse;
SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
// If not allowing software GL, demand accelerated
if( !r_allowSoftwareGL->integer )
SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
if( ( screen = SDL_CreateWindow( CLIENT_WINDOW_TITLE, x, y,
glConfig.vidWidth, glConfig.vidHeight, flags ) ) == 0 )
{
ri.Printf( PRINT_DEVELOPER, "SDL_CreateWindow failed: %s\n", SDL_GetError( ) );
continue;
}
if( fullscreen )
{
SDL_DisplayMode mode;
switch( testColorBits )
{
case 16: mode.format = SDL_PIXELFORMAT_RGB565; break;
case 24: mode.format = SDL_PIXELFORMAT_RGB24; break;
default: ri.Printf( PRINT_DEVELOPER, "testColorBits is %d, can't fullscreen\n", testColorBits ); continue;
}
mode.w = glConfig.vidWidth;
mode.h = glConfig.vidHeight;
mode.refresh_rate = glConfig.displayFrequency = ri.Cvar_VariableIntegerValue( "r_displayRefresh" );
mode.driverdata = NULL;
if( SDL_SetWindowDisplayMode( screen, &mode ) < 0 )
{
ri.Printf( PRINT_DEVELOPER, "SDL_SetWindowDisplayMode failed: %s\n", SDL_GetError( ) );
continue;
}
}
SDL_SetWindowTitle( screen, CLIENT_WINDOW_TITLE );
SDL_SetWindowIcon( screen, icon );
if( ( opengl_context = (QGLContext)SDL_GL_CreateContext( screen ) ) == NULL )
{
Com_Printf( "SDL_GL_CreateContext failed: %s\n", SDL_GetError( ) );
continue;
}
if( SDL_GL_MakeCurrent( screen, opengl_context ) < 0 )
{
Com_Printf( "SDL_GL_MakeCurrent failed: %s\n", SDL_GetError( ) );
continue;
}
SDL_GL_SetSwapInterval( r_swapInterval->integer );
glConfig.colorBits = testColorBits;
glConfig.depthBits = testDepthBits;
glConfig.stencilBits = testStencilBits;
Com_Printf( "Using %d color bits, %d depth, %d stencil display.\n",
glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits );
break;
}
/*SDL_FreeSurface( icon );*/
GLimp_DetectAvailableModes();
glstring = (char *) qglGetString (GL_RENDERER);
Com_Printf( "GL_RENDERER: %s\n", glstring );
return RSERR_OK;
#if 0
const char* glstring;
int sdlcolorbits;
int colorbits, depthbits, stencilbits;
int tcolorbits, tdepthbits, tstencilbits;
int samples;
int i = 0;
Uint32 flags = SDL_WINDOW_OPENGL;
Com_Printf( "Initializing OpenGL display\n");
if ( r_allowResize->integer )
flags |= SDL_WINDOW_RESIZABLE;
if( videoInfo == NULL )
{
static SDL_DisplayMode sVideoInfo;
static SDL_PixelFormat sPixelFormat;
if (SDL_GetCurrentDisplayMode( 0, &sVideoInfo ) < 0)
Com_Error(ERR_FATAL, "SDL_GetCurrentDisplayMode failed : %s\n", SDL_GetError());
// Take a copy of the videoInfo
sPixelFormat.format = sVideoInfo.format;
sPixelFormat.palette = NULL; // Should already be the case
//Com_Memcpy( &sVideoInfo, videoInfo, sizeof( SDL_DisplayMode ) );
sVideoInfo.format = sPixelFormat.format;
videoInfo = &sVideoInfo;
if( videoInfo->h > 0 )
{
glConfig.displayWidth = videoInfo->w;
glConfig.displayHeight = videoInfo->h;
// Guess the display aspect ratio through the desktop resolution
// by assuming (relatively safely) that it is set at or close to
// the display's native aspect ratio
glConfig.displayAspect = (float)videoInfo->w / (float)videoInfo->h;
Com_Printf( "Estimated display aspect: %.3f\n", glConfig.displayAspect );
}
else
{
glConfig.displayWidth = 480;
glConfig.displayHeight = 640;
glConfig.displayAspect = 1.333f;
Com_Printf(
"Cannot estimate display resolution/aspect, assuming 640x480/1.333\n" );
}
}
Com_Printf( "...setting mode %d:", mode );
if (mode == -2)
{
// use desktop video resolution
if( videoInfo->h > 0 )
{
glConfig.vidWidth = videoInfo->w;
glConfig.vidHeight = videoInfo->h;
}
else
{
glConfig.vidWidth = 640;
glConfig.vidHeight = 480;
Com_Printf(
"Cannot determine display resolution, assuming 640x480\n" );
}
glConfig.displayAspect = (float)glConfig.vidWidth / (float)glConfig.vidHeight;
}
else if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, /*&glConfig.displayAspect,*/ mode ) )
{
Com_Printf( " invalid mode\n" );
return RSERR_INVALID_MODE;
}
Com_Printf( " %d %d\n", glConfig.vidWidth, glConfig.vidHeight);
if (fullscreen)
{
flags |= SDL_WINDOW_FULLSCREEN;
glConfig.isFullscreen = qtrue;
}
else
{
if (noborder)
flags |= SDL_WINDOW_BORDERLESS;
glConfig.isFullscreen = qfalse;
}
colorbits = r_colorbits->value;
if ((!colorbits) || (colorbits >= 32))
colorbits = 24;
if (!r_depthbits->value)
depthbits = 24;
else
depthbits = r_depthbits->value;
stencilbits = r_stencilbits->value;
//samples = r_ext_multisample->value;
for (i = 0; i < 16; i++)
{
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2 :
if (colorbits == 24)
colorbits = 16;
break;
case 1 :
if (depthbits == 24)
depthbits = 16;
else if (depthbits == 16)
depthbits = 8;
case 3 :
if (stencilbits == 24)
stencilbits = 16;
else if (stencilbits == 16)
stencilbits = 8;
}
}
tcolorbits = colorbits;
tdepthbits = depthbits;
tstencilbits = stencilbits;
if ((i % 4) == 3)
{ // reduce colorbits
if (tcolorbits == 24)
tcolorbits = 16;
}
if ((i % 4) == 2)
{ // reduce depthbits
if (tdepthbits == 24)
tdepthbits = 16;
else if (tdepthbits == 16)
tdepthbits = 8;
}
if ((i % 4) == 1)
{ // reduce stencilbits
if (tstencilbits == 24)
tstencilbits = 16;
else if (tstencilbits == 16)
tstencilbits = 8;
else
tstencilbits = 0;
}
sdlcolorbits = 4;
if (tcolorbits == 24)
sdlcolorbits = 8;
#ifdef __sgi /* Fix for SGIs grabbing too many bits of color */
if (sdlcolorbits == 4)
sdlcolorbits = 0; /* Use minimum size for 16-bit color */
/* Need alpha or else SGIs choose 36+ bit RGB mode */
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 1);
#endif
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, tdepthbits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, tstencilbits );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );
/*if(r_stereoEnabled->integer)
{
glConfig.stereoEnabled = qtrue;
SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
}
else
{*/
glConfig.stereoEnabled = qfalse;
SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
//}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
#if 0 // See http://bugzilla.icculus.org/show_bug.cgi?id=3526
// If not allowing software GL, demand accelerated
if( !r_allowSoftwareGL->integer )
{
if( SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 ) < 0 )
{
Com_Printf( "Unable to guarantee accelerated "
"visual with libSDL < 1.2.10\n" );
}
}
#endif
if( SDL_GL_SetSwapInterval(r_swapInterval->integer ) < 0 )
Com_Printf( "SDL_GL_SetSwapInterval not supported\n" );
#ifdef USE_ICON
{
SDL_Surface *icon = SDL_CreateRGBSurfaceFrom(
(void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
SDL_WM_SetIcon( icon, NULL );
SDL_FreeSurface( icon );
}
#endif
SDL_ShowCursor(0);
if (!(window = SDL_CreateWindow(CLIENT_WINDOW_TITLE, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, glConfig.vidWidth, glConfig.vidHeight, flags)))
{
Com_Printf( "SDL_CreateWindow failed: %s\n", SDL_GetError( ) );
continue;
}
opengl_context = SDL_GL_CreateContext(window);
Com_Printf( "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
sdlcolorbits, sdlcolorbits, sdlcolorbits, tdepthbits, tstencilbits);
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
GLimp_DetectAvailableModes();
if (!window)
{
Com_Printf( "Couldn't get a visual\n" );
return RSERR_INVALID_MODE;
}
screen = window;
// FIXME: Defines needed here
glstring = (char *) qglGetString (GL_RENDERER);
Com_Printf( "GL_RENDERER: %s\n", glstring );
return RSERR_OK;
#endif
}
/*
===============
GLimp_SetMode
===============
*/
static int GLimp_SetMode( int mode, bool fullscreen, bool noborder )
{
const char *glstring;
int perChannelColorBits;
int alphaBits, depthBits, stencilBits;
int samples;
int i = 0;
SDL_Surface *icon = nullptr;
SDL_DisplayMode desktopMode;
Uint32 flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
int x, y;
GLenum glewResult;
ri.Printf( PRINT_ALL, "Initializing OpenGL display\n" );
if ( r_allowResize->integer )
{
flags |= SDL_WINDOW_RESIZABLE;
}
if ( r_centerWindow->integer )
{
// center window on specified display
x = SDL_WINDOWPOS_CENTERED_DISPLAY( r_displayIndex->integer );
y = SDL_WINDOWPOS_CENTERED_DISPLAY( r_displayIndex->integer );
}
else
{
x = SDL_WINDOWPOS_UNDEFINED_DISPLAY( r_displayIndex->integer );
y = SDL_WINDOWPOS_UNDEFINED_DISPLAY( r_displayIndex->integer );
}
icon = SDL_CreateRGBSurfaceFrom( ( void * ) CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
if ( SDL_GetDesktopDisplayMode( r_displayIndex->integer, &desktopMode ) == 0 )
{
displayAspect = ( float ) desktopMode.w / ( float ) desktopMode.h;
ri.Printf( PRINT_ALL, "Display aspect: %.3f\n", displayAspect );
}
else
{
Com_Memset( &desktopMode, 0, sizeof( SDL_DisplayMode ) );
ri.Printf( PRINT_ALL, "Cannot determine display aspect (%s), assuming 1.333\n", SDL_GetError() );
}
ri.Printf( PRINT_ALL, "...setting mode %d:", mode );
if ( mode == -2 )
{
// use desktop video resolution
if ( desktopMode.h > 0 )
{
glConfig.vidWidth = desktopMode.w;
glConfig.vidHeight = desktopMode.h;
}
else
{
glConfig.vidWidth = 640;
glConfig.vidHeight = 480;
ri.Printf( PRINT_ALL, "Cannot determine display resolution, assuming 640x480\n" );
}
glConfig.windowAspect = ( float ) glConfig.vidWidth / ( float ) glConfig.vidHeight;
}
else 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\n", glConfig.vidWidth, glConfig.vidHeight );
Cvar_Set( "r_customwidth", va("%d", glConfig.vidWidth ) );
Cvar_Set( "r_customheight", va("%d", glConfig.vidHeight ) );
do
{
if ( glContext != nullptr )
{
SDL_GL_DeleteContext( glContext );
glContext = nullptr;
}
if ( window != nullptr )
{
SDL_GetWindowPosition( window, &x, &y );
ri.Printf( PRINT_DEVELOPER, "Existing window at %dx%d before being destroyed\n", x, y );
SDL_DestroyWindow( window );
window = nullptr;
}
// we come back here if we couldn't get a visual and there's
// something we can switch off
if ( fullscreen )
{
flags |= SDL_WINDOW_FULLSCREEN;
glConfig.isFullscreen = true;
}
else
{
if ( noborder )
{
flags |= SDL_WINDOW_BORDERLESS;
}
glConfig.isFullscreen = false;
}
colorBits = r_colorbits->integer;
if ( ( !colorBits ) || ( colorBits >= 32 ) )
{
colorBits = 24;
}
alphaBits = r_alphabits->integer;
if ( alphaBits < 0 )
{
alphaBits = 0;
}
depthBits = r_depthbits->integer;
if ( !depthBits )
{
depthBits = 24;
}
stencilBits = r_stencilbits->integer;
samples = r_ext_multisample->integer;
for ( i = 0; i < 16; i++ )
{
int testColorBits, testDepthBits, testStencilBits;
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ( ( i % 4 ) == 0 && i )
{
// one pass, reduce
switch ( i / 4 )
{
case 2:
if ( colorBits == 24 )
{
colorBits = 16;
}
break;
case 1:
if ( depthBits == 24 )
{
depthBits = 16;
}
else if ( depthBits == 16 )
{
depthBits = 8;
}
case 3:
if ( stencilBits == 24 )
{
stencilBits = 16;
}
else if ( stencilBits == 16 )
{
stencilBits = 8;
}
}
}
testColorBits = colorBits;
testDepthBits = depthBits;
testStencilBits = stencilBits;
if ( ( i % 4 ) == 3 )
{
// reduce colorbits
if ( testColorBits == 24 )
{
testColorBits = 16;
}
}
if ( ( i % 4 ) == 2 )
{
// reduce depthbits
if ( testDepthBits == 24 )
{
testDepthBits = 16;
}
else if ( testDepthBits == 16 )
{
testDepthBits = 8;
}
}
if ( ( i % 4 ) == 1 )
{
// reduce stencilbits
if ( testStencilBits == 24 )
{
testStencilBits = 16;
}
else if ( testStencilBits == 16 )
{
testStencilBits = 8;
}
else
{
testStencilBits = 0;
}
}
if ( testColorBits == 24 )
{
perChannelColorBits = 8;
}
else
{
perChannelColorBits = 4;
}
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, alphaBits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, testDepthBits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, testStencilBits );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
if ( !r_glAllowSoftware->integer )
{
SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
}
if ( r_glCoreProfile->integer || r_glDebugProfile->integer )
{
int major = r_glMajorVersion->integer;
int minor = r_glMinorVersion->integer;
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, major );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, minor );
if ( r_glCoreProfile->integer )
{
SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE );
}
else
{
SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY );
}
if ( r_glDebugProfile->integer )
{
SDL_GL_SetAttribute( SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG );
}
}
window = SDL_CreateWindow( CLIENT_WINDOW_TITLE, x, y, glConfig.vidWidth, glConfig.vidHeight, flags );
if ( !window )
{
ri.Printf( PRINT_DEVELOPER, "SDL_CreateWindow failed: %s\n", SDL_GetError() );
continue;
}
SDL_SetWindowIcon( window, icon );
glContext = SDL_GL_CreateContext( window );
if ( !glContext )
{
ri.Printf( PRINT_DEVELOPER, "SDL_GL_CreateContext failed: %s\n", SDL_GetError() );
continue;
}
SDL_GL_SetSwapInterval( r_swapInterval->integer );
glConfig.colorBits = testColorBits;
glConfig.depthBits = testDepthBits;
glConfig.stencilBits = testStencilBits;
ri.Printf( PRINT_ALL, "Using %d Color bits, %d depth, %d stencil display.\n",
glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits );
break;
}
if ( samples && ( !glContext || !window ) )
{
r_ext_multisample->integer = 0;
}
} while ( ( !glContext || !window ) && samples );
SDL_FreeSurface( icon );
glewResult = glewInit();
if ( glewResult != GLEW_OK )
{
// glewInit failed, something is seriously wrong
ri.Error( ERR_FATAL, "GLW_StartOpenGL() - could not load OpenGL subsystem: %s", glewGetErrorString( glewResult ) );
}
else
{
ri.Printf( PRINT_ALL, "Using GLEW %s\n", glewGetString( GLEW_VERSION ) );
}
int GLmajor, GLminor;
sscanf( ( const char * ) glGetString( GL_VERSION ), "%d.%d", &GLmajor, &GLminor );
if ( GLmajor < 2 || ( GLmajor == 2 && GLminor < 1 ) )
{
// missing shader support, switch to 1.x renderer
return RSERR_OLD_GL;
}
if ( GLmajor < 3 || ( GLmajor == 3 && GLminor < 2 ) )
{
// shaders are supported, but not all GL3.x features
ri.Printf( PRINT_ALL, "Using enhanced (GL3) Renderer in GL 2.x mode...\n" );
}
else
{
ri.Printf( PRINT_ALL, "Using enhanced (GL3) Renderer in GL 3.x mode...\n" );
glConfig.driverType = GLDRV_OPENGL3;
}
GLimp_DetectAvailableModes();
glstring = ( char * ) glGetString( GL_RENDERER );
ri.Printf( PRINT_ALL, "GL_RENDERER: %s\n", glstring );
return RSERR_OK;
}
static int GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder)
{
int perChannelColorBits;
int colorBits, depthBits, stencilBits;
int samples;
int i = 0;
SDL_Surface *icon = NULL;
SDL_DisplayMode desktopMode;
int display = 0;
int x = SDL_WINDOWPOS_UNDEFINED, y = SDL_WINDOWPOS_UNDEFINED;
Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_INPUT_GRABBED;
#ifndef FEATURE_RENDERER_GLES
GLenum glewResult;
#endif
Ren_Print("Initializing OpenGL display\n");
if (r_allowResize->integer && !fullscreen)
{
flags |= SDL_WINDOW_RESIZABLE;
}
icon = SDL_CreateRGBSurfaceFrom(
(void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
// If a window exists, note its display index
if (main_window != NULL)
{
display = SDL_GetWindowDisplayIndex(main_window);
}
if (SDL_GetDesktopDisplayMode(display, &desktopMode) == 0)
{
displayAspect = (float)desktopMode.w / (float)desktopMode.h;
Ren_Print("Estimated display aspect: %.3f\n", displayAspect);
}
else
{
Com_Memset(&desktopMode, 0, sizeof(SDL_DisplayMode));
Ren_Print("Cannot estimate display aspect, assuming 1.333\n");
}
Ren_Print("...setting mode %d: ", mode);
if (mode == -2)
{
// use desktop video resolution
if (desktopMode.h > 0)
{
glConfig.vidWidth = desktopMode.w;
glConfig.vidHeight = desktopMode.h;
}
else
{
glConfig.vidWidth = 640;
glConfig.vidHeight = 480;
Ren_Print("Cannot determine display resolution, assuming 640x480\n");
}
glConfig.windowAspect = (float)glConfig.vidWidth / (float)glConfig.vidHeight;
}
else if (!R_GetModeInfo(&glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode))
{
Ren_Print("invalid mode\n");
return RSERR_INVALID_MODE;
}
Ren_Print("%dx%d\n", glConfig.vidWidth, glConfig.vidHeight);
// Center window
if (r_centerWindow->integer && !fullscreen)
{
x = (desktopMode.w / 2) - (glConfig.vidWidth / 2);
y = (desktopMode.h / 2) - (glConfig.vidHeight / 2);
}
// Destroy existing state if it exists
if (SDL_glContext != NULL)
{
SDL_GL_DeleteContext(SDL_glContext);
SDL_glContext = NULL;
}
if (main_window != NULL)
{
SDL_GetWindowPosition(main_window, &x, &y);
Ren_Developer("Existing window at %dx%d before being destroyed\n", x, y);
SDL_DestroyWindow(main_window);
main_window = NULL;
}
if (fullscreen)
{
if (r_mode->integer == -2)
{
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
}
else
{
flags |= SDL_WINDOW_FULLSCREEN;
}
glConfig.isFullscreen = qtrue;
}
else
{
if (noborder)
{
flags |= SDL_WINDOW_BORDERLESS;
}
glConfig.isFullscreen = qfalse;
}
colorBits = r_colorbits->value;
if ((!colorBits) || (colorBits >= 32))
{
colorBits = 24;
}
if (!r_depthbits->value)
{
depthBits = 24;
}
else
{
depthBits = r_depthbits->value;
}
stencilBits = r_stencilbits->value;
samples = r_ext_multisample->value;
for (i = 0; i < 16; i++)
{
int testColorBits, testDepthBits, testStencilBits;
// 0 - default
// 1 - minus colorBits
// 2 - minus depthBits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2:
if (colorBits == 24)
{
colorBits = 16;
}
break;
case 1:
if (depthBits == 32)
{
depthBits = 24;
}
else if (depthBits == 24)
{
depthBits = 16;
}
else if (depthBits == 16)
{
depthBits = 8;
}
case 3: // fall through
if (stencilBits == 24)
{
stencilBits = 16;
}
else if (stencilBits == 16)
{
stencilBits = 8;
}
}
}
testColorBits = colorBits;
testDepthBits = depthBits;
testStencilBits = stencilBits;
if ((i % 4) == 3) // reduce colorbits
{
if (testColorBits == 24)
{
testColorBits = 16;
}
}
if ((i % 4) == 2) // reduce depthbits
{
if (testDepthBits == 24)
{
testDepthBits = 16;
}
else if (testDepthBits == 16)
{
testDepthBits = 8;
}
}
if ((i % 4) == 1) // reduce stencilbits
{
if (testStencilBits == 24)
{
testStencilBits = 16;
}
else if (testStencilBits == 16)
{
testStencilBits = 8;
}
else
{
testStencilBits = 0;
}
}
if (testColorBits == 24)
{
perChannelColorBits = 8;
}
else
{
perChannelColorBits = 4;
}
#ifdef __sgi // Fix for SGIs grabbing too many bits of color
if (perChannelColorBits == 4)
{
perChannelColorBits = 0; /* Use minimum size for 16-bit color */
}
// Need alpha or else SGIs choose 36+ bit RGB mode
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 1);
#endif
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, perChannelColorBits);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, perChannelColorBits);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, perChannelColorBits);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, testDepthBits);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, testStencilBits);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, samples);
// SDL2 uses opengl by default, if we want opengl es we need to set this attribute
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_EGL, 1);
if (r_stereoEnabled->integer)
{
glConfig.stereoEnabled = qtrue;
SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
}
else
{
glConfig.stereoEnabled = qfalse;
SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
}
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// If not allowing software GL, demand accelerated
if (!r_allowSoftwareGL->integer)
{
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
}
main_window = SDL_CreateWindow(CLIENT_WINDOW_TITLE, x, y, glConfig.vidWidth, glConfig.vidHeight, flags | SDL_WINDOW_SHOWN);
if (!main_window)
{
Ren_Developer("SDL_CreateWindow failed: %s\n", SDL_GetError());
continue;
}
//This is disabled since at least now we have no use for this
/*
if (!Glimp_Create2DRenderer(main_window))
{
continue;
}
*/
if (fullscreen)
{
SDL_DisplayMode mode;
switch (testColorBits)
{
case 16: mode.format = SDL_PIXELFORMAT_RGB565; break;
case 24: mode.format = SDL_PIXELFORMAT_RGB24; break;
default: Ren_Developer("testColorBits is %d, can't fullscreen\n", testColorBits); continue;
}
mode.w = glConfig.vidWidth;
mode.h = glConfig.vidHeight;
mode.refresh_rate = glConfig.displayFrequency = ri.Cvar_VariableIntegerValue("r_displayRefresh");
mode.driverdata = NULL;
if (SDL_SetWindowDisplayMode(main_window, &mode) < 0)
{
Ren_Developer("SDL_SetWindowDisplayMode failed: %s\n", SDL_GetError());
continue;
}
}
SDL_SetWindowIcon(main_window, icon);
#if defined(FEATURE_RENDERER2)
glewExperimental = GL_TRUE;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
#endif
if ((SDL_glContext = SDL_GL_CreateContext(main_window)) == NULL)
{
Ren_Developer("SDL_GL_CreateContext failed: %s\n", SDL_GetError());
continue;
}
SDL_GL_MakeCurrent(main_window, SDL_glContext);
SDL_GL_SetSwapInterval(r_swapInterval->integer);
glConfig.colorBits = testColorBits;
glConfig.depthBits = testDepthBits;
glConfig.stencilBits = testStencilBits;
ri.Printf(PRINT_ALL, "Using %d color bits, %d depth, %d stencil display.\n",
glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits);
break;
}
GLimp_DetectAvailableModes();
#if !defined(FEATURE_RENDERER_GLES)
glewResult = glewInit();
if (GLEW_OK != glewResult)
{
// glewInit failed, something is seriously wrong
Ren_Fatal("GLW_StartOpenGL() - could not load OpenGL subsystem: %s", glewGetErrorString(glewResult));
}
else
{
Ren_Print("Using GLEW %s\n", glewGetString(GLEW_VERSION));
}
#endif
if (!GLimp_InitOpenGLContext())
{
return RSERR_OLD_GL;
}
if (!main_window) //|| !main_renderer)
{
Ren_Print("Couldn't get a visual\n");
return RSERR_INVALID_MODE;
}
SDL_FreeSurface(icon);
return RSERR_OK;
}
/*
===============
GLimp_SetMode
===============
*/
static int GLimp_SetMode( qboolean failSafe, qboolean fullscreen )
{
const char* glstring;
int sdlcolorbits;
int colorbits, depthbits, stencilbits;
int tcolorbits, tdepthbits, tstencilbits;
int i = 0;
SDL_Surface *vidscreen = NULL;
Uint32 flags = SDL_OPENGL;
ri.Printf( PRINT_ALL, "Initializing OpenGL display\n");
#if !SDL_VERSION_ATLEAST(1, 2, 10)
// 1.2.10 is needed to get the desktop resolution
glConfig.displayAspect = 4.0f / 3.0f;
#elif MINSDL_PATCH >= 10
# error Ifdeffery no longer necessary, please remove
#else
if( videoInfo == NULL )
{
static SDL_VideoInfo sVideoInfo;
static SDL_PixelFormat sPixelFormat;
videoInfo = SDL_GetVideoInfo( );
// Take a copy of the videoInfo
Com_Memcpy( &sPixelFormat, videoInfo->vfmt, sizeof( SDL_PixelFormat ) );
sPixelFormat.palette = NULL; // Should already be the case
Com_Memcpy( &sVideoInfo, videoInfo, sizeof( SDL_VideoInfo ) );
sVideoInfo.vfmt = &sPixelFormat;
videoInfo = &sVideoInfo;
// Guess the display aspect ratio through the desktop resolution
// by assuming (relatively safely) that it is set at or close to
// the display's native aspect ratio
glConfig.displayAspect = (float)videoInfo->current_w / (float)videoInfo->current_h;
ri.Printf( PRINT_ALL, "Estimated display aspect: %.3f\n", glConfig.displayAspect );
}
#endif
if( !failSafe )
{
glConfig.vidWidth = r_width->integer;
glConfig.vidHeight = r_height->integer;
glConfig.windowAspect = r_width->value /
( r_height->value * r_pixelAspect->value );
}
else if( glConfig.vidWidth != R_FAILSAFE_WIDTH &&
glConfig.vidHeight != R_FAILSAFE_HEIGHT )
{
ri.Printf( PRINT_ALL, "Setting mode %dx%d failed, falling back on mode %dx%d\n",
glConfig.vidWidth, glConfig.vidHeight, R_FAILSAFE_WIDTH, R_FAILSAFE_HEIGHT );
glConfig.vidWidth = R_FAILSAFE_WIDTH;
glConfig.vidHeight = R_FAILSAFE_HEIGHT;
glConfig.windowAspect = 1.0f;
}
else
return RSERR_INVALID_MODE;
ri.Printf (PRINT_ALL, "...setting mode %dx%d\n", glConfig.vidWidth, glConfig.vidHeight);
if (fullscreen)
{
flags |= SDL_FULLSCREEN;
glConfig.isFullscreen = qtrue;
}
else
glConfig.isFullscreen = qfalse;
if (!r_colorbits->value)
colorbits = 24;
else
colorbits = r_colorbits->value;
if (!r_depthbits->value)
depthbits = 24;
else
depthbits = r_depthbits->value;
stencilbits = r_stencilbits->value;
for (i = 0; i < 16; i++)
{
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2 :
if (colorbits == 24)
colorbits = 16;
break;
case 1 :
if (depthbits == 24)
depthbits = 16;
else if (depthbits == 16)
depthbits = 8;
case 3 :
if (stencilbits == 24)
stencilbits = 16;
else if (stencilbits == 16)
stencilbits = 8;
}
}
tcolorbits = colorbits;
tdepthbits = depthbits;
tstencilbits = stencilbits;
if ((i % 4) == 3)
{ // reduce colorbits
if (tcolorbits == 24)
tcolorbits = 16;
}
if ((i % 4) == 2)
{ // reduce depthbits
if (tdepthbits == 24)
tdepthbits = 16;
else if (tdepthbits == 16)
tdepthbits = 8;
}
if ((i % 4) == 1)
{ // reduce stencilbits
if (tstencilbits == 24)
tstencilbits = 16;
else if (tstencilbits == 16)
tstencilbits = 8;
else
tstencilbits = 0;
}
sdlcolorbits = 4;
if (tcolorbits == 24)
sdlcolorbits = 8;
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, tdepthbits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, tstencilbits );
if(r_stereoEnabled->integer)
{
glConfig.stereoEnabled = qtrue;
SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
}
else
{
glConfig.stereoEnabled = qfalse;
SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
#if 0 // See http://bugzilla.icculus.org/show_bug.cgi?id=3526
// If not allowing software GL, demand accelerated
if( !r_allowSoftwareGL->integer )
{
if( SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 ) < 0 )
{
ri.Printf( PRINT_ALL, "Unable to guarantee accelerated "
"visual with libSDL < 1.2.10\n" );
}
}
#endif
if( SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, r_swapInterval->integer ) < 0 )
ri.Printf( PRINT_ALL, "r_swapInterval requires libSDL >= 1.2.10\n" );
#ifdef USE_ICON
{
SDL_Surface *icon = SDL_CreateRGBSurfaceFrom(
(void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
SDL_WM_SetIcon( icon, NULL );
SDL_FreeSurface( icon );
}
#endif
SDL_WM_SetCaption(CLIENT_WINDOW_TITLE, CLIENT_WINDOW_MIN_TITLE);
SDL_ShowCursor(0);
if (!(vidscreen = SDL_SetVideoMode(glConfig.vidWidth, glConfig.vidHeight, colorbits, flags)))
{
ri.Printf( PRINT_DEVELOPER, "SDL_SetVideoMode failed: %s\n", SDL_GetError( ) );
continue;
}
opengl_context = GLimp_GetCurrentContext();
ri.Printf( PRINT_ALL, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
sdlcolorbits, sdlcolorbits, sdlcolorbits, tdepthbits, tstencilbits);
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
GLimp_DetectAvailableModes();
if (!vidscreen)
{
ri.Printf( PRINT_ALL, "Couldn't get a visual\n" );
return RSERR_INVALID_MODE;
}
screen = vidscreen;
glstring = (char *) qglGetString (GL_RENDERER);
ri.Printf( PRINT_ALL, "GL_RENDERER: %s\n", glstring );
return RSERR_OK;
}
static int GLimp_SetMode( void )
{
const char* glstring;
//int sdlcolorbits;
int /*colorbits, depthbits, stencilbits, */stereo;
//int tcolorbits, tdepthbits, tstencilbits;
int samples;
int i = 0;
SDL_DisplayMode displayMode;
//SDL_Surface *vidscreen = NULL;
Uint32 flags = SDL_WINDOW_OPENGL|SDL_WINDOW_RESIZABLE;
static int desktop_w, desktop_h; // desktop resolution
/*if(window) {
return RSERR_INVALID_MODE;
}*/
ri.Printf( PRINT_DEVELOPER, "Initializing OpenGL display\n");
//if ( r_allowResize->integer )
// flags |= SDL_WINDOW_RESIZABLE;
// Guess the display aspect ratio through the desktop resolution
// by assuming (relatively safely) that it is set at or close to
// the display's native aspect ratio
//videoInfo = SDL_GetVideoInfo();
//if( videoInfo->current_h == 0 )
if( SDL_GetDesktopDisplayMode( 0, &displayMode ) == 0 )//FIXME: Use SDL_GetWindowDisplayIndex instead of 0?
{
if( !desktop_w ) { // first time through, resolve desktop resolution
desktop_w = displayMode.w;
desktop_h = displayMode.h;
}
}
else
{
ri.Printf( PRINT_ALL, "Cannot get display info, assuming 800x600\n" );
if( !desktop_w ) { // first time through, resolve desktop resolution
desktop_w = 800;
desktop_h = 600;
}
}
glConfig.displayAspect = (float)desktop_w / (float)desktop_h;
ri.Printf( PRINT_DEVELOPER, "Estimated display aspect: %.3f\n", glConfig.displayAspect );
//if( !failSafe )
//{
if ( r_width->modified || r_height->modified || r_pixelAspect->modified )
{
for ( i = 0; i < 12; i++ )
{
if ( r_width->integer == vidModes[ i ].width &&
r_height->integer == vidModes[ i ].height &&
r_pixelAspect->integer == vidModes[ i ].pixelAspect )
{
Cvar_SetValue( "r_mode", i );
break;
}
}
if ( i == 12 )
Cvar_Set( "r_mode", "-1" );
}
else if ( r_mode->modified && r_mode->integer >= 0 )
{
Cvar_SetValue( "r_width", vidModes[ r_mode->integer ].width );
Cvar_SetValue( "r_height", vidModes[ r_mode->integer ].height );
Cvar_SetValue( "r_pixelAspect", vidModes[ r_mode->integer ].pixelAspect );
}
r_width->modified = qfalse;
r_height->modified = qfalse;
r_pixelAspect->modified = qfalse;
r_mode->modified = qfalse;
glConfig.vidWidth = ( r_width->integer ? r_width->integer : desktop_w );
glConfig.vidHeight = ( r_height->integer ? r_height->integer : desktop_h );
if(glConfig.vidWidth > desktop_w) {
glConfig.vidWidth = desktop_w;
}
if(glConfig.vidHeight > desktop_h) {
glConfig.vidHeight = desktop_h;
}
glConfig.windowAspect = glConfig.vidWidth / ( (float)glConfig.vidHeight * r_pixelAspect->value );
/*}
else if( glConfig.vidWidth != R_FAILSAFE_WIDTH &&
glConfig.vidHeight != R_FAILSAFE_HEIGHT )
{
ri.Printf( PRINT_ALL, "Setting mode %dx%d failed, falling back on mode %dx%d\n",
glConfig.vidWidth, glConfig.vidHeight, R_FAILSAFE_WIDTH, R_FAILSAFE_HEIGHT );
glConfig.vidWidth = R_FAILSAFE_WIDTH;
glConfig.vidHeight = R_FAILSAFE_HEIGHT;
glConfig.windowAspect = 1.0f;
}
else
return RSERR_INVALID_MODE;*/
ri.Printf (PRINT_DEVELOPER, "...setting mode %dx%d\n", glConfig.vidWidth, glConfig.vidHeight);
if (r_fullscreen->integer) {
glConfig.vidWidth = desktop_w;
glConfig.vidHeight = desktop_h;
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
}
/*colorbits = r_colorbits->value;
if (!colorbits || colorbits > 32)
colorbits = 32;
if (!r_depthbits->value)
depthbits = 24;
else
depthbits = r_depthbits->value;
stencilbits = r_stencilbits->value;
samples = r_ext_multisample->value;*/
samples = r_ext_multisample->value;
/*for (i = 0; i < 16; i++)
{
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2 :
if (colorbits == 32)
colorbits = 24;
else if (colorbits == 24)
colorbits = 16;
break;
case 1 :
if (depthbits == 24)
depthbits = 16;
else if (depthbits == 16)
depthbits = 8;
case 3 :
if (stencilbits == 24)
stencilbits = 16;
else if (stencilbits == 16)
stencilbits = 8;
}
}
tcolorbits = colorbits;
tdepthbits = depthbits;
tstencilbits = stencilbits;
if ((i % 4) == 3)
{ // reduce colorbits
if (tcolorbits == 32)
tcolorbits = 24;
if (tcolorbits == 24)
tcolorbits = 16;
}
if ((i % 4) == 2)
{ // reduce depthbits
if (tdepthbits == 24)
tdepthbits = 16;
else if (tdepthbits == 16)
tdepthbits = 8;
}
if ((i % 4) == 1)
{ // reduce stencilbits
if (tstencilbits == 24)
tstencilbits = 16;
else if (tstencilbits == 16)
tstencilbits = 8;
else
tstencilbits = 0;
}
if (tcolorbits >= 24)
sdlcolorbits = 8;
else
sdlcolorbits = 4;*/
//#ifdef __sgi /* Fix for SGIs grabbing too many bits of color */
// if (sdlcolorbits == 4)
// sdlcolorbits = 0; /* Use minimum size for 16-bit color */
/* Need alpha or else SGIs choose 36+ bit RGB mode */
// SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 1);
//#endif
/*SDL_GL_SetAttribute( SDL_GL_RED_SIZE, colorbits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, colorbits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, colorbits );
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, colorbits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, depthbits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, stencilbits );
*/
if(r_stereoEnabled->integer) {
//glConfig.stereoEnabled = qtrue;
SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
}
else {
//glConfig.stereoEnabled = qfalse;
SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );
if ( !(window = SDL_CreateWindow( CLIENT_WINDOW_TITLE, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
glConfig.vidWidth, glConfig.vidHeight, flags )) )
//if (!(vidscreen = SDL_SetVideoMode(glConfig.vidWidth, glConfig.vidHeight, colorbits, flags)))
{
ri.Printf( PRINT_ALL, "SDL_CreateWindow failed: %s\n", SDL_GetError( ) );
return RSERR_INVALID_MODE;
}
if ( !(context = SDL_GL_CreateContext( window )) ) {
ri.Printf( PRINT_ALL, "SDL_GL_CreateContext failed: %s\n", SDL_GetError( ) );
SDL_DestroyWindow( window );
window = NULL;
return RSERR_INVALID_MODE;
}
//if( SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, r_swapInterval->integer ) < 0 )
if( SDL_GL_SetSwapInterval( r_swapInterval->integer ) != 0 )
ri.Printf( PRINT_ALL, "r_swapInterval failed (%s)\n", SDL_GetError( ) );
#ifdef USE_ICON
{
SDL_Surface *icon = SDL_CreateRGBSurfaceFrom(
(void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
//SDL_WM_SetIcon( icon, NULL );
SDL_SetWindowIcon( window, icon );
SDL_FreeSurface( icon );
}
#endif
//SDL_WM_SetCaption(CLIENT_WINDOW_TITLE, CLIENT_WINDOW_MIN_TITLE);
//SDL_ShowCursor(0);
//SDL_ShowCursor(0);
GLimp_GetCurrentContext();
//ri.Printf( PRINT_DEVELOPER, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
// sdlcolorbits, sdlcolorbits, sdlcolorbits, tdepthbits, tstencilbits);
SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &glConfig.colorBits );
SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &glConfig.depthBits );
SDL_GL_GetAttribute( SDL_GL_STENCIL_SIZE, &glConfig.stencilBits );
SDL_GL_GetAttribute( SDL_GL_STEREO, &stereo );
if(stereo) {
glConfig.stereoEnabled = qtrue;
}
else {
glConfig.stereoEnabled = qfalse;
}
if(SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN_DESKTOP) {
glConfig.isFullscreen = qtrue;
}
else {
if(r_fullscreen->integer) {
Cvar_Set( "r_fullscreen", "0" );
}
glConfig.isFullscreen = qfalse;
}
/*glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
*/
GLimp_DetectAvailableModes();
if (!window || !context)
{
ri.Printf( PRINT_ALL, "Couldn't get a visual\n" );
return RSERR_INVALID_MODE;
}
//screen = vidscreen;
glstring = (char *) qglGetString (GL_RENDERER);
ri.Printf( PRINT_ALL, "GL_RENDERER: %s\n", glstring );
return RSERR_OK;
}
