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; }