X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Flibgame%2Fsdl.c;h=04fa05e8c5151be5721ad9c07bcce1e1f06173ca;hp=661bf6fb7546aeb8611b974ae74b478e50a3c812;hb=aa931ed885e278dc0102b5e10f59b2ba52fb690a;hpb=bf9e47bb97f16c998644758a383209fa4d4fc87b diff --git a/src/libgame/sdl.c b/src/libgame/sdl.c index 661bf6fb..04fa05e8 100644 --- a/src/libgame/sdl.c +++ b/src/libgame/sdl.c @@ -37,6 +37,11 @@ static boolean limit_screen_updates = FALSE; /* functions from SGE library */ void sge_Line(SDL_Surface *, Sint16, Sint16, Sint16, Sint16, Uint32); +#if defined(USE_TOUCH_INPUT_OVERLAY) +/* functions to draw overlay graphics for touch device input */ +static void DrawTouchInputOverlay(); +#endif + void SDLLimitScreenUpdates(boolean enable) { limit_screen_updates = enable; @@ -201,6 +206,12 @@ static void UpdateScreenExt(SDL_Rect *rect, boolean with_frame_delay) SDL_SetRenderTarget(sdl_renderer, NULL); SDL_RenderCopy(sdl_renderer, sdl_texture_target, src_rect2, dst_rect2); } + +#if defined(USE_TOUCH_INPUT_OVERLAY) + // draw overlay graphics for touch device input, if needed + DrawTouchInputOverlay(); +#endif + #endif // global synchronization point of the game to align video frame delay @@ -428,6 +439,9 @@ boolean SDLSetNativeSurface(SDL_Surface **surface) #if defined(TARGET_SDL2) static SDL_Texture *SDLCreateTextureFromSurface(SDL_Surface *surface) { + if (program.headless) + return NULL; + SDL_Texture *texture = SDL_CreateTextureFromSurface(sdl_renderer, surface); if (texture == NULL) @@ -491,8 +505,11 @@ void SDLInitVideoDisplay(void) #endif } -void SDLInitVideoBuffer(boolean fullscreen) +inline static void SDLInitVideoBuffer_VideoBuffer(boolean fullscreen) { + if (program.headless) + return; + video.window_scaling_percent = setup.window_scaling_percent; video.window_scaling_quality = setup.window_scaling_quality; @@ -520,7 +537,10 @@ void SDLInitVideoBuffer(boolean fullscreen) #else SDL_WM_SetCaption(program.window_title, program.window_title); #endif +} +inline static void SDLInitVideoBuffer_DrawBuffer() +{ /* SDL cannot directly draw to the visible video framebuffer like X11, but always uses a backbuffer, which is then blitted to the visible video framebuffer with 'SDL_UpdateRect' (or replaced with the current @@ -536,6 +556,16 @@ void SDLInitVideoBuffer(boolean fullscreen) /* create additional (symbolic) buffer for double-buffering */ ReCreateBitmap(&window, video.width, video.height); + + /* create dummy drawing buffer for headless mode, if needed */ + if (program.headless) + ReCreateBitmap(&backbuffer, video.width, video.height); +} + +void SDLInitVideoBuffer(boolean fullscreen) +{ + SDLInitVideoBuffer_VideoBuffer(fullscreen); + SDLInitVideoBuffer_DrawBuffer(); } static boolean SDLCreateScreen(boolean fullscreen) @@ -559,10 +589,10 @@ static boolean SDLCreateScreen(boolean fullscreen) it will crash if flags are *not* set to SDL_RENDERER_SOFTWARE (because it will try to use accelerated graphics and apparently fails miserably) */ int renderer_flags = SDL_RENDERER_SOFTWARE; -#endif #endif SDLSetScreenSizeAndOffsets(video.width, video.height); +#endif int width = video.width; int height = video.height; @@ -910,7 +940,7 @@ void SDLSetScreenSizeAndOffsets(int width, int height) video.screen_xoffset = 0; video.screen_yoffset = 0; -#if defined(PLATFORM_ANDROID) +#if defined(USE_COMPLETE_DISPLAY) float ratio_video = (float) width / height; float ratio_display = (float) video.display_width / video.display_height; @@ -972,6 +1002,9 @@ void SDLRedrawWindow() void SDLCreateBitmapContent(Bitmap *bitmap, int width, int height, int depth) { + if (program.headless) + return; + SDL_Surface *surface = SDL_CreateRGBSurface(SURFACE_FLAGS, width, height, depth, 0,0,0, 0); @@ -2356,6 +2389,14 @@ Bitmap *SDLLoadImage(char *filename) Bitmap *new_bitmap = CreateBitmapStruct(); SDL_Surface *sdl_image_tmp; + if (program.headless) + { + /* prevent sanity check warnings at later stage */ + new_bitmap->width = new_bitmap->height = 1; + + return new_bitmap; + } + print_timestamp_init("SDLLoadImage"); print_timestamp_time(getBaseNamePtr(filename)); @@ -2445,6 +2486,9 @@ void SDLSetMouseCursor(struct MouseCursorInfo *cursor_info) void SDLOpenAudio(void) { + if (program.headless) + return; + #if !defined(TARGET_SDL2) if (!strEqual(setup.system.sdl_audiodriver, ARG_DEFAULT)) SDL_putenv(getStringCat2("SDL_AUDIODRIVER=", setup.system.sdl_audiodriver)); @@ -2547,31 +2591,75 @@ void SDLHandleWindowManagerEvent(Event *event) /* joystick functions */ /* ========================================================================= */ -static SDL_Joystick *sdl_joystick[MAX_PLAYERS] = { NULL, NULL, NULL, NULL }; -static int sdl_js_axis[MAX_PLAYERS][2] = { {0, 0}, {0, 0}, {0, 0}, {0, 0} }; -static int sdl_js_button[MAX_PLAYERS][2] = { {0, 0}, {0, 0}, {0, 0}, {0, 0} }; +#if defined(TARGET_SDL2) +static void *sdl_joystick[MAX_PLAYERS]; // game controller or joystick +#else +static SDL_Joystick *sdl_joystick[MAX_PLAYERS]; // only joysticks supported +#endif +static int sdl_js_axis_raw[MAX_PLAYERS][2]; +static int sdl_js_axis[MAX_PLAYERS][2]; +static int sdl_js_button[MAX_PLAYERS][2]; +static boolean sdl_is_controller[MAX_PLAYERS]; static boolean SDLOpenJoystick(int nr) { - if (nr < 0 || nr > MAX_PLAYERS) + if (nr < 0 || nr >= MAX_PLAYERS) return FALSE; - return ((sdl_joystick[nr] = SDL_JoystickOpen(nr)) == NULL ? FALSE : TRUE); +#if defined(TARGET_SDL2) + sdl_is_controller[nr] = SDL_IsGameController(nr); +#else + sdl_is_controller[nr] = FALSE; +#endif + +#if 1 + Error(ERR_DEBUG, "opening joystick %d (%s)", + nr, (sdl_is_controller[nr] ? "game controller" : "joystick")); +#endif + +#if defined(TARGET_SDL2) + if (sdl_is_controller[nr]) + sdl_joystick[nr] = SDL_GameControllerOpen(nr); + else + sdl_joystick[nr] = SDL_JoystickOpen(nr); +#else + sdl_joystick[nr] = SDL_JoystickOpen(nr); +#endif + + return (sdl_joystick[nr] != NULL); } static void SDLCloseJoystick(int nr) { - if (nr < 0 || nr > MAX_PLAYERS) + if (nr < 0 || nr >= MAX_PLAYERS) return; +#if 1 + Error(ERR_DEBUG, "closing joystick %d", nr); +#endif + +#if defined(TARGET_SDL2) + if (sdl_is_controller[nr]) + SDL_GameControllerClose(sdl_joystick[nr]); + else + SDL_JoystickClose(sdl_joystick[nr]); +#else SDL_JoystickClose(sdl_joystick[nr]); +#endif sdl_joystick[nr] = NULL; + + sdl_js_axis_raw[nr][0] = -1; + sdl_js_axis_raw[nr][1] = -1; + sdl_js_axis[nr][0] = 0; + sdl_js_axis[nr][1] = 0; + sdl_js_button[nr][0] = 0; + sdl_js_button[nr][1] = 0; } -static boolean SDLCheckJoystickOpened(int nr) +boolean SDLCheckJoystickOpened(int nr) { - if (nr < 0 || nr > MAX_PLAYERS) + if (nr < 0 || nr >= MAX_PLAYERS) return FALSE; #if defined(TARGET_SDL2) @@ -2581,23 +2669,164 @@ static boolean SDLCheckJoystickOpened(int nr) #endif } +static void setJoystickAxis(int nr, int axis_id_raw, int axis_value) +{ +#if defined(TARGET_SDL2) + int axis_id = (axis_id_raw == SDL_CONTROLLER_AXIS_LEFTX || + axis_id_raw == SDL_CONTROLLER_AXIS_RIGHTX ? 0 : + axis_id_raw == SDL_CONTROLLER_AXIS_LEFTY || + axis_id_raw == SDL_CONTROLLER_AXIS_RIGHTY ? 1 : -1); +#else + int axis_id = axis_id_raw % 2; +#endif + + if (nr < 0 || nr >= MAX_PLAYERS) + return; + + if (axis_id == -1) + return; + + // prevent (slightly jittering, but centered) axis A from resetting axis B + if (ABS(axis_value) < JOYSTICK_PERCENT * JOYSTICK_MAX_AXIS_POS / 100 && + axis_id_raw != sdl_js_axis_raw[nr][axis_id]) + return; + + sdl_js_axis[nr][axis_id] = axis_value; + sdl_js_axis_raw[nr][axis_id] = axis_id_raw; +} + +static void setJoystickButton(int nr, int button_id_raw, int button_state) +{ +#if defined(TARGET_SDL2) + int button_id = (button_id_raw == SDL_CONTROLLER_BUTTON_A || + button_id_raw == SDL_CONTROLLER_BUTTON_X || + button_id_raw == SDL_CONTROLLER_BUTTON_LEFTSHOULDER || + button_id_raw == SDL_CONTROLLER_BUTTON_LEFTSTICK || + button_id_raw == SDL_CONTROLLER_BUTTON_RIGHTSTICK ? 0 : + button_id_raw == SDL_CONTROLLER_BUTTON_B || + button_id_raw == SDL_CONTROLLER_BUTTON_Y || + button_id_raw == SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ? 1 : + -1); + + if (button_id_raw == SDL_CONTROLLER_BUTTON_DPAD_LEFT) + sdl_js_axis[nr][0] = button_state * JOYSTICK_XLEFT; + else if (button_id_raw == SDL_CONTROLLER_BUTTON_DPAD_RIGHT) + sdl_js_axis[nr][0] = button_state * JOYSTICK_XRIGHT; + else if (button_id_raw == SDL_CONTROLLER_BUTTON_DPAD_UP) + sdl_js_axis[nr][1] = button_state * JOYSTICK_YUPPER; + else if (button_id_raw == SDL_CONTROLLER_BUTTON_DPAD_DOWN) + sdl_js_axis[nr][1] = button_state * JOYSTICK_YLOWER; + + if (button_id_raw == SDL_CONTROLLER_BUTTON_DPAD_LEFT || + button_id_raw == SDL_CONTROLLER_BUTTON_DPAD_RIGHT || + button_id_raw == SDL_CONTROLLER_BUTTON_DPAD_UP || + button_id_raw == SDL_CONTROLLER_BUTTON_DPAD_DOWN) + sdl_js_axis_raw[nr][0] = sdl_js_axis_raw[nr][1] = -1; +#else + int button_id = button_id_raw % 2; +#endif + + if (nr < 0 || nr >= MAX_PLAYERS) + return; + + if (button_id == -1) + return; + + sdl_js_button[nr][button_id] = button_state; +} + void HandleJoystickEvent(Event *event) { switch(event->type) { +#if defined(TARGET_SDL2) + case SDL_CONTROLLERDEVICEADDED: +#if 1 + Error(ERR_DEBUG, "SDL_CONTROLLERDEVICEADDED: device %d added", + event->cdevice.which); +#endif + InitJoysticks(); + break; + + case SDL_CONTROLLERDEVICEREMOVED: +#if 1 + Error(ERR_DEBUG, "SDL_CONTROLLERDEVICEREMOVED: device %d removed", + event->cdevice.which); +#endif + InitJoysticks(); + break; + + case SDL_CONTROLLERAXISMOTION: +#if 1 + Error(ERR_DEBUG, "SDL_CONTROLLERAXISMOTION: device %d, axis %d: %d", + event->caxis.which, event->caxis.axis, event->caxis.value); +#endif + setJoystickAxis(event->caxis.which, + event->caxis.axis, + event->caxis.value); + break; + + case SDL_CONTROLLERBUTTONDOWN: +#if 1 + Error(ERR_DEBUG, "SDL_CONTROLLERBUTTONDOWN: device %d, button %d", + event->cbutton.which, event->cbutton.button); +#endif + setJoystickButton(event->cbutton.which, + event->cbutton.button, + TRUE); + break; + + case SDL_CONTROLLERBUTTONUP: +#if 1 + Error(ERR_DEBUG, "SDL_CONTROLLERBUTTONUP: device %d, button %d", + event->cbutton.which, event->cbutton.button); +#endif + setJoystickButton(event->cbutton.which, + event->cbutton.button, + FALSE); + break; +#endif + case SDL_JOYAXISMOTION: - if (event->jaxis.axis < 2) - sdl_js_axis[event->jaxis.which][event->jaxis.axis]= event->jaxis.value; + if (sdl_is_controller[event->jaxis.which]) + break; + +#if 1 + Error(ERR_DEBUG, "SDL_JOYAXISMOTION: device %d, axis %d: %d", + event->jaxis.which, event->jaxis.axis, event->jaxis.value); +#endif + if (event->jaxis.axis < 4) + setJoystickAxis(event->jaxis.which, + event->jaxis.axis, + event->jaxis.value); break; case SDL_JOYBUTTONDOWN: - if (event->jbutton.button < 2) - sdl_js_button[event->jbutton.which][event->jbutton.button] = TRUE; + if (sdl_is_controller[event->jaxis.which]) + break; + +#if 1 + Error(ERR_DEBUG, "SDL_JOYBUTTONDOWN: device %d, button %d", + event->jbutton.which, event->jbutton.button); +#endif + if (event->jbutton.button < 4) + setJoystickButton(event->jbutton.which, + event->jbutton.button, + TRUE); break; case SDL_JOYBUTTONUP: - if (event->jbutton.button < 2) - sdl_js_button[event->jbutton.which][event->jbutton.button] = FALSE; + if (sdl_is_controller[event->jaxis.which]) + break; + +#if 1 + Error(ERR_DEBUG, "SDL_JOYBUTTONUP: device %d, button %d", + event->jbutton.which, event->jbutton.button); +#endif + if (event->jbutton.button < 4) + setJoystickButton(event->jbutton.which, + event->jbutton.button, + FALSE); break; default: @@ -2609,19 +2838,73 @@ void SDLInitJoysticks() { static boolean sdl_joystick_subsystem_initialized = FALSE; boolean print_warning = !sdl_joystick_subsystem_initialized; +#if defined(TARGET_SDL2) + char *mappings_file_base = getPath2(options.ro_base_directory, + GAMECONTROLLER_BASENAME); + char *mappings_file_user = getPath2(getUserGameDataDir(), + GAMECONTROLLER_BASENAME); + int num_mappings; +#endif int i; if (!sdl_joystick_subsystem_initialized) { sdl_joystick_subsystem_initialized = TRUE; +#if defined(TARGET_SDL2) + SDL_SetHint(SDL_HINT_ACCELEROMETER_AS_JOYSTICK, "0"); + + if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) < 0) +#else if (SDL_InitSubSystem(SDL_INIT_JOYSTICK) < 0) +#endif { Error(ERR_EXIT, "SDL_Init() failed: %s", SDL_GetError()); return; } + +#if defined(TARGET_SDL2) + num_mappings = SDL_GameControllerAddMappingsFromFile(mappings_file_base); + + if (num_mappings != -1) + Error(ERR_INFO, "%d game controller base mapping(s) added", num_mappings); + else + Error(ERR_WARN, "no game controller base mappings found"); + + num_mappings = SDL_GameControllerAddMappingsFromFile(mappings_file_user); + + if (num_mappings != -1) + Error(ERR_INFO, "%d game controller user mapping(s) added", num_mappings); + else + Error(ERR_WARN, "no game controller user mappings found"); + + Error(ERR_INFO, "%d joystick(s) found:", SDL_NumJoysticks()); + + checked_free(mappings_file_base); + checked_free(mappings_file_user); + + for (i = 0; i < SDL_NumJoysticks(); i++) + { + const char *name, *type; + + if (SDL_IsGameController(i)) + { + name = SDL_GameControllerNameForIndex(i); + type = "game controller"; + } + else + { + name = SDL_JoystickNameForIndex(i); + type = "joystick"; + } + + Error(ERR_INFO, "- joystick %d (%s): '%s'", + i, type, (name ? name : "(Unknown)")); + } +#endif } + /* assign joysticks from configured to connected joystick for all players */ for (i = 0; i < MAX_PLAYERS; i++) { /* get configured joystick for this player */ @@ -2636,28 +2919,21 @@ void SDLInitJoysticks() joystick_nr = -1; } - /* misuse joystick file descriptor variable to store joystick number */ - joystick.fd[i] = joystick_nr; - - if (joystick_nr == -1) - continue; + /* store configured joystick number for each player */ + joystick.nr[i] = joystick_nr; + } + /* now open all connected joysticks (regardless if configured or not) */ + for (i = 0; i < SDL_NumJoysticks(); i++) + { /* this allows subsequent calls to 'InitJoysticks' for re-initialization */ - if (SDLCheckJoystickOpened(joystick_nr)) - SDLCloseJoystick(joystick_nr); - - if (!setup.input[i].use_joystick) - continue; - - if (!SDLOpenJoystick(joystick_nr)) - { - if (print_warning) - Error(ERR_WARN, "cannot open joystick %d", joystick_nr); + if (SDLCheckJoystickOpened(i)) + SDLCloseJoystick(i); - continue; - } - - joystick.status = JOYSTICK_ACTIVATED; + if (SDLOpenJoystick(i)) + joystick.status = JOYSTICK_ACTIVATED; + else if (print_warning) + Error(ERR_WARN, "cannot open joystick %d", i); } } @@ -2678,3 +2954,98 @@ boolean SDLReadJoystick(int nr, int *x, int *y, boolean *b1, boolean *b2) return TRUE; } + +#if defined(USE_TOUCH_INPUT_OVERLAY) +static void DrawTouchInputOverlay() +{ + static SDL_Texture *texture = NULL; + static boolean initialized = FALSE; + static boolean deactivated = TRUE; + static int width = 0, height = 0; + static int alpha_max = SDL_ALPHA_OPAQUE / 2; + static int alpha_step = 5; + static int alpha_last = 0; + static int alpha = 0; + + if (!overlay.active && deactivated) + return; + + if (overlay.active) + { + if (alpha < alpha_max) + alpha = MIN(alpha + alpha_step, alpha_max); + + deactivated = FALSE; + } + else + { + alpha = MAX(0, alpha - alpha_step); + + if (alpha == 0) + deactivated = TRUE; + } + + if (!initialized) + { + char *basename = "overlay/VirtualButtons.png"; + char *filename = getCustomImageFilename(basename); + + if (filename == NULL) + Error(ERR_EXIT, "LoadCustomImage(): cannot find file '%s'", basename); + + SDL_Surface *surface; + + if ((surface = IMG_Load(filename)) == NULL) + Error(ERR_EXIT, "IMG_Load() failed: %s", SDL_GetError()); + + width = surface->w; + height = surface->h; + + /* set black pixel to transparent if no alpha channel / transparent color */ + if (!SDLHasAlpha(surface) && + !SDLHasColorKey(surface)) + SDL_SetColorKey(surface, SET_TRANSPARENT_PIXEL, + SDL_MapRGB(surface->format, 0x00, 0x00, 0x00)); + + if ((texture = SDLCreateTextureFromSurface(surface)) == NULL) + Error(ERR_EXIT, "SDLCreateTextureFromSurface() failed"); + + SDL_FreeSurface(surface); + + SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND); + SDL_SetTextureAlphaMod(texture, alpha_max); + + initialized = TRUE; + } + + if (alpha != alpha_last) + SDL_SetTextureAlphaMod(texture, alpha); + + alpha_last = alpha; + + float ratio_overlay = (float) width / height; + float ratio_screen = (float) video.screen_width / video.screen_height; + int width_scaled, height_scaled; + int xpos, ypos; + + if (ratio_overlay > ratio_screen) + { + width_scaled = video.screen_width; + height_scaled = video.screen_height * ratio_screen / ratio_overlay; + xpos = 0; + ypos = video.screen_height - height_scaled; + } + else + { + width_scaled = video.screen_width * ratio_overlay / ratio_screen; + height_scaled = video.screen_height; + xpos = (video.screen_width - width_scaled) / 2; + ypos = 0; + } + + SDL_Rect src_rect = { 0, 0, width, height }; + SDL_Rect dst_rect = { xpos, ypos, width_scaled, height_scaled }; + + SDL_RenderCopy(sdl_renderer, texture, &src_rect, &dst_rect); +} +#endif