/*GLOBAL FUNCTIONS*/ void NLF_screen_init() { int flags; int aux; char *str; int sdlRet; NLF_bool saydone; /*INITIALIZING SDL_IMAGE*/ flags = IMG_INIT_JPG | IMG_INIT_PNG | IMG_INIT_TIF; if((IMG_Init(flags) & flags) != flags) { flags = IMG_INIT_TIF; if((IMG_Init(flags) & flags) != flags) { printf("\tCan't initialize SDL_image\nSDL_IMAGE ERROR: %s\n", IMG_GetError()); printf("\ttraing for TIF format... "); flags = IMG_INIT_TIF; if((IMG_Init(flags) & flags) != flags) { printf("fail\n\tSDL_IMAGE ERROR: %s\n", IMG_GetError()); tifFlag = NLF_True; }else{ printf("done\n"); tifFlag = NLF_False; } printf("\ttraing for PNG format... \n"); flags = IMG_INIT_PNG; if((IMG_Init(flags) & flags) != flags) { printf("fail\n\tSDL_IMAGE ERROR: %s\n", IMG_GetError()); pngFlag = NLF_True; }else{ printf("done\n"); pngFlag = NLF_False; } printf("\ttraing for JPG format... \n"); flags = IMG_INIT_JPG; if((IMG_Init(flags) & flags) != flags) { printf("fail\n\tSDL_IMAGE ERROR: %s\n", IMG_GetError()); jpgFlag = NLF_True; }else{ printf("done\n"); jpgFlag = NLF_False; } if(jpgFlag == NLF_False && pngFlag == NLF_False && tifFlag == NLF_False) { printf("\tScreen module initialization has failed.\n"); str = SDL_GetError(); printf("\tSDL_ERROR: %s\n", str); printf("\tAborting\n"); NLF_error_make_file_crash_report(NLF_ErrorSDLImageInitializer, "Screen module initialization has failed", "SDL Error: ", str, NULL); exit(NLF_ErrorSDLImageInitializer); } } }else{ jpgFlag = NLF_True; pngFlag = NLF_True; tifFlag = NLF_True; } /************************/ /*SETTING GLOBALS VARIABLES*/ ///GETTING DISPLAY INFORMATIONS aux = SDL_GetNumVideoDisplays(); if(aux < 0) { //error case printf("Fail trying to get video display number.\n"); str = SDL_GetError(); printf("\tSDL_ERROR: %s\n", str); printf("\tAborting\n"); NLF_error_make_file_crash_report(NLF_ErrorSDLProblem, "Fail trying to get video display number", "SDL Error: ", str, NULL); exit(aux); }else{ displayInUse = 0; printf("\n\t%d Displays avaliable, piking the number %d as pattern\n", aux, displayInUse + 1); } displayInfoUnknown = NLF_False; for(aux = 0; aux < 3; aux++) { saydone = NLF_False; if(aux == 0) sdlRet = SDL_GetCurrentDisplayMode(displayInUse, &videoMode); else if(aux == 1) sdlRet = SDL_GetDisplayMode(displayInUse, displayInUse, &videoMode); else if(aux == 2) sdlRet = SDL_GetWindowDisplayMode(displayInUse, &videoMode); if(sdlRet != 0) { if(aux == 2) { //totally unsuccessful case printf("\tSorry, impossible to get display #%d mode:\n\tSDL_ERROR: %s\n", displayInUse + 1, SDL_GetError()); printf("\tstandard 800x600 will be set\n"); displayInfoUnknown = NLF_True; }else{ printf("\tSorry, could not get display #%d mode:\n\tSDL_ERROR: %s\n", displayInUse + 1, SDL_GetError()); printf("\ttrying another way...\n"); saydone = NLF_True; } }else{ printf("\tcurrent display(%d) mode detected %dx%dpx @ %dhz. \n", displayInUse + 1, videoMode.w, videoMode.h, videoMode.refresh_rate); if(videoMode.w == 0 || videoMode.h == 0 || videoMode.refresh_rate == 0) { printf("\tSorry, could not get all display #%d mode information\n", displayInUse + 1); printf("\ttrying another way...\n"); saydone = NLF_True; }else{ printf("\tdone\n"); aux = 3; } } } ///**************************** /*SETTING SOME GLOBAL VARIABLES*/ camera.x = 0; camera.y = 0; if(displayInfoUnknown == NLF_False) { camera.w = 800; camera.h = 600; }else{ camera.w = videoMode.w; camera.h = videoMode.h; } screens = NULL; currentFPS = 0; //there's just no need to the FPS be greater then the display refresh rate (videoMode.refresh_rate >= 60 || videoMode.refresh_rate == 0) ? (idealFPS = 60): (idealFPS = videoMode.refresh_rate); /*******************************/ ///CREATING WINDOW SET window = SDL_CreateWindow("NorthLionFramework Game", 0, 0, camera.w, camera.h, SDL_WINDOW_BORDERLESS | SDL_WINDOW_MAXIMIZED); if(window == NULL) { printf("\tCould not craete the window\n"); str = SDL_GetError(); printf("\tSDL_ERROR: %s\n", str); printf("\tAborting\n"); NLF_error_make_file_crash_report(NLF_ErrorSDLProblem, "Could not craete the window", "SDL Error: ", str, NULL); exit(NLF_ErrorSDLProblem); //I don't know what to do else but quiting... you know, we need a window .-. } //this loop will try to initialize the render the best way possible for(aux = 0; aux < 4 && window_rederer == NULL; aux++) { switch(aux) { case 0: flags = SDL_RENDERER_SOFTWARE | SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE; break; case 1: flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE; break; case 2: flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC; break; case 3: flags = SDL_RENDERER_ACCELERATED; break; } if(aux > 0) printf("\ttrying flags(%d)... ", flags); window_rederer = SDL_CreateRenderer(window, -1, flags); if(window_rederer == NULL) { if(aux > 0) printf("fail\n"); if(aux != 3) { printf("\tCould not create render with all flags(%d)\n", flags); printf("\tSDL_ERROR: %s\n", SDL_GetError()); }else{ printf("\tIt was impossible to create the render.\n"); str = SDL_GetError(); printf("\tSDL_ERROR: %s\n", str); printf("\tAborting\n"); NLF_error_make_file_crash_report(NLF_ErrorSDLProblem, "It was impossible to create the render", "SDL Error: ", str, NULL); exit(NLF_ErrorSDLProblem); //I don't know what to do else but quiting... you know, we also need a renderer .-. } }else{ if(aux > 0) printf("done\n"); } } if(aux > 0) ///******************* ///GETTING VIDEO CARD INFORMATION aux = 0; if(SDL_GetRendererInfo(window_rederer, &rendererInfo) < 0) { printf("\tCould not get information about the renderer.\n"); printf("\tSDL_ERROR: %s\n", SDL_GetError()); rendererInfoUnknown = NLF_True; }else{ aux = 1; rendererInfoUnknown = NLF_False; } if(SDL_GetRenderDriverInfo(displayInUse, &rendererDriverInfo) < 0) { printf("\tCould not get information about the renderer driver.\n"); printf("\tSDL_ERROR: %s\n", SDL_GetError()); rendererDriverInfoUnkown = NLF_True; }else{ aux = 1; rendererDriverInfoUnkown = NLF_False; } ///****************************** /***************************/ }
/* =============== GLimp_DetectAvailableModes =============== */ static void GLimp_DetectAvailableModes( void ) { 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 ); } }
SDL_bool SDLTest_CommonInit(SDLTest_CommonState * state) { int i, j, m, n, w, h; SDL_DisplayMode fullscreen_mode; if (state->flags & SDL_INIT_VIDEO) { if (state->verbose & VERBOSE_VIDEO) { n = SDL_GetNumVideoDrivers(); if (n == 0) { fprintf(stderr, "No built-in video drivers\n"); } else { fprintf(stderr, "Built-in video drivers:"); for (i = 0; i < n; ++i) { if (i > 0) { fprintf(stderr, ","); } fprintf(stderr, " %s", SDL_GetVideoDriver(i)); } fprintf(stderr, "\n"); } } if (SDL_VideoInit(state->videodriver) < 0) { fprintf(stderr, "Couldn't initialize video driver: %s\n", SDL_GetError()); return SDL_FALSE; } if (state->verbose & VERBOSE_VIDEO) { fprintf(stderr, "Video driver: %s\n", SDL_GetCurrentVideoDriver()); } /* Upload GL settings */ SDL_GL_SetAttribute(SDL_GL_RED_SIZE, state->gl_red_size); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, state->gl_green_size); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, state->gl_blue_size); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, state->gl_alpha_size); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, state->gl_double_buffer); SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, state->gl_buffer_size); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, state->gl_depth_size); SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, state->gl_stencil_size); SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, state->gl_accum_red_size); SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, state->gl_accum_green_size); SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, state->gl_accum_blue_size); SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, state->gl_accum_alpha_size); SDL_GL_SetAttribute(SDL_GL_STEREO, state->gl_stereo); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, state->gl_multisamplebuffers); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, state->gl_multisamplesamples); if (state->gl_accelerated >= 0) { SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, state->gl_accelerated); } SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, state->gl_retained_backing); if (state->gl_major_version) { SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, state->gl_major_version); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, state->gl_minor_version); } if (state->verbose & VERBOSE_MODES) { SDL_Rect bounds; SDL_DisplayMode mode; int bpp; Uint32 Rmask, Gmask, Bmask, Amask; n = SDL_GetNumVideoDisplays(); fprintf(stderr, "Number of displays: %d\n", n); for (i = 0; i < n; ++i) { fprintf(stderr, "Display %d: %s\n", i, SDL_GetDisplayName(i)); SDL_zero(bounds); SDL_GetDisplayBounds(i, &bounds); fprintf(stderr, "Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y); SDL_GetDesktopDisplayMode(i, &mode); SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask, &Bmask, &Amask); fprintf(stderr, " Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n", mode.w, mode.h, mode.refresh_rate, bpp, SDL_GetPixelFormatName(mode.format)); if (Rmask || Gmask || Bmask) { fprintf(stderr, " Red Mask = 0x%.8x\n", Rmask); fprintf(stderr, " Green Mask = 0x%.8x\n", Gmask); fprintf(stderr, " Blue Mask = 0x%.8x\n", Bmask); if (Amask) fprintf(stderr, " Alpha Mask = 0x%.8x\n", Amask); } /* Print available fullscreen video modes */ m = SDL_GetNumDisplayModes(i); if (m == 0) { fprintf(stderr, "No available fullscreen video modes\n"); } else { fprintf(stderr, " Fullscreen video modes:\n"); for (j = 0; j < m; ++j) { SDL_GetDisplayMode(i, j, &mode); SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask, &Bmask, &Amask); fprintf(stderr, " Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n", j, mode.w, mode.h, mode.refresh_rate, bpp, SDL_GetPixelFormatName(mode.format)); if (Rmask || Gmask || Bmask) { fprintf(stderr, " Red Mask = 0x%.8x\n", Rmask); fprintf(stderr, " Green Mask = 0x%.8x\n", Gmask); fprintf(stderr, " Blue Mask = 0x%.8x\n", Bmask); if (Amask) fprintf(stderr, " Alpha Mask = 0x%.8x\n", Amask); } } } } } if (state->verbose & VERBOSE_RENDER) { SDL_RendererInfo info; n = SDL_GetNumRenderDrivers(); if (n == 0) { fprintf(stderr, "No built-in render drivers\n"); } else { fprintf(stderr, "Built-in render drivers:\n"); for (i = 0; i < n; ++i) { SDL_GetRenderDriverInfo(i, &info); SDLTest_PrintRenderer(&info); } } } SDL_zero(fullscreen_mode); switch (state->depth) { case 8: fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8; break; case 15: fullscreen_mode.format = SDL_PIXELFORMAT_RGB555; break; case 16: fullscreen_mode.format = SDL_PIXELFORMAT_RGB565; break; case 24: fullscreen_mode.format = SDL_PIXELFORMAT_RGB24; break; default: fullscreen_mode.format = SDL_PIXELFORMAT_RGB888; break; } fullscreen_mode.refresh_rate = state->refresh_rate; state->windows = (SDL_Window **) SDL_malloc(state->num_windows * sizeof(*state->windows)); state->renderers = (SDL_Renderer **) SDL_malloc(state->num_windows * sizeof(*state->renderers)); if (!state->windows || !state->renderers) { fprintf(stderr, "Out of memory!\n"); return SDL_FALSE; } for (i = 0; i < state->num_windows; ++i) { char title[1024]; if (state->num_windows > 1) { SDL_snprintf(title, SDL_arraysize(title), "%s %d", state->window_title, i + 1); } else { SDL_strlcpy(title, state->window_title, SDL_arraysize(title)); } state->windows[i] = SDL_CreateWindow(title, state->window_x, state->window_y, state->window_w, state->window_h, state->window_flags); if (!state->windows[i]) { fprintf(stderr, "Couldn't create window: %s\n", SDL_GetError()); return SDL_FALSE; } if (state->window_minW || state->window_minH) { SDL_SetWindowMinimumSize(state->windows[i], state->window_minW, state->window_minH); } if (state->window_maxW || state->window_maxH) { SDL_SetWindowMaximumSize(state->windows[i], state->window_maxW, state->window_maxH); } SDL_GetWindowSize(state->windows[i], &w, &h); if (!(state->window_flags & SDL_WINDOW_RESIZABLE) && (w != state->window_w || h != state->window_h)) { printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h); state->window_w = w; state->window_h = h; } if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) { fprintf(stderr, "Can't set up fullscreen display mode: %s\n", SDL_GetError()); return SDL_FALSE; } if (state->window_icon) { SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon); if (icon) { SDL_SetWindowIcon(state->windows[i], icon); SDL_FreeSurface(icon); } } SDL_ShowWindow(state->windows[i]); state->renderers[i] = NULL; if (!state->skip_renderer && (state->renderdriver || !(state->window_flags & SDL_WINDOW_OPENGL))) { m = -1; if (state->renderdriver) { SDL_RendererInfo info; n = SDL_GetNumRenderDrivers(); for (j = 0; j < n; ++j) { SDL_GetRenderDriverInfo(j, &info); if (SDL_strcasecmp(info.name, state->renderdriver) == 0) { m = j; break; } } if (m == n) { fprintf(stderr, "Couldn't find render driver named %s", state->renderdriver); return SDL_FALSE; } } state->renderers[i] = SDL_CreateRenderer(state->windows[i], m, state->render_flags); if (!state->renderers[i]) { fprintf(stderr, "Couldn't create renderer: %s\n", SDL_GetError()); return SDL_FALSE; } if (state->verbose & VERBOSE_RENDER) { SDL_RendererInfo info; fprintf(stderr, "Current renderer:\n"); SDL_GetRendererInfo(state->renderers[i], &info); SDLTest_PrintRenderer(&info); } } } } if (state->flags & SDL_INIT_AUDIO) { if (state->verbose & VERBOSE_AUDIO) { n = SDL_GetNumAudioDrivers(); if (n == 0) { fprintf(stderr, "No built-in audio drivers\n"); } else { fprintf(stderr, "Built-in audio drivers:"); for (i = 0; i < n; ++i) { if (i > 0) { fprintf(stderr, ","); } fprintf(stderr, " %s", SDL_GetAudioDriver(i)); } fprintf(stderr, "\n"); } } if (SDL_AudioInit(state->audiodriver) < 0) { fprintf(stderr, "Couldn't initialize audio driver: %s\n", SDL_GetError()); return SDL_FALSE; } if (state->verbose & VERBOSE_VIDEO) { fprintf(stderr, "Audio driver: %s\n", SDL_GetCurrentAudioDriver()); } if (SDL_OpenAudio(&state->audiospec, NULL) < 0) { fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError()); return SDL_FALSE; } } return SDL_TRUE; }
/* =============== GLimp_DetectAvailableModes =============== */ static void GLimp_DetectAvailableModes(void) { int i, j; char buf[ MAX_STRING_CHARS ] = { 0 }; size_t numSDLModes; SDL_Rect *modes; int numModes = 0; int display = SDL_GetWindowDisplayIndex( SDL_window ); SDL_DisplayMode windowMode; if( SDL_GetWindowDisplayMode( SDL_window, &windowMode ) < 0 ) { ri.Printf( PRINT_WARNING, "Couldn't get window display mode, no resolutions detected\n" ); return; } numSDLModes = SDL_GetNumDisplayModes( display ); modes = SDL_calloc( numSDLModes, sizeof( SDL_Rect ) ); if ( !modes ) { ri.Error( ERR_FATAL, "Out of memory" ); } for( i = 0; i < numSDLModes; 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" ); SDL_free( modes ); return; } if( windowMode.format != mode.format ) continue; // SDL can give the same resolution with different refresh rates. // Only list resolution once. for( j = 0; j < numModes; j++ ) { if( mode.w == modes[ j ].w && mode.h == modes[ j ].h ) break; } if( j != numModes ) 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%u, buffer too small\n", modes[ i ].w, modes[ i ].h ); } if( *buf ) { buf[ strlen( buf ) - 1 ] = 0; ri.Printf( PRINT_ALL, "Available modes: '%s'\n", buf ); ri.Cvar_Set( "r_availableModes", buf ); } SDL_free( modes ); }
bool Graphics::SelectResolution() { SDL_DisplayMode curr, close; curr.w = 320; curr.h = 240; curr.driverdata = NULL; curr.refresh_rate = 0; curr.format = 0; // Getting biggest display mode // On iPhone 4S (retina device) there is two set of resolutions. // On iPad 2 - only one set. int displayModes = SDL_GetNumDisplayModes(0); if (displayModes <= 0) { staterr("SDL_GetNumDisplayModes modes count = %d, %s", displayModes, SDL_GetError()); return true; } int maxw = 0; int maxi = 0; for (int i = 0; i < displayModes; ++i) { if (SDL_GetDisplayMode(0, i, &close)) { staterr("SDL_GetDisplayMode %s", SDL_GetError()); return true; } int w = close.w > close.h ? close.w : close.h; if (w > maxw) { maxw = w; maxi = i; } } if (SDL_GetDisplayMode(0, maxi, &close)) { staterr("SDL_GetDisplayMode %s", SDL_GetError()); return true; } if (close.w < close.h) std::swap(close.w, close.h); stat("closest w = %d, h = %d, dm = %u", close.w, close.h, close.format); // Scale will be set by the width. Width will be changed to be best possible // Height will be set by scale. // Both width and height will be made even. // iPad 1/2 // 1024/320 = 3.2 = 3; 1024/3 = 341.3 = 341 = 340 // 768/3 = 256 // iPad 3/4 // 2048/320 = 6.4 = 6; 2048/6 = 341.3 = 341 = 340 // 1536/6 = 256 // iPhone 4/4s // 960/320 = 3; 960 / 3 = 320 // 640/3 = 213.3 = 213 = 212 // iPhone 5 // 1136/320 = 3.55 = 3; 1136/3 = 378.6 = 378 // 640/3 = 213.3 = 213 = 212 // TODO something with former versions of iPhone. // Scale factor must be 1.5 on them. int wf = close.w / 320; Graphics::SCREEN_WIDTH = int((close.w / wf) & 0xfffffffe); Graphics::SCREEN_HEIGHT = int((close.h / wf) & 0xfffffffe); NXSurface::SetScale(wf); return false; }
/** * @brief Initializes Game Window. * @param TITLE Set the title of the Window. * @param Background Set the background of the window. * @param SDL_SCREEN_FLAGS Start the window with given flags. * @return Returns 0 on success. */ int GameWindow::init( const char* TITLE , SDL_Color Background , int SDL_SCREEN_FLAGS ) { //If it already was inited, do not bother with it again if ( this->inited ) return 0; //Support for Resizeable windows //Check if the settings contain the option bool resizable; if ( this->content->Settings()->getBool ( "window" , "resizeable" , &resizable ) == true ) { //Evaluate if the option is set on if ( resizable ) { SDL_SCREEN_FLAGS |= SDL_WINDOW_RESIZABLE; } } //Support for fullscreen windows //Check if the settings contain the option bool fullscreen; if ( this->content->Settings()->getBool ( "window" , "fullscreen", &fullscreen ) == true ) { //Evaluate if the option is set on if ( fullscreen ) { SDL_SCREEN_FLAGS |= //Build option to use SDL_WINDOW_FULLSCREEN instead of DESKTOP #ifdef GAME_WINDOW_USE_WINDOW_FULLSCREEN SDL_WINDOW_FULLSCREEN; #else SDL_WINDOW_FULLSCREEN_DESKTOP; #endif } } int display = 0; this->content->Settings()->getInt ( "window" , "display" , &display ); //Set display to be rendered to SDL_DisplayMode display_mode; if ( SDL_GetDisplayMode( display , 0 , &display_mode ) != 0 ) { display = 0; std::cout << "An error has occurred" << std::endl << SDL_GetError() << std::endl; std::cout << "Defaulting to display index : " << display << std::endl; } int WIDTH = 800; if ( this->content->Settings()->getInt( "window" , "width" , &WIDTH ) == false ) { std::string native; if ( this->content->Settings()->get ( "window" , "width" , &native ) == true ) { if ( native == "native" ) { //Set height as native screen width SDL_DisplayMode dm; if ( SDL_GetDesktopDisplayMode( display , &dm ) == 0 ) { WIDTH = dm.w; } } } if ( WIDTH == 800 ) { std::cout << "Warning! Window width is set to default, 800px" << std::endl; } } int HIEGHT = 600; if ( this->content->Settings()->getInt( "window" , "height" , &HIEGHT ) == false ) { std::string native; if ( this->content->Settings()->get ( "window" , "height" , &native ) == true ) { if ( native == "native" ) { //Set height as native screen height SDL_DisplayMode dm; if ( SDL_GetDesktopDisplayMode( display , &dm ) == 0 ) { HIEGHT = dm.h; } } } if ( HIEGHT == 600 ) { std::cout << "Warning! Window height is set to default, 600px" << std::endl; } } //Create the window this->window = SDL_CreateWindow ( TITLE , SDL_WINDOWPOS_CENTERED_DISPLAY( display ) , SDL_WINDOWPOS_CENTERED_DISPLAY( display ) , WIDTH , HIEGHT , SDL_SCREEN_FLAGS ); //Set minimum size of window (640x480) SDL_SetWindowMinimumSize( this->window , 640, 480 ); SDL_SetWindowDisplayMode( this->window , &display_mode ); //Check if the window was created if ( this->window == nullptr ) { std::cout << "An error has occurred" << std::endl << SDL_GetError() << std::endl; std::cerr << SDL_GetError() << std::endl; return 1; } int render_flags = SDL_RENDERER_ACCELERATED; //Support for SDL_Render VSync //Check if the settings contain the option bool vsync; if ( this->content->Settings()->getBool ( "window" , "vsync" , &vsync ) ) { //Evaluate if the option is set on if ( vsync ) { //render_flags |= SDL_RENDERER_PRESENTVSYNC; this->CAP_FRAMES = true; } } int FRAME_LIMIT = display_mode.refresh_rate; if ( this->content->Settings()->getInt ( "window" , "framelimit" , &FRAME_LIMIT ) ) { std::cout << FRAME_LIMIT << std::endl; if ( FRAME_LIMIT > 0 ) { this->FRAME_LIMIT = FRAME_LIMIT; } else { std::cout << "Cannot set negative Frame Limit " << FRAME_LIMIT << std::endl; } } else { this->FRAME_LIMIT = FRAME_LIMIT; } bool windowborder = false; if ( this->content->Settings()->getBool ( "window" , "borderless" , &windowborder ) ) { if ( windowborder ) { SDL_SetWindowBordered( this->window , SDL_FALSE ); } } //Create Renderer this->renderer = SDL_CreateRenderer ( this->window , -1 , render_flags ); //Make sure it was created correctly if ( this->renderer == nullptr ) { std::cout << "An error has occurred" << std::endl << SDL_GetError() << std::endl; std::cerr << SDL_GetError() << std::endl; return 1; } //Set background colour this->background = Background; //Check if the System has a battery this->has_battery = etc::has_battery(); //Camera bnounds this->camera.setBounds( WIDTH , HIEGHT ); this->camera.setPosition( 0, 0 ); this->textures = graphics::TextureManager(this->renderer); this->content->Maps()->init(&(this->textures) , this->content->TileTypes()); this->content->load(); this->inited = true; //All done correctly return 0; }
bool RenderWindow2D::CreateWindowAndRenderer(unsigned int width, unsigned int height) { int iRet = SDL_Init(SDL_INIT_VIDEO); if (iRet < 0) { ATLTRACE(_T("couldn't init SDL\n")); return false; } unsigned int scaledWidth = width * scaleFactor; unsigned int scaledHeight = height * scaleFactor; SDL_DisplayMode mode = {0}; if (SDL_GetDisplayMode(0, 0, &mode) < 0) { return false; } int bitsPerPixel = SDL_BITSPERPIXEL(mode.format) == 24 ? 32 : SDL_BITSPERPIXEL(mode.format); unscaledSurfaceBuffer.resize(width * height * (bitsPerPixel / 8), 0); SDL_Window* rawWindow = nullptr; SDL_Renderer* rawRenderer = nullptr; SDL_CreateWindowAndRenderer( scaledWidth, scaledHeight, SDL_WINDOW_SHOWN | SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC, &rawWindow, &rawRenderer); if (rawWindow == nullptr || rawRenderer == nullptr) return false; window.reset(rawWindow, &SDL_DestroyWindow); renderer.reset(rawRenderer, &SDL_DestroyRenderer); SDL_RenderSetLogicalSize(renderer.get(), scaledWidth, scaledHeight); ATLTRACE(_T("SDL window, res=%ux%u, %i bpp, refresh rate: %i Hz\n"), scaledWidth, scaledHeight, bitsPerPixel, mode.refresh_rate); // create texture Uint32 pixelFormat = bitsPerPixel == 16 ? SDL_PIXELFORMAT_RGB565 : SDL_PIXELFORMAT_ARGB8888; int bpp = 0; Uint32 rmask = 0, gmask = 0, bmask = 0, amask = 0; SDL_PixelFormatEnumToMasks(pixelFormat, &bpp, &rmask, &gmask, &bmask, &amask); SDL_Surface* rawSurface = SDL_CreateRGBSurface(0, scaledWidth, scaledHeight, bpp, rmask, gmask, bmask, amask); if (rawSurface == nullptr) return false; surface.reset(rawSurface, &SDL_FreeSurface); SDL_Texture* rawTexture = SDL_CreateTexture( renderer.get(), pixelFormat, SDL_TEXTUREACCESS_STREAMING, scaledWidth, scaledHeight); if (rawTexture != nullptr) texture.reset(rawTexture, &SDL_DestroyTexture); return rawTexture != nullptr; }
SettingsWindow::SettingsWindow() : WindowBase("openmw_settings_window.layout"), mKeyboardMode(true) { configureWidgets(mMainWidget); setTitle("#{sOptions}"); getWidget(mSettingsTab, "SettingsTab"); getWidget(mOkButton, "OkButton"); getWidget(mResolutionList, "ResolutionList"); getWidget(mFullscreenButton, "FullscreenButton"); getWidget(mWindowBorderButton, "WindowBorderButton"); getWidget(mTextureFilteringButton, "TextureFilteringButton"); getWidget(mAnisotropyBox, "AnisotropyBox"); getWidget(mControlsBox, "ControlsBox"); getWidget(mResetControlsButton, "ResetControlsButton"); getWidget(mKeyboardSwitch, "KeyboardButton"); getWidget(mControllerSwitch, "ControllerButton"); getWidget(mWaterTextureSize, "WaterTextureSize"); #ifndef WIN32 // hide gamma controls since it currently does not work under Linux MyGUI::ScrollBar *gammaSlider; getWidget(gammaSlider, "GammaSlider"); gammaSlider->setVisible(false); MyGUI::TextBox *textBox; getWidget(textBox, "GammaText"); textBox->setVisible(false); getWidget(textBox, "GammaTextDark"); textBox->setVisible(false); getWidget(textBox, "GammaTextLight"); textBox->setVisible(false); #endif mMainWidget->castType<MyGUI::Window>()->eventWindowChangeCoord += MyGUI::newDelegate(this, &SettingsWindow::onWindowResize); mSettingsTab->eventTabChangeSelect += MyGUI::newDelegate(this, &SettingsWindow::onTabChanged); mOkButton->eventMouseButtonClick += MyGUI::newDelegate(this, &SettingsWindow::onOkButtonClicked); mTextureFilteringButton->eventComboChangePosition += MyGUI::newDelegate(this, &SettingsWindow::onTextureFilteringChanged); mResolutionList->eventListChangePosition += MyGUI::newDelegate(this, &SettingsWindow::onResolutionSelected); mWaterTextureSize->eventComboChangePosition += MyGUI::newDelegate(this, &SettingsWindow::onWaterTextureSizeChanged); mKeyboardSwitch->eventMouseButtonClick += MyGUI::newDelegate(this, &SettingsWindow::onKeyboardSwitchClicked); mControllerSwitch->eventMouseButtonClick += MyGUI::newDelegate(this, &SettingsWindow::onControllerSwitchClicked); center(); mResetControlsButton->eventMouseButtonClick += MyGUI::newDelegate(this, &SettingsWindow::onResetDefaultBindings); // fill resolution list int screen = Settings::Manager::getInt("screen", "Video"); int numDisplayModes = SDL_GetNumDisplayModes(screen); std::vector < std::pair<int, int> > resolutions; for (int i = 0; i < numDisplayModes; i++) { SDL_DisplayMode mode; SDL_GetDisplayMode(screen, i, &mode); resolutions.push_back(std::make_pair(mode.w, mode.h)); } std::sort(resolutions.begin(), resolutions.end(), sortResolutions); for (std::vector < std::pair<int, int> >::const_iterator it=resolutions.begin(); it!=resolutions.end(); ++it) { std::string str = MyGUI::utility::toString(it->first) + " x " + MyGUI::utility::toString(it->second) + " (" + getAspect(it->first,it->second) + ")"; if (mResolutionList->findItemIndexWith(str) == MyGUI::ITEM_NONE) mResolutionList->addItem(str); } highlightCurrentResolution(); std::string tmip = Settings::Manager::getString("texture mipmap", "General"); mTextureFilteringButton->setCaption(textureMipmappingToStr(tmip)); int waterTextureSize = Settings::Manager::getInt ("rtt size", "Water"); if (waterTextureSize >= 512) mWaterTextureSize->setIndexSelected(0); if (waterTextureSize >= 1024) mWaterTextureSize->setIndexSelected(1); if (waterTextureSize >= 2048) mWaterTextureSize->setIndexSelected(2); mWindowBorderButton->setEnabled(!Settings::Manager::getBool("fullscreen", "Video")); mKeyboardSwitch->setStateSelected(true); mControllerSwitch->setStateSelected(false); }