/*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);
}