void video_set_brightness( double brightness )
{
video_options.brightness = brightness;
if ( video_window != NULL ) {
SDL_SetWindowBrightness( video_window, brightness );
}
}
/**
* @brief This routine is responsible for initializing the OS specific portions of OpenGL
* @param[in,out] glConfig
* @param[in] context
*/
void GLimp_Init(glconfig_t *glConfig, windowContext_t *context)
{
SDL_version compiled;
SDL_version linked;
SDL_VERSION(&compiled);
SDL_GetVersion(&linked);
Com_Printf("SDL build version %d.%d.%d - link version %d.%d.%d.\n", compiled.major, compiled.minor, compiled.patch, linked.major, linked.minor, linked.patch);
GLimp_InitCvars();
if (Cvar_VariableIntegerValue("com_abnormalExit"))
{
Cvar_Set("r_mode", va("%d", R_MODE_FALLBACK));
Cvar_Set("r_fullscreen", "0");
Cvar_Set("r_centerWindow", "0");
Cvar_Set("com_abnormalExit", "0");
}
Sys_GLimpInit();
// Create the window and set up the context
if (GLimp_StartDriverAndSetMode(glConfig, r_mode->integer, (qboolean) !!r_fullscreen->integer, (qboolean) !!r_noBorder->integer, context))
{
goto success;
}
// Try again, this time in a platform specific "safe mode"
Sys_GLimpSafeInit();
if (GLimp_StartDriverAndSetMode(glConfig, r_mode->integer, (qboolean) !!r_fullscreen->integer, qfalse, context))
{
goto success;
}
// Finally, try the default screen resolution
if (r_mode->integer != R_MODE_FALLBACK)
{
Com_Printf("Setting r_mode %d failed, falling back on r_mode %d\n", r_mode->integer, R_MODE_FALLBACK);
if (GLimp_StartDriverAndSetMode(glConfig, R_MODE_FALLBACK, qfalse, qfalse, context))
{
goto success;
}
}
// Nothing worked, give up
Com_Error(ERR_VID_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n");
success:
// Only using SDL_SetWindowBrightness to determine if hardware gamma is supported
glConfig->deviceSupportsGamma = !r_ignorehwgamma->integer && SDL_SetWindowBrightness(main_window, 1.0f) >= 0;
re.InitOpenGL();
Cvar_Get("r_availableModes", "", CVAR_ROM);
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init();
}
/*
===============
GLimp_Init
This routine is responsible for initializing the OS specific portions
of OpenGL
===============
*/
void GLimp_Init( void )
{
r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
//r_allowResize = ri.Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE );
Sys_GLimpInit( );
#ifdef SDL_VIDEO_DRIVER_X11
XInitThreads( );
#endif
// create the window and set up the context
if( GLimp_StartDriverAndSetMode( ) )
goto success;
// Try again, this time in a platform specific "safe mode"
Sys_GLimpSafeInit( );
if( GLimp_StartDriverAndSetMode( ) )
goto success;
// Finally, try the default screen resolution
//if( GLimp_StartDriverAndSetMode( qtrue, r_fullscreen->integer ) )
// goto success;
// Nothing worked, give up
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
success:
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = (SDL_SetWindowBrightness( window, 1.0f ) == 0)?1:0;//FIXME: Use SDL_SetWindowGammaRamp with NULL instead?
// Mysteriously, if you use an NVidia graphics card and multiple monitors,
// SDL_SetGamma will incorrectly return false... the first time; ask
// again and you get the correct answer. This is a suspected driver bug, see
// http://bugzilla.icculus.org/show_bug.cgi?id=4316
//glConfig.deviceSupportsGamma = SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0;
// get our config strings
Q_strncpyz( glConfig.vendor_string, (char *) qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, (char *) qglGetString (GL_RENDERER), sizeof( glConfig.renderer_string ) );
if (*glConfig.renderer_string && glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] == '\n')
glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] = 0;
Q_strncpyz( glConfig.version_string, (char *) qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, (char *) qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
// initialize extensions
GLimp_InitExtensions( );
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init( );
}
int main ( int argc, char** argv )
{
SDL_Init(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK);
srand(time(0));
freopen("stdout.txt","w",stdout);
SoundList.open("resources/sound/flist.txt");
printf("Searching sounds...\n");
char tmp[257];
std::string st;
while(SoundList.good())
{
SoundList.getline(tmp,256);
st=tmp;
if(st!="")sounds.push_back(st);
}
random_shuffle(sounds.begin(),sounds.end());
uFMOD_Init();
printf("Current track: %s\n",sounds[ptr].c_str());
uFMOD_Load(("resources/sound/"+sounds[ptr]).c_str(),FMOD_LOOP_OFF);
if(SDL_NumJoysticks()==1)js=SDL_JoystickOpen(0);
SDL_Surface* icon=IMG_Load("icon.png");
TTF_Init();
font=TTF_OpenFont("font.ttf",26);
Window=SDL_CreateWindow("Space Ride",SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,SCREEN_W,SCREEN_H,SDL_WINDOW_SHOWN);
Renderer=SDL_CreateRenderer(Window,-1,SDL_RENDERER_PRESENTVSYNC|SDL_RENDERER_ACCELERATED);
SDL_SetWindowIcon(Window,icon);
SDL_SetWindowBrightness(Window,0.5);
SetPriorityClass(GetCurrentProcess(),REALTIME_PRIORITY_CLASS);
play();
TTF_CloseFont(font);
uFMOD_Free();
unload_res();
printf("Unloaded all resources.");
if(js)SDL_JoystickClose(js);
SDL_DestroyWindow(Window);
SDL_FreeSurface(icon);
TTF_Quit();
SDL_Quit();
return 0;
}
void SetBrightness(float val)
{
/* This function exists because SDL2 uses function for brightness which is not supported by opensource X11 drivers */
/* val < 0.0f tries to restore the brightness, less than -1.0 doesn't affect SDL function */
#ifdef USE_X11_GAMMA
static BOOL firstCall = true;
SDL_SysWMinfo sysInfo;
SDL_VERSION(&sysInfo.version);
if (SDL_GetWindowWMInfo(sdlWin, &sysInfo) && sysInfo.subsystem == SDL_SYSWM_X11)
{
static XF86VidModeGamma gammaToRestore = {-1.0f, -1.0f, -1.0f};
static _XF86VidModeGetGamma XF86VidModeGetGamma;
static _XF86VidModeSetGamma XF86VidModeSetGamma;
if (firstCall && (!XF86VidModeGetGamma || !XF86VidModeSetGamma))
{
void *Xxf86vm = SDL_LoadObject(SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE);
if (Xxf86vm)
{
XF86VidModeGetGamma = SDL_LoadFunction(Xxf86vm, "XF86VidModeGetGamma");
XF86VidModeSetGamma = SDL_LoadFunction(Xxf86vm, "XF86VidModeSetGamma");
}
}
firstCall = false;
if (XF86VidModeGetGamma && XF86VidModeSetGamma)
{
int screen = SDL_GetWindowDisplayIndex(sdlWin);
if (screen < 0)
screen = 0;
if (gammaToRestore.red == -1.0f && gammaToRestore.green == -1.0f && gammaToRestore.blue == -1.0f)
XF86VidModeGetGamma(sysInfo.info.x11.display, screen, &gammaToRestore); //Get brightness at first attempt
if (val < 0.0f)
{
if (gammaToRestore.red >= 0.0f && gammaToRestore.green >= 0.0f && gammaToRestore.blue >= 0.0f && XF86VidModeSetGamma(sysInfo.info.x11.display, screen, &gammaToRestore)) //Restore brightness
return;
else
val = 1.0f;
}
if (val >= 0.0f)
{
XF86VidModeGamma gamma = {val, val, val};
if (XF86VidModeSetGamma(sysInfo.info.x11.display, screen, &gamma)) //Set brightness
return;
}
}
}
#endif
if (val >= -1.0f)
SDL_SetWindowBrightness(sdlWin, val < 0.0f ? 1.0f : val);
}
window_t WIN_Init( const windowDesc_t *windowDesc, glconfig_t *glConfig )
{
Cmd_AddCommand("modelist", R_ModeList_f);
Cmd_AddCommand("minimize", GLimp_Minimize);
r_sdlDriver = Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
// Window cvars
r_fullscreen = Cvar_Get( "r_fullscreen", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_noborder = Cvar_Get( "r_noborder", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_centerWindow = Cvar_Get( "r_centerWindow", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_customwidth = Cvar_Get( "r_customwidth", "1600", CVAR_ARCHIVE|CVAR_LATCH );
r_customheight = Cvar_Get( "r_customheight", "1024", CVAR_ARCHIVE|CVAR_LATCH );
r_swapInterval = Cvar_Get( "r_swapInterval", "0", CVAR_ARCHIVE );
r_stereo = Cvar_Get( "r_stereo", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_mode = Cvar_Get( "r_mode", "4", CVAR_ARCHIVE|CVAR_LATCH );
r_displayRefresh = Cvar_Get( "r_displayRefresh", "0", CVAR_LATCH );
Cvar_CheckRange( r_displayRefresh, 0, 240, qtrue );
// Window render surface cvars
r_stencilbits = Cvar_Get( "r_stencilbits", "8", CVAR_ARCHIVE|CVAR_LATCH );
r_depthbits = Cvar_Get( "r_depthbits", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_colorbits = Cvar_Get( "r_colorbits", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_ignorehwgamma = Cvar_Get( "r_ignorehwgamma", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_ext_multisample = Cvar_Get( "r_ext_multisample", "0", CVAR_ARCHIVE|CVAR_LATCH );
// Create the window and set up the context
if(!GLimp_StartDriverAndSetMode( glConfig, windowDesc, r_mode->integer,
(qboolean)r_fullscreen->integer, (qboolean)r_noborder->integer ))
{
if( r_mode->integer != R_MODE_FALLBACK )
{
Com_Printf( "Setting r_mode %d failed, falling back on r_mode %d\n", r_mode->integer, R_MODE_FALLBACK );
if (!GLimp_StartDriverAndSetMode( glConfig, windowDesc, R_MODE_FALLBACK, qfalse, qfalse ))
{
// Nothing worked, give up
Com_Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
}
}
}
glConfig->deviceSupportsGamma =
(qboolean)(!r_ignorehwgamma->integer && SDL_SetWindowBrightness( screen, 1.0f ) >= 0);
Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init( screen );
// window_t is only really useful for Windows if the renderer wants to create a D3D context.
window_t window = {};
window.api = windowDesc->api;
#if defined(_WIN32)
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
if ( SDL_GetWindowWMInfo(screen, &info) )
{
switch(info.subsystem) {
case SDL_SYSWM_WINDOWS:
window.handle = info.info.win.window;
break;
default:
break;
}
}
#endif
return window;
}
/*
===============
GLimp_Init
This routine is responsible for initializing the OS specific portions
of OpenGL
===============
*/
void GLimp_Init( void )
{
ri->Printf( PRINT_DEVELOPER, "Glimp_Init( )\n" );
r_allowSoftwareGL = ri->Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_sdlDriver = ri->Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
r_allowResize = ri->Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE | CVAR_LATCH );
r_centerWindow = ri->Cvar_Get( "r_centerWindow", "0", CVAR_ARCHIVE | CVAR_LATCH );
if( ri->Cvar_VariableIntegerValue( "com_abnormalExit" ) )
{
ri->Cvar_Set( "r_mode", va( "%d", R_MODE_FALLBACK ) );
ri->Cvar_Set( "r_fullscreen", "0" );
ri->Cvar_Set( "r_centerWindow", "0" );
ri->Cvar_Set( "com_abnormalExit", "0" );
}
ri->Sys_GLimpInit( );
// Create the window and set up the context
if(GLimp_StartDriverAndSetMode(r_mode->integer, (r_fullscreen->integer != 0), (r_noborder->integer != 0)))
goto success;
// Try again, this time in a platform specific "safe mode"
ri->Sys_GLimpSafeInit( );
if(GLimp_StartDriverAndSetMode(r_mode->integer, (r_fullscreen->integer != 0), false))
goto success;
// Finally, try the default screen resolution
if( r_mode->integer != R_MODE_FALLBACK )
{
ri->Printf( PRINT_ALL, "Setting r_mode %d failed, falling back on r_mode %d\n",
r_mode->integer, R_MODE_FALLBACK );
if(GLimp_StartDriverAndSetMode(R_MODE_FALLBACK, false, false))
goto success;
}
// Nothing worked, give up
ri->Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
success:
// These values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
// Only using SDL_SetWindowBrightness to determine if hardware gamma is supported
glConfig.deviceSupportsGamma = !r_ignorehwgamma->integer &&
SDL_SetWindowBrightness( SDL_window, 1.0f ) >= 0;
// get our config strings
Q_strncpyz( glConfig.vendor_string, (char *) qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, (char *) qglGetString (GL_RENDERER), sizeof( glConfig.renderer_string ) );
if (*glConfig.renderer_string && glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] == '\n')
glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] = 0;
Q_strncpyz( glConfig.version_string, (char *) qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, (char *) qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
// initialize extensions
GLimp_InitExtensions( );
ri->Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
ri->IN_Init( SDL_window );
}
int SDLFrontend::init (int width, int height, bool fullscreen, EventHandler &eventHandler)
{
if (width == -1 && height == -1)
fullscreen = true;
info(LOG_CLIENT,
String::format("initializing: %i:%i - fullscreen: %s", width, height, fullscreen ? "true" : "false"));
INIT_Subsystem(SDL_INIT_VIDEO, true);
INIT_Subsystem(SDL_INIT_JOYSTICK, false);
INIT_Subsystem(SDL_INIT_GAMECONTROLLER, false);
INIT_Subsystem(SDL_INIT_HAPTIC, false);
initJoystickAndHaptic();
SDL_DisplayMode displayMode;
SDL_GetDesktopDisplayMode(0, &displayMode);
const char *name = SDL_GetPixelFormatName(displayMode.format);
info(LOG_CLIENT, String::format("current desktop mode: %dx%d@%dHz (%s)",
displayMode.w, displayMode.h, displayMode.refresh_rate, name));
if (width == -1)
width = 800;//displayMode.w;
if (height == -1)
height = 480; //displayMode.h;
setGLAttributes();
setHints();
int doubleBuffered = 0;
SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &doubleBuffered);
info(LOG_CLIENT, String::format("doublebuffer: %s", doubleBuffered ? "activated" : "disabled"));
int flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
#ifdef __IPHONEOS__
flags |= SDL_WINDOW_RESIZABLE;
#endif
#if 1 //defined __IPHONEOS__ || defined __ANDROID__
if (fullscreen)
flags |= SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS;
#else
if (fullscreen)
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_BORDERLESS;
#endif
const int videoDrivers = SDL_GetNumVideoDrivers();
for (int i = 0; i < videoDrivers; ++i) {
info(LOG_CLIENT, String::format("available driver: %s", SDL_GetVideoDriver(i)));
}
info(LOG_CLIENT, String::format("driver: %s", SDL_GetCurrentVideoDriver()));
const int displays = SDL_GetNumVideoDisplays();
info(LOG_CLIENT, String::format("found %i display(s)", displays));
if (fullscreen && displays > 1) {
width = displayMode.w;
height = displayMode.h;
info(LOG_CLIENT, String::format("use fake fullscreen for the first display: %i:%i", width, height));
}
_window = SDL_CreateWindow(Singleton<Application>::getInstance().getName().c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, flags);
if (!_window) {
sdlCheckError();
return -1;
}
SDL_DisableScreenSaver();
initRenderer();
resetColor();
GLContext::get().init();
if (SDL_SetWindowBrightness(_window, 1.0f) == -1)
sdlCheckError();
if (Config.isGrabMouse() && (!fullscreen || displays > 1)) {
SDL_SetWindowGrab(_window, SDL_TRUE);
}
int screen = 0;
int modes = SDL_GetNumDisplayModes(screen);
info(LOG_CLIENT, "possible display modes:");
for (int i = 0; i < modes; i++) {
SDL_GetDisplayMode(screen, i, &displayMode);
name = SDL_GetPixelFormatName(displayMode.format);
info(LOG_CLIENT, String::format("%dx%d@%dHz %s",
displayMode.w, displayMode.h, displayMode.refresh_rate, name));
}
// some platforms may override or hardcode the resolution - so
// we have to query it here to get the actual resolution
SDL_GetWindowSize(_window, &width, &height);
if (SDL_SetRelativeMouseMode(SDL_TRUE) == -1)
error(LOG_CLIENT, "no relative mouse mode support");
SDL_ShowCursor(0);
info(LOG_CLIENT, String::format("actual resolution: %dx%d", width, height));
setVSync(ConfigManager::get().isVSync());
const int initState = IMG_Init(IMG_INIT_PNG);
if (!(initState & IMG_INIT_PNG)) {
sdlCheckError();
System.exit("No png support", 1);
}
_width = width;
_height = height;
updateViewport(0, 0, getWidth(), getHeight());
onInit();
_eventHandler = &eventHandler;
_eventHandler->registerObserver(_console.get());
_eventHandler->registerObserver(this);
info(LOG_CLIENT, "init the shader manager");
ShaderManager::get().init();
if (!Config.isSoundEnabled()) {
info(LOG_CLIENT, "sound disabled");
} else if (!SoundControl.init(true)) {
error(LOG_CLIENT, "sound initialization failed");
}
return 0;
}
void GLimp_Init( void )
{
ri->Cvar_Get( "r_restartOnResize", "1", CVAR_ARCHIVE );
ri->Cvar_Get( "r_resizeDelay", "1000", CVAR_ARCHIVE );
r_allowSoftwareGL = ri->Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_sdlDriver = ri->Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
r_allowResize = ri->Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE );
/* if( Cvar_VariableIntegerValue( "com_abnormalExit" ) )
{
Cvar_Set( "r_mode", va( "%d", R_MODE_FALLBACK ) );
Cvar_Set( "r_picmap", "1" );
Cvar_Set( "r_texturebits", "0" );
Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
Cvar_Set( "r_fullscreen", "0" );
Cvar_Set( "r_centerWindow", "0" );
Cvar_Set( "com_abnormalExit", "0" );
}*/
// Create the window and set up the context
if(GLimp_StartDriverAndSetMode(r_mode->integer, (qboolean)r_fullscreen->integer, (qboolean)r_noborder->integer))
goto success;
// Try again, this time in a platform specific "safe mode"
/* Sys_GLimpSafeInit( );
if(GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, qfalse))
goto success; */
/* // Finally, try the default screen resolution
if( r_mode->integer != R_MODE_FALLBACK )
{
Com_Printf( "Setting r_mode %d failed, falling back on r_mode %d\n",
r_mode->integer, R_MODE_FALLBACK );
if(GLimp_StartDriverAndSetMode(R_MODE_FALLBACK, qfalse, qfalse))
goto success;
}*/
// Nothing worked, give up
Com_Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
success:
// This values force the UI to disable driver selection
// glConfig.driverType = GLDRV_ICD;
// glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = (qboolean)(!r_ignorehwgamma->integer &&
SDL_SetWindowBrightness( screen, 1.0f ) >= 0);
// get our config strings
glConfig.vendor_string = (const char *) qglGetString (GL_VENDOR);
glConfig.renderer_string = (const char *) qglGetString (GL_RENDERER);
glConfig.version_string = (const char *) qglGetString (GL_VERSION);
glConfig.extensions_string = (const char *) qglGetString (GL_EXTENSIONS);
// OpenGL driver constants
qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.maxTextureSize );
// stubbed or broken drivers may have reported 0...
if ( glConfig.maxTextureSize <= 0 )
{
glConfig.maxTextureSize = 0;
}
// initialize extensions
GLimp_InitExtensions( );
ri->Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
ri->IN_Init( screen );
}
/**
* @brief Initialize the OpenGL context, returning true on success, false on failure.
*/
void R_InitContext(void) {
int32_t w, h;
memset(&r_context, 0, sizeof(r_context));
if (SDL_WasInit(SDL_INIT_VIDEO) == 0) {
if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
Com_Error(ERROR_FATAL, "%s\n", SDL_GetError());
}
}
uint32_t flags = SDL_WINDOW_OPENGL;
if (r_allow_high_dpi->integer) {
flags |= SDL_WINDOW_ALLOW_HIGHDPI;
}
if (r_fullscreen->integer) {
w = Max(0, r_width->integer);
h = Max(0, r_height->integer);
if (r_width->integer == 0 && r_height->integer == 0) {
SDL_DisplayMode best;
SDL_GetDesktopDisplayMode(0, &best);
w = best.w;
h = best.h;
}
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
} else {
w = Max(0, r_windowed_width->integer);
h = Max(0, r_windowed_height->integer);
flags |= SDL_WINDOW_RESIZABLE;
}
Com_Print(" Trying %dx%d..\n", w, h);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
const int32_t s = Clamp(r_multisample->integer, 0, 8);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, s ? 1 : 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, s);
if ((r_context.window = SDL_CreateWindow(PACKAGE_STRING,
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, flags)) == NULL) {
Com_Error(ERROR_FATAL, "Failed to set video mode: %s\n", SDL_GetError());
}
Com_Print(" Setting up OpenGL context..\n");
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
if ((r_context.context = SDL_GL_CreateContext(r_context.window)) == NULL) {
Com_Error(ERROR_FATAL, "Failed to create OpenGL context: %s\n", SDL_GetError());
}
int32_t attr[SDL_GL_CONTEXT_RELEASE_BEHAVIOR];
for (int32_t i = 0; i < SDL_GL_CONTEXT_RELEASE_BEHAVIOR; i++) {
SDL_GL_GetAttribute(i, &attr[i]);
}
Com_Verbose(" Buffer Sizes: r %i g %i b %i a %i depth %i stencil %i framebuffer %i\n", attr[SDL_GL_RED_SIZE],
attr[SDL_GL_GREEN_SIZE], attr[SDL_GL_BLUE_SIZE], attr[SDL_GL_ALPHA_SIZE], attr[SDL_GL_DEPTH_SIZE],
attr[SDL_GL_STENCIL_SIZE], attr[SDL_GL_BUFFER_SIZE]);
Com_Verbose(" Double-buffered: %s\n", attr[SDL_GL_DOUBLEBUFFER] ? "yes" : "no");
Com_Verbose(" Multisample: %i buffers, %i samples\n", attr[SDL_GL_MULTISAMPLEBUFFERS],
attr[SDL_GL_MULTISAMPLESAMPLES]);
Com_Verbose(" Version: %i.%i (%i flags, %i profile)\n", attr[SDL_GL_CONTEXT_MAJOR_VERSION],
attr[SDL_GL_CONTEXT_MINOR_VERSION], attr[SDL_GL_CONTEXT_FLAGS], attr[SDL_GL_CONTEXT_PROFILE_MASK]);
if (SDL_GL_SetSwapInterval(r_swap_interval->integer) == -1) {
Com_Warn("Failed to set swap interval %d: %s\n", r_swap_interval->integer, SDL_GetError());
}
if (SDL_SetWindowBrightness(r_context.window, r_gamma->value) == -1) {
Com_Warn("Failed to set gamma %1.1f: %s\n", r_gamma->value, SDL_GetError());
}
int32_t dw, dh;
SDL_GL_GetDrawableSize(r_context.window, &dw, &dh);
r_context.render_width = r_context.width = dw;
r_context.render_height = r_context.height = dh;
int32_t ww, wh;
SDL_GetWindowSize(r_context.window, &ww, &wh);
r_context.window_width = ww;
r_context.window_height = wh;
r_context.high_dpi = dw > ww && dh > wh;
r_context.fullscreen = SDL_GetWindowFlags(r_context.window) & SDL_WINDOW_FULLSCREEN;
R_SetWindowIcon();
}
void SDL::setGamma(SDL_Window *const window, const float gamma)
{
SDL_SetWindowBrightness(window, gamma);
}
/**
* @brief This routine is responsible for initializing the OS specific portions of OpenGL
*/
void GLimp_Init(void)
{
r_allowSoftwareGL = ri.Cvar_Get("r_allowSoftwareGL", "0", CVAR_LATCH);
r_allowResize = ri.Cvar_Get("r_allowResize", "0", CVAR_ARCHIVE);
r_centerWindow = ri.Cvar_Get("r_centerWindow", "0", CVAR_ARCHIVE);
if (ri.Cvar_VariableIntegerValue("com_abnormalExit"))
{
ri.Cvar_Set("r_mode", va("%d", R_MODE_FALLBACK));
ri.Cvar_Set("r_fullscreen", "0");
ri.Cvar_Set("r_centerWindow", "0");
ri.Cvar_Set("com_abnormalExit", "0");
}
ri.Sys_GLimpInit();
// Create the window and set up the context
if (GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, r_noborder->integer))
{
goto success;
}
// Try again, this time in a platform specific "safe mode"
ri.Sys_GLimpSafeInit();
if (GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, qfalse))
{
goto success;
}
// Finally, try the default screen resolution
if (r_mode->integer != R_MODE_FALLBACK)
{
Ren_Print("Setting r_mode %d failed, falling back on r_mode %d\n",
r_mode->integer, R_MODE_FALLBACK);
if (GLimp_StartDriverAndSetMode(R_MODE_FALLBACK, qfalse, qfalse))
{
goto success;
}
}
// Nothing worked, give up
Ren_Fatal("GLimp_Init() - could not load OpenGL subsystem\n");
success:
//Clear the screen with a black color thanks
Glimp_ClearScreen();
#ifdef FEATURE_RENDERER2
if (glConfig.driverType != GLDRV_OPENGL3)
{
glConfig.driverType = GLDRV_ICD;
}
#else
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
#endif
glConfig.hardwareType = GLHW_GENERIC;
// Only using SDL_SetWindowBrightness to determine if hardware gamma is supported
glConfig.deviceSupportsGamma = !r_ignorehwgamma->integer &&
SDL_SetWindowBrightness(main_window, 1.0f) >= 0;
// Get extension strings
if (glConfig.driverType != GLDRV_OPENGL3)
{
Q_strncpyz(glConfig.extensions_string, ( char * ) glGetString(GL_EXTENSIONS), sizeof(glConfig.extensions_string));
}
#ifndef FEATURE_RENDERER_GLES
else
{
int i = 0, exts = 0;
glGetIntegerv(GL_NUM_EXTENSIONS, &exts);
glConfig.extensions_string[0] = 0;
for (i = 0; i < exts; i++)
{
if (strlen(glConfig.extensions_string) + 100 >= sizeof(glConfig.extensions_string))
{
//Just so we wont error out when there are really a lot of extensions
break;
}
Q_strcat(glConfig.extensions_string, sizeof(glConfig.extensions_string), va("%s ", glGetStringi(GL_EXTENSIONS, i)));
}
}
#endif // FEATURE_RENDERER_GLES
// initialize extensions
GLimp_SetHardware();
#ifdef FEATURE_RENDERER2
GLimp_InitExtensionsR2(); // renderer2
#else
GLimp_InitExtensions(); // vanilla renderer
#endif
ri.Cvar_Get("r_availableModes", "", CVAR_ROM);
// This depends on SDL_INIT_VIDEO, hence having it here
ri.IN_Init();
}
void brightness(float bright) {
if(SDL_SetWindowBrightness(ptr.get(), bright)) {
GUM_ERROR_HANDLER();
}
}
bool ZWindow::SetBrightness(float bright)
{
return SDL_SetWindowBrightness(m_win,bright)==0;
}
int inline Window::setWindowBrightness(State & state, SDL_Window * window){
Stack * stack = state.stack;
SDL_SetWindowBrightness(window, static_cast<float>(stack->to<LUA_NUMBER>(1)));
return 0;
}
