void Window::getPosition(int &x, int &y, int &displayindex) { if (!window) { x = y = 0; displayindex = 0; return; } displayindex = std::max(SDL_GetWindowDisplayIndex(window), 0); SDL_GetWindowPosition(window, &x, &y); // In SDL <= 2.0.3, fullscreen windows are always reported as 0,0. In every // other case we need to convert the position from global coordinates to the // monitor's coordinate space. if (x != 0 || y != 0) { SDL_Rect displaybounds = {}; SDL_GetDisplayBounds(displayindex, &displaybounds); x -= displaybounds.x; y -= displaybounds.y; } }
SDL_Rect CVideo::bound() const { SDL_Rect rc; int display = window? SDL_GetWindowDisplayIndex(window): 0; SDL_GetDisplayBounds(display, &rc); return rc; }
void Window::SetMaxMinResolution( SDL_Window * window, int &min_width, int &min_height, int &max_width, int &max_height ){ if( window == NULL or window == nullptr ){ return; } int DisplayIndex = SDL_GetWindowDisplayIndex( window ); SDL_DisplayMode CurrentDisplayMode; if( SDL_GetDisplayMode( DisplayIndex, SDL_GetNumDisplayModes( DisplayIndex ) - 1, &CurrentDisplayMode ) == 0 ){ min_width = CurrentDisplayMode.w; min_height = CurrentDisplayMode.h; logger << ( "[LOG] Minimal resolution: " + to_string( min_width ) + "x" + to_string( min_height ) ); } else{ logger << ( "[ERROR] SDL_GetDisplayMode: " + string( SDL_GetError() ) ); return; } SDL_SetWindowMinimumSize( window, min_width, min_height ); if( SDL_GetDisplayMode( DisplayIndex, 0, &CurrentDisplayMode ) == 0 ){ max_width = CurrentDisplayMode.w; max_height = CurrentDisplayMode.h; logger << ( "[LOG] Maximal resolution: " + to_string( max_width ) + "x" + to_string( max_height ) ); } else{ logger << ( "[ERROR] SDL_GetDisplayMode: " + string( SDL_GetError() ) ); return; } SDL_SetWindowMaximumSize( window, max_width, max_height ); }
/* =============== GLimp_DetectAvailableModes =============== */ static bool GLimp_DetectAvailableModes(void) { int i; char buf[ MAX_STRING_CHARS ] = { 0 }; SDL_Rect modes[ 128 ]; int numModes = 0; int display = SDL_GetWindowDisplayIndex( screen ); SDL_DisplayMode windowMode; if( SDL_GetWindowDisplayMode( screen, &windowMode ) < 0 ) { Com_Printf( "Couldn't get window display mode, no resolutions detected (%s).\n", SDL_GetError() ); return false; } int numDisplayModes = SDL_GetNumDisplayModes( display ); for( i = 0; i < numDisplayModes; i++ ) { SDL_DisplayMode mode; if( SDL_GetDisplayMode( display, i, &mode ) < 0 ) continue; if( !mode.w || !mode.h ) { Com_Printf( "Display supports any resolution\n" ); return true; } if( windowMode.format != mode.format ) continue; modes[ numModes ].w = mode.w; modes[ numModes ].h = mode.h; numModes++; } if( numModes > 1 ) qsort( modes, numModes, sizeof( SDL_Rect ), GLimp_CompareModes ); for( i = 0; i < numModes; i++ ) { const char *newModeString = va( "%ux%u ", modes[ i ].w, modes[ i ].h ); if( strlen( newModeString ) < (int)sizeof( buf ) - strlen( buf ) ) Q_strcat( buf, sizeof( buf ), newModeString ); else Com_Printf( "Skipping mode %ux%x, buffer too small\n", modes[ i ].w, modes[ i ].h ); } if( *buf ) { buf[ strlen( buf ) - 1 ] = 0; Com_Printf( "Available modes: '%s'\n", buf ); ri->Cvar_Set( "r_availableModes", buf ); } return true; }
bool KPSdl2UserInterface::IsWindowResolutionSupported( int width, int height) const { int index; SDL_Rect rect; if (window == nullptr) { // If there is no window opened yet we just can make a guess. index = 0; } else { index = SDL_GetWindowDisplayIndex(window); } if (index < 0) { BLogger::Log("*** SDL_GetWindowDisplayIndex error: ", SDL_GetError()); return false; } auto result = SDL_GetDisplayBounds(index, &rect); if (result < 0) { BLogger::Log("*** SDL_GetDisplayBounds error: ", SDL_GetError()); return false; } return width <= rect.w && (height <= rect.h); }
static void _GetBestFullscreenResolution( SDL_HWindow hWnd, int32 *pWidth, int32 *pHeight ) { uint32 InitializedMode = false; uint32 BestWidth = 0; uint32 BestHeight = 0; uint32 ModeIndex = 0; int32 dsp_idx = SDL_GetWindowDisplayIndex( hWnd ); if ( dsp_idx < 0 ) { dsp_idx = 0; } SDL_DisplayMode dsp_mode; FMemory::Memzero( &dsp_mode, sizeof(SDL_DisplayMode) ); while ( !SDL_GetDisplayMode( dsp_idx, ModeIndex++, &dsp_mode ) ) { bool IsEqualOrBetterWidth = FMath::Abs((int32)dsp_mode.w - (int32)(*pWidth)) <= FMath::Abs((int32)BestWidth - (int32)(*pWidth )); bool IsEqualOrBetterHeight = FMath::Abs((int32)dsp_mode.h - (int32)(*pHeight)) <= FMath::Abs((int32)BestHeight - (int32)(*pHeight)); if (!InitializedMode || (IsEqualOrBetterWidth && IsEqualOrBetterHeight)) { BestWidth = dsp_mode.w; BestHeight = dsp_mode.h; InitializedMode = true; } } check(InitializedMode); *pWidth = BestWidth; *pHeight = BestHeight; }
int video_display(void) { if (window) return SDL_GetWindowDisplayIndex(window); else return -1; }
void SDL2Window::changeMode(DisplayMode mode, bool makeFullscreen) { if(!m_window) { m_size = mode.resolution; m_fullscreen = makeFullscreen; return; } if(m_fullscreen == makeFullscreen && m_size == mode.resolution) { return; } bool wasFullscreen = m_fullscreen; m_renderer->beforeResize(wasFullscreen || makeFullscreen); if(makeFullscreen) { if(mode.resolution != Vec2i_ZERO) { SDL_DisplayMode sdlmode; SDL_DisplayMode requested; requested.driverdata = NULL; requested.format = 0; requested.refresh_rate = 0; requested.w = mode.resolution.x; requested.h = mode.resolution.y; int display = SDL_GetWindowDisplayIndex(m_window); if(!SDL_GetClosestDisplayMode(display, &requested, &sdlmode)) { if(SDL_GetDesktopDisplayMode(display, &sdlmode)) { return; } } if(SDL_SetWindowDisplayMode(m_window, &sdlmode) < 0) { return; } } } Uint32 flags = getSDLFlagsForMode(mode.resolution, makeFullscreen); if(SDL_SetWindowFullscreen(m_window, flags) < 0) { return; } if(!makeFullscreen) { SDL_SetWindowSize(m_window, mode.resolution.x, mode.resolution.y); } if(wasFullscreen != makeFullscreen) { onToggleFullscreen(makeFullscreen); } if(makeFullscreen) { // SDL regrettably sends resize events when a fullscreen window is minimized. // Because of that we ignore all size change events when fullscreen. // Instead, handle the size change here. updateSize(); } tick(); }
void loop() { SDL_Event event; /* Check for events */ while (SDL_PollEvent(&event)) { SDLTest_CommonEvent(state, &event, &done); if (event.type == SDL_WINDOWEVENT) { if (event.window.event == SDL_WINDOWEVENT_RESIZED) { SDL_Window *window = SDL_GetWindowFromID(event.window.windowID); if (window) { SDL_Log("Window %d resized to %dx%d\n", event.window.windowID, event.window.data1, event.window.data2); } } if (event.window.event == SDL_WINDOWEVENT_MOVED) { SDL_Window *window = SDL_GetWindowFromID(event.window.windowID); if (window) { SDL_Log("Window %d moved to %d,%d (display %s)\n", event.window.windowID, event.window.data1, event.window.data2, SDL_GetDisplayName(SDL_GetWindowDisplayIndex(window))); } } } if (event.type == SDL_KEYUP) { SDL_bool updateCursor = SDL_FALSE; if (event.key.keysym.sym == SDLK_LEFT) { --system_cursor; if (system_cursor < 0) { system_cursor = SDL_NUM_SYSTEM_CURSORS - 1; } updateCursor = SDL_TRUE; } else if (event.key.keysym.sym == SDLK_RIGHT) { ++system_cursor; if (system_cursor >= SDL_NUM_SYSTEM_CURSORS) { system_cursor = 0; } updateCursor = SDL_TRUE; } if (updateCursor) { SDL_Log("Changing cursor to \"%s\"", cursorNames[system_cursor]); SDL_FreeCursor(cursor); cursor = SDL_CreateSystemCursor((SDL_SystemCursor)system_cursor); SDL_SetCursor(cursor); } } } #ifdef __EMSCRIPTEN__ if (done) { emscripten_cancel_main_loop(); } #endif }
/* get desktop resolution */ static void get_current_resolution(int *w, int *h) { int displayidx; SDL_Rect rect = { 0, 0, 0, 0 }; if (window) { TCOD_IFNOT(window) return; displayidx = SDL_GetWindowDisplayIndex(window); TCOD_IFNOT(displayidx >= 0) return; } else {
int GraphicsManager::getSystemHeight() const { int displayIndex = SDL_GetWindowDisplayIndex(_screen); SDL_DisplayMode maxHeight; // The display mode are sorted by, in this order, greater bpp, largest width, largest height and higher refresh rate. SDL_GetDisplayMode(displayIndex, 0, &maxHeight); return maxHeight.h; }
bool gutGetDisplayIndex(unsigned *display) { chkwin; int i; i = SDL_GetWindowDisplayIndex(gut.core->window.handle); if (i < 0) return false; gut.core->window.display = (unsigned) i; *display = (unsigned) i; return true; }
/* =============== GLimp_DetectAvailableModes =============== */ static void GLimp_DetectAvailableModes() { char buf[MAX_STRING_CHARS] = {0}; SDL_Rect modes[128]; int numModes = 0; int i; SDL_DisplayMode windowMode; int display; display = SDL_GetWindowDisplayIndex(window); if (SDL_GetWindowDisplayMode(window, &windowMode) < 0) { ri.Printf(PRINT_WARNING, "Couldn't get window display mode: %s\n", SDL_GetError()); return; } for (i = 0; i < SDL_GetNumDisplayModes(display); i++) { SDL_DisplayMode mode; if (SDL_GetDisplayMode(display, i, &mode) < 0) { continue; } if (!mode.w || !mode.h) { ri.Printf(PRINT_ALL, "Display supports any resolution\n"); return; } if (windowMode.format != mode.format || windowMode.refresh_rate != mode.refresh_rate) { continue; } modes[numModes].w = mode.w; modes[numModes].h = mode.h; numModes++; } if (numModes > 1) { qsort(modes, numModes, sizeof(SDL_Rect), GLimp_CompareModes); } for (i = 0; i < numModes; i++) { const char* newModeString = va("%ux%u ", modes[i].w, modes[i].h); if (strlen(newModeString) < (int) sizeof(buf) - strlen(buf)) { Q_strcat(buf, sizeof(buf), newModeString); } else { ri.Printf(PRINT_WARNING, "Skipping mode %ux%x, buffer too small\n", modes[i].w, modes[i].h); } } if (*buf) { ri.Printf(PRINT_ALL, "Available modes: '%s'\n", buf); ri.Cvar_Set("r_availableModes", buf); } }
void UIInterface::getScreenSize(int *width, int *height) { SDL_Rect bounds; int displayIndex = SDL_GetWindowDisplayIndex(this->m_Win); SDL_GetDisplayBounds(displayIndex, &bounds); if (width) *width = bounds.w; if (height) *height = bounds.h; }
WindowMode getDisplaySize() const override { SDL_DisplayMode new_mode; int display_index = 0; if(window_ != nullptr) { display_index = SDL_GetWindowDisplayIndex(window_.get()); } SDL_GetDesktopDisplayMode(display_index, &new_mode); WindowMode mode = { new_mode.w, new_mode.h, std::make_shared<SDLPixelFormat>(new_mode.format), new_mode.refresh_rate }; return mode; }
static int get_refresh_rate(SDL_Window * win) { SDL_DisplayMode mode; int displayIndex = SDL_GetWindowDisplayIndex(win); if (SDL_GetDesktopDisplayMode(displayIndex, &mode) != 0 ) { return 0; } else { return mode.refresh_rate; } }
static uint32_t getRefreshRate(SDL_Window* window) { int displayIndex = SDL_GetWindowDisplayIndex(window); SDL_DisplayMode displayMode; //stores refresh rate if(SDL_GetDesktopDisplayMode(displayIndex, &displayMode) != 0 && displayMode.refresh_rate != 0) { return displayMode.refresh_rate; } return DEFAULT_REFRESH_RATE; }
static void get_closest_mode(int *w, int *h) { SDL_DisplayMode wantedmode, closestmode; wantedmode.w = *w; wantedmode.h = *h; wantedmode.format = 0; /* don't care for rest. */ wantedmode.refresh_rate = 0; wantedmode.driverdata = 0; if (SDL_GetClosestDisplayMode(window?SDL_GetWindowDisplayIndex(window):0, &wantedmode, &closestmode) == &closestmode) { *w=closestmode.w; *h=closestmode.h; } }
void ProcessEvent(OpenBlox::OBGame* gameInst, SDL_Event event){ switch(event.type){ case SDL_MOUSEMOTION: { SDL_MouseMotionEvent motion = event.motion; gameInst->mouseMove(QPoint(motion.x, motion.y)); break; } case SDL_MOUSEBUTTONDOWN: { SDL_MouseButtonEvent btn = event.button; gameInst->mousePress(btn.button, QPoint(btn.x, btn.y)); break; } case SDL_KEYDOWN: { SDL_KeyboardEvent keyEvt = event.key; SDL_Keysym key = keyEvt.keysym; #ifndef OPENBLOX_STUDIO if(key.sym == SDLK_F11){ if((SDL_GetWindowFlags(OpenBlox::mw) & SDL_WINDOW_FULLSCREEN) == SDL_WINDOW_FULLSCREEN){ SDL_SetWindowFullscreen(OpenBlox::mw, 0); }else{ SDL_DisplayMode dm; if(SDL_GetDesktopDisplayMode(SDL_GetWindowDisplayIndex(OpenBlox::mw), &dm) == 0){ SDL_SetWindowDisplayMode(OpenBlox::mw, &dm); } SDL_SetWindowFullscreen(OpenBlox::mw, SDL_WINDOW_FULLSCREEN); } } #endif break; } case SDL_KEYUP: { SDL_KeyboardEvent keyEvt = event.key; SDL_Keysym key = keyEvt.keysym; Q_UNUSED(key) break; } case SDL_WINDOWEVENT: { SDL_WindowEvent wevt = event.window; switch(wevt.event){ case SDL_WINDOWEVENT_RESIZED: { gameInst->resized(); } } break; } case SDL_QUIT: { shouldQuit = true; break; } } }
static void video_check_fullscreen_sanity(void) { SDL_DisplayMode mode; if(SDL_GetCurrentDisplayMode(SDL_GetWindowDisplayIndex(video.window), &mode)) { log_warn("SDL_GetCurrentDisplayMode failed: %s", SDL_GetError()); return; } if(video.current.width != mode.w || video.current.height != mode.h) { log_warn("BUG: window is not actually fullscreen after modesetting. Video mode: %ix%i, window size: %ix%i", mode.w, mode.h, video.current.width, video.current.height); } }
static int32_t sdl_get_refresh_rate(SDL_Window* window) { int32_t result; int32_t index; SDL_DisplayMode mode; /* default refresh rate is 60 Hz */ result = DEFAULT_REFRESH_RATE; index = SDL_GetWindowDisplayIndex(window); if ((SDL_GetDesktopDisplayMode(index, &mode) == 0) && (mode.refresh_rate != 0)) { result = mode.refresh_rate; } return (result); }
//-------------------------------------------------------------------------------------------- bool SDLX_Get_Screen_Info( SDLX_screen_info_t& psi, bool make_report ) { Uint32 init_flags = 0; SDL_Window *window; init_flags = SDL_WasInit( SDL_INIT_EVERYTHING ); if ( 0 == init_flags ) { if ( make_report ) Log::get().message("ERROR: SDLX_Get_Screen_Info() called before initializing SDL\n"); return false; } else if ( HAS_NO_BITS( init_flags, SDL_INIT_VIDEO ) ) { if ( make_report ) Log::get().message("ERROR: SDLX_Get_Screen_Info() called before initializing SDL video driver\n"); return false; } // store the screen info for everyone to use window = Ego::GraphicsSystem::window; psi.window = window; SDL_GetWindowSize(window, &(psi.x), &(psi.y)); SDLX_GetDrawableSize(window, &(psi.drawWidth), &(psi.drawHeight)); // Grab all the available video modes psi.video_mode_list.clear(); int displayNum = SDL_GetWindowDisplayIndex(window); int numDisplayModes = SDL_GetNumDisplayModes(displayNum); for (int i = 0; i < numDisplayModes; i++) { SDL_DisplayMode mode; SDL_GetDisplayMode(displayNum, i, &mode); psi.video_mode_list.push_back(mode); } // log the video driver info psi.szDriver = SDL_GetCurrentVideoDriver(); // grab all SDL_GL_* attributes SDLX_sdl_gl_attrib_t::download(psi.gl_att); // translate the surface flags into the bitfield SDLX_sdl_video_flags_t::download(psi.flags, SDL_GetWindowFlags(window)); if (make_report) { SDLX_screen_info_t::report(psi); } return true; }
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); }
bool Window::setFullscreen(bool fullscreen, Window::FullscreenType fstype) { if (!window) return false; if (graphics.get() && graphics->isCanvasActive()) throw love::Exception("love.window.setFullscreen cannot be called while a Canvas is active in love.graphics."); WindowSettings newsettings = settings; newsettings.fullscreen = fullscreen; newsettings.fstype = fstype; Uint32 sdlflags = 0; if (fullscreen) { if (fstype == FULLSCREEN_DESKTOP) sdlflags = SDL_WINDOW_FULLSCREEN_DESKTOP; else { sdlflags = SDL_WINDOW_FULLSCREEN; SDL_DisplayMode mode = {}; mode.w = windowWidth; mode.h = windowHeight; SDL_GetClosestDisplayMode(SDL_GetWindowDisplayIndex(window), &mode, &mode); SDL_SetWindowDisplayMode(window, &mode); } } #ifdef LOVE_ANDROID love::android::setImmersive(fullscreen); #endif if (SDL_SetWindowFullscreen(window, sdlflags) == 0) { SDL_GL_MakeCurrent(window, context); updateSettings(newsettings, true); // Apparently this gets un-set when we exit fullscreen (at least in OS X). if (!fullscreen) SDL_SetWindowMinimumSize(window, settings.minwidth, settings.minheight); return true; } return false; }
GHOST_TUns16 GHOST_WindowSDL::getDPIHint() { int displayIndex = SDL_GetWindowDisplayIndex(m_sdl_win); if (displayIndex < 0) { return 96; } float ddpi; if (SDL_GetDisplayDPI(displayIndex, &ddpi, NULL, NULL) != 0) { return 96; } return (int)ddpi; }
PPSize PPDisplayDevice::getDisplayResolution() const { // Find the monitor MilkyTracker is being displayed on int currentDisplay = SDL_GetWindowDisplayIndex(theWindow); // Structure to hold the display resolution SDL_DisplayMode* displayMode = new SDL_DisplayMode; // If this fails, return -1 dimensions (makes MilkyTracker display an error) if (SDL_GetDesktopDisplayMode(currentDisplay, displayMode) != 0) { return PPSize(-1, -1); } // Return the desktop size return PPSize(displayMode->w, displayMode->h); }
bool FLinuxWindow::GetFullScreenInfo( int32& X, int32& Y, int32& Width, int32& Height ) const { SDL_Rect DisplayRect; int DisplayIdx = SDL_GetWindowDisplayIndex(HWnd); if (DisplayIdx >= 0 && SDL_GetDisplayBounds(DisplayIdx, &DisplayRect) == 0) { X = DisplayRect.x; Y = DisplayRect.y; Width = DisplayRect.w; Height = DisplayRect.h; return true; } return false; }
void Window::handle() { this->_displayIndex = SDL_GetWindowDisplayIndex(this->_window); SDL_GetCurrentDisplayMode(this->_displayIndex, &this->_displayMode); SDL_GetWindowSize(this->_window, &this->_windowMode.w, &this->_windowMode.h); SDL_GetWindowPosition(this->_window, &this->_windowMode.x, &this->_windowMode.y); this->scaleRenderer(); std::cout << "The window was updated in some form!\n" << "It's currently sitting on the display with an index of " << this->_displayIndex << "\n" << "A screen width and height of " << this->_displayMode.w << " and " << this->_displayMode.h << "\n" << "And a refresh rate of " << this->_displayMode.refresh_rate << "\n" << "Oh, and now the window itself has the dimensions of " << this->_windowMode.w << " by " << this->_windowMode.h << "\n" << "At the position " << this->_windowMode.x << " and " << this->_windowMode.y << "\n"; }
std::vector<WindowMode> getWindowModes(std::function<bool(const WindowMode&)> mode_filter) const override { std::vector<WindowMode> res; int display_index = 0; if(window_ != nullptr) { display_index = SDL_GetWindowDisplayIndex(window_.get()); } const int nmodes = SDL_GetNumDisplayModes(display_index); for(int n = 0; n != nmodes; ++n) { SDL_DisplayMode new_mode; const int nvalue = SDL_GetDisplayMode(display_index, n, &new_mode); if(nvalue != 0) { LOG_ERROR("QUERYING DISPLAY INFO: " << SDL_GetError()); continue; } WindowMode mode = { new_mode.w, new_mode.h, std::make_shared<SDLPixelFormat>(new_mode.format), new_mode.refresh_rate }; // filter modes based on pixel format here if(mode_filter(mode)) { res.emplace_back(mode); } } return res; }
bool LWindow::init() { //Create window mWindow = SDL_CreateWindow( "SDL Tutorial", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE ); if( mWindow != NULL ) { mMouseFocus = true; mKeyboardFocus = true; mWidth = SCREEN_WIDTH; mHeight = SCREEN_HEIGHT; //Create renderer for window mRenderer = SDL_CreateRenderer( mWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC ); if( mRenderer == NULL ) { printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() ); SDL_DestroyWindow( mWindow ); mWindow = NULL; } else { //Initialize renderer color SDL_SetRenderDrawColor( mRenderer, 0xFF, 0xFF, 0xFF, 0xFF ); //Grab window identifiers mWindowID = SDL_GetWindowID( mWindow ); mWindowDisplayID = SDL_GetWindowDisplayIndex( mWindow ); //Flag as opened mShown = true; } } else { printf( "Window could not be created! SDL Error: %s\n", SDL_GetError() ); } return mWindow != NULL && mRenderer != NULL; }