From 3f2965eaac24df12f0374d38920e118470134b18 Mon Sep 17 00:00:00 2001 From: Gregory Montoir Date: Sun, 19 Dec 2021 08:09:02 +0800 Subject: [PATCH] Import blues from 6d8f0b2a --- bb/level.c | 10 ++- bb/screen.c | 12 ++- bb/unpack.c | 37 ++++----- ja/screen.c | 2 +- p2/bosses.c | 22 +++--- p2/game.h | 2 +- p2/level.c | 4 +- p2/screen.c | 15 ++-- p2/unpack.c | 2 +- sys.h | 2 +- sys_sdl2.c | 220 ++++++++++++++++++++++++++++++---------------------- 11 files changed, 182 insertions(+), 146 deletions(-) diff --git a/bb/level.c b/bb/level.c index ba5fbdd..44edd91 100644 --- a/bb/level.c +++ b/bb/level.c @@ -106,30 +106,32 @@ static void init_level() { if (g_vars.play_demo_flag) { g_vars.objects[OBJECT_NUM_PLAYER1].unk60 = 0; } + const int xoffs = (TILEMAP_SCREEN_W / 16) / 2; int xpos = g_options.start_xpos16; if (xpos < 0) { xpos = g_vars.level_xpos[OBJECT_NUM_PLAYER1]; if (!g_vars.two_players_flag && (g_vars.objects[OBJECT_NUM_PLAYER1].unk60 || g_vars.objects[OBJECT_NUM_PLAYER2].unk60)) { xpos = restart_xpos[g_vars.level * 2]; } - xpos = (xpos >> 4) - 10; + xpos = (xpos >> 4) - xoffs; } else { - g_vars.level_xpos[OBJECT_NUM_PLAYER1] = (xpos << 4) + 10; + g_vars.level_xpos[OBJECT_NUM_PLAYER1] = (xpos << 4) + xoffs; } if (xpos < 0) { xpos = 0; } g_vars.screen_tilemap_xorigin = xpos << 4; + const int yoffs = (TILEMAP_SCREEN_H / 16) / 2 + 1; int ypos = g_options.start_ypos16; if (ypos < 0) { ypos = g_vars.level_ypos[OBJECT_NUM_PLAYER1]; if (!g_vars.two_players_flag && (g_vars.objects[OBJECT_NUM_PLAYER1].unk60 || g_vars.objects[OBJECT_NUM_PLAYER2].unk60)) { ypos = restart_ypos[g_vars.level * 2]; } - ypos = (ypos >> 4) - 6; + ypos = (ypos >> 4) - yoffs; } else { - g_vars.level_ypos[OBJECT_NUM_PLAYER1] = (ypos << 4) + 6; + g_vars.level_ypos[OBJECT_NUM_PLAYER1] = (ypos << 4) + yoffs; } if (ypos < 0) { ypos = 0; diff --git a/bb/screen.c b/bb/screen.c index 4dec4a9..f5c0363 100644 --- a/bb/screen.c +++ b/bb/screen.c @@ -272,11 +272,17 @@ static void decode_graphics(int spr_type, int start, int end, const uint8_t *dit max_h = h; } } + if (g_res.amiga_data && start == 0) { + for (int i = 0; i < MAX_SPRITESHEET_W * MAX_SPRITESHEET_H; ++i) { + if (data[i] != 0) { + data[i] |= 16; + } + } + } assert(max_w <= MAX_SPRITESHEET_W); assert(current_y + max_h <= MAX_SPRITESHEET_H); g_sys.render_unload_sprites(spr_type); - const int palette_offset = (g_res.amiga_data && start == 0) ? 16 : 0; - g_sys.render_load_sprites(spr_type, end - start, r, data, MAX_SPRITESHEET_W, current_y + max_h, palette_offset, color_key); + g_sys.render_load_sprites(spr_type, end - start, r, data, MAX_SPRITESHEET_W, current_y + max_h, color_key, false); free(data); } } @@ -305,7 +311,7 @@ void screen_load_graphics(const uint8_t *dither_lut_sqv, const uint8_t *dither_l dither_graphics(data, FG_TILE_W * g_res.avt_count, FG_TILE_W * g_res.avt_count, FG_TILE_H, dither_lut_avt, color_key); } g_sys.render_unload_sprites(RENDER_SPR_FG); - g_sys.render_load_sprites(RENDER_SPR_FG, g_res.avt_count, r, data, g_res.avt_count * FG_TILE_W, FG_TILE_H, 0, color_key); + g_sys.render_load_sprites(RENDER_SPR_FG, g_res.avt_count, r, data, g_res.avt_count * FG_TILE_W, FG_TILE_H, color_key, false); free(data); } // background tiles (Amiga) - re-arrange to match DOS .ck1/.ck2 layout diff --git a/bb/unpack.c b/bb/unpack.c index a44e71a..4713cfb 100644 --- a/bb/unpack.c +++ b/bb/unpack.c @@ -4,50 +4,43 @@ struct unpack_t { uint8_t dict_buf[0x200 * 2]; - uint8_t rd[0x1000]; }; static struct unpack_t g_unpack; int unpack(FILE *in, uint8_t *dst) { - fread(g_unpack.rd, 1, 6, in); - const int uncompressed_size = (READ_LE_UINT16(g_unpack.rd) << 16) + READ_LE_UINT16(g_unpack.rd + 2); - const int dict_len = READ_LE_UINT16(g_unpack.rd + 4); + uint8_t buf[6]; + fread(buf, 1, 6, in); + const int uncompressed_size = (READ_LE_UINT16(buf) << 16) + READ_LE_UINT16(buf + 2); + const int dict_len = READ_LE_UINT16(buf + 4); print_debug(DBG_UNPACK, "SQV uncompressed size %d dict_len %d", uncompressed_size, dict_len); fread(g_unpack.dict_buf, 1, dict_len, in); const uint8_t *start = dst; - const uint8_t *src = g_unpack.rd; - int len = 1; - int bytes_count = 2; + int bits_count = 1; uint16_t bits = 0; uint16_t val = 0; while ((dst - start) < uncompressed_size) { - --len; - if (len == 0) { - bytes_count -= 2; - if (bytes_count == 0) { - bytes_count = fread(g_unpack.rd, 1, 0x1000, in); - if (bytes_count == 0) { - break; - } - bytes_count += (bytes_count & 1); - src = g_unpack.rd; + --bits_count; + if (bits_count == 0) { + if (fread(buf, 1, 2, in) == 0) { + break; } - bits = READ_BE_UINT16(src); src += 2; - len = 17; - continue; + bits = READ_BE_UINT16(buf); + bits_count = 16; } - const int carry = (bits & 0x8000) != 0; + const bool carry = (bits & 0x8000) != 0; bits <<= 1; if (carry) { val += 2; } - assert(val < 0x400); + assert((val & 1) == 0); + assert(val < dict_len); val = READ_LE_UINT16(g_unpack.dict_buf + val); if ((val & 0x8000) == 0) { continue; } + assert((val & 0x7F00) == 0); *dst++ = val & 255; val = 0; } diff --git a/ja/screen.c b/ja/screen.c index 94defba..b795a0b 100644 --- a/ja/screen.c +++ b/ja/screen.c @@ -231,7 +231,7 @@ void video_load_sprites() { assert(max_w <= MAX_SPRITESHEET_W); assert(current_y + max_h <= MAX_SPRITESHEET_H); g_sys.render_unload_sprites(RENDER_SPR_GAME); - g_sys.render_load_sprites(RENDER_SPR_GAME, count, r, data, MAX_SPRITESHEET_W, current_y + max_h, 0, 0x0); + g_sys.render_load_sprites(RENDER_SPR_GAME, count, r, data, MAX_SPRITESHEET_W, current_y + max_h, 0x0, false); free(data); } } diff --git a/p2/bosses.c b/p2/bosses.c index f570a84..4102545 100644 --- a/p2/bosses.c +++ b/p2/bosses.c @@ -138,23 +138,23 @@ static void level_update_boss_gorilla_init_objects(const uint16_t *p) { ++g_vars.boss.parts[3].y_pos; } if (g_vars.boss.hdir) { - g_vars.boss.parts[0].spr_num |= 0x8000; - g_vars.boss.parts[1].spr_num |= 0x8000; - g_vars.boss.parts[2].spr_num |= 0x8000; - g_vars.boss.parts[3].spr_num |= 0x8000; - g_vars.boss.parts[4].spr_num |= 0x8000; + for (int i = 0; i < 5; ++i) { + g_vars.boss.parts[i].spr_num |= 0x8000; + } } for (int i = 0; i < 5; ++i) { struct object_t *obj = &g_vars.objects_tbl[103 + i]; const uint16_t addr = *p++; - if (addr == 0xA609) { + switch (addr) { + case 0xA609: g_vars.boss.obj1 = obj; - } - if (addr == 0xA60F) { + break; + case 0xA60F: g_vars.boss.obj2 = obj; - } - if (addr == 0xA603) { + break; + case 0xA603: g_vars.boss.obj3 = obj; + break; } assert(addr == 0xA5F7 || addr == 0xA5FD || addr == 0xA603 || addr == 0xA609 || addr == 0xA60F); const int num = (addr - 0xA5F7) / 6; @@ -597,7 +597,7 @@ static void level_update_boss_tree() { g_vars.boss_level5.spr106_pos = 0; } uint8_t ah = 1; - if (g_vars.boss_level5.spr106_pos != 0) { + if (g_vars.boss_level5.spr106_pos != 1) { ah = 3; g_vars.shake_screen_counter = 4; obj_player->x_pos += 2; diff --git a/p2/game.h b/p2/game.h index 33a0ad8..6495497 100644 --- a/p2/game.h +++ b/p2/game.h @@ -299,7 +299,7 @@ extern const uint8_t monster_anim_tbl[1100]; extern const uint8_t boss_minotaur_seq_data[86]; extern const uint16_t boss_gorilla_data[19 * 10]; extern const uint16_t boss_gorilla_spr_tbl[46 * 3]; /* uint16_t: spr1_num, uint16_t: spr2_num, int8_t: dx, int8_t: dy */ -extern const uint16_t snow_pattern1_data[11]; +extern const uint16_t snow_pattern1_data[1]; extern const uint16_t snow_pattern2_data[10]; /* game.c */ diff --git a/p2/level.c b/p2/level.c index b910e94..4424759 100644 --- a/p2/level.c +++ b/p2/level.c @@ -944,7 +944,7 @@ static void level_update_tile1(uint16_t offset) { level_update_tile_type_1(offset); break; case 2: - level_update_tile_type_2(offset); + level_update_tile_type_2(); break; default: print_warning("Unhandled level_update_tile1 type %d", type); @@ -2097,7 +2097,7 @@ static void level_update_player_anim_0(uint8_t al) { const uint8_t *anim = level_update_player_anim1_num(18, 36); level_update_object_anim(anim); if ((g_vars.level_draw_counter & 3) == 0) { - level_init_object_hit_from_player_pos(&g_vars.objects_tbl[1]); + level_init_object_hit_from_player_pos(); } g_vars.objects_tbl[1].data.p.current_anim_num = 0; return; diff --git a/p2/screen.c b/p2/screen.c index 67afe08..e417e8b 100644 --- a/p2/screen.c +++ b/p2/screen.c @@ -61,6 +61,9 @@ static void convert_planar_tile_4bpp(const uint8_t *src, uint8_t *dst, int dst_p void video_draw_string(int offset, int hspace, const char *s) { offset += hspace; + const int y = (offset * 8) / 320 + (GAME_SCREEN_H - 200) / 2; + const int x = (offset * 8) % 320 + (GAME_SCREEN_W - 320) / 2; + uint8_t *dst = g_res.vga + y * GAME_SCREEN_W + x; while (*s) { uint8_t code = *s++; if (code != 0x20) { @@ -68,10 +71,10 @@ void video_draw_string(int offset, int hspace, const char *s) { if (code > 9) { code -= 2; } - decode_planar(g_res.allfonts + code * 48, g_res.vga + offset * 8, 320, 8, 12, 0); - } - ++offset; - } + decode_planar(g_res.allfonts + code * 48, dst, GAME_SCREEN_W, 8, 12, 0); + } + dst += 8; + } } void video_draw_panel_number(int offset, int num) { @@ -188,7 +191,7 @@ void video_load_front_tiles() { decode_planar(g_res.frontdat + tile * 16 * 8, g_res.vga + y * w + x, w, 16, 16, 0); ++tile; if (tile == count) { - g_sys.render_load_sprites(RENDER_SPR_FG, count, r, g_res.vga, w, h, 0, 0x0); + g_sys.render_load_sprites(RENDER_SPR_FG, count, r, g_res.vga, w, h, 0x0, true); return; } } @@ -260,7 +263,7 @@ void video_load_sprites() { assert(max_w <= MAX_SPRITESHEET_W); assert(current_y + max_h <= MAX_SPRITESHEET_H); g_sys.render_unload_sprites(RENDER_SPR_GAME); - g_sys.render_load_sprites(RENDER_SPR_GAME, count, r, data, MAX_SPRITESHEET_W, current_y + max_h, 0, 0x0); + g_sys.render_load_sprites(RENDER_SPR_GAME, count, r, data, MAX_SPRITESHEET_W, current_y + max_h, 0x0, true); free(data); print_debug(DBG_SCREEN, "sprites total_size %d count %d", offset, count); } diff --git a/p2/unpack.c b/p2/unpack.c index 790a8a5..e69c106 100644 --- a/p2/unpack.c +++ b/p2/unpack.c @@ -250,7 +250,7 @@ static int unpack_sqv(FILE *in, struct unpack_sqv_t *u) { int bytes_count = 2; int state = 0; int count = 0; - uint8_t code, prev; + uint8_t code, prev = 0; uint16_t bits = 0; uint16_t val = 0; while ((dst - output_buffer) < uncompressed_size) { diff --git a/sys.h b/sys.h index 1bc9fcb..2effbfa 100644 --- a/sys.h +++ b/sys.h @@ -55,7 +55,7 @@ struct sys_t { void (*stop_audio)(); void (*lock_audio)(); void (*unlock_audio)(); - void (*render_load_sprites)(int spr_type, int count, const struct sys_rect_t *r, const uint8_t *data, int w, int h, int palette_offset, uint8_t color_key); + void (*render_load_sprites)(int spr_type, int count, const struct sys_rect_t *r, const uint8_t *data, int w, int h, uint8_t color_key, bool update_pal); void (*render_unload_sprites)(int spr_type); void (*render_add_sprite)(int spr_type, int frame, int x, int y, int xflip); void (*render_clear_sprites)(); diff --git a/sys_sdl2.c b/sys_sdl2.c index 98dd83b..6d97980 100644 --- a/sys_sdl2.c +++ b/sys_sdl2.c @@ -5,16 +5,18 @@ #define COPPER_BARS_H 80 #define MAX_SPRITES 256 +#define MAX_SPRITESHEETS 3 static const int FADE_STEPS = 16; struct spritesheet_t { int count; SDL_Rect *r; + SDL_Surface *surface; SDL_Texture *texture; }; -static struct spritesheet_t _spritesheets[3]; +static struct spritesheet_t _spritesheets[MAX_SPRITESHEETS]; struct sprite_t { int sheet; @@ -33,11 +35,12 @@ static SDL_Window *_window; static SDL_Renderer *_renderer; static SDL_Texture *_texture; static SDL_PixelFormat *_fmt; +static SDL_Palette *_palette; static uint32_t _screen_palette[256]; static uint32_t *_screen_buffer; -static struct input_t *_input = &g_sys.input; -static int _copper_color; +static int _copper_color_key; static uint32_t _copper_palette[COPPER_BARS_H]; + static SDL_GameController *_controller; static SDL_Joystick *_joystick; @@ -45,13 +48,10 @@ static int sdl2_init() { SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER); SDL_ShowCursor(SDL_DISABLE); _screen_w = _screen_h = 0; - _window = 0; - _renderer = 0; - _texture = 0; - _fmt = 0; memset(_screen_palette, 0, sizeof(_screen_palette)); + _palette = SDL_AllocPalette(256); _screen_buffer = 0; - _copper_color = -1; + _copper_color_key = -1; SDL_GameControllerAddMappingsFromFile("gamecontrollerdb.txt"); _controller = 0; const int count = SDL_NumJoysticks(); @@ -80,6 +80,10 @@ static void sdl2_fini() { SDL_FreeFormat(_fmt); _fmt = 0; } + if (_palette) { + SDL_FreePalette(_palette); + _palette = 0; + } if (_texture) { SDL_DestroyTexture(_texture); _texture = 0; @@ -140,22 +144,33 @@ static uint32_t convert_amiga_color(uint16_t color) { r |= r << 4; uint8_t g = (color >> 4) & 15; g |= g << 4; - uint8_t b = color & 15; + uint8_t b = color & 15; b |= b << 4; return SDL_MapRGB(_fmt, r, g, b); } +static void set_amiga_color(uint16_t color, SDL_Color *p) { + const uint8_t r = (color >> 8) & 15; + p->r = (r << 4) | r; + const uint8_t g = (color >> 4) & 15; + p->g = (g << 4) | g; + const uint8_t b = color & 15; + p->b = (b << 4) | b; +} + static void sdl2_set_palette_amiga(const uint16_t *colors, int offset) { + SDL_Color *palette_colors = &_palette->colors[offset]; for (int i = 0; i < 16; ++i) { _screen_palette[offset + i] = convert_amiga_color(colors[i]); + set_amiga_color(colors[i], &palette_colors[i]); } } static void sdl2_set_copper_bars(const uint16_t *data) { if (!data) { - _copper_color = -1; + _copper_color_key = -1; } else { - _copper_color = (data[0] - 0x180) / 2; + _copper_color_key = (data[0] - 0x180) / 2; const uint16_t *src = data + 1; uint32_t *dst = _copper_palette; for (int i = 0; i < COPPER_BARS_H / 5; ++i) { @@ -170,6 +185,7 @@ static void sdl2_set_copper_bars(const uint16_t *data) { } static void sdl2_set_screen_palette(const uint8_t *colors, int offset, int count, int depth) { + SDL_Color *palette_colors = &_palette->colors[offset]; const int shift = 8 - depth; for (int i = 0; i < count; ++i) { int r = colors[0]; @@ -181,8 +197,18 @@ static void sdl2_set_screen_palette(const uint8_t *colors, int offset, int count b = (b << shift) | (b >> (depth - shift)); } _screen_palette[offset + i] = SDL_MapRGB(_fmt, r, g, b); + palette_colors[i].r = r; + palette_colors[i].g = g; + palette_colors[i].b = b; colors += 3; } + for (int i = 0; i < ARRAYSIZE(_spritesheets); ++i) { + struct spritesheet_t *sheet = &_spritesheets[i]; + if (sheet->surface) { + SDL_DestroyTexture(sheet->texture); + sheet->texture = SDL_CreateTextureFromSurface(_renderer, sheet->surface); + } + } } static void sdl2_set_palette_color(int i, const uint8_t *colors) { @@ -261,12 +287,12 @@ static void sdl2_transition_screen(enum sys_transition_e type, bool open) { } static void sdl2_update_screen(const uint8_t *p, int present) { - if (_copper_color != -1) { + if (_copper_color_key != -1) { for (int j = 0; j < _screen_h; ++j) { if (j / 2 < COPPER_BARS_H) { const uint32_t line_color = _copper_palette[j / 2]; for (int i = 0; i < _screen_w; ++i) { - _screen_buffer[j * _screen_w + i] = (p[i] == _copper_color) ? line_color : _screen_palette[p[i]]; + _screen_buffer[j * _screen_w + i] = (p[i] == _copper_color_key) ? line_color : _screen_palette[p[i]]; } } else { for (int i = 0; i < _screen_w; ++i) { @@ -310,179 +336,179 @@ static void sdl2_update_screen(const uint8_t *p, int present) { } } -static void handle_keyevent(int keysym, bool keydown) { +static void handle_keyevent(int keysym, bool keydown, struct input_t *input) { switch (keysym) { case SDLK_LEFT: if (keydown) { - _input->direction |= INPUT_DIRECTION_LEFT; + input->direction |= INPUT_DIRECTION_LEFT; } else { - _input->direction &= ~INPUT_DIRECTION_LEFT; + input->direction &= ~INPUT_DIRECTION_LEFT; } break; case SDLK_RIGHT: if (keydown) { - _input->direction |= INPUT_DIRECTION_RIGHT; + input->direction |= INPUT_DIRECTION_RIGHT; } else { - _input->direction &= ~INPUT_DIRECTION_RIGHT; + input->direction &= ~INPUT_DIRECTION_RIGHT; } break; case SDLK_UP: if (keydown) { - _input->direction |= INPUT_DIRECTION_UP; + input->direction |= INPUT_DIRECTION_UP; } else { - _input->direction &= ~INPUT_DIRECTION_UP; + input->direction &= ~INPUT_DIRECTION_UP; } break; case SDLK_DOWN: if (keydown) { - _input->direction |= INPUT_DIRECTION_DOWN; + input->direction |= INPUT_DIRECTION_DOWN; } else { - _input->direction &= ~INPUT_DIRECTION_DOWN; + input->direction &= ~INPUT_DIRECTION_DOWN; } break; case SDLK_RETURN: case SDLK_SPACE: - _input->space = keydown; + input->space = keydown; break; case SDLK_ESCAPE: - _input->escape = keydown; + input->escape = keydown; break; case SDLK_1: - _input->digit1 = keydown; + input->digit1 = keydown; break; case SDLK_2: - _input->digit2 = keydown; + input->digit2 = keydown; break; case SDLK_3: - _input->digit3 = keydown; + input->digit3 = keydown; break; } } -static void handle_controlleraxis(int axis, int value) { +static void handle_controlleraxis(int axis, int value, struct input_t *input) { static const int THRESHOLD = 3200; switch (axis) { case SDL_CONTROLLER_AXIS_LEFTX: case SDL_CONTROLLER_AXIS_RIGHTX: if (value < -THRESHOLD) { - _input->direction |= INPUT_DIRECTION_LEFT; + input->direction |= INPUT_DIRECTION_LEFT; } else { - _input->direction &= ~INPUT_DIRECTION_LEFT; + input->direction &= ~INPUT_DIRECTION_LEFT; } if (value > THRESHOLD) { - _input->direction |= INPUT_DIRECTION_RIGHT; + input->direction |= INPUT_DIRECTION_RIGHT; } else { - _input->direction &= ~INPUT_DIRECTION_RIGHT; + input->direction &= ~INPUT_DIRECTION_RIGHT; } break; case SDL_CONTROLLER_AXIS_LEFTY: case SDL_CONTROLLER_AXIS_RIGHTY: if (value < -THRESHOLD) { - _input->direction |= INPUT_DIRECTION_UP; + input->direction |= INPUT_DIRECTION_UP; } else { - _input->direction &= ~INPUT_DIRECTION_UP; + input->direction &= ~INPUT_DIRECTION_UP; } if (value > THRESHOLD) { - _input->direction |= INPUT_DIRECTION_DOWN; + input->direction |= INPUT_DIRECTION_DOWN; } else { - _input->direction &= ~INPUT_DIRECTION_DOWN; + input->direction &= ~INPUT_DIRECTION_DOWN; } break; } } -static void handle_controllerbutton(int button, bool pressed) { +static void handle_controllerbutton(int button, bool pressed, struct input_t *input) { switch (button) { case SDL_CONTROLLER_BUTTON_A: case SDL_CONTROLLER_BUTTON_B: case SDL_CONTROLLER_BUTTON_X: case SDL_CONTROLLER_BUTTON_Y: - _input->space = pressed; + input->space = pressed; break; case SDL_CONTROLLER_BUTTON_BACK: - _input->escape = pressed; + input->escape = pressed; break; case SDL_CONTROLLER_BUTTON_START: break; case SDL_CONTROLLER_BUTTON_DPAD_UP: if (pressed) { - _input->direction |= INPUT_DIRECTION_UP; + input->direction |= INPUT_DIRECTION_UP; } else { - _input->direction &= ~INPUT_DIRECTION_UP; + input->direction &= ~INPUT_DIRECTION_UP; } break; case SDL_CONTROLLER_BUTTON_DPAD_DOWN: if (pressed) { - _input->direction |= INPUT_DIRECTION_DOWN; + input->direction |= INPUT_DIRECTION_DOWN; } else { - _input->direction &= ~INPUT_DIRECTION_DOWN; + input->direction &= ~INPUT_DIRECTION_DOWN; } break; case SDL_CONTROLLER_BUTTON_DPAD_LEFT: if (pressed) { - _input->direction |= INPUT_DIRECTION_LEFT; + input->direction |= INPUT_DIRECTION_LEFT; } else { - _input->direction &= ~INPUT_DIRECTION_LEFT; + input->direction &= ~INPUT_DIRECTION_LEFT; } break; case SDL_CONTROLLER_BUTTON_DPAD_RIGHT: if (pressed) { - _input->direction |= INPUT_DIRECTION_RIGHT; + input->direction |= INPUT_DIRECTION_RIGHT; } else { - _input->direction &= ~INPUT_DIRECTION_RIGHT; + input->direction &= ~INPUT_DIRECTION_RIGHT; } break; } } -static void handle_joystickhatmotion(int value) { - _input->direction = 0; +static void handle_joystickhatmotion(int value, struct input_t *input) { + input->direction = 0; if (value & SDL_HAT_UP) { - _input->direction |= INPUT_DIRECTION_UP; + input->direction |= INPUT_DIRECTION_UP; } if (value & SDL_HAT_DOWN) { - _input->direction |= INPUT_DIRECTION_DOWN; + input->direction |= INPUT_DIRECTION_DOWN; } if (value & SDL_HAT_LEFT) { - _input->direction |= INPUT_DIRECTION_LEFT; + input->direction |= INPUT_DIRECTION_LEFT; } if (value & SDL_HAT_RIGHT) { - _input->direction |= INPUT_DIRECTION_RIGHT; + input->direction |= INPUT_DIRECTION_RIGHT; } } -static void handle_joystickaxismotion(int axis, int value) { +static void handle_joystickaxismotion(int axis, int value, struct input_t *input) { static const int THRESHOLD = 3200; switch (axis) { case 0: - _input->direction &= ~(INPUT_DIRECTION_RIGHT | INPUT_DIRECTION_LEFT); + input->direction &= ~(INPUT_DIRECTION_RIGHT | INPUT_DIRECTION_LEFT); if (value > THRESHOLD) { - _input->direction |= INPUT_DIRECTION_RIGHT; + input->direction |= INPUT_DIRECTION_RIGHT; } else if (value < -THRESHOLD) { - _input->direction |= INPUT_DIRECTION_LEFT; + input->direction |= INPUT_DIRECTION_LEFT; } break; case 1: - _input->direction &= ~(INPUT_DIRECTION_UP | INPUT_DIRECTION_DOWN); + input->direction &= ~(INPUT_DIRECTION_UP | INPUT_DIRECTION_DOWN); if (value > THRESHOLD) { - _input->direction |= INPUT_DIRECTION_DOWN; + input->direction |= INPUT_DIRECTION_DOWN; } else if (value < -THRESHOLD) { - _input->direction |= INPUT_DIRECTION_UP; + input->direction |= INPUT_DIRECTION_UP; } break; } } -static void handle_joystickbutton(int button, int pressed) { +static void handle_joystickbutton(int button, int pressed, struct input_t *input) { if (button == 0) { - _input->space = pressed; + input->space = pressed; } } static int handle_event(const SDL_Event *ev, bool *paused) { switch (ev->type) { case SDL_QUIT: - _input->quit = true; + g_sys.input.quit = true; break; case SDL_WINDOWEVENT: switch (ev->window.event) { @@ -494,10 +520,10 @@ static int handle_event(const SDL_Event *ev, bool *paused) { } break; case SDL_KEYUP: - handle_keyevent(ev->key.keysym.sym, 0); + handle_keyevent(ev->key.keysym.sym, 0, &g_sys.input); break; case SDL_KEYDOWN: - handle_keyevent(ev->key.keysym.sym, 1); + handle_keyevent(ev->key.keysym.sym, 1, &g_sys.input); break; case SDL_CONTROLLERDEVICEADDED: if (!_controller) { @@ -516,37 +542,37 @@ static int handle_event(const SDL_Event *ev, bool *paused) { break; case SDL_CONTROLLERBUTTONUP: if (_controller) { - handle_controllerbutton(ev->cbutton.button, 0); + handle_controllerbutton(ev->cbutton.button, 0, &g_sys.input); } break; case SDL_CONTROLLERBUTTONDOWN: if (_controller) { - handle_controllerbutton(ev->cbutton.button, 1); + handle_controllerbutton(ev->cbutton.button, 1, &g_sys.input); } break; case SDL_CONTROLLERAXISMOTION: if (_controller) { - handle_controlleraxis(ev->caxis.axis, ev->caxis.value); + handle_controlleraxis(ev->caxis.axis, ev->caxis.value, &g_sys.input); } break; case SDL_JOYHATMOTION: if (_joystick) { - handle_joystickhatmotion(ev->jhat.value); + handle_joystickhatmotion(ev->jhat.value, &g_sys.input); } break; case SDL_JOYAXISMOTION: if (_joystick) { - handle_joystickaxismotion(ev->jaxis.axis, ev->jaxis.value); + handle_joystickaxismotion(ev->jaxis.axis, ev->jaxis.value, &g_sys.input); } break; case SDL_JOYBUTTONUP: if (_joystick) { - handle_joystickbutton(ev->jbutton.button, 0); + handle_joystickbutton(ev->jbutton.button, 0, &g_sys.input); } break; case SDL_JOYBUTTONDOWN: if (_joystick) { - handle_joystickbutton(ev->jbutton.button, 1); + handle_joystickbutton(ev->jbutton.button, 1, &g_sys.input); } break; default: @@ -561,7 +587,7 @@ static void sdl2_process_events() { SDL_Event ev; while (SDL_PollEvent(&ev)) { handle_event(&ev, &paused); - if (_input->quit) { + if (g_sys.input.quit) { break; } } @@ -606,39 +632,45 @@ static void sdl2_unlock_audio() { SDL_UnlockAudio(); } -static void render_load_sprites(int spr_type, int count, const struct sys_rect_t *r, const uint8_t *data, int w, int h, int palette_offset, uint8_t color_key) { +static void render_load_sprites(int spr_type, int count, const struct sys_rect_t *r, const uint8_t *data, int w, int h, uint8_t color_key, bool update_pal) { assert(spr_type < ARRAYSIZE(_spritesheets)); - struct spritesheet_t *spr_sheet = &_spritesheets[spr_type]; - spr_sheet->count = count; - spr_sheet->r = (SDL_Rect *)malloc(count * sizeof(SDL_Rect)); + struct spritesheet_t *sheet = &_spritesheets[spr_type]; + sheet->count = count; + sheet->r = (SDL_Rect *)malloc(count * sizeof(SDL_Rect)); for (int i = 0; i < count; ++i) { - SDL_Rect *rect = &spr_sheet->r[i]; + SDL_Rect *rect = &sheet->r[i]; rect->x = r[i].x; rect->y = r[i].y; rect->w = r[i].w; rect->h = r[i].h; } - uint32_t *argb = (uint32_t *)malloc(w * h * sizeof(uint32_t)); - if (!argb) { - print_warning("Failed to allocate RGB buffer for sprites type %d", spr_type); - } else { - spr_sheet->texture = SDL_CreateTexture(_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STATIC, w, h); - SDL_SetTextureBlendMode(spr_sheet->texture, SDL_BLENDMODE_BLEND); - for (int i = 0; i < w * h; ++i) { - argb[i] = (data[i] == color_key) ? 0 : (0xFF000000 | _screen_palette[palette_offset + data[i]]); - } - SDL_UpdateTexture(spr_sheet->texture, 0, argb, w * sizeof(uint32_t)); - free(argb); + SDL_Surface *surface = SDL_CreateRGBSurface(0, w, h, 8, 0x0, 0x0, 0x0, 0x0); + SDL_SetSurfacePalette(surface, _palette); + SDL_SetColorKey(surface, 1, color_key); + SDL_LockSurface(surface); + for (int y = 0; y < h; ++y) { + memcpy(((uint8_t *)surface->pixels) + y * surface->pitch, data + y * w, w); + } + SDL_UnlockSurface(surface); + sheet->texture = SDL_CreateTextureFromSurface(_renderer, surface); + if (update_pal) { /* update texture on palette change */ + sheet->surface = surface; + } else { + SDL_FreeSurface(sheet->surface); + sheet->surface = 0; } } static void render_unload_sprites(int spr_type) { - struct spritesheet_t *spr_sheet = &_spritesheets[spr_type]; - free(spr_sheet->r); - if (spr_sheet->texture) { - SDL_DestroyTexture(spr_sheet->texture); + struct spritesheet_t *sheet = &_spritesheets[spr_type]; + free(sheet->r); + if (sheet->surface) { + SDL_FreeSurface(sheet->surface); } - memset(spr_sheet, 0, sizeof(struct spritesheet_t)); + if (sheet->texture) { + SDL_DestroyTexture(sheet->texture); + } + memset(sheet, 0, sizeof(struct spritesheet_t)); } static void render_add_sprite(int spr_type, int frame, int x, int y, int xflip) {