/*
===============
GLimp_StartDriverAndSetMode
===============
*/
static qboolean GLimp_StartDriverAndSetMode(int mode, qboolean fullscreen, qboolean noborder)
{
rserr_t err;
if (!SDL_WasInit(SDL_INIT_VIDEO))
{
const char *driverName;
if (SDL_Init(SDL_INIT_VIDEO) == -1)
{
Com_Printf( "SDL_Init( SDL_INIT_VIDEO ) FAILED (%s)\n",
SDL_GetError());
return qfalse;
}
driverName = SDL_GetCurrentVideoDriver();
if (!driverName)
{
Com_Error( ERR_FATAL, "No video driver initialized" );
return qfalse;
}
Com_Printf( "SDL using driver \"%s\"\n", driverName );
ri->Cvar_Set( "r_sdlDriver", driverName );
}
if (SDL_GetNumVideoDisplays() <= 0)
{
Com_Error( ERR_FATAL, "SDL_GetNumVideoDisplays() FAILED (%s)", SDL_GetError() );
}
if (fullscreen && ri->Cvar_VariableIntegerValue( "in_nograb" ) )
{
Com_Printf( "Fullscreen not allowed with in_nograb 1\n");
ri->Cvar_Set( "r_fullscreen", "0" );
r_fullscreen->modified = qfalse;
fullscreen = qfalse;
}
err = GLimp_SetMode(mode, fullscreen, noborder);
switch ( err )
{
case RSERR_INVALID_FULLSCREEN:
Com_Printf( "...WARNING: fullscreen unavailable in this mode\n" );
return qfalse;
case RSERR_INVALID_MODE:
Com_Printf( "...WARNING: could not set the given mode (%d)\n", mode );
return qfalse;
case RSERR_UNKNOWN:
Com_Printf( "...ERROR: no display modes could be found.\n" );
return qfalse;
default:
break;
}
return qtrue;
}
bool Graphics::videoInfo()
{
logger->log("SDL video info");
#ifdef USE_SDL2
logger->log("Using video driver: %s", SDL_GetCurrentVideoDriver());
if (mRenderer)
{
SDL_RendererInfo info;
SDL_GetRendererInfo(mRenderer, &info);
dumpRendererInfo("Current SDL renderer name: %s", info);
const int num = SDL_GetNumRenderDrivers();
logger->log("Known renderers");
for (int f = 0; f < num; f ++)
{
if (!SDL_GetRenderDriverInfo(f, &info))
dumpRendererInfo("renderer name: %s", info);
}
}
#else
char videoDriverName[65];
if (SDL_VideoDriverName(videoDriverName, 64))
logger->log("Using video driver: %s", videoDriverName);
else
logger->log1("Using video driver: unknown");
mDoubleBuffer = ((mWindow->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF);
logger->log("Double buffer mode: %s", mDoubleBuffer ? "yes" : "no");
ImageHelper::dumpSurfaceFormat(mWindow);
const SDL_VideoInfo *const vi = SDL_GetVideoInfo();
if (!vi)
return false;
logger->log("Possible to create hardware surfaces: %s",
((vi->hw_available) ? "yes" : "no"));
logger->log("Window manager available: %s",
((vi->wm_available) ? "yes" : "no"));
logger->log("Accelerated hardware to hardware blits: %s",
((vi->blit_hw) ? "yes" : "no"));
logger->log("Accelerated hardware to hardware colorkey blits: %s",
((vi->blit_hw_CC) ? "yes" : "no"));
logger->log("Accelerated hardware to hardware alpha blits: %s",
((vi->blit_hw_A) ? "yes" : "no"));
logger->log("Accelerated software to hardware blits: %s",
((vi->blit_sw) ? "yes" : "no"));
logger->log("Accelerated software to hardware colorkey blits: %s",
((vi->blit_sw_CC) ? "yes" : "no"));
logger->log("Accelerated software to hardware alpha blits: %s",
((vi->blit_sw_A) ? "yes" : "no"));
logger->log("Accelerated color fills: %s",
((vi->blit_fill) ? "yes" : "no"));
#endif
return true;
}
static int lua_SDL_GetCurrentVideoDriver(lutok::state& state){
const char * driver = SDL_GetCurrentVideoDriver();
if (driver){
state.push_string(driver);
return 1;
}else{
return 0;
}
}
char *
SDL_VideoDriverName(char *namebuf, int maxlen)
{
const char *name = SDL_GetCurrentVideoDriver();
if (name) {
SDL_strlcpy(namebuf, name, maxlen);
return namebuf;
}
return NULL;
}
int
main(int argc, char *argv[])
{
SDL_DisplayMode mode;
int num_displays, dpy;
/* Enable standard application logging */
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
/* Load the SDL library */
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
return 1;
}
SDL_Log("Using video target '%s'.\n", SDL_GetCurrentVideoDriver());
num_displays = SDL_GetNumVideoDisplays();
SDL_Log("See %d displays.\n", num_displays);
for (dpy = 0; dpy < num_displays; dpy++) {
const int num_modes = SDL_GetNumDisplayModes(dpy);
SDL_Rect rect = { 0, 0, 0, 0 };
int m;
SDL_GetDisplayBounds(dpy, &rect);
SDL_Log("%d: \"%s\" (%dx%d, (%d, %d)), %d modes.\n", dpy, SDL_GetDisplayName(dpy), rect.w, rect.h, rect.x, rect.y, num_modes);
if (SDL_GetCurrentDisplayMode(dpy, &mode) == -1) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " CURRENT: failed to query (%s)\n", SDL_GetError());
} else {
print_mode("CURRENT", &mode);
}
if (SDL_GetDesktopDisplayMode(dpy, &mode) == -1) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " DESKTOP: failed to query (%s)\n", SDL_GetError());
} else {
print_mode("DESKTOP", &mode);
}
for (m = 0; m < num_modes; m++) {
if (SDL_GetDisplayMode(dpy, m, &mode) == -1) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " MODE %d: failed to query (%s)\n", m, SDL_GetError());
} else {
char prefix[64];
SDL_snprintf(prefix, sizeof (prefix), " MODE %d", m);
print_mode(prefix, &mode);
}
}
SDL_Log("\n");
}
return 0;
}
//--------------------------------------------------------------------------------------------
bool SDLX_Get_Screen_Info( SDLX_screen_info_t& psi, bool make_report )
{
Uint32 init_flags = 0;
SDL_Window *window;
init_flags = SDL_WasInit( SDL_INIT_EVERYTHING );
if ( 0 == init_flags )
{
if ( make_report ) Log::get().message("ERROR: SDLX_Get_Screen_Info() called before initializing SDL\n");
return false;
}
else if ( HAS_NO_BITS( init_flags, SDL_INIT_VIDEO ) )
{
if ( make_report ) Log::get().message("ERROR: SDLX_Get_Screen_Info() called before initializing SDL video driver\n");
return false;
}
// store the screen info for everyone to use
window = Ego::GraphicsSystem::window;
psi.window = window;
SDL_GetWindowSize(window, &(psi.x), &(psi.y));
SDLX_GetDrawableSize(window, &(psi.drawWidth), &(psi.drawHeight));
// Grab all the available video modes
psi.video_mode_list.clear();
int displayNum = SDL_GetWindowDisplayIndex(window);
int numDisplayModes = SDL_GetNumDisplayModes(displayNum);
for (int i = 0; i < numDisplayModes; i++) {
SDL_DisplayMode mode;
SDL_GetDisplayMode(displayNum, i, &mode);
psi.video_mode_list.push_back(mode);
}
// log the video driver info
psi.szDriver = SDL_GetCurrentVideoDriver();
// grab all SDL_GL_* attributes
SDLX_sdl_gl_attrib_t::download(psi.gl_att);
// translate the surface flags into the bitfield
SDLX_sdl_video_flags_t::download(psi.flags, SDL_GetWindowFlags(window));
if (make_report)
{
SDLX_screen_info_t::report(psi);
}
return true;
}
/*
===============
GLimp_StartDriverAndSetMode
===============
*/
static qboolean GLimp_StartDriverAndSetMode( void )
{
rserr_t err;
if (!SDL_WasInit(SDL_INIT_VIDEO))
{
const char *driverName;
if (SDL_Init(SDL_INIT_VIDEO) != 0)
{
ri.Printf( PRINT_ALL, "SDL_Init( SDL_INIT_VIDEO ) FAILED (%s)\n",
SDL_GetError());
return qfalse;
}
//SDL_VideoDriverName( driverName, sizeof( driverName ) - 1 );
driverName = SDL_GetCurrentVideoDriver( );
ri.Printf( PRINT_ALL, "SDL using driver \"%s\"\n", driverName );
Cvar_Set( "r_sdlDriver", driverName );
}
if (r_fullscreen->integer && Cvar_VariableIntegerValue( "in_nograb" ) )
{
ri.Printf( PRINT_ALL, "Fullscreen not allowed with in_nograb 1\n");
ri.Cvar_Set( "r_fullscreen", "0" );
r_fullscreen->modified = qfalse;
//fullscreen = qfalse;
}
err = GLimp_SetMode( );
switch ( err )
{
case RSERR_INVALID_FULLSCREEN:
ri.Printf( PRINT_ALL, "...WARNING: fullscreen unavailable in this mode\n" );
return qfalse;
case RSERR_INVALID_MODE:
ri.Printf( PRINT_ALL, "...WARNING: could not set the given mode\n" );
return qfalse;
default:
break;
}
return qtrue;
}
/**
* @brief GLimp_StartDriverAndSetMode
* @param[in] glConfig
* @param[in] mode
* @param[in] fullscreen
* @param[in] noborder
* @param[in] context
* @return
*/
static qboolean GLimp_StartDriverAndSetMode(glconfig_t *glConfig, int mode, qboolean fullscreen, qboolean noborder, windowContext_t *context)
{
rserr_t err;
if (!SDL_WasInit(SDL_INIT_VIDEO))
{
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
Com_Printf("SDL_Init( SDL_INIT_VIDEO ) FAILED (%s)\n", SDL_GetError());
return qfalse;
}
Com_Printf("SDL initialized driver \"%s\"\n", SDL_GetCurrentVideoDriver());
}
if (fullscreen && Cvar_VariableIntegerValue("in_nograb"))
{
Com_Printf("Fullscreen not allowed with in_nograb 1\n");
Cvar_Set("r_fullscreen", "0");
r_fullscreen->modified = qfalse;
fullscreen = qfalse;
}
err = GLimp_SetMode(glConfig, mode, fullscreen, noborder, context);
switch (err)
{
case RSERR_OK:
return qtrue;
case RSERR_INVALID_FULLSCREEN:
Com_Printf("...WARNING: fullscreen unavailable in this mode\n");
break;
case RSERR_INVALID_MODE:
Com_Printf("...WARNING: could not set the given mode (%d)\n", mode);
break;
case RSERR_OLD_GL:
Com_Error(ERR_VID_FATAL, "Could not create opengl 3 context");
case RSERR_UNKNOWN: // fall through
default:
Com_Error(ERR_VID_FATAL, "Can't set mode - an unknown error occured");
}
return qfalse;
}
static void osd_sdl_info(void)
{
#if SDL_VERSION_ATLEAST(1,3,0)
int i, cur, num = SDL_GetNumVideoDrivers();
mame_printf_verbose("Available videodrivers: ");
for (i=0;i<num;i++)
{
const char *name = SDL_GetVideoDriver(i);
mame_printf_verbose("%s ", name);
}
mame_printf_verbose("\n");
mame_printf_verbose("Current Videodriver: %s\n", SDL_GetCurrentVideoDriver());
num = SDL_GetNumVideoDisplays();
cur = SDL_GetCurrentVideoDisplay();
for (i=0;i<num;i++)
{
SDL_DisplayMode mode;
int j;
SDL_SelectVideoDisplay(i);
mame_printf_verbose("\tDisplay #%d\n", i);
if (SDL_GetDesktopDisplayMode(&mode));
mame_printf_verbose("\t\tDesktop Mode: %dx%d-%d@%d\n", mode.w, mode.h, SDL_BITSPERPIXEL(mode.format), mode.refresh_rate);
if (SDL_GetCurrentDisplayMode(&mode));
mame_printf_verbose("\t\tCurrent Display Mode: %dx%d-%d@%d\n", mode.w, mode.h, SDL_BITSPERPIXEL(mode.format), mode.refresh_rate);
mame_printf_verbose("\t\tRenderdrivers:\n");
for (j=0; j<SDL_GetNumRenderDrivers(); j++)
{
SDL_RendererInfo info;
SDL_GetRenderDriverInfo(j, &info);
mame_printf_verbose("\t\t\t%10s (%dx%d)\n", info.name, info.max_texture_width, info.max_texture_height);
}
}
SDL_SelectVideoDisplay(cur);
mame_printf_verbose("Available audio drivers: \n");
num = SDL_GetNumAudioDrivers();
for (i=0;i<num;i++)
{
mame_printf_verbose("\t%-20s\n", SDL_GetAudioDriver(i));
}
#endif
}
/*
===============
GLimp_StartDriverAndSetMode
===============
*/
static bool GLimp_StartDriverAndSetMode(int mode, bool fullscreen, bool noborder)
{
rserr_t err;
if (!SDL_WasInit(SDL_INIT_VIDEO))
{
const char *driverName;
if (SDL_Init(SDL_INIT_VIDEO) == -1)
{
ri->Printf( PRINT_ALL, "SDL_Init( SDL_INIT_VIDEO ) FAILED (%s)\n", SDL_GetError());
return qfalse;
}
driverName = SDL_GetCurrentVideoDriver( );
ri->Printf( PRINT_ALL, "SDL using driver \"%s\"\n", driverName );
ri->Cvar_Set( "r_sdlDriver", driverName );
}
if (fullscreen && ri->Cvar_VariableIntegerValue( "in_nograb" ) )
{
ri->Printf( PRINT_ALL, "Fullscreen not allowed with in_nograb 1\n");
ri->Cvar_Set( "r_fullscreen", "0" );
r_fullscreen->modified = false;
fullscreen = false;
}
err = (rserr_t)GLimp_SetMode(mode, fullscreen, noborder);
switch ( err )
{
case RSERR_INVALID_FULLSCREEN:
ri->Printf( PRINT_ALL, "...WARNING: fullscreen unavailable in this mode\n" );
return false;
case RSERR_INVALID_MODE:
ri->Printf( PRINT_ALL, "...WARNING: could not set the given mode (%d)\n", mode );
return false;
default:
break;
}
return true;
}
static qboolean GLimp_StartDriverAndSetMode(int mode, qboolean fullscreen, qboolean noborder)
{
rserr_t err;
if (!SDL_WasInit(SDL_INIT_VIDEO))
{
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
Ren_Print("SDL_Init( SDL_INIT_VIDEO ) FAILED (%s)\n", SDL_GetError());
return qfalse;
}
Ren_Print("SDL initialized driver \"%s\"\n", SDL_GetCurrentVideoDriver());
}
if (fullscreen && ri.Cvar_VariableIntegerValue("in_nograb"))
{
Ren_Print("Fullscreen not allowed with in_nograb 1\n");
ri.Cvar_Set("r_fullscreen", "0");
r_fullscreen->modified = qfalse;
fullscreen = qfalse;
}
err = GLimp_SetMode(mode, fullscreen, noborder);
switch (err)
{
case RSERR_INVALID_FULLSCREEN:
Ren_Print("...WARNING: fullscreen unavailable in this mode\n");
return qfalse;
case RSERR_INVALID_MODE:
Ren_Print("...WARNING: could not set the given mode (%d)\n", mode);
return qfalse;
case RSERR_OLD_GL:
ri.Error(ERR_VID_FATAL, "Could not create opengl 3 context");
return qfalse;
default:
break;
}
return qtrue;
}
/*
* Initialzes the SDL OpenGL context
*/
int
GLimp_Init(void)
{
if (!SDL_WasInit(SDL_INIT_VIDEO))
{
if (SDL_Init(SDL_INIT_VIDEO) == -1)
{
VID_Printf(PRINT_ALL, "Couldn't init SDL video: %s.\n",
SDL_GetError());
return false;
}
#if SDL_VERSION_ATLEAST(2, 0, 0)
const char* driverName = SDL_GetCurrentVideoDriver();
#else
char driverName[64];
SDL_VideoDriverName(driverName, sizeof(driverName));
#endif
VID_Printf(PRINT_ALL, "SDL video driver is \"%s\".\n", driverName);
}
return true;
}
void I_InitGraphics ()
{
if (SDL_InitSubSystem (SDL_INIT_VIDEO) < 0)
{
I_FatalError ("Could not initialize SDL video:\n%s\n", SDL_GetError());
return;
}
Printf("Using video driver %s\n", SDL_GetCurrentVideoDriver());
UCVarValue val;
val.Bool = !!Args->CheckParm ("-devparm");
ticker.SetGenericRepDefault (val, CVAR_Bool);
Video = new SDLVideo (0);
if (Video == NULL)
I_FatalError ("Failed to initialize display");
atterm (I_ShutdownGraphics);
Video->SetWindowedScale (vid_winscale);
}
static bool StartDriverAndSetMode(int mode, bool fullscreen, bool noborder)
{
if (!SDL_WasInit(SDL_INIT_VIDEO))
{
if (SDL_Init(SDL_INIT_VIDEO) == -1)
{
interface::Printf("SDL_Init( SDL_INIT_VIDEO ) FAILED (%s)\n", SDL_GetError());
return false;
}
const char *driverName = SDL_GetCurrentVideoDriver();
interface::Printf("SDL using driver \"%s\"\n", driverName);
interface::Cvar_Set("r_sdlDriver", driverName);
}
if (fullscreen && interface::Cvar_GetInteger("in_nograb"))
{
interface::Printf("Fullscreen not allowed with in_nograb 1\n");
interface::Cvar_Set( "r_fullscreen", "0" );
g_cvars.fullscreen.clearModified();
fullscreen = false;
}
switch (SetMode(mode, fullscreen, noborder))
{
case SetModeResult::InvalidFullScreen:
interface::Printf("...WARNING: fullscreen unavailable in this mode\n");
return false;
case SetModeResult::InvalidMode:
interface::Printf("...WARNING: could not set the given mode (%d)\n", mode);
return false;
default:
break;
}
return true;
}
SDLHardwareRenderDevice::SDLHardwareRenderDevice()
: window(NULL)
, renderer(NULL)
, texture(NULL)
, titlebar_icon(NULL)
, title(NULL)
, background_color(0,0,0,0)
{
logInfo("Using Render Device: SDLHardwareRenderDevice (hardware, SDL 2, %s)", SDL_GetCurrentVideoDriver());
fullscreen = FULLSCREEN;
hwsurface = HWSURFACE;
vsync = VSYNC;
texture_filter = TEXTURE_FILTER;
min_screen.x = MIN_SCREEN_W;
min_screen.y = MIN_SCREEN_H;
SDL_DisplayMode desktop;
if (SDL_GetDesktopDisplayMode(0, &desktop) == 0) {
// we only support display #0
logInfo("RenderDevice: %d display(s), using display 0 (%dx%d @ %dhz)", SDL_GetNumVideoDisplays(), desktop.w, desktop.h, desktop.refresh_rate);
}
}
std::vector<Window::ContextAttribs> Window::getContextAttribsList() const
{
// If we already have a set of context attributes that we know work, just
// return that. love.graphics doesn't really support switching GL versions
// after the first initialization.
if (contextAttribs.versionMajor > 0)
return std::vector<ContextAttribs>{contextAttribs};
bool preferGLES = false;
#ifdef LOVE_GRAPHICS_USE_OPENGLES
preferGLES = true;
#endif
const char *curdriver = SDL_GetCurrentVideoDriver();
const char *glesdrivers[] = {"RPI", "Android", "uikit", "winrt", "emscripten"};
// We always want to try OpenGL ES first on certain video backends.
for (const char *glesdriver : glesdrivers)
{
if (curdriver && strstr(curdriver, glesdriver) == curdriver)
{
preferGLES = true;
// Prior to SDL 2.0.4, backends that use OpenGL ES didn't properly
// ask for a sRGB framebuffer when requested by SDL_GL_SetAttribute.
// FIXME: This doesn't account for windowing backends that sometimes
// use EGL, e.g. the X11 and windows SDL backends.
if (hasSDL203orEarlier)
graphics::setGammaCorrect(false);
break;
}
}
if (!preferGLES)
{
const char *gleshint = SDL_GetHint("LOVE_GRAPHICS_USE_OPENGLES");
preferGLES = (gleshint != nullptr && gleshint[0] != '0');
}
// Do we want a debug context?
bool debug = love::graphics::isDebugEnabled();
const char *preferGL2hint = SDL_GetHint("LOVE_GRAPHICS_USE_GL2");
bool preferGL2 = (preferGL2hint != nullptr && preferGL2hint[0] != '0');
std::vector<ContextAttribs> glcontexts = {{2, 1, false, debug}};
glcontexts.insert(preferGL2 ? glcontexts.end() : glcontexts.begin(), {3, 3, false, debug});
std::vector<ContextAttribs> glescontexts = {{2, 0, true, debug}};
// While UWP SDL is above 2.0.4, it still doesn't support OpenGL ES 3+
#ifndef LOVE_WINDOWS_UWP
// OpenGL ES 3+ contexts are only properly supported in SDL 2.0.4+.
if (!hasSDL203orEarlier)
glescontexts.insert(preferGL2 ? glescontexts.end() : glescontexts.begin(), {3, 0, true, debug});
#endif
std::vector<ContextAttribs> attribslist;
if (preferGLES)
{
attribslist.insert(attribslist.end(), glescontexts.begin(), glescontexts.end());
attribslist.insert(attribslist.end(), glcontexts.begin(), glcontexts.end());
}
else
{
attribslist.insert(attribslist.end(), glcontexts.begin(), glcontexts.end());
attribslist.insert(attribslist.end(), glescontexts.begin(), glescontexts.end());
}
return attribslist;
}
void OSystem_SDL::initBackend() {
// Check if backend has not been initialized
assert(!_inited);
#if SDL_VERSION_ATLEAST(2, 0, 0)
const char *sdlDriverName = SDL_GetCurrentVideoDriver();
#else
const int maxNameLen = 20;
char sdlDriverName[maxNameLen];
sdlDriverName[0] = '\0';
SDL_VideoDriverName(sdlDriverName, maxNameLen);
#endif
// Using printf rather than debug() here as debug()/logging
// is not active by this point.
debug(1, "Using SDL Video Driver \"%s\"", sdlDriverName);
// Create the default event source, in case a custom backend
// manager didn't provide one yet.
if (_eventSource == 0)
_eventSource = new ResVmSdlEventSource(); // ResidualVm: was SdlEventSource
if (_graphicsManager == 0) {
if (_graphicsManager == 0) {
_graphicsManager = new SurfaceSdlGraphicsManager(_eventSource, _window);
}
}
if (_savefileManager == 0)
_savefileManager = new DefaultSaveFileManager();
if (_mixerManager == 0) {
_mixerManager = new SdlMixerManager();
// Setup and start mixer
_mixerManager->init();
}
#ifdef ENABLE_EVENTRECORDER
g_eventRec.registerMixerManager(_mixerManager);
g_eventRec.registerTimerManager(new SdlTimerManager());
#else
if (_timerManager == 0)
_timerManager = new SdlTimerManager();
#endif
if (_audiocdManager == 0) {
// Audio CD support was removed with SDL 1.3
#if SDL_VERSION_ATLEAST(1, 3, 0)
_audiocdManager = new DefaultAudioCDManager();
#else
_audiocdManager = new SdlAudioCDManager();
#endif
}
// Setup a custom program icon.
_window->setupIcon();
_inited = true;
ModularBackend::initBackend();
// We have to initialize the graphics manager before the event manager
// so the virtual keyboard can be initialized, but we have to add the
// graphics manager as an event observer after initializing the event
// manager.
dynamic_cast<SdlGraphicsManager *>(_graphicsManager)->activateManager();
}
int
main(int argc, char *argv[])
{
int i, done;
const char *driver;
SDL_Window *window;
SDL_Texture *sprite;
int window_w, window_h;
int sprite_w, sprite_h;
SDL_Event event;
if (SDL_VideoInit(NULL, 0) < 0) {
fprintf(stderr, "Couldn't initialize SDL video: %s\n",
SDL_GetError());
exit(1);
}
driver = SDL_GetCurrentVideoDriver();
/* Find a native window driver and create a native window */
for (i = 0; factories[i]; ++i) {
if (SDL_strcmp(driver, factories[i]->tag) == 0) {
factory = factories[i];
break;
}
}
if (!factory) {
fprintf(stderr, "Couldn't find native window code for %s driver\n",
driver);
quit(2);
}
printf("Creating native window for %s driver\n", driver);
native_window = factory->CreateNativeWindow(WINDOW_W, WINDOW_H);
if (!native_window) {
fprintf(stderr, "Couldn't create native window\n");
quit(3);
}
window = SDL_CreateWindowFrom(native_window);
if (!window) {
fprintf(stderr, "Couldn't create SDL window: %s\n", SDL_GetError());
quit(4);
}
SDL_SetWindowTitle(window, "SDL Native Window Test");
/* Create the renderer */
if (SDL_CreateRenderer(window, -1, 0) < 0) {
fprintf(stderr, "Couldn't create renderer: %s\n", SDL_GetError());
quit(5);
}
/* Clear the window, load the sprite and go! */
SDL_SelectRenderer(window);
SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
SDL_RenderClear();
sprite = LoadSprite(window, "icon.bmp");
if (!sprite) {
quit(6);
}
/* Allocate memory for the sprite info */
SDL_GetWindowSize(window, &window_w, &window_h);
SDL_QueryTexture(sprite, NULL, NULL, &sprite_w, &sprite_h);
positions = (SDL_Rect *) SDL_malloc(NUM_SPRITES * sizeof(SDL_Rect));
velocities = (SDL_Rect *) SDL_malloc(NUM_SPRITES * sizeof(SDL_Rect));
if (!positions || !velocities) {
fprintf(stderr, "Out of memory!\n");
quit(2);
}
srand(time(NULL));
for (i = 0; i < NUM_SPRITES; ++i) {
positions[i].x = rand() % (window_w - sprite_w);
positions[i].y = rand() % (window_h - sprite_h);
positions[i].w = sprite_w;
positions[i].h = sprite_h;
velocities[i].x = 0;
velocities[i].y = 0;
while (!velocities[i].x && !velocities[i].y) {
velocities[i].x = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED;
velocities[i].y = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED;
}
}
/* Main render loop */
done = 0;
while (!done) {
/* Check for events */
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_WINDOWEVENT:
switch (event.window.event) {
case SDL_WINDOWEVENT_EXPOSED:
SDL_SelectRenderer(event.window.windowID);
SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
SDL_RenderClear();
break;
}
break;
case SDL_QUIT:
done = 1;
break;
default:
break;
}
}
MoveSprites(window, sprite);
}
quit(0);
}
void OSystem_SDL::initBackend() {
// Check if backend has not been initialized
assert(!_inited);
#if SDL_VERSION_ATLEAST(2, 0, 0)
const char *sdlDriverName = SDL_GetCurrentVideoDriver();
#else
const int maxNameLen = 20;
char sdlDriverName[maxNameLen];
sdlDriverName[0] = '\0';
SDL_VideoDriverName(sdlDriverName, maxNameLen);
#endif
// Using printf rather than debug() here as debug()/logging
// is not active by this point.
debug(1, "Using SDL Video Driver \"%s\"", sdlDriverName);
// Create the default event source, in case a custom backend
// manager didn't provide one yet.
if (_eventSource == 0)
_eventSource = new SdlEventSource();
#ifdef USE_OPENGL
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_DisplayMode displayMode;
if (!SDL_GetDesktopDisplayMode(0, &displayMode)) {
_desktopWidth = displayMode.w;
_desktopHeight = displayMode.h;
}
#else
// Query the desktop resolution. We simply hope nothing tried to change
// the resolution so far.
const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
if (videoInfo && videoInfo->current_w > 0 && videoInfo->current_h > 0) {
_desktopWidth = videoInfo->current_w;
_desktopHeight = videoInfo->current_h;
}
#endif
#endif
if (_graphicsManager == 0) {
#ifdef USE_OPENGL
// Setup a list with both SDL and OpenGL graphics modes. We only do
// this whenever the subclass did not already set up an graphics
// manager yet. This is because we don't know the type of the graphics
// manager of the subclass, thus we cannot easily switch between the
// OpenGL one and the set up one. It also is to be expected that the
// subclass does not want any switching of graphics managers anyway.
setupGraphicsModes();
if (ConfMan.hasKey("gfx_mode")) {
// If the gfx_mode is from OpenGL, create the OpenGL graphics manager
Common::String gfxMode(ConfMan.get("gfx_mode"));
for (uint i = _firstGLMode; i < _graphicsModeIds.size(); ++i) {
if (!scumm_stricmp(_graphicsModes[i].name, gfxMode.c_str())) {
_graphicsManager = new OpenGLSdlGraphicsManager(_desktopWidth, _desktopHeight, _eventSource, _window);
_graphicsMode = i;
break;
}
}
}
#endif
if (_graphicsManager == 0) {
_graphicsManager = new SurfaceSdlGraphicsManager(_eventSource, _window);
}
}
if (_savefileManager == 0)
_savefileManager = new DefaultSaveFileManager();
if (_mixerManager == 0) {
_mixerManager = new SdlMixerManager();
// Setup and start mixer
_mixerManager->init();
}
#ifdef ENABLE_EVENTRECORDER
g_eventRec.registerMixerManager(_mixerManager);
g_eventRec.registerTimerManager(new SdlTimerManager());
#else
if (_timerManager == 0)
_timerManager = new SdlTimerManager();
#endif
_audiocdManager = createAudioCDManager();
// Setup a custom program icon.
_window->setupIcon();
_inited = true;
ModularBackend::initBackend();
// We have to initialize the graphics manager before the event manager
// so the virtual keyboard can be initialized, but we have to add the
// graphics manager as an event observer after initializing the event
// manager.
dynamic_cast<SdlGraphicsManager *>(_graphicsManager)->activateManager();
}
int SDLFrontend::init (int width, int height, bool fullscreen, EventHandler &eventHandler)
{
if (width == -1 && height == -1)
fullscreen = true;
info(LOG_CLIENT,
String::format("initializing: %i:%i - fullscreen: %s", width, height, fullscreen ? "true" : "false"));
INIT_Subsystem(SDL_INIT_VIDEO, true);
INIT_Subsystem(SDL_INIT_JOYSTICK, false);
INIT_Subsystem(SDL_INIT_GAMECONTROLLER, false);
INIT_Subsystem(SDL_INIT_HAPTIC, false);
initJoystickAndHaptic();
SDL_DisplayMode displayMode;
SDL_GetDesktopDisplayMode(0, &displayMode);
const char *name = SDL_GetPixelFormatName(displayMode.format);
info(LOG_CLIENT, String::format("current desktop mode: %dx%d@%dHz (%s)",
displayMode.w, displayMode.h, displayMode.refresh_rate, name));
if (width == -1)
width = 800;//displayMode.w;
if (height == -1)
height = 480; //displayMode.h;
setGLAttributes();
setHints();
int doubleBuffered = 0;
SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &doubleBuffered);
info(LOG_CLIENT, String::format("doublebuffer: %s", doubleBuffered ? "activated" : "disabled"));
int flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
#ifdef __IPHONEOS__
flags |= SDL_WINDOW_RESIZABLE;
#endif
#if 1 //defined __IPHONEOS__ || defined __ANDROID__
if (fullscreen)
flags |= SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS;
#else
if (fullscreen)
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_BORDERLESS;
#endif
const int videoDrivers = SDL_GetNumVideoDrivers();
for (int i = 0; i < videoDrivers; ++i) {
info(LOG_CLIENT, String::format("available driver: %s", SDL_GetVideoDriver(i)));
}
info(LOG_CLIENT, String::format("driver: %s", SDL_GetCurrentVideoDriver()));
const int displays = SDL_GetNumVideoDisplays();
info(LOG_CLIENT, String::format("found %i display(s)", displays));
if (fullscreen && displays > 1) {
width = displayMode.w;
height = displayMode.h;
info(LOG_CLIENT, String::format("use fake fullscreen for the first display: %i:%i", width, height));
}
_window = SDL_CreateWindow(Singleton<Application>::getInstance().getName().c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, flags);
if (!_window) {
sdlCheckError();
return -1;
}
SDL_DisableScreenSaver();
initRenderer();
resetColor();
GLContext::get().init();
if (SDL_SetWindowBrightness(_window, 1.0f) == -1)
sdlCheckError();
if (Config.isGrabMouse() && (!fullscreen || displays > 1)) {
SDL_SetWindowGrab(_window, SDL_TRUE);
}
int screen = 0;
int modes = SDL_GetNumDisplayModes(screen);
info(LOG_CLIENT, "possible display modes:");
for (int i = 0; i < modes; i++) {
SDL_GetDisplayMode(screen, i, &displayMode);
name = SDL_GetPixelFormatName(displayMode.format);
info(LOG_CLIENT, String::format("%dx%d@%dHz %s",
displayMode.w, displayMode.h, displayMode.refresh_rate, name));
}
// some platforms may override or hardcode the resolution - so
// we have to query it here to get the actual resolution
SDL_GetWindowSize(_window, &width, &height);
if (SDL_SetRelativeMouseMode(SDL_TRUE) == -1)
error(LOG_CLIENT, "no relative mouse mode support");
SDL_ShowCursor(0);
info(LOG_CLIENT, String::format("actual resolution: %dx%d", width, height));
setVSync(ConfigManager::get().isVSync());
const int initState = IMG_Init(IMG_INIT_PNG);
if (!(initState & IMG_INIT_PNG)) {
sdlCheckError();
System.exit("No png support", 1);
}
_width = width;
_height = height;
updateViewport(0, 0, getWidth(), getHeight());
onInit();
_eventHandler = &eventHandler;
_eventHandler->registerObserver(_console.get());
_eventHandler->registerObserver(this);
info(LOG_CLIENT, "init the shader manager");
ShaderManager::get().init();
if (!Config.isSoundEnabled()) {
info(LOG_CLIENT, "sound disabled");
} else if (!SoundControl.init(true)) {
error(LOG_CLIENT, "sound initialization failed");
}
return 0;
}
/*
===============
GLimp_StartDriverAndSetMode
===============
*/
static bool GLimp_StartDriverAndSetMode( int mode, bool fullscreen, bool noborder )
{
rserr_t err;
int numDisplays;
if ( !SDL_WasInit( SDL_INIT_VIDEO ) )
{
const char *driverName;
SDL_version v;
SDL_GetVersion( &v );
ri.Printf( PRINT_ALL, "SDL_Init( SDL_INIT_VIDEO )... " );
ri.Printf( PRINT_ALL, "Using SDL Version %u.%u.%u\n", v.major, v.minor, v.patch );
if ( SDL_Init( SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE ) == -1 )
{
ri.Printf( PRINT_ALL, "SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) FAILED (%s)\n", SDL_GetError() );
return false;
}
driverName = SDL_GetCurrentVideoDriver();
if ( !driverName )
{
ri.Error( ERR_FATAL, "No video driver initialized\n" );
}
ri.Printf( PRINT_ALL, "SDL using driver \"%s\"\n", driverName );
ri.Cvar_Set( "r_sdlDriver", driverName );
}
numDisplays = SDL_GetNumVideoDisplays();
if ( numDisplays <= 0 )
{
ri.Error( ERR_FATAL, "SDL_GetNumVideoDisplays FAILED (%s)\n", SDL_GetError() );
}
AssertCvarRange( r_displayIndex, 0, numDisplays - 1, true );
if ( fullscreen && ri.Cvar_VariableIntegerValue( "in_nograb" ) )
{
ri.Printf( PRINT_ALL, "Fullscreen not allowed with in_nograb 1\n" );
ri.Cvar_Set( "r_fullscreen", "0" );
r_fullscreen->modified = false;
fullscreen = false;
}
err = (rserr_t) GLimp_SetMode( mode, fullscreen, noborder );
switch ( err )
{
case RSERR_INVALID_FULLSCREEN:
ri.Printf( PRINT_ALL, "...WARNING: fullscreen unavailable in this mode\n" );
return false;
case RSERR_INVALID_MODE:
ri.Printf( PRINT_ALL, "...WARNING: could not set the given mode (%d)\n", mode );
return false;
case RSERR_OLD_GL:
ri.Printf( PRINT_ALL, "...WARNING: OpenGL too old\n" );
return false;
default:
break;
}
return true;
}
int config_init ( int argc, char **argv )
{
const char *config_name = DEFAULT_CONFIG_FILE; // name of the used config file, can be overwritten via CLI
const struct configOption_st *opt;
const char *exe = argv[0];
int default_config = 1;
int testparsing = 0;
argc--; argv++;
#ifdef __EMSCRIPTEN__
exe = strdup("/files/emscripten-virtual-executable");
#endif
#ifdef _WIN32
console_open_window();
#endif
SDL_VERSION(&sdlver_compiled);
SDL_GetVersion(&sdlver_linked);
if (sdlver_linked.major < 2 || (sdlver_linked.minor == 0 && sdlver_linked.patch < 4)) {
ERROR_WINDOW("Too old SDL library linked, at least version 2.0.4 is required.");
return 1;
}
/* SDL info on paths */
if (get_path_info())
return 1;
/* ugly hack: pre-parse comand line to find debug statement (to be worse, it does not handle single argument options too well ... */
#ifdef DISABLE_DEBUG
printf("DEBUG: disabled at compilation time." NL);
#else
while (testparsing < argc) {
if (!strcmp(argv[testparsing], "-" DEBUGFILE_OPT) && testparsing != argc - 1 && strcmp(argv[testparsing + 1], "none")) {
debug_fp = fopen(argv[testparsing + 1], "w");
DEBUGPRINT("DEBUG: enable logging into file: %s" NL, argv[testparsing + 1]);
if (debug_fp == NULL)
fprintf(stderr, "Cannot open debug logging file: %s" NL, argv[testparsing + 1]);
break;
}
testparsing++;
}
testparsing = 0;
#endif
/* end of ugly hack */
/* let's continue with the info block ... */
DEBUGPRINT("%s %s v%s %s %s" NL
"GIT %s compiled by (%s) at (%s) with (%s)-(%s)" NL
"Platform: (%s) (%d-bit), video: (%s), audio: (%s), "
"SDL version compiled: (%d.%d.%d) and linked: (%d.%d.%d) rev (%s)" NL NL,
WINDOW_TITLE, DESCRIPTION, VERSION, COPYRIGHT, PROJECT_PAGE,
XEMU_BUILDINFO_GIT, XEMU_BUILDINFO_ON, XEMU_BUILDINFO_AT, CC_TYPE, XEMU_BUILDINFO_CC,
SDL_GetPlatform(), ARCH_BITS, SDL_GetCurrentVideoDriver(), SDL_GetCurrentAudioDriver(),
sdlver_compiled.major, sdlver_compiled.minor, sdlver_compiled.patch,
sdlver_linked.major, sdlver_linked.minor, sdlver_linked.patch, SDL_GetRevision()
);
DEBUGPRINT("PATH: executable: %s" NL, exe);
/* SDL path info block printout */
DEBUGPRINT("PATH: SDL base path: %s" NL, app_base_path);
DEBUGPRINT("PATH: SDL pref path: %s" NL, app_pref_path);
#ifndef _WIN32
DEBUGPRINT("PATH: data directory: %s/" NL, DATADIR);
#endif
DEBUGPRINT("PATH: Current directory: %s" NL NL, current_directory);
/* Look the very basic command line switches first */
if (argc && is_help_request_option(argv[0])) {
opt = configOptions;
printf("USAGE:" NL NL
"\t%s -optname optval -optname2 optval2 ..." NL NL "OPTIONS:" NL NL
"-config" NL "\tUse config file (or do not use the default one, if \"none\" is specified). This must be the first option if used! [default: @config]" NL,
exe
);
while (opt->name) {
printf("-%s" NL "\t%s [default: %s]" NL, opt->name, opt->help, opt->defval ? opt->defval : "-");
opt++;
}
printf(NL "%s" NL, disclaimer);
#ifdef _WIN32
if (!console_is_open)
ERROR_WINDOW("Could not dump help, since console couldn't be allocated.");
#endif
XEMUEXIT(0);
}
DEBUGPRINT("%s" NL NL, disclaimer);
if (argc && !strcasecmp(argv[0], "-testparsing")) {
testparsing = 1;
argc--; argv++;
}
if (argc & 1) {
fprintf(stderr, "FATAL: Bad command line: should be even number of parameters (two for an option as key and its value)" NL);
return 1;
}
if (argc > 1 && !strcmp(argv[0], "-config")) {
default_config = 0;
config_name = argv[1];
argc -= 2;
argv += 2;
}
/* Set default (built-in) values */
opt = configOptions;
while (opt->name) {
if (opt->defval)
config_set_internal(opt->name, -1, opt->defval);
opt++;
}
config_set_internal("rom", 0, COMBINED_ROM_FN); // set default "combined" ROM image set (from segment 0, starting with EXOS)
/* Default values for the keyboard follows ... */
keymap_preinit_config_internal();
/* check if we have written sample config file, if there is not, let's create one */
save_sample_config(DEFAULT_CONFIG_SAMPLE_FILE);
/* now parse config file (not the sample one!) if there is any */
if (strcasecmp(config_name, "none")) {
char path[PATH_MAX + 1];
FILE *f = open_emu_file(config_name, "r", path);
DEBUGPRINT("CONFIG: config file: %s (%s)" NL, config_name, f ? path : "*** CANNOT OPEN, NOT USING CONFIG FILE ***");
if (f) {
if (load_config_file_stream(f, path)) {
fclose(f);
return 1;
}
fclose(f);
} else if (!default_config) {
fprintf(stderr, "FATAL: Cannot open requested config file: %s" NL, config_name);
return 1;
} else
DEBUGPRINT("CONFIG: Skipping default config file (cannot open), using built-in defaults." NL);
} else
DEBUGPRINT("CONFIG: Using config file: DISABLED in command line" NL);
/* parse command line ... */
if (parse_command_line(argc, argv))
return -1;
/* open debug file, if it was not requested via command line at the beginning ... */
if (!debug_fp && strcmp(config_getopt_str(DEBUGFILE_OPT), "none")) {
debug_fp = fopen(config_getopt_str(DEBUGFILE_OPT), "w");
DEBUGPRINT("DEBUG: enable logging into file: %s" NL, config_getopt_str(DEBUGFILE_OPT));
if (!debug_fp)
ERROR_WINDOW("Cannot open debug messages log file requested: %s", config_getopt_str(DEBUGFILE_OPT));
}
if (debug_fp)
INFO_WINDOW("DEBUG: Debug messages logging is active");
else
printf("DEBUG: No debug messages logging is active." NL);
/* test parsing mode? */
if (testparsing) {
printf(NL "--- TEST DUMP OF *PARSED* CONFIGURATION (requested)" NL NL);
dump_config(stdout);
printf(NL "--- END OF TEST PARSING MODE (requested)" NL);
XEMUEXIT(0);
}
DEBUG("CONFIG: End of configuration step." NL NL);
/* Close console, unless user requested it with the -console option */
#ifdef _WIN32
if (!config_getopt_int("console"))
console_close_window();
#else
if (config_getopt_int("console"))
console_open_window(); // on non-windows, it only will mark console as open for monitor to be used ..
#endif
return 0;
}
int video_init(int window_w,
int window_h,
int fullscreen,
int vsync,
const char* scaler_name,
int scale_factor) {
state.w = window_w;
state.h = window_h;
state.fs = fullscreen;
state.vsync = vsync;
state.fade = 1.0f;
state.target = NULL;
state.target_move_x = 0;
state.target_move_y = 0;
// Load scaler (if any)
memset(state.scaler_name, 0, sizeof(state.scaler_name));
strncpy(state.scaler_name, scaler_name, sizeof(state.scaler_name)-1);
if(video_load_scaler(scaler_name, scale_factor)) {
DEBUG("Scaler \"%s\" plugin not found; using Nearest neighbour scaling.", scaler_name);
state.scale_factor = 1;
} else {
DEBUG("Scaler \"%s\" loaded w/ factor %d", scaler_name, scale_factor);
state.scale_factor = scale_factor;
}
// Clear palettes
state.cur_palette = malloc(sizeof(screen_palette));
state.base_palette = malloc(sizeof(palette));
memset(state.cur_palette, 0, sizeof(screen_palette));
state.cur_palette->version = 1;
// Form title string
char title[32];
sprintf(title, "OpenOMF v%d.%d.%d", V_MAJOR, V_MINOR, V_PATCH);
// Open window
state.window = SDL_CreateWindow(
title,
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
window_w,
window_h,
SDL_WINDOW_SHOWN);
if(state.window == NULL) {
PERROR("Could not create window: %s", SDL_GetError());
return 1;
}
// Set fullscreen if needed
if(state.fs) {
if(SDL_SetWindowFullscreen(state.window, SDL_WINDOW_FULLSCREEN) != 0) {
PERROR("Could not set fullscreen mode!");
} else {
DEBUG("Fullscreen enabled!");
}
} else {
SDL_SetWindowFullscreen(state.window, 0);
}
// Form flags
int renderer_flags = SDL_RENDERER_ACCELERATED;
if(state.vsync) {
renderer_flags |= SDL_RENDERER_PRESENTVSYNC;
}
// Create renderer
state.renderer = SDL_CreateRenderer(
state.window,
-1,
renderer_flags);
if(state.renderer == NULL) {
PERROR("Could not create renderer: %s", SDL_GetError());
return 1;
}
// Default resolution for renderer. This will them get scaled up to screen size.
SDL_RenderSetLogicalSize(state.renderer,
NATIVE_W * state.scale_factor,
NATIVE_H * state.scale_factor);
// Disable screensaver :/
SDL_DisableScreenSaver();
// Set rendertargets
reset_targets();
// Init texture cache
tcache_init(state.renderer, state.scale_factor, &state.scaler);
// Init hardware renderer
state.cur_renderer = VIDEO_RENDERER_HW;
video_hw_init(&state);
// Get renderer data
SDL_RendererInfo rinfo;
SDL_GetRendererInfo(state.renderer, &rinfo);
// Show some info
INFO("Video Init OK");
INFO(" * Driver: %s", SDL_GetCurrentVideoDriver());
INFO(" * Renderer: %s", rinfo.name);
INFO(" * Accelerated: %s", (rinfo.flags & SDL_RENDERER_ACCELERATED) ? "Yes" : "No");
INFO(" * VSync support: %s", (rinfo.flags & SDL_RENDERER_PRESENTVSYNC) ? "Yes" : "No");
INFO(" * Target support: %s", (rinfo.flags & SDL_RENDERER_TARGETTEXTURE) ? "Yes" : "No");
return 0;
}
SDL_bool
CommonInit(CommonState * state)
{
int i, j, m, n;
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) < 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());
}
if (state->verbose & VERBOSE_MODES) {
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:\n", i);
SDL_SelectVideoDisplay(i);
SDL_GetDesktopDisplayMode(&mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
&Bmask, &Amask);
fprintf(stderr,
" Current mode: %dx%d@%dHz, %d bits-per-pixel\n",
mode.w, mode.h, mode.refresh_rate, bpp);
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();
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(j, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
&Gmask, &Bmask, &Amask);
fprintf(stderr,
" Mode %d: %dx%d@%dHz, %d bits-per-pixel\n",
j, mode.w, mode.h, mode.refresh_rate, bpp);
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);
}
}
}
}
}
SDL_SelectVideoDisplay(state->display);
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);
PrintRenderer(&info);
}
}
}
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;
default:
fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
break;
}
fullscreen_mode.w = state->window_w;
fullscreen_mode.h = state->window_h;
fullscreen_mode.refresh_rate = state->refresh_rate;
SDL_SetFullscreenDisplayMode(&fullscreen_mode);
state->windows =
(SDL_WindowID *) SDL_malloc(state->num_windows *
sizeof(*state->windows));
if (!state->windows) {
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->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;
}
}
if (SDL_CreateRenderer
(state->windows[i], m, state->render_flags) < 0) {
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(&info);
PrintRenderer(&info);
}
}
}
SDL_SelectRenderer(state->windows[0]);
}
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;
}
int InitVideo(FCEUGI *gi)
{
// This is a big TODO. Stubbing this off into its own function,
// as the SDL surface routines have changed drastically in SDL2
// TODO - SDL2
const char * window_name;
int error, flags = 0;
int doublebuf, xstretch, ystretch, xres, yres, show_fps;
uint32_t Amask, Rmask, Gmask, Bmask;
int bpp;
FCEUI_printf("Initializing video (SDL2.x) ...");
// load the relevant configuration variables
g_config->getOption("SDL.Fullscreen", &s_fullscreen);
g_config->getOption("SDL.DoubleBuffering", &doublebuf);
#ifdef OPENGL
g_config->getOption("SDL.OpenGL", &s_useOpenGL);
#endif
g_config->getOption("SDL.SpecialFilter", &s_sponge);
g_config->getOption("SDL.XStretch", &xstretch);
g_config->getOption("SDL.YStretch", &ystretch);
g_config->getOption("SDL.LastXRes", &xres);
g_config->getOption("SDL.LastYRes", &yres);
g_config->getOption("SDL.ClipSides", &s_clipSides);
g_config->getOption("SDL.NoFrame", &noframe);
g_config->getOption("SDL.ShowFPS", &show_fps);
// check the starting, ending, and total scan lines
FCEUI_GetCurrentVidSystem(&s_srendline, &s_erendline);
s_tlines = s_erendline - s_srendline + 1;
#if OPENGL
if( !s_useOpenGL || s_sponge )
{
FCEUD_PrintError("SDL2 Does not support non-OpenGL rendering or special filters\n");
KillVideo();
return -1;
}
#endif
// initialize the SDL video subsystem if it is not already active
if(!SDL_WasInit(SDL_INIT_VIDEO)) {
error = SDL_InitSubSystem(SDL_INIT_VIDEO);
if(error) {
FCEUD_PrintError(SDL_GetError());
return -1;
}
}
s_inited = 1;
// For simplicity, hard-code this to 32bpp for now...
s_curbpp = 32;
// If game is running, set window name accordingly
if( gi )
{
window_name = (const char *) gi->name;
}
else
{
window_name = "FCE Ultra";
}
s_exs = 1.0;
s_eys = 1.0;
if(s_fullscreen) {
s_window = SDL_CreateWindow( window_name,
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
0, 0, // Res not specified in full-screen mode
SDL_WINDOW_FULLSCREEN_DESKTOP);
} else {
#if defined(_GTK) && defined(SDL_VIDEO_DRIVER_X11)
if(noGui == 0 && strcmp(SDL_GetCurrentVideoDriver(), "x11") == 0) {
s_window = SDL_CreateWindowFrom((void*)GDK_WINDOW_XID (gtk_widget_get_window(evbox)));
}
else
#endif
s_window = SDL_CreateWindow( window_name,
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
xres, yres,
0);
}
// This stuff all applies regardless of full-screen vs windowed mode.
s_renderer = SDL_CreateRenderer(s_window, -1, 0);
// Set logical rendering size & specify scaling mode. All rendering is
// now done to the renderer rather than directly to the screen surface.
// The renderer takes care of any scaling necessary.
//
// NOTE: setting scale quality to "nearest" will result in a blown-up but
// pixelated while "linear" will tend to blur everything.
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "nearest");
SDL_RenderSetLogicalSize(s_renderer, xres, yres);
//
// Create the texture that will ultimately be rendered.
// s_screen is used to build up an image, then the texture will be updated
// all at once when it's ready
s_texture = SDL_CreateTexture(s_renderer,
SDL_PIXELFORMAT_ARGB8888,
SDL_TEXTUREACCESS_STREAMING,
xres, yres);
//
// Create a surface to draw pixels onto
//
SDL_PixelFormatEnumToMasks(SDL_PIXELFORMAT_ARGB8888, &bpp, &Rmask, &Gmask, &Bmask, &Amask);
s_screen = SDL_CreateRGBSurface(0, xres, yres, bpp,
Rmask, Gmask, Bmask, Amask);
if( !s_screen )
{
FCEUD_PrintError(SDL_GetError());
return -1;
}
//
// Setup Icon surface
//
#ifdef LSB_FIRST
s_IconSurface = SDL_CreateRGBSurfaceFrom((void *)fceu_playicon.pixel_data,
32, 32, 24, 32 * 3,
0xFF, 0xFF00, 0xFF0000, 0x00);
#else
s_IconSurface = SDL_CreateRGBSurfaceFrom((void *)fceu_playicon.pixel_data,
32, 32, 24, 32 * 3,
0xFF0000, 0xFF00, 0xFF, 0x00);
#endif
SDL_SetWindowIcon(s_window, s_IconSurface);
s_paletterefresh = 1; // Force palette refresh
// always init blit to high since bpp forced to 32 for now.
InitBlitToHigh(s_curbpp >> 3,
s_screen->format->Rmask,
s_screen->format->Gmask,
s_screen->format->Bmask,
0, //s_eefx, Hard-code SFX off
0, //s_sponge, Hard-code special filters off.
0);
return 0;
}
SDLHardwareRenderDevice::SDLHardwareRenderDevice()
: window(NULL)
, renderer(NULL)
, texture(NULL)
, titlebar_icon(NULL)
, title(NULL)
, background_color(0,0,0,0)
{
Utils::logInfo("Using Render Device: SDLHardwareRenderDevice (hardware, SDL 2, %s)", SDL_GetCurrentVideoDriver());
fullscreen = settings->fullscreen;
hwsurface = settings->hwsurface;
vsync = settings->vsync;
texture_filter = settings->texture_filter;
min_screen.x = eset->resolutions.min_screen_w;
min_screen.y = eset->resolutions.min_screen_h;
SDL_DisplayMode desktop;
if (SDL_GetDesktopDisplayMode(0, &desktop) == 0) {
// we only support display #0
Utils::logInfo("RenderDevice: %d display(s), using display 0 (%dx%d @ %dhz)", SDL_GetNumVideoDisplays(), desktop.w, desktop.h, desktop.refresh_rate);
}
}
int main(int argc, char **argv) {
if(SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
return -1;
}
if(TTF_Init() < 0) {
fprintf(stderr, "Couldn't initialize font rendering: %s\n", TTF_GetError());
return -1;
}
int width = 800;
int height = 600;
Uint32 frameRate = BASE_FRAME_RATE_MS;
SDL_bool vsync = SDL_FALSE;
#if SDL_MAJOR_VERSION == 2
SDL_DisplayMode current;
for(int i = 0; i < SDL_GetNumVideoDisplays(); ++i){
if(SDL_GetCurrentDisplayMode(i, ¤t) != 0)
fprintf(stderr, "Couldn't get display mode: %s\n", SDL_GetError());
else {
printf("Display %d is %dx%d\n", i, current.w, current.h);
width = current.w;
height = current.h;
}
}
Uint32 flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC;
if(argc > 1) {
if(strncmp(argv[1], "-novsync", 8) == 0)
flags &= ~SDL_RENDERER_PRESENTVSYNC;
if(strncmp(argv[1], "-software", 9) == 0)
flags = SDL_RENDERER_SOFTWARE;
char *n = strchr(argv[1], '=');
if(n) {
n++;
frameRate = strtoul(n, 0, 0);
}
}
SDL_Window *window = SDL_CreateWindow(argv[0], SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width + GetIntelOffset(), height, SDL_WINDOW_SHOWN | SDL_WINDOW_FULLSCREEN);
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, flags);
SDL_ShowCursor(SDL_DISABLE);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_DisableScreenSaver();
SDL_RendererInfo info;
if(SDL_GetRendererInfo(renderer, &info) == 0) {
printf("Using video driver: %s with renderer %s\n", SDL_GetCurrentVideoDriver(), info.name);
if(info.flags & SDL_RENDERER_SOFTWARE)
printf("*** Using SDL_RENDERER_SOFTWARE\n");
if(info.flags & SDL_RENDERER_ACCELERATED)
printf("*** Using SDL_RENDERER_ACCELERATED\n");
if(info.flags & SDL_RENDERER_PRESENTVSYNC) {
printf("*** Using SDL_RENDERER_PRESENTVSYNC\n");
vsync = SDL_TRUE;
}
if(info.flags & SDL_RENDERER_TARGETTEXTURE)
printf("*** Using SDL_RENDERER_TARGETTEXTURE\n");
}
#else
const SDL_VideoInfo *pVideoInfo = SDL_GetVideoInfo();
if(pVideoInfo == 0) {
fprintf(stderr, "Couldn't get display information: %s\n", SDL_GetError());
exit(1);
}
printf("Display is %dx%d\n", pVideoInfo->current_w, pVideoInfo->current_h);
width = pVideoInfo->current_w;
height = pVideoInfo->current_h;
SDL_Surface *screen = SDL_SetVideoMode(width, height, pVideoInfo->vfmt->BitsPerPixel, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN);
if(screen == 0) {
fprintf(stderr, "Couldn't set video mode: %s\n", SDL_GetError());
exit(1);
}
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 1);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_ShowCursor(SDL_DISABLE);
#endif
TTF_Font *font = TTF_OpenFont("AlteHaasGroteskBold.ttf", 60);
if(font == 0) {
fprintf(stderr, "Can't open font for stats: %s", TTF_GetError());
goto cleanup;
}
SDL_Event event;
SDL_bool m_run = SDL_TRUE;
Uint32 lastFrame = 0;
float fps = 0.0f;
SDL_Color foregroundColor = { 0xff, 0xff, 0 };
char tmp[64];
int delta = 1;
int position = 0;
while(m_run) {
while(SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_KEYDOWN:
if(event.key.keysym.sym == SDLK_ESCAPE)
m_run = SDL_FALSE;
break;
case SDL_QUIT:
m_run = SDL_FALSE;
break;
default:
break;
}
}
Uint32 start = SDL_GetTicks();
#if SDL_MAJOR_VERSION == 2
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0xff);
SDL_RenderClear(renderer);
#else
SDL_FillRect(screen, 0, 0);
#endif
snprintf(tmp, sizeof(tmp), "Current fps = %.1f", fps);
SDL_Surface *textSurface = TTF_RenderText_Solid(font, tmp, foregroundColor);
if(textSurface) {
#if SDL_MAJOR_VERSION == 2
SDL_Texture *textTexture = SDL_CreateTextureFromSurface(renderer, textSurface);
#endif
SDL_Rect location;
location.h = textSurface->h;
location.w = textSurface->w;
location.x = position;
location.y = height / 2 - textSurface->h / 2;
#if SDL_MAJOR_VERSION == 1
SDL_BlitSurface(textSurface, 0, screen, &location);
#endif
SDL_FreeSurface(textSurface);
position += delta;
if(position >= width - textSurface->w || position <= 0)
delta *= -1;
#if SDL_MAJOR_VERSION == 2
if(textTexture) {
SDL_RenderCopy(renderer, textTexture, 0, &location);
SDL_DestroyTexture(textTexture);
}
#endif
}
#if SDL_MAJOR_VERSION == 2
SDL_RenderPresent(renderer);
#else
SDL_Flip(screen);
#endif
Uint32 end = SDL_GetTicks();
Uint32 elapsed = end - lastFrame;
// delay for the remainder of the base rate so we keep a decent frame rate if there's no vsync
if(vsync == SDL_FALSE && frameRate > elapsed)
SDL_Delay(frameRate - elapsed);
if(elapsed > frameRate * 3) {
struct timeb tp;
ftime(&tp);
time_t now;
struct tm *ti;
char buf[255];
time(&now);
ti = localtime(&now);
strftime(buf, sizeof(buf), "%I:%M:%S", ti);
printf("%s.%d: Frame took %ums\n", buf, tp.millitm, elapsed);
}
// remember now as the starting point for the next frame
lastFrame = SDL_GetTicks();
// update statistics
elapsed = lastFrame - start;
fps = 1000.0f / (float)elapsed;
//printf("Current frame rate is %6.3f fps (%ums) \r", fps, elapsed);
}
printf("\n");
cleanup:
#if SDL_MAJOR_VERSION == 2
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
#else
SDL_FreeSurface(screen);
#endif
TTF_Quit();
SDL_Quit();
return 0;
}
int
main(int argc, char *argv[])
{
const SDL_VideoInfo *info;
int i, d, n;
const char *driver;
SDL_DisplayMode mode;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
int nmodes;
/* Print available video drivers */
n = SDL_GetNumVideoDrivers();
if (n == 0) {
printf("No built-in video drivers\n");
} else {
printf("Built-in video drivers:");
for (i = 0; i < n; ++i) {
if (i > 0) {
printf(",");
}
printf(" %s", SDL_GetVideoDriver(i));
}
printf("\n");
}
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
exit(1);
}
driver = SDL_GetCurrentVideoDriver();
if (driver) {
printf("Video driver: %s\n", driver);
}
printf("Number of displays: %d\n", SDL_GetNumVideoDisplays());
for (d = 0; d < SDL_GetNumVideoDisplays(); ++d) {
printf("Display %d:\n", d);
SDL_SelectVideoDisplay(d);
SDL_GetDesktopDisplayMode(&mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask, &Bmask,
&Amask);
printf(" Current mode: %dx%d@%dHz, %d bits-per-pixel\n", mode.w,
mode.h, mode.refresh_rate, bpp);
if (Rmask || Gmask || Bmask) {
printf(" Red Mask = 0x%.8x\n", Rmask);
printf(" Green Mask = 0x%.8x\n", Gmask);
printf(" Blue Mask = 0x%.8x\n", Bmask);
if (Amask)
printf(" Alpha Mask = 0x%.8x\n", Amask);
}
/* Print available fullscreen video modes */
nmodes = SDL_GetNumDisplayModes();
if (nmodes == 0) {
printf("No available fullscreen video modes\n");
} else {
printf(" Fullscreen video modes:\n");
for (i = 0; i < nmodes; ++i) {
SDL_GetDisplayMode(i, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
&Gmask, &Bmask, &Amask);
printf(" Mode %d: %dx%d@%dHz, %d bits-per-pixel\n", i,
mode.w, mode.h, mode.refresh_rate, bpp);
if (Rmask || Gmask || Bmask) {
printf(" Red Mask = 0x%.8x\n", Rmask);
printf(" Green Mask = 0x%.8x\n", Gmask);
printf(" Blue Mask = 0x%.8x\n", Bmask);
if (Amask)
printf(" Alpha Mask = 0x%.8x\n", Amask);
}
}
}
}
info = SDL_GetVideoInfo();
if (info->wm_available) {
printf("A window manager is available\n");
}
if (info->hw_available) {
printf("Hardware surfaces are available (%dK video memory)\n",
info->video_mem);
}
if (info->blit_hw) {
printf("Copy blits between hardware surfaces are accelerated\n");
}
if (info->blit_hw_CC) {
printf("Colorkey blits between hardware surfaces are accelerated\n");
}
if (info->blit_hw_A) {
printf("Alpha blits between hardware surfaces are accelerated\n");
}
if (info->blit_sw) {
printf
("Copy blits from software surfaces to hardware surfaces are accelerated\n");
}
if (info->blit_sw_CC) {
printf
("Colorkey blits from software surfaces to hardware surfaces are accelerated\n");
}
if (info->blit_sw_A) {
printf
("Alpha blits from software surfaces to hardware surfaces are accelerated\n");
}
if (info->blit_fill) {
printf("Color fills on hardware surfaces are accelerated\n");
}
printf("Current resolution: %dx%d\n", info->current_w, info->current_h);
#if 0
if (argv[1] && (strcmp(argv[1], "-benchmark") == 0)) {
RunVideoTests();
}
#endif
SDL_Quit();
return (0);
}
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->gl_debug) {
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
}
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->logical_w && state->logical_h) {
SDL_RenderSetLogicalSize(state->renderers[i], state->logical_w, state->logical_h);
} else if (state->scale) {
SDL_RenderSetScale(state->renderers[i], state->scale, state->scale);
}
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;
}
/**
* @brief Init the SDL window
*/
bool R_InitGraphics (const viddefContext_t* context)
{
uint32_t flags;
int i;
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
if (context->multisample > 0) {
Com_Printf("I: set multisample buffers to %i\n", context->multisample);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, context->multisample);
} else {
Com_Printf("I: disable multisample buffers\n");
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
}
#if SDL_VERSION_ATLEAST(2,0,0)
/* valid values are between -1 and 1 */
i = std::min(1, std::max(-1, context->swapinterval));
Com_Printf("I: set swap control to %i\n", i);
SDL_GL_SetSwapInterval(i);
flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
if (context->fullscreen)
flags |= SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS;
const int videoDrivers = SDL_GetNumVideoDrivers();
for (int i = 0; i < videoDrivers; ++i) {
Com_Printf("available driver: %s\n", SDL_GetVideoDriver(i));
}
SDL_DisplayMode displayMode;
SDL_GetDesktopDisplayMode(0, &displayMode);
const char* name = SDL_GetPixelFormatName(displayMode.format);
Com_Printf("current desktop mode: %dx%d@%dHz (%s)\n",
displayMode.w, displayMode.h, displayMode.refresh_rate, name);
SDL_VideoInit(nullptr);
SDL_SetModState(KMOD_NONE);
SDL_StopTextInput();
Com_Printf("driver: %s\n", SDL_GetCurrentVideoDriver());
const int displays = SDL_GetNumVideoDisplays();
Com_Printf("found %i display(s)\n", displays);
int width = context->width;
int height = context->height;
if (context->fullscreen && displays > 1) {
width = displayMode.w;
height = displayMode.h;
Com_Printf("use fake fullscreen for the first display: %i:%i\n", width, height);
}
cls.window = SDL_CreateWindow(GAME_TITLE_LONG, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, flags);
if (!cls.window) {
const char* error = SDL_GetError();
Com_Printf("SDL SDL_CreateWindow failed: %s\n", error);
SDL_ClearError();
return -1;
}
cls.context = SDL_GL_CreateContext(cls.window);
#else
/* valid values are between 0 and 2 */
i = std::min(2, std::max(0, context->swapinterval));
Com_Printf("I: set swap control to %i\n", i);
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, i);
flags = SDL_OPENGL;
if (context->fullscreen)
flags |= SDL_FULLSCREEN;
/*flags |= SDL_NOFRAME;*/
SDL_Surface* screen = SDL_SetVideoMode(context->width, context->height, 0, flags);
if (!screen) {
const char* error = SDL_GetError();
Com_Printf("SDL SetVideoMode failed: %s\n", error);
SDL_ClearError();
return false;
}
#endif
SDL_ShowCursor(SDL_DISABLE);
return true;
}
