// (c) 1995-2014 by Artsoft Entertainment
// Holger Schemel
// info@artsoft.org
-// http://www.artsoft.org/
+// https://www.artsoft.org/
// ----------------------------------------------------------------------------
// sdl.c
// ============================================================================
static int LastFrameCounter = 0;
boolean changed = (FrameCounter != LastFrameCounter);
- printf("::: FrameCounter == %d [%s]\n", FrameCounter,
- (changed ? "-" : "SAME FRAME UPDATED"));
+ Debug("internal:frame", "FrameCounter == %d [%s]", FrameCounter,
+ (changed ? "-" : "SAME FRAME UPDATED"));
LastFrameCounter = FrameCounter;
if (filename == NULL)
{
- Error(ERR_WARN, "SDLSetWindowIcon(): cannot find file '%s'", basename);
+ Warn("SDLSetWindowIcon(): cannot find file '%s'", basename);
return;
}
if ((surface = IMG_Load(filename)) == NULL)
{
- Error(ERR_WARN, "IMG_Load() failed: %s", SDL_GetError());
+ Warn("IMG_Load('%s') failed: %s", basename, SDL_GetError());
return;
}
SDL_SetSurfaceAlphaMod(surface, alpha);
}
+const char *SDLGetRendererName(void)
+{
+ static SDL_RendererInfo renderer_info;
+
+ SDL_GetRendererInfo(sdl_renderer, &renderer_info);
+
+ return renderer_info.name;
+}
+
SDL_Surface *SDLGetNativeSurface(SDL_Surface *surface)
{
SDL_PixelFormat format;
if (new_surface == NULL)
Error(ERR_EXIT, "SDL_ConvertSurface() failed: %s", SDL_GetError());
+ // workaround for a bug in SDL 2.0.12 (which does not convert the color key)
+ if (SDLHasColorKey(surface) && !SDLHasColorKey(new_surface))
+ SDL_SetColorKey(new_surface, SET_TRANSPARENT_PIXEL,
+ SDLGetColorKey(surface));
+
return new_surface;
}
void SDLInitVideoDisplay(void)
{
+ // set hint to select render driver as specified in setup config file
+ if (!strEqual(setup.system.sdl_renderdriver, ARG_DEFAULT))
+ SDL_SetHint(SDL_HINT_RENDER_DRIVER, setup.system.sdl_renderdriver);
+
// initialize SDL video
if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
Error(ERR_EXIT, "SDL_InitSubSystem() failed: %s", SDL_GetError());
{
SDL_Surface *new_surface = NULL;
- int surface_flags_window = SURFACE_FLAGS | SDL_WINDOW_RESIZABLE;
+ int surface_flags_window = SURFACE_FLAGS;
int surface_flags_fullscreen = SURFACE_FLAGS | SDL_WINDOW_FULLSCREEN_DESKTOP;
#if 1
int renderer_flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
+
+ video.vsync_mode = VSYNC_MODE_OFF;
+
+ if (!strEqual(setup.vsync_mode, STR_VSYNC_MODE_OFF))
+ {
+ renderer_flags |= SDL_RENDERER_PRESENTVSYNC;
+ video.vsync_mode = VSYNC_MODE_NORMAL;
+ }
#else
/* If SDL_CreateRenderer() is called from within a VirtualBox Windows VM
_without_ enabling 2D/3D acceleration and/or guest additions installed,
int renderer_flags = SDL_RENDERER_SOFTWARE;
#endif
- SDLSetScreenSizeAndOffsets(video.width, video.height);
-
int width = video.width;
int height = video.height;
int screen_width = video.screen_width;
if (sdl_renderer != NULL)
{
- SDL_RenderSetLogicalSize(sdl_renderer, screen_width, screen_height);
// SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, setup.window_scaling_quality);
+ // required for setting adaptive vsync when using OpenGL renderer
SDLSetScreenVsyncMode(setup.vsync_mode);
sdl_texture_stream = SDL_CreateTexture(sdl_renderer,
new_surface = SDL_CreateRGBSurface(0, width, height, 32, 0,0,0, 0);
if (new_surface == NULL)
- Error(ERR_WARN, "SDL_CreateRGBSurface() failed: %s", SDL_GetError());
+ Warn("SDL_CreateRGBSurface() failed: %s", SDL_GetError());
}
else
{
- Error(ERR_WARN, "SDL_CreateTexture() failed: %s", SDL_GetError());
+ Warn("SDL_CreateTexture() failed: %s", SDL_GetError());
}
}
else
{
- Error(ERR_WARN, "SDL_CreateRenderer() failed: %s", SDL_GetError());
+ Warn("SDL_CreateRenderer() failed: %s", SDL_GetError());
}
}
else
{
- Error(ERR_WARN, "SDL_CreateWindow() failed: %s", SDL_GetError());
+ Warn("SDL_CreateWindow() failed: %s", SDL_GetError());
}
+ SDLSetScreenProperties();
+
// store fullscreen state ("video.fullscreen_enabled" may not reflect this!)
if (new_surface != NULL)
fullscreen_enabled = fullscreen;
void SDLSetDisplaySize(void)
{
- SDL_Rect display_bounds;
+ if (sdl_renderer != NULL)
+ {
+ int w, h;
+
+ SDL_GetRendererOutputSize(sdl_renderer, &w, &h);
+
+ video.display_width = w;
+ video.display_height = h;
+
+#if 0
+ Debug("video", "SDL renderer size: %d x %d",
+ video.display_width, video.display_height);
+#endif
+ }
+ else
+ {
+ SDL_Rect display_bounds;
- SDL_GetDisplayBounds(0, &display_bounds);
+ SDL_GetDisplayBounds(0, &display_bounds);
- video.display_width = display_bounds.w;
- video.display_height = display_bounds.h;
+ video.display_width = display_bounds.w;
+ video.display_height = display_bounds.h;
#if 0
- Error(ERR_DEBUG, "SDL real screen size: %d x %d",
- video.display_width, video.display_height);
+ Debug("video", "SDL display size: %d x %d",
+ video.display_width, video.display_height);
#endif
+ }
}
void SDLSetScreenSizeAndOffsets(int width, int height)
video.screen_yoffset = (video.screen_height - height) / 2;
#if 0
- Error(ERR_DEBUG, "Changing screen from %dx%d to %dx%d (%.2f to %.2f)",
+ Debug("video", "Changing screen from %dx%d to %dx%d (%.2f to %.2f)",
width, height,
video.screen_width, video.screen_height,
ratio_video, ratio_display);
void SDLSetScreenProperties(void)
{
+ SDLSetDisplaySize();
SDLSetScreenSizeAndOffsets(video.width, video.height);
SDLSetScreenSizeForRenderer(video.screen_width, video.screen_height);
}
void SDLSetScreenVsyncMode(char *vsync_mode)
{
- int interval =
- (strEqual(vsync_mode, STR_VSYNC_MODE_NORMAL) ? VSYNC_MODE_NORMAL :
- strEqual(vsync_mode, STR_VSYNC_MODE_ADAPTIVE) ? VSYNC_MODE_ADAPTIVE :
- VSYNC_MODE_OFF);
+ // changing vsync mode without re-creating renderer only supported by OpenGL
+ if (!strPrefixLower((char *)SDLGetRendererName(), "opengl"))
+ return;
+
+ int interval = VSYNC_MODE_STR_TO_INT(vsync_mode);
int result = SDL_GL_SetSwapInterval(interval);
// if adaptive vsync requested, but not supported, retry with normal vsync
if (result == -1 && interval == VSYNC_MODE_ADAPTIVE)
- SDL_GL_SetSwapInterval(VSYNC_MODE_NORMAL);
+ {
+ interval = VSYNC_MODE_NORMAL;
+
+ result = SDL_GL_SetSwapInterval(interval);
+ }
+
+ if (result == -1)
+ interval = VSYNC_MODE_OFF;
+
+ video.vsync_mode = interval;
}
void SDLRedrawWindow(void)
time_current = SDL_GetTicks();
+ if (fade_delay <= 0)
+ {
+ // immediately draw final target frame without delay
+ fade_mode &= (FADE_MODE_FADE | FADE_MODE_TRANSFORM);
+ fade_delay = 1;
+ time_current -= 1;
+
+ // when fading without delay, also skip post delay
+ post_delay = 0;
+ }
+
if (fade_mode == FADE_MODE_MELT)
{
boolean done = FALSE;
// load image to temporary surface
if ((sdl_image_tmp = IMG_Load(filename)) == NULL)
- Error(ERR_EXIT, "IMG_Load() failed: %s", SDL_GetError());
+ Error(ERR_EXIT, "IMG_Load('%s') failed: %s", getBaseNamePtr(filename),
+ SDL_GetError());
print_timestamp_time("IMG_Load");
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
{
- Error(ERR_WARN, "SDL_InitSubSystem() failed: %s", SDL_GetError());
+ Warn("SDL_InitSubSystem() failed: %s", SDL_GetError());
+
return;
}
AUDIO_NUM_CHANNELS_STEREO,
setup.system.audio_fragment_size) < 0)
{
- Error(ERR_WARN, "Mix_OpenAudio() failed: %s", SDL_GetError());
+ Warn("Mix_OpenAudio() failed: %s", SDL_GetError());
+
return;
}
sdl_is_controller[nr] = SDL_IsGameController(nr);
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "opening joystick %d (%s)",
+ Debug("joystick", "opening joystick %d (%s)",
nr, (sdl_is_controller[nr] ? "game controller" : "joystick"));
#endif
return;
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "closing joystick %d", nr);
+ Debug("joystick", "closing joystick %d", nr);
#endif
if (sdl_is_controller[nr])
void HandleJoystickEvent(Event *event)
{
- switch(event->type)
+ // when using joystick, disable overlay touch buttons
+ runtime.uses_touch_device = FALSE;
+
+ switch (event->type)
{
case SDL_CONTROLLERDEVICEADDED:
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_CONTROLLERDEVICEADDED: device %d added",
+ Debug("joystick", "SDL_CONTROLLERDEVICEADDED: device %d added",
event->cdevice.which);
#endif
InitJoysticks();
case SDL_CONTROLLERDEVICEREMOVED:
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_CONTROLLERDEVICEREMOVED: device %d removed",
+ Debug("joystick", "SDL_CONTROLLERDEVICEREMOVED: device %d removed",
event->cdevice.which);
#endif
InitJoysticks();
case SDL_CONTROLLERAXISMOTION:
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_CONTROLLERAXISMOTION: device %d, axis %d: %d",
+ Debug("joystick", "SDL_CONTROLLERAXISMOTION: device %d, axis %d: %d",
event->caxis.which, event->caxis.axis, event->caxis.value);
#endif
setJoystickAxis(event->caxis.which,
case SDL_CONTROLLERBUTTONDOWN:
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_CONTROLLERBUTTONDOWN: device %d, button %d",
+ Debug("joystick", "SDL_CONTROLLERBUTTONDOWN: device %d, button %d",
event->cbutton.which, event->cbutton.button);
#endif
setJoystickButton(event->cbutton.which,
case SDL_CONTROLLERBUTTONUP:
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_CONTROLLERBUTTONUP: device %d, button %d",
+ Debug("joystick", "SDL_CONTROLLERBUTTONUP: device %d, button %d",
event->cbutton.which, event->cbutton.button);
#endif
setJoystickButton(event->cbutton.which,
break;
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_JOYAXISMOTION: device %d, axis %d: %d",
+ Debug("joystick", "SDL_JOYAXISMOTION: device %d, axis %d: %d",
event->jaxis.which, event->jaxis.axis, event->jaxis.value);
#endif
if (event->jaxis.axis < 4)
break;
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_JOYBUTTONDOWN: device %d, button %d",
+ Debug("joystick", "SDL_JOYBUTTONDOWN: device %d, button %d",
event->jbutton.which, event->jbutton.button);
#endif
if (event->jbutton.button < 4)
break;
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_JOYBUTTONUP: device %d, button %d",
+ Debug("joystick", "SDL_JOYBUTTONUP: device %d, button %d",
event->jbutton.which, event->jbutton.button);
#endif
if (event->jbutton.button < 4)
if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) < 0)
{
Error(ERR_EXIT, "SDL_Init() failed: %s", SDL_GetError());
+
return;
}
// the included game controller base mappings should always be found
if (num_mappings == -1)
- Error(ERR_WARN, "no game controller base mappings found");
+ Warn("no game controller base mappings found");
#if DEBUG_JOYSTICKS
else
- Error(ERR_INFO, "%d game controller base mapping(s) added", num_mappings);
+ Debug("joystick", "%d game controller base mapping(s) added",
+ num_mappings);
#endif
num_mappings = SDL_GameControllerAddMappingsFromFile(mappings_file_user);
#if DEBUG_JOYSTICKS
// the personal game controller user mappings may or may not be found
if (num_mappings == -1)
- Error(ERR_WARN, "no game controller user mappings found");
+ Warn("no game controller user mappings found");
else
- Error(ERR_INFO, "%d game controller user mapping(s) added", num_mappings);
+ Debug("joystick", , "%d game controller user mapping(s) added",
+ num_mappings);
- Error(ERR_INFO, "%d joystick(s) found:", SDL_NumJoysticks());
+ Debug("joystick", "%d joystick(s) found:", SDL_NumJoysticks());
#endif
checked_free(mappings_file_base);
type = "joystick";
}
- Error(ERR_INFO, "- joystick %d (%s): '%s'",
+ Debug("joystick", "- joystick %d (%s): '%s'",
i, type, (name ? name : "(Unknown)"));
}
#endif
if (joystick_nr >= SDL_NumJoysticks())
{
if (setup.input[i].use_joystick && print_warning)
- Error(ERR_WARN, "cannot find joystick %d", joystick_nr);
+ Warn("cannot find joystick %d", joystick_nr);
joystick_nr = -1;
}
if (SDLOpenJoystick(i))
joystick.status = JOYSTICK_ACTIVATED;
else if (print_warning)
- Error(ERR_WARN, "cannot open joystick %d", i);
+ Warn("cannot open joystick %d", i);
}
SDLClearJoystickState();
projects / rocksndiamonds.git / blobdiff