X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Flibgame%2Fsystem.c;h=64f67a179593cbd844576d746892c5a9fc17d489;hp=615d9d339b8c4981d35b47c52f8deda891a9e9af;hb=30eb586d06bc4d1ee7388dced1c20e530292aa93;hpb=5abed77f4575375756d228a2afc749589a25c87a diff --git a/src/libgame/system.c b/src/libgame/system.c index 615d9d33..64f67a17 100644 --- a/src/libgame/system.c +++ b/src/libgame/system.c @@ -1,15 +1,13 @@ -/*********************************************************** -* Artsoft Retro-Game Library * -*----------------------------------------------------------* -* (c) 1994-2006 Artsoft Entertainment * -* Holger Schemel * -* Detmolder Strasse 189 * -* 33604 Bielefeld * -* Germany * -* e-mail: info@artsoft.org * -*----------------------------------------------------------* -* system.c * -***********************************************************/ +// ============================================================================ +// Artsoft Retro-Game Library +// ---------------------------------------------------------------------------- +// (c) 1995-2014 by Artsoft Entertainment +// Holger Schemel +// info@artsoft.org +// http://www.artsoft.org/ +// ---------------------------------------------------------------------------- +// system.c +// ============================================================================ #include #include @@ -23,16 +21,21 @@ #include "joystick.h" #include "misc.h" +#define ENABLE_UNUSED_CODE 0 /* currently unused functions */ + /* ========================================================================= */ /* exported variables */ /* ========================================================================= */ struct ProgramInfo program; +struct NetworkInfo network; struct OptionInfo options; struct VideoSystemInfo video; struct AudioSystemInfo audio; struct GfxInfo gfx; +struct TileCursorInfo tile_cursor; +struct OverlayInfo overlay; struct ArtworkInfo artwork; struct JoystickInfo joystick; struct SetupInfo setup; @@ -42,25 +45,21 @@ LevelDirTree *leveldir_first = NULL; LevelDirTree *leveldir_current = NULL; int level_nr; +struct LevelSetInfo levelset; struct LevelStats level_stats[MAX_LEVELS]; -Display *display = NULL; -Visual *visual = NULL; -int screen = 0; -Colormap cmap = None; - DrawWindow *window = NULL; DrawBuffer *backbuffer = NULL; DrawBuffer *drawto = NULL; int button_status = MB_NOT_PRESSED; boolean motion_status = FALSE; +int wheel_steps = DEFAULT_WHEEL_STEPS; #if defined(TARGET_SDL2) boolean keyrepeat_status = TRUE; #endif int redraw_mask = REDRAW_NONE; -int redraw_tiles = 0; int FrameCounter = 0; @@ -69,44 +68,86 @@ int FrameCounter = 0; /* init/close functions */ /* ========================================================================= */ -void InitProgramInfo(char *argv0, - char *userdata_subdir, char *userdata_subdir_unix, +void InitProgramInfo(char *argv0, char *config_filename, char *userdata_subdir, char *program_title, char *icon_title, - char *sdl_icon_filename, char *cookie_prefix, - int program_version) + char *icon_filename, char *cookie_prefix, + char *program_version_string, int program_version) { program.command_basepath = getBasePath(argv0); program.command_basename = getBaseName(argv0); + program.config_filename = config_filename; + program.userdata_subdir = userdata_subdir; - program.userdata_subdir_unix = userdata_subdir_unix; program.userdata_path = getUserGameDataDir(); program.program_title = program_title; program.window_title = "(undefined)"; program.icon_title = icon_title; - program.sdl_icon_filename = sdl_icon_filename; + program.icon_filename = icon_filename; program.cookie_prefix = cookie_prefix; + program.version_super = VERSION_SUPER(program_version); program.version_major = VERSION_MAJOR(program_version); program.version_minor = VERSION_MINOR(program_version); program.version_patch = VERSION_PATCH(program_version); - program.version_build = VERSION_BUILD(program_version); program.version_ident = program_version; - program.error_filename = getErrorFilename(ERROR_BASENAME); - program.error_file = stderr; + program.version_string = program_version_string; + + program.log_filename[LOG_OUT_ID] = getLogFilename(LOG_OUT_BASENAME); + program.log_filename[LOG_ERR_ID] = getLogFilename(LOG_ERR_BASENAME); + program.log_file[LOG_OUT_ID] = program.log_file_default[LOG_OUT_ID] = stdout; + program.log_file[LOG_ERR_ID] = program.log_file_default[LOG_ERR_ID] = stderr; + + program.headless = FALSE; } -void SetWindowTitle() +void InitNetworkInfo(boolean enabled, boolean connected, boolean serveronly, + char *server_host, int server_port) +{ + network.enabled = enabled; + network.connected = connected; + network.serveronly = serveronly; + + network.server_host = server_host; + network.server_port = server_port; +} + +void InitScoresInfo(void) +{ + char *global_scores_dir = getPath2(getCommonDataDir(), SCORES_DIRECTORY); + + program.global_scores = directoryExists(global_scores_dir); + program.many_scores_per_name = !program.global_scores; + +#if 0 + if (options.debug) + { + if (program.global_scores) + { + Error(ERR_DEBUG, "Using global, multi-user scores directory '%s'.", + global_scores_dir); + Error(ERR_DEBUG, "Remove to enable single-user scores directory."); + Error(ERR_DEBUG, "(This enables multipe score entries per user.)"); + } + else + { + Error(ERR_DEBUG, "Using private, single-user scores directory."); + } + } +#endif + + free(global_scores_dir); +} + +void SetWindowTitle(void) { program.window_title = program.window_title_function(); -#if defined(TARGET_SDL) SDLSetWindowTitle(); -#endif } void InitWindowTitleFunction(char *(*window_title_function)(void)) @@ -124,13 +165,11 @@ void InitExitFunction(void (*exit_function)(int)) program.exit_function = exit_function; /* set signal handlers to custom exit function */ - signal(SIGINT, exit_function); + // signal(SIGINT, exit_function); signal(SIGTERM, exit_function); -#if defined(TARGET_SDL) /* set exit function to automatically cleanup SDL stuff after exit() */ atexit(SDL_Quit); -#endif } void InitPlatformDependentStuff(void) @@ -138,19 +177,8 @@ void InitPlatformDependentStuff(void) // this is initialized in GetOptions(), but may already be used before options.verbose = TRUE; -#if defined(PLATFORM_MACOSX) - updateUserGameDataDir(); -#endif - -#if 1 - openErrorFile(); -#else -#if !defined(PLATFORM_UNIX) || defined(PLATFORM_MACOSX) - openErrorFile(); -#endif -#endif + OpenLogFiles(); -#if defined(TARGET_SDL) #if defined(TARGET_SDL2) int sdl_init_flags = SDL_INIT_EVENTS | SDL_INIT_NOPARACHUTE; #else @@ -161,14 +189,11 @@ void InitPlatformDependentStuff(void) Error(ERR_EXIT, "SDL_Init() failed: %s", SDL_GetError()); SDLNet_Init(); -#endif } void ClosePlatformDependentStuff(void) { -#if defined(PLATFORM_WIN32) - closeErrorFile(); -#endif + CloseLogFiles(); } void InitGfxFieldInfo(int sx, int sy, int sxsize, int sysize, @@ -187,11 +212,6 @@ void InitGfxFieldInfo(int sx, int sy, int sxsize, int sysize, gfx.field_save_buffer = field_save_buffer; -#if 0 - gfx.background_bitmap = NULL; - gfx.background_bitmap_mask = REDRAW_NONE; -#endif - SetDrawDeactivationMask(REDRAW_NONE); /* do not deactivate drawing */ SetDrawBackgroundMask(REDRAW_NONE); /* deactivate masked drawing */ } @@ -228,14 +248,26 @@ void InitGfxDoor3Info(int ex, int ey, int exsize, int eysize) void InitGfxWindowInfo(int win_xsize, int win_ysize) { + if (win_xsize != gfx.win_xsize || win_ysize != gfx.win_ysize) + { + ReCreateBitmap(&gfx.background_bitmap, win_xsize, win_ysize); + +#if defined(TARGET_SDL2) + ReCreateBitmap(&gfx.final_screen_bitmap, win_xsize, win_ysize); +#endif + + ReCreateBitmap(&gfx.fade_bitmap_backup, win_xsize, win_ysize); + ReCreateBitmap(&gfx.fade_bitmap_source, win_xsize, win_ysize); + ReCreateBitmap(&gfx.fade_bitmap_target, win_xsize, win_ysize); + ReCreateBitmap(&gfx.fade_bitmap_black, win_xsize, win_ysize); + + ClearRectangle(gfx.fade_bitmap_black, 0, 0, win_xsize, win_ysize); + } + gfx.win_xsize = win_xsize; gfx.win_ysize = win_ysize; -#if 1 gfx.background_bitmap_mask = REDRAW_NONE; - - ReCreateBitmap(&gfx.background_bitmap, win_xsize, win_ysize, DEFAULT_DEPTH); -#endif } void InitGfxScrollbufferInfo(int scrollbuffer_width, int scrollbuffer_height) @@ -260,7 +292,22 @@ void InitGfxDrawBusyAnimFunction(void (*draw_busy_anim_function)(void)) gfx.draw_busy_anim_function = draw_busy_anim_function; } -void InitGfxCustomArtworkInfo() +void InitGfxDrawGlobalAnimFunction(void (*draw_global_anim_function)(int, int)) +{ + gfx.draw_global_anim_function = draw_global_anim_function; +} + +void InitGfxDrawGlobalBorderFunction(void (*draw_global_border_function)(int)) +{ + gfx.draw_global_border_function = draw_global_border_function; +} + +void InitGfxDrawTileCursorFunction(void (*draw_tile_cursor_function)(int)) +{ + gfx.draw_tile_cursor_function = draw_tile_cursor_function; +} + +void InitGfxCustomArtworkInfo(void) { gfx.override_level_graphics = FALSE; gfx.override_level_sounds = FALSE; @@ -269,87 +316,142 @@ void InitGfxCustomArtworkInfo() gfx.draw_init_text = TRUE; } -void SetDrawDeactivationMask(int draw_deactivation_mask) +void InitGfxOtherSettings(void) { - gfx.draw_deactivation_mask = draw_deactivation_mask; + gfx.cursor_mode = CURSOR_DEFAULT; } -void SetDrawBackgroundMask(int draw_background_mask) +void InitTileCursorInfo(void) { - gfx.draw_background_mask = draw_background_mask; -} + tile_cursor.enabled = FALSE; + tile_cursor.active = FALSE; + tile_cursor.moving = FALSE; -#if 0 + tile_cursor.xpos = 0; + tile_cursor.ypos = 0; + tile_cursor.x = 0; + tile_cursor.y = 0; + tile_cursor.target_x = 0; + tile_cursor.target_y = 0; -static void DrawBitmapFromTile(Bitmap *bitmap, Bitmap *tile, - int dest_x, int dest_y, int width, int height) + tile_cursor.sx = 0; + tile_cursor.sy = 0; +} + +void InitOverlayInfo(void) { - int bitmap_xsize = width; - int bitmap_ysize = height; - int tile_xsize = tile->width; - int tile_ysize = tile->height; - int tile_xsteps = (bitmap_xsize + tile_xsize - 1) / tile_xsize; - int tile_ysteps = (bitmap_ysize + tile_ysize - 1) / tile_ysize; + int nr = GRID_ACTIVE_NR(); int x, y; - for (y = 0; y < tile_ysteps; y++) - { - for (x = 0; x < tile_xsteps; x++) - { - int draw_x = dest_x + x * tile_xsize; - int draw_y = dest_y + y * tile_ysize; - int draw_xsize = MIN(tile_xsize, bitmap_xsize - x * tile_xsize); - int draw_ysize = MIN(tile_ysize, bitmap_ysize - y * tile_ysize); + overlay.enabled = FALSE; + overlay.active = FALSE; - BlitBitmap(tile, bitmap, 0, 0, draw_xsize, draw_ysize, draw_x, draw_y); - } - } + overlay.show_grid = FALSE; + + overlay.grid_xsize = setup.touch.grid_xsize[nr]; + overlay.grid_ysize = setup.touch.grid_ysize[nr]; + + for (x = 0; x < MAX_GRID_XSIZE; x++) + for (y = 0; y < MAX_GRID_YSIZE; y++) + overlay.grid_button[x][y] = setup.touch.grid_button[nr][x][y]; + + overlay.grid_button_highlight = CHAR_GRID_BUTTON_NONE; + overlay.grid_button_action = JOY_NO_ACTION; + +#if defined(USE_TOUCH_INPUT_OVERLAY) + if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS)) + overlay.enabled = TRUE; +#endif } -void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask) +void SetTileCursorEnabled(boolean enabled) { - if (background_bitmap_tile != NULL) - gfx.background_bitmap_mask |= mask; - else - gfx.background_bitmap_mask &= ~mask; + tile_cursor.enabled = enabled; +} -#if 0 - if (gfx.background_bitmap == NULL) - gfx.background_bitmap = CreateBitmap(video.width, video.height, - DEFAULT_DEPTH); -#endif +void SetTileCursorActive(boolean active) +{ + tile_cursor.active = active; +} - if (background_bitmap_tile == NULL) /* empty background requested */ - return; +void SetTileCursorTargetXY(int x, int y) +{ + // delayed placement of tile selection cursor at target position + // (tile cursor will be moved to target position step by step) - if (mask == REDRAW_ALL) - DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile, - 0, 0, video.width, video.height); - else if (mask == REDRAW_FIELD) - DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile, - gfx.real_sx, gfx.real_sy, - gfx.full_sxsize, gfx.full_sysize); - else if (mask == REDRAW_DOOR_1) - DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile, - gfx.dx, gfx.dy, - gfx.dxsize, gfx.dysize); + tile_cursor.xpos = x; + tile_cursor.ypos = y; + tile_cursor.target_x = tile_cursor.sx + x * gfx.game_tile_size; + tile_cursor.target_y = tile_cursor.sy + y * gfx.game_tile_size; + + tile_cursor.moving = TRUE; } -#else +void SetTileCursorXY(int x, int y) +{ + // immediate placement of tile selection cursor at target position + + SetTileCursorTargetXY(x, y); + + tile_cursor.x = tile_cursor.target_x; + tile_cursor.y = tile_cursor.target_y; + + tile_cursor.moving = FALSE; +} + +void SetTileCursorSXSY(int sx, int sy) +{ + tile_cursor.sx = sx; + tile_cursor.sy = sy; +} + +void SetOverlayEnabled(boolean enabled) +{ + overlay.enabled = enabled; +} + +void SetOverlayActive(boolean active) +{ + overlay.active = active; +} + +void SetOverlayShowGrid(boolean show_grid) +{ + overlay.show_grid = show_grid; + + SetOverlayActive(show_grid); + + if (show_grid) + SetOverlayEnabled(TRUE); +} + +boolean GetOverlayActive(void) +{ + return overlay.active; +} + +void SetDrawDeactivationMask(int draw_deactivation_mask) +{ + gfx.draw_deactivation_mask = draw_deactivation_mask; +} + +int GetDrawDeactivationMask(void) +{ + return gfx.draw_deactivation_mask; +} -void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask) +void SetDrawBackgroundMask(int draw_background_mask) +{ + gfx.draw_background_mask = draw_background_mask; +} + +static void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask) { if (background_bitmap_tile != NULL) gfx.background_bitmap_mask |= mask; else gfx.background_bitmap_mask &= ~mask; -#if 0 - if (gfx.background_bitmap == NULL) - gfx.background_bitmap = CreateBitmap(video.width, video.height, - DEFAULT_DEPTH); -#endif - if (background_bitmap_tile == NULL) /* empty background requested */ return; @@ -364,8 +466,6 @@ void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask) gfx.dx, gfx.dy, gfx.dxsize, gfx.dysize); } -#endif - void SetWindowBackgroundBitmap(Bitmap *background_bitmap_tile) { /* remove every mask before setting mask for window */ @@ -401,9 +501,12 @@ inline static int GetRealDepth(int depth) } inline static void sysFillRectangle(Bitmap *bitmap, int x, int y, - int width, int height, Pixel color) + int width, int height, Pixel color) { SDLFillRectangle(bitmap, x, y, width, height, color); + + if (bitmap == backbuffer) + SetRedrawMaskFromArea(x, y, width, height); } inline static void sysCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap, @@ -412,53 +515,67 @@ inline static void sysCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap, { SDLCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height, dst_x, dst_y, mask_mode); + + if (dst_bitmap == backbuffer) + SetRedrawMaskFromArea(dst_x, dst_y, width, height); } void LimitScreenUpdates(boolean enable) { -#if defined(TARGET_SDL) SDLLimitScreenUpdates(enable); -#endif +} + +void InitVideoDefaults(void) +{ + video.default_depth = 32; } void InitVideoDisplay(void) { + if (program.headless) + return; + SDLInitVideoDisplay(); +#if defined(TARGET_SDL2) + SDLSetDisplaySize(); +#endif } void CloseVideoDisplay(void) { KeyboardAutoRepeatOn(); -#if defined(TARGET_SDL) SDL_QuitSubSystem(SDL_INIT_VIDEO); -#else - if (display) - XCloseDisplay(display); -#endif } void InitVideoBuffer(int width, int height, int depth, boolean fullscreen) { -#if 0 - printf("::: InitVideoBuffer\n"); -#endif - video.width = width; video.height = height; video.depth = GetRealDepth(depth); + video.screen_width = width; + video.screen_height = height; + video.screen_xoffset = 0; + video.screen_yoffset = 0; + video.fullscreen_available = FULLSCREEN_STATUS; video.fullscreen_enabled = FALSE; - // video.fullscreen_initial = FALSE; -#if 0 - video.fullscreen_mode_current = NULL; - video.fullscreen_modes = NULL; -#endif video.window_scaling_available = WINDOW_SCALING_STATUS; - SDLInitVideoBuffer(&backbuffer, &window, fullscreen); + video.frame_delay = 0; + video.frame_delay_value = GAME_FRAME_DELAY; + + video.shifted_up = FALSE; + video.shifted_up_pos = 0; + video.shifted_up_pos_last = 0; + video.shifted_up_delay = 0; + video.shifted_up_delay_value = ONE_SECOND_DELAY / 4; + + SDLInitVideoBuffer(fullscreen); + + video.initialized = !program.headless; drawto = backbuffer; } @@ -497,7 +614,7 @@ void FreeBitmap(Bitmap *bitmap) Bitmap *CreateBitmapStruct(void) { - return checked_calloc(sizeof(struct SDLSurfaceInfo)); + return checked_calloc(sizeof(Bitmap)); } Bitmap *CreateBitmap(int width, int height, int depth) @@ -515,9 +632,21 @@ Bitmap *CreateBitmap(int width, int height, int depth) return new_bitmap; } -void ReCreateBitmap(Bitmap **bitmap, int width, int height, int depth) +void ReCreateBitmap(Bitmap **bitmap, int width, int height) { - Bitmap *new_bitmap = CreateBitmap(width, height, depth); + if (*bitmap != NULL) + { + /* if new bitmap size fits into old one, no need to re-create it */ + if (width <= (*bitmap)->width && + height <= (*bitmap)->height) + return; + + /* else adjust size so that old and new bitmap size fit into it */ + width = MAX(width, (*bitmap)->width); + height = MAX(height, (*bitmap)->height); + } + + Bitmap *new_bitmap = CreateBitmap(width, height, DEFAULT_DEPTH); if (*bitmap == NULL) { @@ -530,9 +659,33 @@ void ReCreateBitmap(Bitmap **bitmap, int width, int height, int depth) } } -void CloseWindow(DrawWindow *window) +#if 0 +static void CloseWindow(DrawWindow *window) { } +#endif + +void SetRedrawMaskFromArea(int x, int y, int width, int height) +{ + int x1 = x; + int y1 = y; + int x2 = x + width - 1; + int y2 = y + height - 1; + + if (width == 0 || height == 0) + return; + + if (IN_GFX_FIELD_FULL(x1, y1) && IN_GFX_FIELD_FULL(x2, y2)) + redraw_mask |= REDRAW_FIELD; + else if (IN_GFX_DOOR_1(x1, y1) && IN_GFX_DOOR_1(x2, y2)) + redraw_mask |= REDRAW_DOOR_1; + else if (IN_GFX_DOOR_2(x1, y1) && IN_GFX_DOOR_2(x2, y2)) + redraw_mask |= REDRAW_DOOR_2; + else if (IN_GFX_DOOR_3(x1, y1) && IN_GFX_DOOR_3(x2, y2)) + redraw_mask |= REDRAW_DOOR_3; + else + redraw_mask = REDRAW_ALL; +} inline static boolean CheckDrawingArea(int x, int y, int width, int height, int draw_mask) @@ -543,7 +696,6 @@ inline static boolean CheckDrawingArea(int x, int y, int width, int height, if (draw_mask & REDRAW_ALL) return TRUE; -#if 1 if ((draw_mask & REDRAW_FIELD) && IN_GFX_FIELD_FULL(x, y)) return TRUE; @@ -555,19 +707,17 @@ inline static boolean CheckDrawingArea(int x, int y, int width, int height, if ((draw_mask & REDRAW_DOOR_3) && IN_GFX_DOOR_3(x, y)) return TRUE; -#else - if ((draw_mask & REDRAW_FIELD) && - x >= gfx.real_sx && x < gfx.real_sx + gfx.full_sxsize) - return TRUE; - if ((draw_mask & REDRAW_DOOR_1) && - x >= gfx.dx && y < gfx.dy + gfx.dysize) + return FALSE; +} + +boolean DrawingDeactivatedField(void) +{ + if (program.headless) return TRUE; - if ((draw_mask & REDRAW_DOOR_2) && - x >= gfx.dx && y >= gfx.vy) + if (gfx.draw_deactivation_mask & REDRAW_FIELD) return TRUE; -#endif return FALSE; } @@ -586,7 +736,6 @@ boolean DrawingOnBackground(int x, int y) static boolean InClippedRectangle(Bitmap *bitmap, int *x, int *y, int *width, int *height, boolean is_dest) { -#if 1 int clip_x, clip_y, clip_width, clip_height; if (gfx.clipping_enabled && is_dest) /* only clip destination bitmap */ @@ -635,41 +784,6 @@ static boolean InClippedRectangle(Bitmap *bitmap, int *x, int *y, } return TRUE; - -#else - - /* skip if rectangle completely outside bitmap */ - - if (*x + *width <= 0 || - *y + *height <= 0 || - *x >= bitmap->width || - *y >= bitmap->height) - return FALSE; - - /* clip if rectangle overlaps bitmap */ - - if (*x < 0) - { - *width += *x; - *x = 0; - } - else if (*x + *width > bitmap->width) - { - *width = bitmap->width - *x; - } - - if (*y < 0) - { - *height += *y; - *y = 0; - } - else if (*y + *height > bitmap->height) - { - *height = bitmap->height - *y; - } - - return TRUE; -#endif } void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap, @@ -679,13 +793,15 @@ void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap, int dst_x_unclipped = dst_x; int dst_y_unclipped = dst_y; + if (program.headless) + return; + if (src_bitmap == NULL || dst_bitmap == NULL) return; if (DrawingDeactivated(dst_x, dst_y, width, height)) return; -#if 1 if (!InClippedRectangle(src_bitmap, &src_x, &src_y, &width, &height, FALSE) || !InClippedRectangle(dst_bitmap, &dst_x, &dst_y, &width, &height, TRUE)) return; @@ -694,40 +810,16 @@ void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap, src_x += dst_x - dst_x_unclipped; src_y += dst_y - dst_y_unclipped; -#else - /* skip if rectangle starts outside bitmap */ - if (src_x >= src_bitmap->width || - src_y >= src_bitmap->height || - dst_x >= dst_bitmap->width || - dst_y >= dst_bitmap->height) - return; - - /* clip if rectangle overlaps bitmap */ - if (src_x + width > src_bitmap->width) - width = src_bitmap->width - src_x; - if (src_y + height > src_bitmap->height) - height = src_bitmap->height - src_y; - if (dst_x + width > dst_bitmap->width) - width = dst_bitmap->width - dst_x; - if (dst_y + height > dst_bitmap->height) - height = dst_bitmap->height - dst_y; -#endif - -#if 1 +#if defined(TARGET_SDL2) /* !!! 2013-12-11: An "old friend" is back. Same bug in SDL2 2.0.1 !!! */ -#if 1 /* !!! 2009-03-30: Fixed by using self-compiled, patched SDL.dll !!! */ /* (This bug still exists in the actual (as of 2009-06-15) version 1.2.13, but is already fixed in SVN and should therefore finally be fixed with the next official SDL release, which is probably version 1.2.14.) */ -#if 1 /* !!! 2009-03-24: It seems that this problem still exists in 1.2.12 !!! */ - //#if defined(TARGET_SDL) && defined(PLATFORM_WIN32) -#if defined(TARGET_SDL2) + if (src_bitmap == dst_bitmap) { - /* !!! THIS IS A BUG (IN THE SDL LIBRARY?) AND SHOULD BE FIXED !!! */ - /* needed when blitting directly to same bitmap -- should not be needed with recent SDL libraries, but apparently does not work in 1.2.11 directly */ @@ -766,15 +858,6 @@ void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap, return; } #endif -#endif -#endif -#endif - -#if 0 - if (dst_x < gfx.sx + gfx.sxsize) - printf("::: %d: BlitBitmap(%d, %d, %d, %d)\n", - FrameCounter, dst_x, dst_y, width, height); -#endif sysCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height, dst_x, dst_y, BLIT_OPAQUE); @@ -807,17 +890,15 @@ void BlitBitmapTiled(Bitmap *src_bitmap, Bitmap *dst_bitmap, } } -void FadeRectangle(Bitmap *bitmap_cross, int x, int y, int width, int height, +void FadeRectangle(int x, int y, int width, int height, int fade_mode, int fade_delay, int post_delay, void (*draw_border_function)(void)) { -#if 1 /* (use destination bitmap "backbuffer" -- "bitmap_cross" may be undefined) */ if (!InClippedRectangle(backbuffer, &x, &y, &width, &height, TRUE)) return; -#endif - SDLFadeRectangle(bitmap_cross, x, y, width, height, + SDLFadeRectangle(x, y, width, height, fade_mode, fade_delay, post_delay, draw_border_function); } @@ -827,21 +908,8 @@ void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height, if (DrawingDeactivated(x, y, width, height)) return; -#if 1 if (!InClippedRectangle(bitmap, &x, &y, &width, &height, TRUE)) return; -#else - /* skip if rectangle starts outside bitmap */ - if (x >= bitmap->width || - y >= bitmap->height) - return; - - /* clip if rectangle overlaps bitmap */ - if (x + width > bitmap->width) - width = bitmap->width - x; - if (y + height > bitmap->height) - height = bitmap->height - y; -#endif sysFillRectangle(bitmap, x, y, width, height, color); } @@ -860,14 +928,6 @@ void ClearRectangleOnBackground(Bitmap *bitmap, int x, int y, ClearRectangle(bitmap, x, y, width, height); } -void SetClipMask(Bitmap *bitmap, GC clip_gc, Pixmap clip_pixmap) -{ -} - -void SetClipOrigin(Bitmap *bitmap, GC clip_gc, int clip_x, int clip_y) -{ -} - void BlitBitmapMasked(Bitmap *src_bitmap, Bitmap *dst_bitmap, int src_x, int src_y, int width, int height, int dst_x, int dst_y) @@ -890,8 +950,6 @@ void BlitBitmapOnBackground(Bitmap *src_bitmap, Bitmap *dst_bitmap, dst_x, dst_y); /* draw foreground */ - SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc, - dst_x - src_x, dst_y - src_y); BlitBitmapMasked(src_bitmap, dst_bitmap, src_x, src_y, width, height, dst_x, dst_y); } @@ -900,6 +958,56 @@ void BlitBitmapOnBackground(Bitmap *src_bitmap, Bitmap *dst_bitmap, dst_x, dst_y); } +void BlitTexture(Bitmap *bitmap, + int src_x, int src_y, int width, int height, + int dst_x, int dst_y) +{ + if (bitmap == NULL) + return; + + SDLBlitTexture(bitmap, src_x, src_y, width, height, dst_x, dst_y, + BLIT_OPAQUE); +} + +void BlitTextureMasked(Bitmap *bitmap, + int src_x, int src_y, int width, int height, + int dst_x, int dst_y) +{ + if (bitmap == NULL) + return; + + SDLBlitTexture(bitmap, src_x, src_y, width, height, dst_x, dst_y, + BLIT_MASKED); +} + +void BlitToScreen(Bitmap *bitmap, + int src_x, int src_y, int width, int height, + int dst_x, int dst_y) +{ + if (bitmap == NULL) + return; + + if (video.screen_rendering_mode == SPECIAL_RENDERING_BITMAP) + BlitBitmap(bitmap, gfx.final_screen_bitmap, src_x, src_y, + width, height, dst_x, dst_y); + else + BlitTexture(bitmap, src_x, src_y, width, height, dst_x, dst_y); +} + +void BlitToScreenMasked(Bitmap *bitmap, + int src_x, int src_y, int width, int height, + int dst_x, int dst_y) +{ + if (bitmap == NULL) + return; + + if (video.screen_rendering_mode == SPECIAL_RENDERING_BITMAP) + BlitBitmapMasked(bitmap, gfx.final_screen_bitmap, src_x, src_y, + width, height, dst_x, dst_y); + else + BlitTextureMasked(bitmap, src_x, src_y, width, height, dst_x, dst_y); +} + void DrawSimpleBlackLine(Bitmap *bitmap, int from_x, int from_y, int to_x, int to_y) { @@ -912,11 +1020,14 @@ void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y, SDLDrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, WHITE_PIXEL); } -void DrawLine(Bitmap *bitmap, int from_x, int from_y, - int to_x, int to_y, Pixel pixel, int line_width) +static void DrawLine(Bitmap *bitmap, int from_x, int from_y, + int to_x, int to_y, Pixel pixel, int line_width) { int x, y; + if (program.headless) + return; + for (x = 0; x < line_width; x++) { for (y = 0; y < line_width; y++) @@ -952,6 +1063,9 @@ void DrawLines(Bitmap *bitmap, struct XY *points, int num_points, Pixel pixel) Pixel GetPixel(Bitmap *bitmap, int x, int y) { + if (program.headless) + return BLACK_PIXEL; + if (x < 0 || x >= bitmap->width || y < 0 || y >= bitmap->height) return BLACK_PIXEL; @@ -962,6 +1076,9 @@ Pixel GetPixel(Bitmap *bitmap, int x, int y) Pixel GetPixelFromRGB(Bitmap *bitmap, unsigned int color_r, unsigned int color_g, unsigned int color_b) { + if (program.headless) + return BLACK_PIXEL; + return SDL_MapRGB(bitmap->surface->format, color_r, color_g, color_b); } @@ -974,19 +1091,8 @@ Pixel GetPixelFromRGBcompact(Bitmap *bitmap, unsigned int color) return GetPixelFromRGB(bitmap, color_r, color_g, color_b); } -/* execute all pending screen drawing operations */ -void FlushDisplay(void) -{ -} - -/* execute and wait for all pending screen drawing operations */ -void SyncDisplay(void) -{ -} - void KeyboardAutoRepeatOn(void) { -#if defined(TARGET_SDL) #if defined(TARGET_SDL2) keyrepeat_status = TRUE; #else @@ -994,56 +1100,38 @@ void KeyboardAutoRepeatOn(void) SDL_DEFAULT_REPEAT_INTERVAL / 2); SDL_EnableUNICODE(1); #endif -#else - if (display) - XAutoRepeatOn(display); -#endif } void KeyboardAutoRepeatOff(void) { -#if defined(TARGET_SDL) #if defined(TARGET_SDL2) keyrepeat_status = FALSE; #else SDL_EnableKeyRepeat(0, SDL_DEFAULT_REPEAT_INTERVAL); SDL_EnableUNICODE(0); #endif -#else - if (display) - XAutoRepeatOff(display); -#endif } -boolean PointerInWindow(DrawWindow *window) +boolean SetVideoMode(boolean fullscreen) { -#if defined(TARGET_SDL) - return TRUE; -#else - Window root, child; - int root_x, root_y; - unsigned int mask; - int win_x, win_y; - - /* if XQueryPointer() returns False, the pointer - is not on the same screen as the specified window */ - return XQueryPointer(display, window->drawable, &root, &child, - &root_x, &root_y, &win_x, &win_y, &mask); -#endif + return SDLSetVideoMode(fullscreen); } -boolean SetVideoMode(boolean fullscreen) +void SetVideoFrameDelay(unsigned int frame_delay_value) +{ + video.frame_delay_value = frame_delay_value; +} + +unsigned int GetVideoFrameDelay(void) { - return SDLSetVideoMode(&backbuffer, fullscreen); + return video.frame_delay_value; } boolean ChangeVideoModeIfNeeded(boolean fullscreen) { -#if defined(TARGET_SDL) if ((fullscreen && !video.fullscreen_enabled && video.fullscreen_available)|| (!fullscreen && video.fullscreen_enabled)) fullscreen = SetVideoMode(fullscreen); -#endif return fullscreen; } @@ -1069,7 +1157,7 @@ Bitmap *LoadCustomImage(char *basename) Error(ERR_EXIT, "LoadCustomImage(): cannot find file '%s'", basename); if ((new_bitmap = LoadImage(filename)) == NULL) - Error(ERR_EXIT, "LoadImage() failed: %s", GetError()); + Error(ERR_EXIT, "LoadImage('%s') failed: %s", basename, GetError()); return new_bitmap; } @@ -1096,7 +1184,7 @@ void ReloadCustomImage(Bitmap *bitmap, char *basename) if ((new_bitmap = LoadImage(filename)) == NULL) { - Error(ERR_WARN, "LoadImage() failed: %s", GetError()); + Error(ERR_WARN, "LoadImage('%s') failed: %s", basename, GetError()); return; } @@ -1113,43 +1201,41 @@ void ReloadCustomImage(Bitmap *bitmap, char *basename) free(new_bitmap); } -Bitmap *ZoomBitmap(Bitmap *src_bitmap, int zoom_width, int zoom_height) +static Bitmap *ZoomBitmap(Bitmap *src_bitmap, int zoom_width, int zoom_height) { -#if 0 - // !!! TEST ONLY !!! - - Bitmap *dst_bitmap = CreateBitmap(zoom_width, zoom_height, DEFAULT_DEPTH); - print_timestamp_time("CreateBitmap"); + return SDLZoomBitmap(src_bitmap, zoom_width, zoom_height); +} - SDL_Rect src_rect, dst_rect; +void ReCreateGameTileSizeBitmap(Bitmap **bitmaps) +{ + if (bitmaps[IMG_BITMAP_CUSTOM]) + { + FreeBitmap(bitmaps[IMG_BITMAP_CUSTOM]); - src_rect.x = 0; - src_rect.y = 0; - src_rect.w = src_bitmap->width - 0; - src_rect.h = src_bitmap->height; + bitmaps[IMG_BITMAP_CUSTOM] = NULL; + } - dst_rect.x = 0; - dst_rect.y = 0; - dst_rect.w = dst_bitmap->width; - dst_rect.h = dst_bitmap->height; + if (gfx.game_tile_size == gfx.standard_tile_size) + { + bitmaps[IMG_BITMAP_GAME] = bitmaps[IMG_BITMAP_STANDARD]; - SDL_BlitScaled(src_bitmap->surface, &src_rect, - dst_bitmap->surface, &dst_rect); - print_timestamp_time("SDL_BlitScaled"); + return; + } -#else + Bitmap *bitmap = bitmaps[IMG_BITMAP_STANDARD]; + int width = bitmap->width * gfx.game_tile_size / gfx.standard_tile_size;; + int height = bitmap->height * gfx.game_tile_size / gfx.standard_tile_size;; - Bitmap *dst_bitmap = SDLZoomBitmap(src_bitmap, zoom_width, zoom_height); -#endif + Bitmap *bitmap_new = ZoomBitmap(bitmap, width, height); - return dst_bitmap; + bitmaps[IMG_BITMAP_CUSTOM] = bitmap_new; + bitmaps[IMG_BITMAP_GAME] = bitmap_new; } -static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor, +static void CreateScaledBitmaps(Bitmap **bitmaps, int zoom_factor, int tile_size, boolean create_small_bitmaps) { - Bitmap swap_bitmap; - Bitmap *new_bitmap; + Bitmap *old_bitmap = bitmaps[IMG_BITMAP_STANDARD]; Bitmap *tmp_bitmap_final = NULL; Bitmap *tmp_bitmap_0 = NULL; Bitmap *tmp_bitmap_1 = NULL; @@ -1165,18 +1251,15 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor, int width_4, height_4; int width_8, height_8; int width_16, height_16; -#if 1 int width_32, height_32; -#endif int old_width, old_height; - int new_width, new_height; + int i; print_timestamp_init("CreateScaledBitmaps"); old_width = old_bitmap->width; old_height = old_bitmap->height; -#if 1 /* calculate new image dimensions for final image size */ width_final = old_width * zoom_factor; height_final = old_height * zoom_factor; @@ -1188,20 +1271,6 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor, else tmp_bitmap_final = old_bitmap; -#else - - /* calculate new image dimensions for final image size */ - width_1 = old_width * zoom_factor; - height_1 = old_height * zoom_factor; - - /* get image with final size (this might require scaling up) */ - /* ("final" size may result in non-standard tile size image) */ - if (zoom_factor != 1) - tmp_bitmap_1 = ZoomBitmap(old_bitmap, width_1, height_1); - else - tmp_bitmap_1 = old_bitmap; -#endif - UPDATE_BUSY_STATE(); width_0 = width_1 = width_final; @@ -1209,7 +1278,6 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor, tmp_bitmap_0 = tmp_bitmap_1 = tmp_bitmap_final; -#if 1 if (create_small_bitmaps) { /* check if we have a non-gameplay tile size image */ @@ -1224,15 +1292,7 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor, else if (width_0 == width_final) tmp_bitmap_0 = tmp_bitmap_final; else - { -#if 0 - if (old_width != width_0) - printf("::: %d, %d -> %d, %d\n", - old_width, old_height, width_0, height_0); -#endif - tmp_bitmap_0 = ZoomBitmap(old_bitmap, width_0, height_0); - } UPDATE_BUSY_STATE(); } @@ -1255,11 +1315,7 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor, UPDATE_BUSY_STATE(); } - } -#endif - if (create_small_bitmaps) - { /* calculate new image dimensions for small images */ width_2 = width_1 / 2; height_2 = height_1 / 2; @@ -1269,12 +1325,9 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor, height_8 = height_1 / 8; width_16 = width_1 / 16; height_16 = height_1 / 16; -#if 1 width_32 = width_1 / 32; height_32 = height_1 / 32; -#endif -#if 1 /* get image with 1/2 of normal size (for use in the level editor) */ if (width_2 == old_width) tmp_bitmap_2 = old_bitmap; @@ -1315,216 +1368,65 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor, UPDATE_BUSY_STATE(); -#else - - /* get image with 1/2 of normal size (for use in the level editor) */ - if (zoom_factor != 2) - tmp_bitmap_2 = ZoomBitmap(tmp_bitmap_1, width_1 / 2, height_1 / 2); - else - tmp_bitmap_2 = old_bitmap; - - UPDATE_BUSY_STATE(); - - /* get image with 1/4 of normal size (for use in the level editor) */ - if (zoom_factor != 4) - tmp_bitmap_4 = ZoomBitmap(tmp_bitmap_2, width_2 / 2, height_2 / 2); - else - tmp_bitmap_4 = old_bitmap; - - UPDATE_BUSY_STATE(); - - /* get image with 1/8 of normal size (for use on the preview screen) */ - if (zoom_factor != 8) - tmp_bitmap_8 = ZoomBitmap(tmp_bitmap_4, width_4 / 2, height_4 / 2); - else - tmp_bitmap_8 = old_bitmap; + bitmaps[IMG_BITMAP_32x32] = tmp_bitmap_1; + bitmaps[IMG_BITMAP_16x16] = tmp_bitmap_2; + bitmaps[IMG_BITMAP_8x8] = tmp_bitmap_4; + bitmaps[IMG_BITMAP_4x4] = tmp_bitmap_8; + bitmaps[IMG_BITMAP_2x2] = tmp_bitmap_16; + bitmaps[IMG_BITMAP_1x1] = tmp_bitmap_32; - UPDATE_BUSY_STATE(); + if (width_0 != width_1) + bitmaps[IMG_BITMAP_CUSTOM] = tmp_bitmap_0; - /* get image with 1/16 of normal size (for use on the preview screen) */ - if (zoom_factor != 16) - tmp_bitmap_16 = ZoomBitmap(tmp_bitmap_8, width_8 / 2, height_8 / 2); + if (bitmaps[IMG_BITMAP_CUSTOM]) + bitmaps[IMG_BITMAP_GAME] = bitmaps[IMG_BITMAP_CUSTOM]; else - tmp_bitmap_16 = old_bitmap; - - UPDATE_BUSY_STATE(); + bitmaps[IMG_BITMAP_GAME] = bitmaps[IMG_BITMAP_STANDARD]; - /* get image with 1/32 of normal size (for use on the preview screen) */ - if (zoom_factor != 32) - tmp_bitmap_32 = ZoomBitmap(tmp_bitmap_16, width_16 / 2, height_16 / 2); - else - tmp_bitmap_32 = old_bitmap; + boolean free_old_bitmap = TRUE; - UPDATE_BUSY_STATE(); -#endif - } - -#if 0 - /* if image was scaled up, create new clipmask for normal size image */ - if (zoom_factor != 1) - { - SDL_Surface *tmp_surface_1 = tmp_bitmap_1->surface; - - if (old_bitmap->surface_masked) - SDL_FreeSurface(old_bitmap->surface_masked); - - SDL_SetColorKey(tmp_surface_1, SET_TRANSPARENT_PIXEL, - SDL_MapRGB(tmp_surface_1->format, 0x00, 0x00, 0x00)); - if ((old_bitmap->surface_masked = SDL_DisplayFormat(tmp_surface_1)) ==NULL) - Error(ERR_EXIT, "SDL_DisplayFormat() failed"); - SDL_SetColorKey(tmp_surface_1, UNSET_TRANSPARENT_PIXEL, 0); - } -#endif - - if (create_small_bitmaps) - { - new_width = width_1; - new_height = height_1 + (height_1 + 1) / 2; /* prevent odd height */ + for (i = 0; i < NUM_IMG_BITMAPS; i++) + if (bitmaps[i] == old_bitmap) + free_old_bitmap = FALSE; -#if 1 - if (width_0 != width_1) + if (free_old_bitmap) { - new_width += width_0; - new_height = MAX(new_height, height_0); - } -#endif - - new_bitmap = CreateBitmap(new_width, new_height, DEFAULT_DEPTH); - -#if 1 - if (width_0 != width_1) - BlitBitmap(tmp_bitmap_0, new_bitmap, 0, 0, width_0, height_0, width_1, 0); -#endif - - BlitBitmap(tmp_bitmap_1, new_bitmap, 0, 0, width_1, height_1, 0, 0); - BlitBitmap(tmp_bitmap_2, new_bitmap, 0, 0, width_1 / 2, height_1 / 2, - 0, height_1); - BlitBitmap(tmp_bitmap_4, new_bitmap, 0, 0, width_1 / 4, height_1 / 4, - width_1 / 2, height_1); - BlitBitmap(tmp_bitmap_8, new_bitmap, 0, 0, width_1 / 8, height_1 / 8, - 3 * width_1 / 4, height_1); - BlitBitmap(tmp_bitmap_16, new_bitmap, 0, 0, width_1 / 16, height_1 / 16, - 7 * width_1 / 8, height_1); - BlitBitmap(tmp_bitmap_32, new_bitmap, 0, 0, width_1 / 32, height_1 / 32, - 15 * width_1 / 16, height_1); + /* copy image filename from old to new standard sized bitmap */ + bitmaps[IMG_BITMAP_STANDARD]->source_filename = + getStringCopy(old_bitmap->source_filename); - UPDATE_BUSY_STATE(); + FreeBitmap(old_bitmap); + } } else { - new_width = width_1; - new_height = height_1; - - new_bitmap = tmp_bitmap_1; /* directly use tmp_bitmap_1 as new bitmap */ - } - - if (create_small_bitmaps) - { - /* if no small bitmaps created, tmp_bitmap_1 is used as new bitmap now */ - -#if 1 - if (tmp_bitmap_final != old_bitmap) - FreeBitmap(tmp_bitmap_final); - - if (tmp_bitmap_0 != old_bitmap && - tmp_bitmap_0 != tmp_bitmap_final) - FreeBitmap(tmp_bitmap_0); - - if (tmp_bitmap_1 != old_bitmap && - tmp_bitmap_1 != tmp_bitmap_final && - tmp_bitmap_1 != tmp_bitmap_0) - FreeBitmap(tmp_bitmap_1); - - if (tmp_bitmap_2 != old_bitmap) - FreeBitmap(tmp_bitmap_2); - - if (tmp_bitmap_4 != old_bitmap) - FreeBitmap(tmp_bitmap_4); - - if (tmp_bitmap_8 != old_bitmap) - FreeBitmap(tmp_bitmap_8); - - if (tmp_bitmap_16 != old_bitmap) - FreeBitmap(tmp_bitmap_16); - - if (tmp_bitmap_32 != old_bitmap) - FreeBitmap(tmp_bitmap_32); - -#else - - if (zoom_factor != 1) - FreeBitmap(tmp_bitmap_1); - - if (zoom_factor != 2) - FreeBitmap(tmp_bitmap_2); - - if (zoom_factor != 4) - FreeBitmap(tmp_bitmap_4); - - if (zoom_factor != 8) - FreeBitmap(tmp_bitmap_8); - - if (zoom_factor != 16) - FreeBitmap(tmp_bitmap_16); - - if (zoom_factor != 32) - FreeBitmap(tmp_bitmap_32); -#endif - } - - /* replace image with extended image (containing 1/1, 1/2, 1/4, 1/8 size) */ -#if defined(TARGET_SDL) - swap_bitmap.surface = old_bitmap->surface; - old_bitmap->surface = new_bitmap->surface; - new_bitmap->surface = swap_bitmap.surface; -#else - swap_bitmap.drawable = old_bitmap->drawable; - old_bitmap->drawable = new_bitmap->drawable; - new_bitmap->drawable = swap_bitmap.drawable; -#endif - - old_bitmap->width = new_bitmap->width; - old_bitmap->height = new_bitmap->height; - -#if 1 - /* this replaces all blit masks created when loading -- maybe optimize this */ - { - SDL_Surface *old_surface = old_bitmap->surface; - - if (old_bitmap->surface_masked) - SDL_FreeSurface(old_bitmap->surface_masked); - - SDL_SetColorKey(old_surface, SET_TRANSPARENT_PIXEL, - SDL_MapRGB(old_surface->format, 0x00, 0x00, 0x00)); - -#if 1 - if ((old_bitmap->surface_masked = SDLGetNativeSurface(old_surface)) == NULL) - Error(ERR_EXIT, "SDL_DisplayFormat() failed"); -#else - if ((old_bitmap->surface_masked = SDL_DisplayFormat(old_surface)) == NULL) - Error(ERR_EXIT, "SDL_DisplayFormat() failed"); -#endif - - SDL_SetColorKey(old_surface, UNSET_TRANSPARENT_PIXEL, 0); + bitmaps[IMG_BITMAP_32x32] = tmp_bitmap_1; } -#endif UPDATE_BUSY_STATE(); - FreeBitmap(new_bitmap); /* this actually frees the _old_ bitmap now */ - print_timestamp_done("CreateScaledBitmaps"); } -void CreateBitmapWithSmallBitmaps(Bitmap *old_bitmap, int zoom_factor, +void CreateBitmapWithSmallBitmaps(Bitmap **bitmaps, int zoom_factor, int tile_size) { - CreateScaledBitmaps(old_bitmap, zoom_factor, tile_size, TRUE); + CreateScaledBitmaps(bitmaps, zoom_factor, tile_size, TRUE); +} + +void CreateBitmapTextures(Bitmap **bitmaps) +{ + SDLCreateBitmapTextures(bitmaps[IMG_BITMAP_STANDARD]); +} + +void FreeBitmapTextures(Bitmap **bitmaps) +{ + SDLFreeBitmapTextures(bitmaps[IMG_BITMAP_STANDARD]); } -void ScaleBitmap(Bitmap *old_bitmap, int zoom_factor) +void ScaleBitmap(Bitmap **bitmaps, int zoom_factor) { - CreateScaledBitmaps(old_bitmap, zoom_factor, 0, FALSE); + CreateScaledBitmaps(bitmaps, zoom_factor, 0, FALSE); } @@ -1672,6 +1574,8 @@ void SetMouseCursor(int mode) mode == CURSOR_PLAYFIELD ? cursor_playfield : NULL); SDLSetMouseCursor(cursor_new); + + gfx.cursor_mode = mode; } @@ -1698,16 +1602,12 @@ void OpenAudio(void) audio.music_channel = 0; audio.first_sound_channel = 0; -#if defined(TARGET_SDL) SDLOpenAudio(); -#endif } void CloseAudio(void) { -#if defined(TARGET_SDL) SDLCloseAudio(); -#endif audio.sound_enabled = FALSE; } @@ -1725,58 +1625,39 @@ void SetAudioMode(boolean enabled) /* event functions */ /* ========================================================================= */ -void InitEventFilter(EventFilter filter_function) -{ - /* set event filter to filter out certain events */ -#if defined(TARGET_SDL) -#if defined(TARGET_SDL2) - SDL_SetEventFilter(filter_function, NULL); -#else - SDL_SetEventFilter(filter_function); -#endif -#endif -} - boolean PendingEvent(void) { -#if defined(TARGET_SDL) return (SDL_PollEvent(NULL) ? TRUE : FALSE); -#else - return (XPending(display) ? TRUE : FALSE); -#endif } -void NextEvent(Event *event) +void WaitEvent(Event *event) { -#if defined(TARGET_SDL) - SDLNextEvent(event); -#else - XNextEvent(display, event); -#endif + SDLWaitEvent(event); } void PeekEvent(Event *event) { -#if defined(TARGET_SDL) #if defined(TARGET_SDL2) SDL_PeepEvents(event, 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT); #else SDL_PeepEvents(event, 1, SDL_PEEKEVENT, SDL_ALLEVENTS); #endif -#else - XPeekEvent(display, event); -#endif +} + +void CheckQuitEvent(void) +{ + if (SDL_QuitRequested()) + program.exit_function(0); } Key GetEventKey(KeyEvent *event, boolean with_modifiers) { -#if defined(TARGET_SDL) #if defined(TARGET_SDL2) /* key up/down events in SDL2 do not return text characters anymore */ return event->keysym.sym; #else -#if 0 +#if ENABLE_UNUSED_CODE printf("unicode == '%d', sym == '%d', mod == '0x%04x'\n", (int)event->keysym.unicode, (int)event->keysym.sym, @@ -1791,19 +1672,6 @@ Key GetEventKey(KeyEvent *event, boolean with_modifiers) return event->keysym.sym; #endif -#else - -#if 0 - printf("with modifiers == '0x%04x', without modifiers == '0x%04x'\n", - (int)XLookupKeysym(event, event->state), - (int)XLookupKeysym(event, 0)); -#endif - - if (with_modifiers) - return XLookupKeysym(event, event->state); - else - return XLookupKeysym(event, 0); -#endif } KeyMod HandleKeyModState(Key key, int key_status) @@ -1853,16 +1721,12 @@ KeyMod HandleKeyModState(Key key, int key_status) return current_modifiers; } -KeyMod GetKeyModState() +KeyMod GetKeyModState(void) { -#if defined(TARGET_SDL) return (KeyMod)SDL_GetModState(); -#else - return HandleKeyModState(KSYM_UNDEFINED, 0); -#endif } -KeyMod GetKeyModStateFromEvents() +KeyMod GetKeyModStateFromEvents(void) { /* always use key modifier state as tracked from key events (this is needed if the modifier key event was injected into the event queue, but the key @@ -1873,16 +1737,44 @@ KeyMod GetKeyModStateFromEvents() return HandleKeyModState(KSYM_UNDEFINED, 0); } +void StartTextInput(int x, int y, int width, int height) +{ +#if defined(TARGET_SDL2) +#if defined(HAS_SCREEN_KEYBOARD) + SDL_StartTextInput(); + + if (y + height > SCREEN_KEYBOARD_POS(video.height)) + { + video.shifted_up_pos = y + height - SCREEN_KEYBOARD_POS(video.height); + video.shifted_up_delay = SDL_GetTicks(); + video.shifted_up = TRUE; + } +#endif +#endif +} + +void StopTextInput(void) +{ +#if defined(TARGET_SDL2) +#if defined(HAS_SCREEN_KEYBOARD) + SDL_StopTextInput(); + + if (video.shifted_up) + { + video.shifted_up_pos = 0; + video.shifted_up_delay = SDL_GetTicks(); + video.shifted_up = FALSE; + } +#endif +#endif +} + boolean CheckCloseWindowEvent(ClientMessageEvent *event) { if (event->type != EVENT_CLIENTMESSAGE) return FALSE; -#if defined(TARGET_SDL) return TRUE; /* the only possible message here is SDL_QUIT */ -#endif - - return FALSE; } @@ -1890,7 +1782,7 @@ boolean CheckCloseWindowEvent(ClientMessageEvent *event) /* joystick functions */ /* ========================================================================= */ -void InitJoysticks() +void InitJoysticks(void) { int i; @@ -1901,21 +1793,22 @@ void InitJoysticks() /* always start with reliable default values */ joystick.status = JOYSTICK_NOT_AVAILABLE; for (i = 0; i < MAX_PLAYERS; i++) - joystick.fd[i] = -1; /* joystick device closed */ + joystick.nr[i] = -1; /* no joystick configured */ -#if defined(TARGET_SDL) SDLInitJoysticks(); -#endif - -#if 0 - for (i = 0; i < MAX_PLAYERS; i++) - printf("::: Joystick for player %d: %d\n", i, joystick.fd[i]); -#endif } boolean ReadJoystick(int nr, int *x, int *y, boolean *b1, boolean *b2) { -#if defined(TARGET_SDL) return SDLReadJoystick(nr, x, y, b1, b2); -#endif +} + +boolean CheckJoystickOpened(int nr) +{ + return SDLCheckJoystickOpened(nr); +} + +void ClearJoystickState(void) +{ + SDLClearJoystickState(); }