void graphics_Quit() {
graphics_Close(0);
if (!graphics3d) {
if (sdlvideoinit) {
SDL_VideoQuit();
sdlvideoinit = 0;
}
SDL_Quit();
}
}
void graphics_ReopenForAndroid() {
// throw away hardware textures:
texturemanager_deviceLost();
// preserve old window size:
int w,h;
w = 0;h = 0;
graphics_GetWindowDimensions(&w, &h);
// preserve renderer:
char renderer[512];
const char* p = graphics_GetCurrentRendererName();
int len = strlen(p)+1;
if (len >= sizeof(renderer)) {
len = sizeof(renderer)-1;
}
memcpy(renderer, p, len);
renderer[sizeof(renderer)-1] = 0;
// preserve window title:
char title[512];
p = graphics_GetWindowTitle();
len = strlen(p)+1;
if (len >= sizeof(title)) {
len = sizeof(title)-1;
}
memcpy(title, p, len);
title[sizeof(title)-1] = 0;
// close window:
graphics_Close(0);
// reopen:
char* e;
graphics_SetMode(w, h, 1, 0, title, renderer, &e);
// transfer textures back to hardware:
graphicstexturemanager_DeviceReopened();
}
int graphics_SetMode(int width, int height, int fullscreen,
int resizable, const char* title, const char* renderer, char** error) {
graphics_calculateUnitToPixels(width, height);
#if defined(ANDROID)
if (!fullscreen) {
// do not use windowed on Android
*error = strdup("Windowed mode is not supported on Android");
return 0;
}
#endif
char errormsg[512];
// initialize SDL video if not done yet
if (!graphics_InitVideoSubsystem(error)) {
return 0;
}
// think about the renderer we want
#ifndef WINDOWS
#ifdef ANDROID
char preferredrenderer[20] = "opengles";
#else
char preferredrenderer[20] = "opengl";
#endif
#else
char preferredrenderer[20] = "direct3d";
#endif
int softwarerendering = 0;
if (renderer) {
if (strcasecmp(renderer, "software") == 0) {
#ifdef ANDROID
// we don't want software rendering on Android
#else
softwarerendering = 1;
strcpy(preferredrenderer, "software");
#endif
} else {
if (strcasecmp(renderer, "opengl") == 0) {
#ifdef ANDROID
// opengles is the opengl we want for android :-)
strcpy(preferredrenderer, "opengles");
#else
// regular opengl on desktop platforms
strcpy(preferredrenderer, "opengl");
#endif
}
#ifdef WINDOWS
// only windows knows direct3d obviously
if (strcasecmp(renderer,"direct3d") == 0) {
strcpy(preferredrenderer, "direct3d");
}
#endif
}
}
// get renderer index
int rendererindex = -1;
if (strlen(preferredrenderer) > 0 && !softwarerendering) {
int count = SDL_GetNumRenderDrivers();
if (count > 0) {
int r = 0;
while (r < count) {
SDL_RendererInfo info;
SDL_GetRenderDriverInfo(r, &info);
if (strcasecmp(info.name, preferredrenderer) == 0) {
rendererindex = r;
break;
}
r++;
}
}
}
// see if anything changes at all
unsigned int oldw = 0;
unsigned int oldh = 0;
graphics_GetWindowDimensions(&oldw,&oldh);
if (mainwindow && mainrenderer &&
width == (int)oldw && height == (int)oldh) {
SDL_RendererInfo info;
SDL_GetRendererInfo(mainrenderer, &info);
if (strcasecmp(preferredrenderer, info.name) == 0) {
// same renderer and resolution
if (strcmp(SDL_GetWindowTitle(mainwindow), title) != 0) {
SDL_SetWindowTitle(mainwindow, title);
}
// toggle fullscreen if desired
if (graphics_IsFullscreen() != fullscreen) {
graphics_ToggleFullscreen();
}
return 1;
}
}
// Check if we support the video mode for fullscreen -
// This is done to avoid SDL allowing impossible modes and
// giving us a fake resized/padded/whatever output we don't want.
if (fullscreen) {
// check all video modes in the list SDL returns for us
int count = graphics_GetNumberOfVideoModes();
int i = 0;
int supportedmode = 0;
while (i < count) {
int w,h;
graphics_GetVideoMode(i, &w, &h);
if (w == width && h == height) {
supportedmode = 1;
break;
}
i++;
}
if (!supportedmode) {
// check for desktop video mode aswell
int w,h;
graphics_GetDesktopVideoMode(&w,&h);
if (w == 0 || h == 0 || width != w || height != h) {
*error = strdup("Video mode is not supported");
return 0;
}
}
}
// notify texture manager of device shutdown
texturemanager_deviceLost();
// destroy old window/renderer if we got one
graphics_Close(1);
// create window
if (fullscreen) {
mainwindow = SDL_CreateWindow(title, 0, 0, width, height,
SDL_WINDOW_FULLSCREEN);
mainwindowfullscreen = 1;
} else {
mainwindow = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_MINIMIZED);
mainwindowfullscreen = 0;
}
if (!mainwindow) {
snprintf(errormsg, sizeof(errormsg),
"Failed to open SDL window: %s", SDL_GetError());
errormsg[sizeof(errormsg)-1] = 0;
*error = strdup(errormsg);
return 0;
}
// see if we actually ended up with the resolution we wanted:
int actualwidth, actualheight;
SDL_GetWindowSize(mainwindow, &actualwidth, &actualheight);
if (actualwidth != width || actualheight != height) {
if (fullscreen) { // we failed to get the requested resolution:
SDL_DestroyWindow(mainwindow);
snprintf(errormsg, sizeof(errormsg), "Failed to open "
"SDL window: ended up with other resolution than requested");
*error = strdup(errormsg);
return 0;
}
}
// Create renderer
if (!softwarerendering) {
mainrenderer = SDL_CreateRenderer(mainwindow, rendererindex,
SDL_RENDERER_ACCELERATED|SDL_RENDERER_PRESENTVSYNC);
if (!mainrenderer) {
softwarerendering = 1;
strcpy(preferredrenderer, "software");
}
}
if (softwarerendering) {
mainrenderer = SDL_CreateRenderer(mainwindow, -1,
SDL_RENDERER_SOFTWARE);
}
if (!mainrenderer) {
// we failed to create the renderer
if (mainwindow) {
// destroy window aswell in case it is open
SDL_DestroyWindow(mainwindow);
mainwindow = NULL;
}
if (softwarerendering) {
snprintf(errormsg, sizeof(errormsg),
"Failed to create SDL renderer (backend software): %s",
SDL_GetError());
} else {
SDL_RendererInfo info;
SDL_GetRenderDriverInfo(rendererindex, &info);
snprintf(errormsg, sizeof(errormsg),
"Failed to create SDL renderer (backend %s): %s",
info.name, SDL_GetError());
}
errormsg[sizeof(errormsg)-1] = 0;
*error = strdup(errormsg);
return 0;
} else {
SDL_RendererInfo info;
SDL_GetRendererInfo(mainrenderer, &info);
}
// notify texture manager that device is back
texturemanager_deviceRestored();
// Transfer textures back to SDL
/*if (!graphicstexturelist_TransferTexturesToHW()) {
SDL_RendererInfo info;
SDL_GetRendererInfo(mainrenderer, &info);
snprintf(errormsg, sizeof(errormsg),
"Failed to create SDL renderer (backend %s): "
"Cannot recreate textures", info.name);
*error = strdup(errormsg);
SDL_DestroyRenderer(mainrenderer);
SDL_DestroyWindow(mainwindow);
return 0;
}*/
// Re-focus window if previously focussed
if (!inbackground) {
SDL_RaiseWindow(mainwindow);
}
graphicsactive = 1;
return 1;
}
void graphics_Quit() {
graphics_Close(0);
}
