void AddSupportedModesForBPP(GraphicsDevice *device, int bpp)
{
SDL_Rect** modes;
SDL_PixelFormat fmt;
int i;
memset(&fmt, 0, sizeof fmt);
fmt.BitsPerPixel = (Uint8)bpp;
modes = SDL_ListModes(&fmt, SDL_FULLSCREEN);
if (modes == (SDL_Rect**)0)
{
return;
}
if (modes == (SDL_Rect**)-1)
{
return;
}
for (i = 0; modes[i]; i++)
{
int validScaleFactors[] = { 1, 2, 3, 4 };
int j;
for (j = 0; j < 4; j++)
{
int scaleFactor = validScaleFactors[j];
int w, h;
if (modes[i]->w % scaleFactor || modes[i]->h % scaleFactor)
{
continue;
}
if (modes[i]->w % 4)
{
// TODO: why does width have to be divisible by 4? 1366x768 doesn't work
continue;
}
w = modes[i]->w / scaleFactor;
h = modes[i]->h / scaleFactor;
if (w < 320 || h < 240)
{
break;
}
AddGraphicsMode(device, w, h, scaleFactor);
}
}
}
int CGraphics_SDL::GetVideoModes(CVideoMode *pModes, int MaxModes)
{
int NumModes = sizeof(g_aFakeModes)/sizeof(CVideoMode);
SDL_Rect **ppModes;
if(g_Config.m_GfxDisplayAllModes)
{
int Count = sizeof(g_aFakeModes)/sizeof(CVideoMode);
mem_copy(pModes, g_aFakeModes, sizeof(g_aFakeModes));
if(MaxModes < Count)
Count = MaxModes;
return Count;
}
// TODO: fix this code on osx or windows
ppModes = SDL_ListModes(NULL, SDL_OPENGL|SDL_GL_DOUBLEBUFFER|SDL_FULLSCREEN);
if(ppModes == NULL)
{
// no modes
NumModes = 0;
}
else if(ppModes == (SDL_Rect**)-1)
{
// all modes
}
else
{
NumModes = 0;
for(int i = 0; ppModes[i]; ++i)
{
if(NumModes == MaxModes)
break;
pModes[NumModes].m_Width = ppModes[i]->w;
pModes[NumModes].m_Height = ppModes[i]->h;
pModes[NumModes].m_Red = 8;
pModes[NumModes].m_Green = 8;
pModes[NumModes].m_Blue = 8;
NumModes++;
}
}
return NumModes;
}
GHOST_TSuccess GHOST_DisplayManagerSDL::getNumDisplaySettings(GHOST_TUns8 display,
GHOST_TInt32& numSettings) const
{
GHOST_ASSERT(display < 1, "Only single display systems are currently supported.\n");
int i;
SDL_Rect **vidmodes;
vidmodes = SDL_ListModes(NULL, SDL_HWSURFACE | SDL_OPENGL |
SDL_FULLSCREEN | SDL_HWPALETTE);
if (!vidmodes) {
fprintf(stderr, "Could not get available video modes: %s.\n",
SDL_GetError());
return GHOST_kFailure;
}
for (i = 0; vidmodes[i]; i++);
numSettings = GHOST_TInt32(i);
return GHOST_kSuccess;
}
/*
===============
GLimp_DetectAvailableModes
===============
*/
static void GLimp_DetectAvailableModes(void)
{
char buf[MAX_STRING_CHARS] = { 0 };
SDL_Rect **modes;
int numModes;
int i;
modes = SDL_ListModes(NULL, SDL_OPENGL | SDL_FULLSCREEN);
if(!modes)
{
ri.Printf(PRINT_WARNING, "Can't get list of available modes\n");
return;
}
if(modes == (SDL_Rect **) - 1)
{
ri.Printf(PRINT_ALL, "Display supports any resolution\n");
return; // can set any resolution
}
for(numModes = 0; modes[numModes]; numModes++);
if(numModes > 1)
qsort(modes + 1, numModes - 1, 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)
{
buf[strlen(buf) - 1] = 0;
ri.Printf(PRINT_ALL, "Available modes: '%s'\n", buf);
ri.Cvar_Set("r_availableModes", buf);
}
}
VideoQueryResult CApplication::GetVideoResolutionList(std::vector<Math::IntPoint> &resolutions,
bool fullScreen, bool resizeable)
{
resolutions.clear();
const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
if (videoInfo == nullptr)
return VIDEO_QUERY_ERROR;
Uint32 videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE;
// Use hardware surface if available
if (videoInfo->hw_available)
videoFlags |= SDL_HWSURFACE;
else
videoFlags |= SDL_SWSURFACE;
// Enable hardware blit if available
if (videoInfo->blit_hw)
videoFlags |= SDL_HWACCEL;
if (resizeable)
videoFlags |= SDL_RESIZABLE;
if (fullScreen)
videoFlags |= SDL_FULLSCREEN;
SDL_Rect **modes = SDL_ListModes(NULL, videoFlags);
if (modes == reinterpret_cast<SDL_Rect **>(0) )
return VIDEO_QUERY_NONE; // no modes available
if (modes == reinterpret_cast<SDL_Rect **>(-1) )
return VIDEO_QUERY_ALL; // all resolutions are possible
for (int i = 0; modes[i] != NULL; ++i)
resolutions.push_back(Math::IntPoint(modes[i]->w, modes[i]->h));
return VIDEO_QUERY_OK;
}
static int resol_enter(struct state *st, struct state *prev)
{
if (!st_back)
{
/* Note the parent screen if not done yet. */
st_back = prev;
}
back_init("back/gui.png");
modes = SDL_ListModes(NULL, SDL_OPENGL | SDL_FULLSCREEN);
if (modes == (SDL_Rect **) -1)
modes = NULL;
audio_music_fade_to(0.5f, "bgm/inter.ogg");
return resol_gui();
}
VIDEOMODE_resolution_t *PLATFORM_AvailableResolutions(unsigned int *size)
{
SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
VIDEOMODE_resolution_t *resolutions;
unsigned int num_modes;
unsigned int i;
if (modes == (SDL_Rect**)0 || modes == (SDL_Rect**)-1)
return NULL;
/* Determine number of available modes. */
for (num_modes = 0; modes[num_modes] != NULL; ++num_modes);
resolutions = Util_malloc(num_modes * sizeof(VIDEOMODE_resolution_t));
for (i = 0; i < num_modes; i++) {
resolutions[i].width = modes[i]->w;
resolutions[i].height = modes[i]->h;
}
*size = num_modes;
return resolutions;
}
QStringList SDLInteraction::getResolutions() const
{
QStringList result;
SDL_Rect **modes;
modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
if((modes == (SDL_Rect **)0) || (modes == (SDL_Rect **)-1))
{
result << "640x480";
} else
{
for(int i = 0; modes[i]; ++i)
if ((modes[i]->w >= 640) && (modes[i]->h >= 480))
result << QString("%1x%2").arg(modes[i]->w).arg(modes[i]->h);
}
return result;
}
std::vector<VideoMode> GetAvailableVideoModes()
{
std::vector<VideoMode> modes;
//querying modes using the current pixel format
//note - this has always been sdl_fullscreen, hopefully it does not matter
SDL_Rect **sdlmodes = SDL_ListModes(NULL, SDL_HWSURFACE | SDL_FULLSCREEN);
if (sdlmodes == 0)
OS::Error("Failed to query video modes");
if (sdlmodes == reinterpret_cast<SDL_Rect **>(-1)) {
// Modes restricted. Fall back to 800x600
modes.push_back(VideoMode(800, 600));
} else {
for (int i=0; sdlmodes[i]; ++i) {
modes.push_back(VideoMode(sdlmodes[i]->w, sdlmodes[i]->h));
}
}
return modes;
}
void PrintAttributes(void)
{
int value;
// current resolution
SDL_Surface *surface = SDL_GetVideoSurface();
SDL_PixelFormat *format = surface->format;
DebugPrint("\nCurrent: %dx%d %dbpp\n", surface->w, surface->h, format->BitsPerPixel);
// get fullscreen resolutions
DebugPrint("\nResolutions:\n");
SDL_Rect **modes = SDL_ListModes(NULL, SDL_OPENGL | SDL_FULLSCREEN);
for (SDL_Rect **mode = modes; *mode != NULL; ++mode)
DebugPrint("%dx%d\n", (*mode)->w, (*mode)->h);
const char *attrib[] =
{
"SDL_GL_RED_SIZE",
"SDL_GL_GREEN_SIZE",
"SDL_GL_BLUE_SIZE",
"SDL_GL_ALPHA_SIZE",
"SDL_GL_BUFFER_SIZE",
"SDL_GL_DOUBLEBUFFER",
"SDL_GL_DEPTH_SIZE",
"SDL_GL_STENCIL_SIZE",
"SDL_GL_ACCUM_RED_SIZE",
"SDL_GL_ACCUM_GREEN_SIZE",
"SDL_GL_ACCUM_BLUE_SIZE",
"SDL_GL_ACCUM_ALPHA_SIZE",
"SDL_GL_STEREO",
"SDL_GL_MULTISAMPLEBUFFERS",
"SDL_GL_MULTISAMPLESAMPLES",
"SDL_GL_ACCELERATED_VISUAL",
"SDL_GL_SWAP_CONTROL"
};
for (int i = 0; i < SDL_arraysize(attrib); ++i)
{
SDL_GL_GetAttribute( SDL_GLattr(i), &value );
DebugPrint( "%s: %d\n", attrib[i], value);
}
}
//! \return Pointer to a list with all video modes supported
video::IVideoModeList* CIrrDeviceSDL::getVideoModeList()
{
if (!VideoModeList.getVideoModeCount())
{
// enumerate video modes.
const SDL_VideoInfo *vi = SDL_GetVideoInfo();
SDL_Rect **modes = SDL_ListModes(vi->vfmt, SDL_Flags);
if (modes != 0)
{
if (modes == (SDL_Rect **)-1)
os::Printer::log("All modes available.\n");
else
{
for (u32 i=0; modes[i]; ++i)
VideoModeList.addMode(core::dimension2d<s32>(modes[i]->w, modes[i]->h), vi->vfmt->BitsPerPixel);
}
}
}
return &VideoModeList;
}
void PrintAvailableResolutions()
{
// Get available fullscreen/hardware modes
SDL_Rect** modes = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_OPENGL);
if (modes == (SDL_Rect**)0) {
LOG("Supported Video modes: No modes available!");
} else if (modes == (SDL_Rect**)-1) {
LOG("Supported Video modes: All modes available.");
} else {
char buffer[1024];
unsigned char n = 0;
for (int i = 0; modes[i]; ++i) {
n += SNPRINTF(&buffer[n], 1024-n, "%dx%d, ", modes[i]->w, modes[i]->h);
}
// remove last comma
if (n >= 2) {
buffer[n - 2] = '\0';
}
LOG("Supported Video modes: %s", buffer);
}
}
GHOST_TSuccess
GHOST_DisplayManagerSDL::getDisplaySetting(GHOST_TUns8 display,
GHOST_TInt32 index,
GHOST_DisplaySetting& setting) const
{
GHOST_ASSERT(display < 1, "Only single display systems are currently supported.\n");
int i;
SDL_Rect **vidmodes;
/* NULL is passed in here to get the modes for the current bit depth.
* Other bit depths may be possible; in that case, an SDL_PixelFormat struct
* should be passed in. To get a complete profile, all possible bit depths
* would need to be iterated over. - z0r */
vidmodes = SDL_ListModes(NULL, SDL_HWSURFACE | SDL_OPENGL |
SDL_FULLSCREEN | SDL_HWPALETTE);
if (!vidmodes) {
fprintf(stderr, "Could not get available video modes: %s.\n",
SDL_GetError());
return GHOST_kFailure;
}
for (i = 0; vidmodes[i]; i++);
GHOST_ASSERT(index < i, "Requested setting outside of valid range.\n");
setting.xPixels = vidmodes[index]->w;
setting.yPixels = vidmodes[index]->h;
SDL_Surface *surf;
surf = SDL_GetVideoSurface();
if (surf == NULL) {
fprintf(stderr, "Getting display setting: %s\n", SDL_GetError());
/* Just guess the bit depth */
setting.bpp = 32;
} else {
setting.bpp = surf->format->BitsPerPixel;
}
/* Just guess the frequency :( */
setting.frequency = 60;
return GHOST_kSuccess;
}
OpenGLSdlGraphicsManager::OpenGLSdlGraphicsManager(uint desktopWidth, uint desktopHeight, SdlEventSource *eventSource)
: SdlGraphicsManager(eventSource), _lastVideoModeLoad(0), _hwScreen(nullptr), _lastRequestedWidth(0), _lastRequestedHeight(0),
_graphicsScale(2), _ignoreLoadVideoMode(false), _gotResize(false), _wantsFullScreen(false), _ignoreResizeEvents(0),
_desiredFullscreenWidth(0), _desiredFullscreenHeight(0) {
// Setup OpenGL attributes for SDL
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_DEPTH_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// Retrieve a list of working fullscreen modes
const SDL_Rect *const *availableModes = SDL_ListModes(NULL, SDL_OPENGL | SDL_FULLSCREEN);
if (availableModes != (void *)-1) {
for (;*availableModes; ++availableModes) {
const SDL_Rect *mode = *availableModes;
_fullscreenVideoModes.push_back(VideoMode(mode->w, mode->h));
}
// Sort the modes in ascending order.
Common::sort(_fullscreenVideoModes.begin(), _fullscreenVideoModes.end());
}
// In case SDL is fine with every mode we will force the desktop mode.
// TODO? We could also try to add some default resolutions here.
if (_fullscreenVideoModes.empty() && desktopWidth && desktopHeight) {
_fullscreenVideoModes.push_back(VideoMode(desktopWidth, desktopHeight));
}
// Get information about display sizes from the previous runs.
if (ConfMan.hasKey("last_fullscreen_mode_width", Common::ConfigManager::kApplicationDomain) && ConfMan.hasKey("last_fullscreen_mode_height", Common::ConfigManager::kApplicationDomain)) {
_desiredFullscreenWidth = ConfMan.getInt("last_fullscreen_mode_width", Common::ConfigManager::kApplicationDomain);
_desiredFullscreenHeight = ConfMan.getInt("last_fullscreen_mode_height", Common::ConfigManager::kApplicationDomain);
} else {
// Use the desktop resolutions when no previous default has been setup.
_desiredFullscreenWidth = desktopWidth;
_desiredFullscreenHeight = desktopHeight;
}
}
// returns possible (fullscreen) resolutions if any.
int gr_list_modes( u_int32_t gsmodes[] )
{
SDL_Rect** modes;
int i = 0, modesnum = 0;
#ifdef OGLES
int sdl_check_flags = SDL_FULLSCREEN; // always use Fullscreen as lead.
#else
int sdl_check_flags = SDL_OPENGL | SDL_FULLSCREEN; // always use Fullscreen as lead.
#endif
if (sdl_no_modeswitch) {
/* TODO: we could use the tvservice to list resolutions on the RPi */
return 0;
}
modes = SDL_ListModes(NULL, sdl_check_flags);
if (modes == (SDL_Rect**)0) // check if we get any modes - if not, return 0
return 0;
if (modes == (SDL_Rect**)-1)
{
return 0; // can obviously use any resolution... strange!
}
else
{
for (i = 0; modes[i]; ++i)
{
if (modes[i]->w > 0xFFF0 || modes[i]->h > 0xFFF0 // resolutions saved in 32bits. so skip bigger ones (unrealistic in 2010) (changed to 0xFFF0 to fix warning)
|| modes[i]->w < 320 || modes[i]->h < 200) // also skip everything smaller than 320x200
continue;
gsmodes[modesnum] = SM(modes[i]->w,modes[i]->h);
modesnum++;
if (modesnum >= 50) // that really seems to be enough big boy.
break;
}
return modesnum;
}
}
void Game_reshape(Game *g) {
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA);
glBlendColor(1.f, 1.f, 1.f, 1.f);
if(g->fullscreen) {
/* La doc ne dit pas s'il faut libérer le tableau à la fin. */
SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
switch((intptr_t)modes) {
case 0: /* Aucun mode n'est disponible. */ break;
case -1: /* Tout mode peut convenir. */ break;
/* Dans les deux cas ci-dessus, on peut toujours
* passer en fullscreen, mais c'est juste moche. */
default: /* On a une liste de modes. */
g->old_window_size.x = g->window_size.x;
g->old_window_size.y = g->window_size.y;
g->window_size.x = modes[0]->w;
g->window_size.y = modes[0]->h;
break;
}
} else if(g->old_window_size.x) {
g->window_size.x = g->old_window_size.x;
g->window_size.y = g->old_window_size.y;
g->old_window_size.x = 0;
}
if(!SDL_SetVideoMode(
g->window_size.x,
g->window_size.y,
g->bits_per_pixel,
SDL_OPENGL | SDL_DOUBLEBUF | SDL_RESIZABLE
|(g->fullscreen ? SDL_FULLSCREEN : 0))) {
fprintf(stderr, "SDL_SetVideoMode() failed :\n\t%s\n Exitting.\n",
SDL_GetError());
exit(EXIT_FAILURE);
}
Game_resizeViewports(g);
Game_resizeSprites(g);
}
static VALUE sdl_listModes(VALUE mod,VALUE flags)
{
SDL_Rect **modes;
int i;
VALUE modesArray;
modes=SDL_ListModes(NULL,NUM2UINT(flags));
if( modes == NULL )
return Qnil;/* no modes available */
if( modes == (SDL_Rect **)-1)
return Qtrue;/* all resolutions available */
/* available modes into modesArray */
modesArray=rb_ary_new();
for(i=0;modes[i]!=NULL;++i){
rb_ary_push( modesArray,
rb_ary_new3( 2, INT2NUM(modes[i]->w), INT2NUM(modes[i]->h)) );
}
return modesArray;
}
int initFullScreen(unsigned int * width,unsigned int * height)
{
SDL_Rect ** modes;
modes = SDL_ListModes(NULL,SDL_FULLSCREEN|SDL_OPENGL);
if ((modes == (SDL_Rect **)0)||(modes == (SDL_Rect **)-1))
return 0;
if (width != NULL)
*width = modes[0]->w;
if (height != NULL)
*height = modes[0]->h;
if (SDL_SetVideoMode(modes[0]->w,
modes[0]->h,
SDL_GetVideoInfo()->vfmt->BitsPerPixel,
SDL_FULLSCREEN|SDL_OPENGL) == NULL)
return -1;
else
{
return 0;
}
}
static void get_closest_mode(int *w, int *h) {
int i;
int bestw,besth;
SDL_Rect **modes = modes=SDL_ListModes(NULL, SDL_FULLSCREEN);
bestw=99999;
besth=99999;
if(modes != (SDL_Rect **)0 && modes != (SDL_Rect **)-1){
for(i=0;modes[i];++i) {
if (modes[i]->w >= *w && modes[i]->w <= bestw
&& modes[i]->h >= *h && modes[i]->h <= besth
&& SDL_VideoModeOK(modes[i]->w, modes[i]->h, 32, SDL_FULLSCREEN)) {
bestw=modes[i]->w;
besth=modes[i]->h;
}
}
}
if ( bestw != 99999) {
*w=bestw;
*h=besth;
}
}
static void sdl_ctx_get_video_size(void *data,
unsigned *width, unsigned *height)
{
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver->video_context_data;
if (!sdl)
return;
*width = sdl->g_width;
*height = sdl->g_height;
if (!sdl->g_win)
{
int i = settings->video.monitor_index;
#ifdef HAVE_SDL2
SDL_DisplayMode mode = {0};
if (SDL_GetCurrentDisplayMode(i, &mode) < 0)
RARCH_WARN("[SDL_GL]: Failed to get display #%i mode: %s\n", i,
SDL_GetError());
#else
SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE);
SDL_Rect mode = {0};
if (!modes)
RARCH_WARN("[SDL_GL]: Failed to detect available video modes: %s\n",
SDL_GetError());
else if (*modes)
mode = **modes;
#endif
*width = mode.w;
*height = mode.h;
}
}
static void AutoAdjustColorDepth(void)
{
SDL_Rect **modes;
SDL_PixelFormat format;
const SDL_VideoInfo *info;
int flags;
if (fullscreen)
{
flags = SDL_FULLSCREEN;
}
else
{
flags = 0;
}
format.BitsPerPixel = screen_bpp;
format.BytesPerPixel = (screen_bpp + 7) / 8;
// Are any screen modes supported at the configured color depth?
modes = SDL_ListModes(&format, flags);
// If not, we must autoadjust to something sensible.
if (modes == NULL)
{
printf("I_InitGraphics: %ibpp color depth not supported.\n",
screen_bpp);
info = SDL_GetVideoInfo();
if (info != NULL && info->vfmt != NULL)
{
screen_bpp = info->vfmt->BitsPerPixel;
}
}
}
bool WindowManager::CreateSDLWindow()
{
if(SDL_Init(SDL_INIT_EVERYTHING) < 0) { // Initialize everything
return false; // or return that there was an error
}
TTF_Init();
if( Mix_OpenAudio( 22050, MIX_DEFAULT_FORMAT, 2, 4096 ) == -1 )
{
return false;
}
_FSModes = SDL_ListModes(NULL, SDL_OPENGL | SDL_HWSURFACE | SDL_FULLSCREEN);
if(_FSModes == (SDL_Rect**)0 || _FSModes == (SDL_Rect **)-1)
return false;
_CurrentFSMode=_FSModes[0]; // Point the global window variable to the new SDL surface
if(_Fullscreen)
{
_Window=SDL_SetVideoMode(_CurrentFSMode->w, _CurrentFSMode->h, 0, SDL_HWSURFACE|SDL_OPENGL|SDL_FULLSCREEN); // and resizable, or return that there has been an error
}
else
{
SDL_Rect Mode;
Mode.x = Mode.y = 0;
Mode.w = 800;
Mode.h = 600;
_CurrentWMode = Mode;
_Window=SDL_SetVideoMode(_CurrentWMode.w, _CurrentWMode.h, 0, SDL_HWSURFACE | SDL_OPENGL);
}
SDL_WM_SetCaption( "VoA: Variations on Asteroids", NULL );
GrabMouse();
return true;
}
void t_screen::togglefullscreen()
{
fullscreen^= 1;
if(fullscreen)
{
SDL_Rect **modes= SDL_ListModes(0, SDL_OPENGL|SDL_FULLSCREEN);
int bestidx= 0, bestdiff= INT_MAX;
int scrsize= width*height;
if(modes!=(SDL_Rect**)-1 && modes!=0 && modes[0]!=0)
{
for(int i= 0; modes[i]; i++)
{
int msize= modes[i]->w*modes[i]->h,
diff= msize-scrsize;
if(msize>=scrsize && diff<bestdiff)
bestidx= i, bestdiff= diff;
}
printf("Selected fullscreen mode %dx%d\n", modes[bestidx]->w, modes[bestidx]->h);
init(modes[bestidx]->w, modes[bestidx]->h, fullscreen);
}
}
else init(width, height, fullscreen);
}
int enumerate_sdl_modes (int *width, int *height, FILE *out)
{
SDL_Rect **modes;
int w = -1;
int h = -1;
int m = -1;
int i;
modes = SDL_ListModes (NULL, SDL_HWSURFACE | SDL_FULLSCREEN);
if (! modes)
fatal (2, "no SDL display modes available\n");
if (modes == (SDL_Rect **) -1)
fatal (2, "all SDL resolutions available (on hardware?)\n");
for (i = 0; modes [i]; i++)
{
if (out)
fprintf (out, " mode %d: %d x %d\n", i, modes [i]->w, modes [i]->h);
// find the largest resolution for the screen
if ((modes [i]->w >= w) && (modes [i]->h >= h)) {
w = modes [i]->w;
h = modes [i]->h;
m = i;
}
}
if (m < 0)
fatal (2, "no matching SDL video modes found\n");
*width = w;
*height = h;
return (m);
}
ModeListModel::ModeListModel()
{
/* Get available fullscreen/hardware modes */
SDL_Rect **modes = SDL_ListModes(nullptr, SDL_FULLSCREEN | SDL_HWSURFACE);
/* Check which modes are available */
if (modes == static_cast<SDL_Rect **>(nullptr))
{
logger->log1("No modes available");
}
else if (modes == reinterpret_cast<SDL_Rect **>(-1))
{
logger->log1("All resolutions available");
}
else
{
for (int i = 0; modes[i]; ++ i)
{
const std::string modeString =
toString(static_cast<int>(modes[i]->w)) + "x"
+ toString(static_cast<int>(modes[i]->h));
mVideoModes.push_back(modeString);
}
}
addCustomMode("640x480");
addCustomMode("800x600");
addCustomMode("1024x768");
addCustomMode("1280x1024");
addCustomMode("1400x900");
addCustomMode("1500x990");
addCustomMode(toString(mainGraphics->mWidth) + "x"
+ toString(mainGraphics->mHeight));
std::sort(mVideoModes.begin(), mVideoModes.end(), modeSorter);
mVideoModes.push_back("custom");
}
void GL_SDL_GetGLModes()
{
const SDL_VideoInfo *info;
SDL_Rect **modes;
int i;
//always keep mode 0 open?
gl_mode_num = 1;
info = SDL_GetVideoInfo();
if (info)
{
Console_DPrintf("Current display: %d bits-per-pixel\n",info->vfmt->BitsPerPixel);
if ( info->vfmt->palette == NULL ) {
Console_DPrintf(" Red Mask = 0x%.8x\n", info->vfmt->Rmask);
Console_DPrintf(" Green Mask = 0x%.8x\n", info->vfmt->Gmask);
Console_DPrintf(" Blue Mask = 0x%.8x\n", info->vfmt->Bmask);
}
}
/* Print available fullscreen video modes */
modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
if ( modes == (SDL_Rect **)0 )
{
Console_DPrintf("No available fullscreen video modes\n");
}
else
if ( modes == (SDL_Rect **)-1 )
{
Console_DPrintf("No special fullscreen video modes\n");
}
else
{
Console_DPrintf("Fullscreen video modes:\n");
for ( i=0; modes[i]; ++i )
{
if (_mode_exists(modes[i]) || info->vfmt->BitsPerPixel <= 16 || (modes[i]->w<=640&&modes[i]->h<=480))
{
continue;
}
gl_modes[gl_mode_num].width = modes[i]->w;
gl_modes[gl_mode_num].height = modes[i]->h;
gl_modes[gl_mode_num].bpp = info->vfmt->BitsPerPixel;
BPrintf(gl_modes[gl_mode_num].name, 20, "%dx%d", modes[i]->w, modes[i]->h);
gl_modes[gl_mode_num].fullscreen = true;
Console_DPrintf("\t%dx%d\n", modes[i]->w, modes[i]->h);
gl_mode_num++;
}
}
GL_GetWindowedModes();
if (info)
{
if ( info->wm_available ) {
Console_DPrintf("A window manager is available\n");
}
if ( info->hw_available ) {
Console_DPrintf("Hardware surfaces are available (%dK video memory)\n",
info->video_mem);
}
if ( info->blit_hw ) {
Console_DPrintf("Copy blits between hardware surfaces are accelerated\n");
}
if ( info->blit_hw_CC ) {
Console_DPrintf("Colorkey blits between hardware surfaces are accelerated\n");
}
if ( info->blit_hw_A ) {
Console_DPrintf("Alpha blits between hardware surfaces are accelerated\n");
}
if ( info->blit_sw ) {
Console_DPrintf("Copy blits from software surfaces to hardware surfaces are accelerated\n");
}
if ( info->blit_sw_CC ) {
Console_DPrintf("Colorkey blits from software surfaces to hardware surfaces are accelerated\n");
}
if ( info->blit_sw_A ) {
Console_DPrintf("Alpha blits from software surfaces to hardware surfaces are accelerated\n");
}
if ( info->blit_fill ) {
Console_DPrintf("Color fills on hardware surfaces are accelerated\n");
}
}
}
bool OpenGLSdlGraphicsManager::setupFullscreenMode() {
SDL_Rect const* const*availableModes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_OPENGL);
// SDL_ListModes() returns -1 in case any dimension is okay. In that
// case we'll reuse the current desktop resolution for fullscreen.
if (availableModes == (void *)-1) {
_videoMode.hardwareWidth = _desktopWidth;
_videoMode.hardwareHeight = _desktopHeight;
_activeFullscreenMode = -2;
return true;
}
// If -2, autodetect the fullscreen mode
// The last used fullscreen mode will be prioritized, if there is no last fullscreen
// mode, the desktop resolution will be used, and in case the desktop resolution
// is not available as a fullscreen mode, the one with smallest metric will be selected.
if (_activeFullscreenMode == -2) {
// Desktop resolution
int desktopModeIndex = -1;
// Best metric mode
const SDL_Rect *bestMode = availableModes[0];
int bestModeIndex = 0;
uint bestMetric = (uint)-1;
// Iterate over all available fullscreen modes
for (int i = 0; const SDL_Rect *mode = availableModes[i]; i++) {
// Try to setup the last used fullscreen mode
if (mode->w == _lastFullscreenModeWidth && mode->h == _lastFullscreenModeHeight) {
_videoMode.hardwareWidth = _lastFullscreenModeWidth;
_videoMode.hardwareHeight = _lastFullscreenModeHeight;
_activeFullscreenMode = i;
return true;
}
if (mode->w == _desktopWidth && mode->h == _desktopHeight)
desktopModeIndex = i;
if (mode->w < _videoMode.overlayWidth)
continue;
if (mode->h < _videoMode.overlayHeight)
continue;
uint metric = mode->w * mode->h - _videoMode.overlayWidth * _videoMode.overlayHeight;
if (metric < bestMetric) {
bestMode = mode;
bestMetric = metric;
bestModeIndex = i;
}
}
if (desktopModeIndex >= 0) {
_videoMode.hardwareWidth = _desktopWidth;
_videoMode.hardwareHeight = _desktopHeight;
_activeFullscreenMode = desktopModeIndex;
return true;
} else if (bestMode) {
_videoMode.hardwareWidth = bestMode->w;
_videoMode.hardwareHeight = bestMode->h;
_activeFullscreenMode = bestModeIndex;
return true;
}
} else {
// Use last fullscreen mode if looping backwards from the first mode
if (_activeFullscreenMode == -1) {
do {
_activeFullscreenMode++;
} while(availableModes[_activeFullscreenMode]);
_activeFullscreenMode--;
}
// Use first fullscreen mode if looping from last mode
if (!availableModes[_activeFullscreenMode])
_activeFullscreenMode = 0;
// Check if the fullscreen mode is valid
if (availableModes[_activeFullscreenMode]) {
_videoMode.hardwareWidth = availableModes[_activeFullscreenMode]->w;
_videoMode.hardwareHeight = availableModes[_activeFullscreenMode]->h;
return true;
}
}
// Could not find any suiting fullscreen mode, return false.
return false;
}
/**
* @brief Initializes the video window.
*/
static void opt_video( unsigned int wid )
{
(void) wid;
int i, j, nres, res_def;
char buf[16];
int cw;
int w, h, y, x, l;
SDL_Rect** modes;
char **res;
const char *s;
/* Get size. */
window_dimWindow( wid, &w, &h );
/* Close button */
window_addButton( wid, -20, 20,
BUTTON_WIDTH, BUTTON_HEIGHT,
"btnClose", "Close", opt_close );
window_addButton( wid, -20 - 1*(BUTTON_WIDTH+20), 20,
BUTTON_WIDTH, BUTTON_HEIGHT,
"btnApply", "Apply", opt_videoSave );
window_addButton( wid, -20 - 2*(BUTTON_WIDTH+20), 20,
BUTTON_WIDTH, BUTTON_HEIGHT,
"btnDefaults", "Defaults", opt_videoDefaults );
/* Resolution bits. */
cw = (w-60)/2;
x = 20;
y = -60;
window_addText( wid, x+20, y, 100, 20, 0, "txtSRes",
NULL, &cDConsole, "Resolution" );
y -= 40;
window_addInput( wid, x, y, 100, 20, "inpRes", 16, 1, NULL );
snprintf( buf, sizeof(buf), "%dx%d", conf.width, conf.height );
window_setInput( wid, "inpRes", buf );
window_setInputFilter( wid, "inpRes",
"abcdefghijklmnopqrstuvwyzABCDEFGHIJKLMNOPQRSTUVWXYZ[]{}()-=*/\\'\"~<>!@#$%^&|_`" );
window_addCheckbox( wid, x+20+100, y, 100, 20,
"chkFullscreen", "Fullscreen", NULL, conf.fullscreen );
y -= 30;
modes = SDL_ListModes( NULL, SDL_OPENGL | SDL_FULLSCREEN );
j = 1;
for (i=0; modes[i]; i++) {
if ((modes[i]->w == conf.width) && (modes[i]->h == conf.height))
j = 0;
}
res = malloc( sizeof(char*) * (i+j) );
nres = 0;
if (j) {
res[0] = malloc(16);
snprintf( res[0], 16, "%dx%d", conf.width, conf.height );
res_def = 0;
nres = 1;
}
for (i=0; modes[i]; i++) {
res[ nres ] = malloc(16);
snprintf( res[ nres ], 16, "%dx%d", modes[i]->w, modes[i]->h );
if ((modes[i]->w == conf.width) && (modes[i]->h == conf.height))
res_def = i;
nres++;
}
window_addList( wid, x, y, 140, 100, "lstRes", res, nres, -1, opt_videoRes );
y -= 150;
/* FPS stuff. */
window_addText( wid, x+20, y, 100, 20, 0, "txtFPSTitle",
NULL, &cDConsole, "FPS Control" );
y -= 30;
s = "FPS Limit";
l = gl_printWidthRaw( NULL, s );
window_addText( wid, x, y, l, 20, 1, "txtSFPS",
NULL, &cBlack, s );
window_addInput( wid, x+l+20, y, 40, 20, "inpFPS", 4, 1, NULL );
toolkit_setListPos( wid, "lstRes", res_def);
window_setInputFilter( wid, "inpFPS",
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ[]{}()-=*/\\'\"~<>!@#$%^&|_`" );
y -= 30;
window_addCheckbox( wid, x, y, cw, 20,
"chkFPS", "Show FPS", NULL, conf.fps_show );
y -= 40;
/* OpenGL options. */
x = 20+cw+20;
y = -60;
window_addText( wid, x+20, y, 100, 20, 0, "txtSGL",
NULL, &cDConsole, "OpenGL" );
y -= 30;
window_addCheckbox( wid, x, y, cw, 20,
"chkVSync", "Vertical Sync", NULL, conf.vsync );
y -= 20;
window_addCheckbox( wid, x, y, cw, 20,
"chkVBO", "Vertex Buffer Objects*", NULL, conf.vbo );
y -= 20;
window_addCheckbox( wid, x, y, cw, 20,
"chkMipmaps", "Mipmaps*", NULL, conf.mipmaps );
y -= 20;
window_addCheckbox( wid, x, y, cw, 20,
"chkInterpolate", "Interpolation*", NULL, conf.interpolate );
y -= 20;
window_addCheckbox( wid, x, y, cw, 20,
"chkNPOT", "NPOT Textures*", NULL, conf.npot );
y -= 30;
window_addText( wid, x, y, cw, 20, 1,
"txtSCompat", NULL, &cBlack, "*Disable for compatibility." );
y -= 40;
/* Features. */
window_addText( wid, x+20, y, 100, 20, 0, "txtSFeatures",
NULL, &cDConsole, "Features" );
y -= 30;
window_addCheckbox( wid, x, y, cw, 20,
"chkEngineGlow", "Engine Glow (More RAM)", NULL, conf.engineglow );
y -= 20;
/* Restart text. */
window_addText( wid, 20, 10, 3*(BUTTON_WIDTH + 20),
30, 0, "txtRestart", &gl_smallFont, &cBlack, NULL );
}
void Pi::Init()
{
config.Load(GetPiUserDir() + "config.ini");
Pi::detail.planets = config.Int("DetailPlanets");
Pi::detail.cities = config.Int("DetailCities");
int width = config.Int("ScrWidth");
int height = config.Int("ScrHeight");
const SDL_VideoInfo *info = NULL;
Uint32 sdlInitFlags = SDL_INIT_VIDEO | SDL_INIT_JOYSTICK;
#if defined _WIN32 && defined _DEBUG
sdlInitFlags |= SDL_INIT_NOPARACHUTE;
#endif
if (SDL_Init(sdlInitFlags) < 0) {
fprintf(stderr, "Video initialization failed: %s\n", SDL_GetError());
exit(-1);
}
InitJoysticks();
// no mode set, find an ok one
if ((width <= 0) || (height <= 0)) {
SDL_Rect **modes = SDL_ListModes(NULL, SDL_HWSURFACE | SDL_FULLSCREEN);
if (modes == 0) {
fprintf(stderr, "It seems no video modes are available...");
}
if (modes == (SDL_Rect **)-1) {
// hm. all modes available. odd. try 800x600
width = 800; height = 600;
} else {
width = modes[0]->w;
height = modes[0]->h;
}
}
info = SDL_GetVideoInfo();
printf("SDL_GetVideoInfo says %d bpp\n", info->vfmt->BitsPerPixel);
switch (info->vfmt->BitsPerPixel) {
case 16:
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
break;
case 24:
case 32:
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
break;
default:
fprintf(stderr, "Invalid pixel depth: %d bpp\n", info->vfmt->BitsPerPixel);
}
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
Uint32 flags = SDL_OPENGL;
if (config.Int("StartFullscreen")) flags |= SDL_FULLSCREEN;
if ((Pi::scrSurface = SDL_SetVideoMode(width, height, info->vfmt->BitsPerPixel, flags)) == 0) {
// fall back on 16-bit depth buffer...
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
fprintf(stderr, "Failed to set video mode. (%s). Re-trying with 16-bit depth buffer.\n", SDL_GetError());
if ((Pi::scrSurface = SDL_SetVideoMode(width, height, info->vfmt->BitsPerPixel, flags)) == 0) {
fprintf(stderr, "Failed to set video mode: %s", SDL_GetError());
}
}
glewInit();
SDL_WM_SetCaption("Pioneer","Pioneer");
Pi::scrWidth = width;
Pi::scrHeight = height;
Pi::scrAspect = width / (float)height;
Pi::rng.seed(time(NULL));
InitOpenGL();
GLFTInit();
// Gui::Init shouldn't initialise any VBOs, since we haven't tested
// that the capability exists. (Gui does not use VBOs so far)
Gui::Init(scrWidth, scrHeight, 800, 600);
if (!GLEW_ARB_vertex_buffer_object) {
Error("OpenGL extension ARB_vertex_buffer_object not supported. Pioneer can not run on your graphics card.");
}
Render::Init(width, height);
draw_progress(0.1f);
Galaxy::Init();
draw_progress(0.2f);
NameGenerator::Init();
if (config.Int("DisableShaders")) Render::ToggleShaders();
if (config.Int("EnableHDR")) Render::ToggleHDR();
draw_progress(0.3f);
LmrModelCompilerInit();
//unsigned int control_word;
//_clearfp();
//_controlfp_s(&control_word, _EM_INEXACT | _EM_UNDERFLOW, _MCW_EM);
//double fpexcept = Pi::timeAccelRates[1] / Pi::timeAccelRates[0];
draw_progress(0.4f);
ShipType::Init();
draw_progress(0.5f);
GeoSphere::Init();
draw_progress(0.6f);
Space::Init();
draw_progress(0.7f);
Polit::Init();
draw_progress(0.8f);
SpaceStation::Init();
draw_progress(0.9f);
if (!config.Int("DisableSound")) {
Sound::Init();
Sound::SetGlobalVolume(config.Float("SfxVolume"));
Sound::Pause(0);
}
draw_progress(1.0f);
// test code to produce list of ship stats
FILE *pStatFile = fopen("shipstat.csv","wt");
if (pStatFile)
{
fprintf(pStatFile, "name,lmrname,hullmass,capacity,xsize,ysize,zsize,facc,racc,uacc,aacc\n");
for (std::map<std::string, ShipType>::iterator i = ShipType::types.begin();
i != ShipType::types.end(); ++i)
{
ShipType *shipdef = &(i->second);
LmrModel *lmrModel = LmrLookupModelByName(shipdef->lmrModelName.c_str());
LmrObjParams lmrParams; memset(&lmrParams, 0, sizeof(LmrObjParams));
LmrCollMesh *collMesh = new LmrCollMesh(lmrModel, &lmrParams);
Aabb aabb = collMesh->GetAabb();
double hullmass = shipdef->hullMass;
double capacity = shipdef->capacity;
double xsize = aabb.max.x-aabb.min.x;
double ysize = aabb.max.y-aabb.min.y;
double zsize = aabb.max.z-aabb.min.z;
double brad = aabb.GetBoundingRadius();
double simass = (hullmass + capacity) * 1000.0;
double angInertia = (2/5.0)*simass*brad*brad;
double acc1 = shipdef->linThrust[ShipType::THRUSTER_FORWARD] / (9.81*simass);
double acc2 = shipdef->linThrust[ShipType::THRUSTER_REVERSE] / (9.81*simass);
double acc3 = shipdef->linThrust[ShipType::THRUSTER_UP] / (9.81*simass);
double acca = shipdef->angThrust/angInertia;
fprintf(pStatFile, "%s,%s,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%f\n",
shipdef->name.c_str(), shipdef->lmrModelName.c_str(), hullmass, capacity,
xsize, ysize, zsize, acc1, acc2, acc3, acca);
}
fclose(pStatFile);
}
gameMenuView = new GameMenuView();
config.Save();
}
static void pick_best_mode(sdl_window_info *window, int *fswidth, int *fsheight)
{
int minimum_width, minimum_height, target_width, target_height;
int i;
float size_score, best_score = 0.0f;
SDL_Rect **modes;
// determine the minimum width/height for the selected target
window->target->compute_minimum_size(minimum_width, minimum_height);
// use those as the target for now
target_width = minimum_width * MAX(1, window->prescale);
target_height = minimum_height * MAX(1, window->prescale);
// if we're not stretching, allow some slop on the minimum since we can handle it
{
minimum_width -= 4;
minimum_height -= 4;
}
#if 1 // defined(SDLMAME_WIN32)
/*
* We need to do this here. If SDL_ListModes is
* called in init_monitors, the call will crash
* on win32
*/
modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_DOUBLEBUF);
#else
modes = window->monitor->modes;
#endif
if (modes == (SDL_Rect **)0)
{
mame_printf_error("SDL: No modes available?!\n");
exit(-1);
}
else if (modes == (SDL_Rect **)-1) // all modes are possible
{
*fswidth = window->maxwidth;
*fsheight = window->maxheight;
}
else
{
for (i = 0; modes[i]; ++i)
{
// compute initial score based on difference between target and current
size_score = 1.0f / (1.0f + fabsf((INT32)modes[i]->w - target_width) + fabsf((INT32)modes[i]->h - target_height));
// if the mode is too small, give a big penalty
if (modes[i]->w < minimum_width || modes[i]->h < minimum_height)
size_score *= 0.01f;
// if mode is smaller than we'd like, it only scores up to 0.1
if (modes[i]->w < target_width || modes[i]->h < target_height)
size_score *= 0.1f;
// if we're looking for a particular mode, that's a winner
if (modes[i]->w == window->maxwidth && modes[i]->h == window->maxheight)
size_score = 2.0f;
mame_printf_verbose("%4dx%4d -> %f\n", (int)modes[i]->w, (int)modes[i]->h, size_score);
// best so far?
if (size_score > best_score)
{
best_score = size_score;
*fswidth = modes[i]->w;
*fsheight = modes[i]->h;
}
}
}
}
