From 809282edadcdaaa4a90223c968a073f933e713fb Mon Sep 17 00:00:00 2001 From: scawful Date: Sun, 19 Jan 2025 20:16:40 -0500 Subject: [PATCH] remove nonstandard type aliases --- src/app/core/platform/font_loader.cc | 113 ++++++------- src/app/core/project.cc | 3 +- src/app/editor/code/memory_editor.h | 2 +- src/app/editor/editor_manager.cc | 50 +++--- src/app/editor/graphics/screen_editor.cc | 4 +- src/app/editor/overworld/overworld_editor.cc | 8 +- src/app/editor/overworld/overworld_editor.h | 12 +- src/app/editor/sprite/zsprite.h | 8 +- src/app/gfx/bitmap.cc | 19 ++- src/app/gfx/bitmap.h | 8 +- src/app/gfx/compression.cc | 150 +++++++++--------- src/app/gfx/compression.h | 63 ++++---- src/app/gfx/scad_format.cc | 12 +- src/app/gfx/snes_palette.cc | 8 +- src/app/gfx/snes_palette.h | 2 +- src/app/gfx/snes_tile.cc | 10 +- src/app/rom.cc | 8 +- src/app/rom.h | 4 +- src/app/zelda3/dungeon/room.cc | 34 ++-- src/app/zelda3/dungeon/room.h | 6 +- src/app/zelda3/dungeon/room_entrance.h | 24 +-- src/app/zelda3/dungeon/room_object.cc | 4 +- src/app/zelda3/dungeon/room_object.h | 2 +- src/app/zelda3/music/tracker.cc | 6 +- src/app/zelda3/music/tracker.h | 6 +- src/app/zelda3/overworld/overworld.cc | 2 +- src/app/zelda3/overworld/overworld_entrance.h | 18 +-- src/app/zelda3/overworld/overworld_exit.h | 47 +++--- src/app/zelda3/overworld/overworld_map.cc | 14 +- src/app/zelda3/screen/title_screen.cc | 10 +- src/app/zelda3/screen/title_screen.h | 12 +- src/cli/z3ed.cc | 5 +- src/cli/z3ed.h | 2 +- src/{app/core/constants.h => util/macro.h} | 13 +- test/gfx/compression_test.cc | 35 ++-- 35 files changed, 367 insertions(+), 357 deletions(-) rename src/{app/core/constants.h => util/macro.h} (94%) diff --git a/src/app/core/platform/font_loader.cc b/src/app/core/platform/font_loader.cc index 306a53c9..43d3da50 100644 --- a/src/app/core/platform/font_loader.cc +++ b/src/app/core/platform/font_loader.cc @@ -5,13 +5,13 @@ #include #include -#include "app/core/constants.h" #include "absl/status/status.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" #include "app/core/platform/file_dialog.h" #include "app/gui/icons.h" #include "imgui/imgui.h" +#include "util/macro.h" namespace yaze { namespace core { @@ -27,54 +27,54 @@ static const float FONT_SIZE_DEFAULT = 16.0f; static const float FONT_SIZE_DROID_SANS = 18.0f; static const float ICON_FONT_SIZE = 18.0f; - namespace { std::string SetFontPath(const std::string& font_path) { #ifdef __APPLE__ #if TARGET_OS_IOS == 1 - const std::string kBundlePath = GetBundleResourcePath(); - return kBundlePath + font_path; + const std::string kBundlePath = GetBundleResourcePath(); + return kBundlePath + font_path; #else - return absl::StrCat(GetBundleResourcePath(), "Contents/Resources/font/", - font_path); + return absl::StrCat(GetBundleResourcePath(), "Contents/Resources/font/", + font_path); #endif #else - return absl::StrCat("assets/font/", font_path); + return absl::StrCat("assets/font/", font_path); #endif } absl::Status LoadFont(const FontConfig& font_config) { - ImGuiIO& io = ImGui::GetIO(); - std::string actual_font_path = SetFontPath(font_config.font_path); - // Check if the file exists with std library first, since ImGui IO will assert - // if the file does not exist - if (!std::filesystem::exists(actual_font_path)) { - return absl::InternalError( - absl::StrFormat("Font file %s does not exist", actual_font_path)); - } + ImGuiIO& io = ImGui::GetIO(); + std::string actual_font_path = SetFontPath(font_config.font_path); + // Check if the file exists with std library first, since ImGui IO will assert + // if the file does not exist + if (!std::filesystem::exists(actual_font_path)) { + return absl::InternalError( + absl::StrFormat("Font file %s does not exist", actual_font_path)); + } - if (!io.Fonts->AddFontFromFileTTF(actual_font_path.data(), font_config.font_size)) { - return absl::InternalError( - absl::StrFormat("Failed to load font from %s", actual_font_path)); - } - return absl::OkStatus(); + if (!io.Fonts->AddFontFromFileTTF(actual_font_path.data(), + font_config.font_size)) { + return absl::InternalError( + absl::StrFormat("Failed to load font from %s", actual_font_path)); + } + return absl::OkStatus(); } absl::Status AddIconFont() { - ImGuiIO& io = ImGui::GetIO(); - static const ImWchar icons_ranges[] = { ICON_MIN_MD, 0xf900, 0 }; - ImFontConfig icons_config; - icons_config.MergeMode = true; - icons_config.GlyphOffset.y = 5.0f; - icons_config.GlyphMinAdvanceX = 13.0f; - icons_config.PixelSnapH = true; - std::string icon_font_path = SetFontPath(FONT_ICON_FILE_NAME_MD); - if (!io.Fonts->AddFontFromFileTTF(icon_font_path.c_str(), ICON_FONT_SIZE, + ImGuiIO& io = ImGui::GetIO(); + static const ImWchar icons_ranges[] = {ICON_MIN_MD, 0xf900, 0}; + ImFontConfig icons_config; + icons_config.MergeMode = true; + icons_config.GlyphOffset.y = 5.0f; + icons_config.GlyphMinAdvanceX = 13.0f; + icons_config.PixelSnapH = true; + std::string icon_font_path = SetFontPath(FONT_ICON_FILE_NAME_MD); + if (!io.Fonts->AddFontFromFileTTF(icon_font_path.c_str(), ICON_FONT_SIZE, &icons_config, icons_ranges)) { - return absl::InternalError("Failed to add icon fonts"); - } - return absl::OkStatus(); + return absl::InternalError("Failed to add icon fonts"); + } + return absl::OkStatus(); } absl::Status AddJapaneseFont() { @@ -86,8 +86,8 @@ absl::Status AddJapaneseFont() { japanese_font_config.PixelSnapH = true; std::string japanese_font_path = SetFontPath(NOTO_SANS_JP); if (!io.Fonts->AddFontFromFileTTF(japanese_font_path.data(), ICON_FONT_SIZE, - &japanese_font_config, - io.Fonts->GetGlyphRangesJapanese())) { + &japanese_font_config, + io.Fonts->GetGlyphRangesJapanese())) { return absl::InternalError("Failed to add Japanese fonts"); } return absl::OkStatus(); @@ -96,7 +96,7 @@ absl::Status AddJapaneseFont() { } // namespace absl::Status LoadPackageFonts() { - ImGuiIO &io = ImGui::GetIO(); + ImGuiIO& io = ImGui::GetIO(); // Icon configuration static const ImWchar icons_ranges[] = {ICON_MIN_MD, 0xf900, 0}; @@ -114,45 +114,46 @@ absl::Status LoadPackageFonts() { icons_config.PixelSnapH = true; // List of fonts to be loaded - std::vector font_paths = { + std::vector font_paths = { KARLA_REGULAR, ROBOTO_MEDIUM, COUSINE_REGULAR, IBM_PLEX_JP, DROID_SANS}; // Load fonts with associated icon and Japanese merges - for (const auto &font_path : font_paths) { + for (const auto& font_path : font_paths) { float font_size = (font_path == DROID_SANS) ? FONT_SIZE_DROID_SANS : FONT_SIZE_DEFAULT; - FontConfig font_config = { font_path, font_size }; - RETURN_IF_ERROR(LoadFont(font_config)); + FontConfig font_config = {font_path, font_size}; + RETURN_IF_ERROR(LoadFont(font_config)); // Merge icon set - RETURN_IF_ERROR(AddIconFont()); + RETURN_IF_ERROR(AddIconFont()); // Merge Japanese font - RETURN_IF_ERROR(AddJapaneseFont()); + RETURN_IF_ERROR(AddJapaneseFont()); } return absl::OkStatus(); } absl::Status ReloadPackageFont(const FontConfig& config) { - ImGuiIO& io = ImGui::GetIO(); - std::string actual_font_path = SetFontPath(config.font_path); - if (!io.Fonts->AddFontFromFileTTF(actual_font_path.data(), config.font_size)) { - return absl::InternalError( - absl::StrFormat("Failed to load font from %s", actual_font_path)); - } - RETURN_IF_ERROR(AddIconFont()); - RETURN_IF_ERROR(AddJapaneseFont()); + ImGuiIO& io = ImGui::GetIO(); + std::string actual_font_path = SetFontPath(config.font_path); + if (!io.Fonts->AddFontFromFileTTF(actual_font_path.data(), + config.font_size)) { + return absl::InternalError( + absl::StrFormat("Failed to load font from %s", actual_font_path)); + } + RETURN_IF_ERROR(AddIconFont()); + RETURN_IF_ERROR(AddJapaneseFont()); return absl::OkStatus(); } #ifdef _WIN32 #include -int CALLBACK EnumFontFamExProc(const LOGFONT *lpelfe, const TEXTMETRIC *lpntme, +int CALLBACK EnumFontFamExProc(const LOGFONT* lpelfe, const TEXTMETRIC* lpntme, DWORD FontType, LPARAM lParam) { // Step 3: Load the font into ImGui - ImGuiIO &io = ImGui::GetIO(); + ImGuiIO& io = ImGui::GetIO(); io.Fonts->AddFontFromFileTTF(lpelfe->lfFaceName, 16.0f); return 1; @@ -175,8 +176,8 @@ void LoadSystemFonts() { RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL, &valueCount, &maxValueNameSize, &maxValueDataSize, NULL, NULL); - char *valueName = new char[maxValueNameSize + 1]; // +1 for null terminator - BYTE *valueData = new BYTE[maxValueDataSize + 1]; // +1 for null terminator + char* valueName = new char[maxValueNameSize + 1]; // +1 for null terminator + BYTE* valueData = new BYTE[maxValueDataSize + 1]; // +1 for null terminator // Enumerate all font entries for (DWORD i = 0; i < valueCount; i++) { @@ -193,7 +194,7 @@ void LoadSystemFonts() { valueData, &valueDataSize) == ERROR_SUCCESS) { if (valueType == REG_SZ) { // Add the font file path to the vector - std::string fontPath(reinterpret_cast(valueData), + std::string fontPath(reinterpret_cast(valueData), valueDataSize); fontPaths.push_back(fontPath); @@ -207,7 +208,7 @@ void LoadSystemFonts() { RegCloseKey(hKey); } - ImGuiIO &io = ImGui::GetIO(); + ImGuiIO& io = ImGui::GetIO(); // List of common font face names static const std::unordered_set commonFontFaceNames = { @@ -226,7 +227,7 @@ void LoadSystemFonts() { "Tahoma", "Lucida Console"}; - for (auto &fontPath : fontPaths) { + for (auto& fontPath : fontPaths) { // Check if the font path has a "C:\" prefix if (fontPath.substr(0, 2) != "C:") { // Add "C:\Windows\Fonts\" prefix to the font path diff --git a/src/app/core/project.cc b/src/app/core/project.cc index 9eed5206..d5140736 100644 --- a/src/app/core/project.cc +++ b/src/app/core/project.cc @@ -3,10 +3,10 @@ #include #include -#include "app/core/constants.h" #include "app/gui/icons.h" #include "imgui/imgui.h" #include "imgui/misc/cpp/imgui_stdlib.h" +#include "util/macro.h" namespace yaze { @@ -184,5 +184,4 @@ std::string ResourceLabelManager::CreateOrGetLabel( return labels_[type][key]; } - } // namespace yaze diff --git a/src/app/editor/code/memory_editor.h b/src/app/editor/code/memory_editor.h index 28e4131d..a0c926b4 100644 --- a/src/app/editor/code/memory_editor.h +++ b/src/app/editor/code/memory_editor.h @@ -1,13 +1,13 @@ #ifndef YAZE_APP_EDITOR_CODE_MEMORY_EDITOR_H #define YAZE_APP_EDITOR_CODE_MEMORY_EDITOR_H -#include "app/core/constants.h" #include "app/core/platform/file_dialog.h" #include "app/editor/code/memory_editor.h" #include "app/gui/input.h" #include "app/rom.h" #include "imgui/imgui.h" #include "imgui_memory_editor.h" +#include "util/macro.h" namespace yaze { namespace editor { diff --git a/src/app/editor/editor_manager.cc b/src/app/editor/editor_manager.cc index d737d4a4..249132ab 100644 --- a/src/app/editor/editor_manager.cc +++ b/src/app/editor/editor_manager.cc @@ -2,7 +2,6 @@ #include "absl/status/status.h" #include "absl/strings/match.h" -#include "app/core/constants.h" #include "app/core/platform/file_dialog.h" #include "app/core/project.h" #include "app/editor/code/assembly_editor.h" @@ -22,6 +21,7 @@ #include "editor/editor.h" #include "imgui/imgui.h" #include "imgui/misc/cpp/imgui_stdlib.h" +#include "util/macro.h" namespace yaze { namespace editor { @@ -62,7 +62,7 @@ absl::Status EditorManager::Update() { DrawPopups(); if (rom()->is_loaded() && !rom_assets_loaded_) { - auto& sheet_manager = GraphicsSheetManager::GetInstance(); + auto &sheet_manager = GraphicsSheetManager::GetInstance(); ASSIGN_OR_RETURN(*sheet_manager.mutable_gfx_sheets(), LoadAllGraphicsData(*rom())) RETURN_IF_ERROR(overworld_editor_.LoadGraphics()); @@ -357,15 +357,19 @@ void EditorManager::DrawPopups() { } void EditorManager::DrawHomepage() { - TextWrapped("Welcome to the Yet Another Zelda3 Editor (yaze)!"); - TextWrapped("This editor is designed to be a comprehensive tool for editing the Legend of Zelda: A Link to the Past."); - TextWrapped("The editor is still in development, so please report any bugs or issues you encounter."); + TextWrapped("Welcome to the Yet Another Zelda3 Editor (yaze)!"); + TextWrapped( + "This editor is designed to be a comprehensive tool for editing the " + "Legend of Zelda: A Link to the Past."); + TextWrapped( + "The editor is still in development, so please report any bugs or issues " + "you encounter."); - static bool managed_startup = false; - - if (Button("Open ROM", ImVec2(200, 0))) { - LoadRom(); - } + static bool managed_startup = false; + + if (Button("Open ROM", ImVec2(200, 0))) { + LoadRom(); + } SameLine(); ImGui::Checkbox("Manage Startup", &managed_startup); Separator(); @@ -467,18 +471,18 @@ void EditorManager::DrawMenuContent() { flags_menu.DrawSystemFlags(); EndMenu(); } - if (BeginMenu("Overworld Flags")) { - flags_menu.DrawOverworldFlags(); - EndMenu(); - } + if (BeginMenu("Overworld Flags")) { + flags_menu.DrawOverworldFlags(); + EndMenu(); + } if (BeginMenu("Dungeon Flags")) { flags_menu.DrawDungeonFlags(); EndMenu(); } - if (BeginMenu("Resource Flags")) { - flags_menu.DrawResourceFlags(); - EndMenu(); - } + if (BeginMenu("Resource Flags")) { + flags_menu.DrawResourceFlags(); + EndMenu(); + } EndMenu(); } @@ -718,7 +722,7 @@ void EditorManager::LoadRom() { auto file_name = FileDialogWrapper::ShowOpenFileDialog(); auto load_rom = rom()->LoadFromFile(file_name); if (load_rom.ok()) { - current_rom_ = rom(); + current_rom_ = rom(); static RecentFilesManager manager("recent_files.txt"); manager.Load(); manager.AddFile(file_name); @@ -736,8 +740,8 @@ void EditorManager::SaveRom() { RETURN_VOID_IF_ERROR(status_); if (core::ExperimentFlags::get().kSaveGraphicsSheet) - PRINT_IF_ERROR(SaveAllGraphicsData(*rom(), - GraphicsSheetManager::GetInstance().gfx_sheets())); + PRINT_IF_ERROR(SaveAllGraphicsData( + *rom(), GraphicsSheetManager::GetInstance().gfx_sheets())); status_ = rom()->SaveToFile(backup_rom_, save_new_auto_); } @@ -750,13 +754,13 @@ void EditorManager::OpenRomOrProject(const std::string &filename) { } } else { status_ = rom()->LoadFromFile(filename); - current_rom_ = rom(); + current_rom_ = rom(); } } absl::Status EditorManager::OpenProject() { RETURN_IF_ERROR(rom()->LoadFromFile(current_project_.rom_filename_)); - current_rom_ = rom(); + current_rom_ = rom(); if (!rom()->resource_label()->LoadLabels(current_project_.labels_filename_)) { return absl::InternalError( diff --git a/src/app/editor/graphics/screen_editor.cc b/src/app/editor/graphics/screen_editor.cc index ab9826e8..2811a3ae 100644 --- a/src/app/editor/graphics/screen_editor.cc +++ b/src/app/editor/graphics/screen_editor.cc @@ -6,7 +6,6 @@ #include "absl/strings/str_format.h" #include "absl/strings/string_view.h" -#include "app/core/constants.h" #include "app/core/platform/file_dialog.h" #include "app/core/platform/renderer.h" #include "app/gfx/bitmap.h" @@ -17,6 +16,7 @@ #include "app/gui/icons.h" #include "app/gui/input.h" #include "imgui/imgui.h" +#include "util/macro.h" namespace yaze { namespace editor { @@ -128,7 +128,7 @@ absl::Status ScreenEditor::LoadDungeonMaps() { int pc_ptr_gfx = core::SnesToPc(ptr_gfx); // Contains data for the next 25 rooms - ASSIGN_OR_RETURN(ushort boss_room_d, + ASSIGN_OR_RETURN(uint16_t boss_room_d, rom()->ReadWord(zelda3::kDungeonMapBossRooms + (d * 2))); ASSIGN_OR_RETURN(nbr_basement_d, diff --git a/src/app/editor/overworld/overworld_editor.cc b/src/app/editor/overworld/overworld_editor.cc index 2236fe04..841d3a0f 100644 --- a/src/app/editor/overworld/overworld_editor.cc +++ b/src/app/editor/overworld/overworld_editor.cc @@ -7,7 +7,6 @@ #include "absl/status/status.h" #include "absl/strings/str_format.h" -#include "app/core/constants.h" #include "app/core/platform/clipboard.h" #include "app/core/platform/renderer.h" #include "app/editor/graphics/palette_editor.h" @@ -24,6 +23,7 @@ #include "app/zelda3/overworld/overworld.h" #include "imgui/imgui.h" #include "imgui_memory_editor.h" +#include "util/macro.h" namespace yaze { namespace editor { @@ -1041,7 +1041,7 @@ absl::Status OverworldEditor::LoadGraphics() { core::logf("Loading overworld tile16 graphics."); // Loop through the tiles and copy their pixel data into separate vectors - for (uint i = 0; i < zelda3::kNumTile16Individual; i++) { + for (unsigned int i = 0; i < zelda3::kNumTile16Individual; i++) { tile16_individual_[i].Create(kTile16Size, kTile16Size, 0x08, kTile16Size * kTile16Size); @@ -1214,7 +1214,7 @@ absl::Status OverworldEditor::RefreshTile16Blockset() { // Loop through the tiles and copy their pixel data into separate vectors std::vector> futures; - for (uint i = 0; i < zelda3::kNumTile16Individual; i++) { + for (unsigned int i = 0; i < zelda3::kNumTile16Individual; i++) { futures.push_back(std::async( std::launch::async, [&](int index) -> absl::Status { @@ -1241,7 +1241,7 @@ absl::Status OverworldEditor::RefreshTile16Blockset() { } // Render the bitmaps of each tile. - for (uint id = 0; id < zelda3::kNumTile16Individual; id++) { + for (unsigned int id = 0; id < zelda3::kNumTile16Individual; id++) { Renderer::GetInstance().UpdateBitmap(&tile16_individual_[id]); } diff --git a/src/app/editor/overworld/overworld_editor.h b/src/app/editor/overworld/overworld_editor.h index cdb78424..4a6dfba3 100644 --- a/src/app/editor/overworld/overworld_editor.h +++ b/src/app/editor/overworld/overworld_editor.h @@ -18,12 +18,12 @@ namespace yaze { namespace editor { -constexpr uint k4BPP = 4; -constexpr uint kByteSize = 3; -constexpr uint kMessageIdSize = 5; -constexpr uint kNumSheetsToLoad = 223; -constexpr uint kTile8DisplayHeight = 64; -constexpr uint kOverworldMapSize = 0x200; +constexpr unsigned int k4BPP = 4; +constexpr unsigned int kByteSize = 3; +constexpr unsigned int kMessageIdSize = 5; +constexpr unsigned int kNumSheetsToLoad = 223; +constexpr unsigned int kTile8DisplayHeight = 64; +constexpr unsigned int kOverworldMapSize = 0x200; constexpr float kInputFieldSize = 30.f; constexpr ImVec2 kOverworldCanvasSize(kOverworldMapSize * 8, kOverworldMapSize * 8); diff --git a/src/app/editor/sprite/zsprite.h b/src/app/editor/sprite/zsprite.h index 4c2c055f..a9ac2361 100644 --- a/src/app/editor/sprite/zsprite.h +++ b/src/app/editor/sprite/zsprite.h @@ -6,8 +6,8 @@ #include #include -#include "app/core/constants.h" #include "absl/status/status.h" +#include "util/macro.h" namespace yaze { namespace editor { @@ -106,8 +106,8 @@ struct ZSprite { offset += sizeof(int); for (int j = 0; j < tCount; j++) { - ushort tid = *reinterpret_cast(&buffer[offset]); - offset += sizeof(ushort); + uint16_t tid = *reinterpret_cast(&buffer[offset]); + offset += sizeof(uint16_t); uint8_t tpal = *reinterpret_cast(&buffer[offset]); offset += sizeof(uint8_t); bool tmx = *reinterpret_cast(&buffer[offset]); @@ -246,7 +246,7 @@ struct ZSprite { for (int j = 0; j < editor.Frames[i].Tiles.size(); j++) { fs.write(reinterpret_cast(&editor.Frames[i].Tiles[j].id), - sizeof(ushort)); + sizeof(uint16_t)); fs.write( reinterpret_cast(&editor.Frames[i].Tiles[j].palette), sizeof(uint8_t)); diff --git a/src/app/gfx/bitmap.cc b/src/app/gfx/bitmap.cc index 576d7bae..942ab43a 100644 --- a/src/app/gfx/bitmap.cc +++ b/src/app/gfx/bitmap.cc @@ -9,13 +9,8 @@ #include #include "absl/status/status.h" -#include "app/core/constants.h" #include "app/gfx/snes_palette.h" - -#define SDL_RETURN_IF_ERROR() \ - if (SDL_GetError() != nullptr) { \ - return absl::InternalError(SDL_GetError()); \ - } +#include "util/macro.h" namespace yaze { namespace gfx { @@ -218,7 +213,8 @@ Bitmap::Bitmap(int width, int height, int depth, int data_size) { Create(width, height, depth, std::vector(data_size, 0)); } -void Bitmap::Initialize(int width, int height, int depth, std::span& data) { +void Bitmap::Initialize(int width, int height, int depth, + std::span &data) { width_ = width; height_ = height; depth_ = depth; @@ -259,7 +255,8 @@ void Bitmap::Create(int width, int height, int depth, int format, GetSnesPixelFormat(format)), SDL_Surface_Deleter{}}; if (surface_ == nullptr) { - SDL_Log("Bitmap::Create.SDL_CreateRGBSurfaceWithFormat failed: %s\n", SDL_GetError()); + SDL_Log("Bitmap::Create.SDL_CreateRGBSurfaceWithFormat failed: %s\n", + SDL_GetError()); active_ = false; return; } @@ -293,7 +290,8 @@ void Bitmap::CreateTexture(SDL_Renderer *renderer) { SDL_TEXTUREACCESS_STREAMING, width_, height_), SDL_Texture_Deleter{}}; if (texture_ == nullptr) { - SDL_Log("Bitmap::CreateTexture.SDL_CreateTextureFromSurface failed: %s\n", SDL_GetError()); + SDL_Log("Bitmap::CreateTexture.SDL_CreateTextureFromSurface failed: %s\n", + SDL_GetError()); } texture_pixels = data_.data(); @@ -301,7 +299,8 @@ void Bitmap::CreateTexture(SDL_Renderer *renderer) { SDL_ConvertSurfaceFormat(surface_.get(), SDL_PIXELFORMAT_ARGB8888, 0), SDL_Surface_Deleter{}}; if (converted_surface_ == nullptr) { - SDL_Log("Bitmap::CreateTexture.SDL_ConvertSurfaceFormat failed: %s\n", SDL_GetError()); + SDL_Log("Bitmap::CreateTexture.SDL_ConvertSurfaceFormat failed: %s\n", + SDL_GetError()); return; } diff --git a/src/app/gfx/bitmap.h b/src/app/gfx/bitmap.h index f1fcef0c..b08a0e6a 100644 --- a/src/app/gfx/bitmap.h +++ b/src/app/gfx/bitmap.h @@ -7,9 +7,9 @@ #include #include "absl/status/status.h" -#include "app/core/constants.h" #include "app/core/platform/sdl_deleter.h" #include "app/gfx/snes_palette.h" +#include "util/macro.h" namespace yaze { @@ -91,10 +91,10 @@ class Bitmap { void SaveSurfaceToFile(std::string_view filename); - void Initialize(int width, int height, int depth, std::span& data); + void Initialize(int width, int height, int depth, std::span &data); void Create(int width, int height, int depth, int data_size) { - Create(width, height, depth, std::vector(data_size, 0)); + Create(width, height, depth, std::vector(data_size, 0)); } void Create(int width, int height, int depth, std::span data); void Create(int width, int height, int depth, @@ -133,7 +133,7 @@ class Bitmap { void Get16x16Tile(int tile_x, int tile_y, std::vector &tile_data, int &tile_data_offset); - void WriteToPixel(int position, uchar value) { + void WriteToPixel(int position, uint8_t value) { if (pixel_data_ == nullptr) { pixel_data_ = data_.data(); } diff --git a/src/app/gfx/compression.cc b/src/app/gfx/compression.cc index c696dd38..bf2c0bc1 100644 --- a/src/app/gfx/compression.cc +++ b/src/app/gfx/compression.cc @@ -6,8 +6,8 @@ #include "absl/status/status.h" #include "absl/status/statusor.h" -#include "app/core/constants.h" #include "app/rom.h" +#include "util/macro.h" #define DEBUG_LOG(msg) std::cout << msg << std::endl @@ -174,7 +174,7 @@ std::vector HyruleMagicDecompress(uint8_t const* src, int* const size, unsigned short c, d; for (;;) { - // retrieve a uchar from the buffer. + // retrieve a uint8_t from the buffer. a = *(src++); // end the decompression routine if we encounter 0xff. @@ -320,10 +320,10 @@ void PrintCompressionChain(const CompressionPiecePointer& chain_head) { } } -void CheckByteRepeat(const uchar* rom_data, DataSizeArray& data_size_taken, +void CheckByteRepeat(const uint8_t* rom_data, DataSizeArray& data_size_taken, CommandArgumentArray& cmd_args, uint& src_data_pos, - const uint last_pos) { - uint pos = src_data_pos; + const unsigned int last_pos) { + unsigned int pos = src_data_pos; char byte_to_repeat = rom_data[pos]; while (pos <= last_pos && rom_data[pos] == byte_to_repeat) { data_size_taken[kCommandByteFill]++; @@ -332,12 +332,12 @@ void CheckByteRepeat(const uchar* rom_data, DataSizeArray& data_size_taken, cmd_args[kCommandByteFill][0] = byte_to_repeat; } -void CheckWordRepeat(const uchar* rom_data, DataSizeArray& data_size_taken, +void CheckWordRepeat(const uint8_t* rom_data, DataSizeArray& data_size_taken, CommandArgumentArray& cmd_args, uint& src_data_pos, - const uint last_pos) { + const unsigned int last_pos) { if (src_data_pos + 2 <= last_pos && rom_data[src_data_pos] != rom_data[src_data_pos + 1]) { - uint pos = src_data_pos; + unsigned int pos = src_data_pos; char byte1 = rom_data[pos]; char byte2 = rom_data[pos + 1]; pos += 2; @@ -354,10 +354,10 @@ void CheckWordRepeat(const uchar* rom_data, DataSizeArray& data_size_taken, } } -void CheckIncByte(const uchar* rom_data, DataSizeArray& data_size_taken, +void CheckIncByte(const uint8_t* rom_data, DataSizeArray& data_size_taken, CommandArgumentArray& cmd_args, uint& src_data_pos, - const uint last_pos) { - uint pos = src_data_pos; + const unsigned int last_pos) { + unsigned int pos = src_data_pos; char byte = rom_data[pos]; pos++; data_size_taken[kCommandIncreasingFill] = 1; @@ -370,14 +370,14 @@ void CheckIncByte(const uchar* rom_data, DataSizeArray& data_size_taken, cmd_args[kCommandIncreasingFill][0] = rom_data[src_data_pos]; } -void CheckIntraCopy(const uchar* rom_data, DataSizeArray& data_size_taken, +void CheckIntraCopy(const uint8_t* rom_data, DataSizeArray& data_size_taken, CommandArgumentArray& cmd_args, uint& src_data_pos, - const uint last_pos, uint start) { + const unsigned int last_pos, unsigned int start) { if (src_data_pos != start) { - uint searching_pos = start; - uint current_pos_u = src_data_pos; - uint copied_size = 0; - uint search_start = start; + unsigned int searching_pos = start; + unsigned int current_pos_u = src_data_pos; + unsigned int copied_size = 0; + unsigned int search_start = start; while (searching_pos < src_data_pos && current_pos_u <= last_pos) { while (rom_data[current_pos_u] != rom_data[searching_pos] && @@ -409,8 +409,8 @@ void CheckIntraCopy(const uchar* rom_data, DataSizeArray& data_size_taken, void ValidateForByteGain(const DataSizeArray& data_size_taken, const CommandSizeArray& cmd_size, uint& max_win, uint& cmd_with_max) { - for (uint cmd_i = 1; cmd_i < 5; cmd_i++) { - uint cmd_size_taken = data_size_taken[cmd_i]; + for (unsigned int cmd_i = 1; cmd_i < 5; cmd_i++) { + unsigned int cmd_size_taken = data_size_taken[cmd_i]; // TODO(@scawful): Replace conditional with table of command sizes // "Table that is even with copy but all other cmd are 2" auto table_check = @@ -424,7 +424,7 @@ void ValidateForByteGain(const DataSizeArray& data_size_taken, } } -void CompressionCommandAlternative(const uchar* rom_data, +void CompressionCommandAlternative(const uint8_t* rom_data, CompressionPiecePointer& compressed_chain, const CommandSizeArray& cmd_size, const CommandArgumentArray& cmd_args, @@ -459,9 +459,9 @@ void CompressionCommandAlternative(const uchar* rom_data, comp_accumulator = 0; } -void CheckByteRepeatV2(const uchar* data, uint& src_pos, const uint last_pos, +void CheckByteRepeatV2(const uint8_t* data, uint& src_pos, const unsigned int last_pos, CompressionCommand& cmd) { - uint i = 0; + unsigned int i = 0; while (src_pos + i < last_pos && data[src_pos] == data[src_pos + i]) { ++i; } @@ -469,10 +469,10 @@ void CheckByteRepeatV2(const uchar* data, uint& src_pos, const uint last_pos, cmd.arguments[kCommandByteFill][0] = data[src_pos]; } -void CheckWordRepeatV2(const uchar* data, uint& src_pos, const uint last_pos, +void CheckWordRepeatV2(const uint8_t* data, uint& src_pos, const unsigned int last_pos, CompressionCommand& cmd) { if (src_pos + 2 <= last_pos && data[src_pos] != data[src_pos + 1]) { - uint pos = src_pos; + unsigned int pos = src_pos; char byte1 = data[pos]; char byte2 = data[pos + 1]; pos += 2; @@ -489,9 +489,9 @@ void CheckWordRepeatV2(const uchar* data, uint& src_pos, const uint last_pos, } } -void CheckIncByteV2(const uchar* rom_data, uint& src_data_pos, - const uint last_pos, CompressionCommand& cmd) { - uint pos = src_data_pos; +void CheckIncByteV2(const uint8_t* rom_data, uint& src_data_pos, + const unsigned int last_pos, CompressionCommand& cmd) { + unsigned int pos = src_data_pos; char byte = rom_data[pos]; pos++; cmd.data_size[kCommandIncreasingFill] = 1; @@ -504,14 +504,14 @@ void CheckIncByteV2(const uchar* rom_data, uint& src_data_pos, cmd.arguments[kCommandIncreasingFill][0] = rom_data[src_data_pos]; } -void CheckIntraCopyV2(const uchar* rom_data, uint& src_data_pos, - const uint last_pos, uint start, +void CheckIntraCopyV2(const uint8_t* rom_data, uint& src_data_pos, + const unsigned int last_pos, unsigned int start, CompressionCommand& cmd) { if (src_data_pos != start) { - uint searching_pos = start; - uint current_pos_u = src_data_pos; - uint copied_size = 0; - uint search_start = start; + unsigned int searching_pos = start; + unsigned int current_pos_u = src_data_pos; + unsigned int copied_size = 0; + unsigned int search_start = start; while (searching_pos < src_data_pos && current_pos_u <= last_pos) { while (rom_data[current_pos_u] != rom_data[searching_pos] && @@ -544,8 +544,8 @@ const std::array kCommandSizes = {1, 2, 2, 2, 3}; // TODO(@scawful): TEST ME void ValidateForByteGainV2(const CompressionCommand& cmd, uint& max_win, uint& cmd_with_max) { - for (uint cmd_i = 1; cmd_i < 5; cmd_i++) { - uint cmd_size_taken = cmd.data_size[cmd_i]; + for (unsigned int cmd_i = 1; cmd_i < 5; cmd_i++) { + unsigned int cmd_size_taken = cmd.data_size[cmd_i]; // Check if the command size exceeds the maximum win and the size in the // command sizes table, except for the repeating bytes command when the size // taken is 3 @@ -558,7 +558,7 @@ void ValidateForByteGainV2(const CompressionCommand& cmd, uint& max_win, } } -void CompressionCommandAlternativeV2(const uchar* rom_data, +void CompressionCommandAlternativeV2(const uint8_t* rom_data, const CompressionCommand& cmd, CompressionPiecePointer& compressed_chain, uint& src_data_pos, uint& comp_accumulator, @@ -593,7 +593,7 @@ void CompressionCommandAlternativeV2(const uchar* rom_data, } void AddAlternativeCompressionCommand( - const uchar* rom_data, CompressionPiecePointer& compressed_chain, + const uint8_t* rom_data, CompressionPiecePointer& compressed_chain, const CompressionCommand& command, uint& source_data_position, uint& uncompressed_data_size, uint& best_command, uint& best_command_gain) { std::cout << "- Identified a gain from command: " << best_command @@ -642,7 +642,7 @@ void AddAlternativeCompressionCommand( absl::StatusOr SplitCompressionPiece( CompressionPiecePointer& piece, int mode) { CompressionPiecePointer new_piece; - uint length_left = piece->length - kMaxLengthCompression; + unsigned int length_left = piece->length - kMaxLengthCompression; piece->length = kMaxLengthCompression; switch (piece->command) { @@ -670,7 +670,7 @@ absl::StatusOr SplitCompressionPiece( } case kCommandRepeatingBytes: { piece->argument_length = kMaxLengthCompression; - uint offset = piece->argument[0] + (piece->argument[1] << 8); + unsigned int offset = piece->argument[0] + (piece->argument[1] << 8); new_piece = std::make_shared( piece->command, length_left, piece->argument, piece->argument_length); if (mode == kNintendoMode2) { @@ -694,7 +694,7 @@ absl::StatusOr SplitCompressionPiece( std::vector CreateCompressionString(CompressionPiecePointer& start, int mode) { - uint pos = 0; + unsigned int pos = 0; auto piece = start; std::vector output; @@ -704,7 +704,8 @@ std::vector CreateCompressionString(CompressionPiecePointer& start, pos++; } else { if (piece->length <= kMaxLengthCompression) { - output.push_back(kCompressionStringMod | ((uchar)piece->command << 2) | + output.push_back(kCompressionStringMod | + ((uint8_t)piece->command << 2) | (((piece->length - 1) & 0xFF00) >> 8)); pos++; printf("Building extended header : cmd: %d, length: %d - %02X\n", @@ -777,7 +778,7 @@ CompressionPiecePointer MergeCopy(CompressionPiecePointer& start) { if (piece->command == kCommandDirectCopy && piece->next != nullptr && piece->next->command == kCommandDirectCopy && piece->length + piece->next->length <= kMaxLengthCompression) { - uint previous_length = piece->length; + unsigned int previous_length = piece->length; piece->length = piece->length + piece->next->length; for (int i = 0; i < piece->next->argument_length; ++i) { @@ -795,7 +796,7 @@ CompressionPiecePointer MergeCopy(CompressionPiecePointer& start) { return start; } -absl::StatusOr> CompressV2(const uchar* data, +absl::StatusOr> CompressV2(const uint8_t* data, const int start, const int length, int mode, bool check) { @@ -814,9 +815,9 @@ absl::StatusOr> CompressV2(const uchar* data, /*cmd_size*/ {0, 1, 2, 1, 2}, /*data_size*/ {0, 0, 0, 0, 0}}; - uint src_pos = start; - uint last_pos = start + length - 1; - uint comp_accumulator = 0; // Used when skipping using copy + unsigned int src_pos = start; + unsigned int last_pos = start + length - 1; + unsigned int comp_accumulator = 0; // Used when skipping using copy while (true) { current_cmd.data_size.fill({}); @@ -827,8 +828,8 @@ absl::StatusOr> CompressV2(const uchar* data, CheckIncByteV2(data, src_pos, last_pos, current_cmd); CheckIntraCopyV2(data, src_pos, last_pos, start, current_cmd); - uint max_win = 2; - uint cmd_with_max = kCommandDirectCopy; + unsigned int max_win = 2; + unsigned int cmd_with_max = kCommandDirectCopy; ValidateForByteGain(current_cmd.data_size, current_cmd.cmd_size, max_win, cmd_with_max); // ValidateForByteGainV2(current_cmd, max_win, cmd_with_max); @@ -871,13 +872,13 @@ absl::StatusOr> CompressV2(const uchar* data, return CreateCompressionString(compressed_chain_start->next, mode); } -absl::StatusOr> CompressGraphics(const uchar* data, +absl::StatusOr> CompressGraphics(const uint8_t* data, const int pos, const int length) { return CompressV2(data, pos, length, kNintendoMode2); } -absl::StatusOr> CompressOverworld(const uchar* data, +absl::StatusOr> CompressOverworld(const uint8_t* data, const int pos, const int length) { return CompressV2(data, pos, length, kNintendoMode1); @@ -889,7 +890,7 @@ absl::StatusOr> CompressOverworld( } void CheckByteRepeatV3(CompressionContext& context) { - uint pos = context.src_pos; + unsigned int pos = context.src_pos; // Ensure the sequence does not start with an uncompressable byte if (pos == 0 || context.data[pos - 1] != context.data[pos]) { @@ -910,7 +911,7 @@ void CheckByteRepeatV3(CompressionContext& context) { void CheckWordRepeatV3(CompressionContext& context) { if (context.src_pos + 1 <= context.last_pos) { // Changed the condition here - uint pos = context.src_pos; + unsigned int pos = context.src_pos; char byte1 = context.data[pos]; char byte2 = context.data[pos + 1]; pos += 2; @@ -935,7 +936,7 @@ void CheckWordRepeatV3(CompressionContext& context) { } void CheckIncByteV3(CompressionContext& context) { - uint pos = context.src_pos; + unsigned int pos = context.src_pos; uint8_t byte = context.data[pos]; pos++; context.current_cmd.data_size[kCommandIncreasingFill] = 1; @@ -974,8 +975,8 @@ void CheckIntraCopyV3(CompressionContext& context) { // beginning if (context.src_pos > 0 && context.src_pos + window_size <= context.data.size()) { - uint max_copied_size = 0; - uint best_search_start = 0; + unsigned int max_copied_size = 0; + unsigned int best_search_start = 0; // Slide the window over the source data for (int win_pos = 1; win_pos < window_size && win_pos < context.src_pos; @@ -991,7 +992,7 @@ void CheckIntraCopyV3(CompressionContext& context) { if (found_pos != search_end) { // Check the entire length of the match - uint len = 0; + unsigned int len = 0; while (context.src_pos + len < context.data.size() && context.data[context.src_pos + len] == *(found_pos + len)) { len++; @@ -1047,8 +1048,8 @@ void DetermineBestCompression(CompressionContext& context) { // Start with the default scenario. context.cmd_with_max = kCommandDirectCopy; - for (uint cmd_i = 1; cmd_i < 5; cmd_i++) { - uint cmd_size_taken = context.current_cmd.data_size[cmd_i]; + for (unsigned int cmd_i = 1; cmd_i < 5; cmd_i++) { + unsigned int cmd_size_taken = context.current_cmd.data_size[cmd_i]; int net_savings = cmd_size_taken - context.current_cmd.cmd_size[cmd_i]; // Skip commands that aren't efficient. @@ -1193,7 +1194,7 @@ absl::Status ValidateCompressionResultV3(const CompressionContext& context) { absl::StatusOr SplitCompressionPieceV3( CompressionPiece& piece, int mode) { CompressionPiece new_piece; - uint length_left = piece.length - kMaxLengthCompression; + unsigned int length_left = piece.length - kMaxLengthCompression; piece.length = kMaxLengthCompression; switch (piece.command) { @@ -1220,7 +1221,7 @@ absl::StatusOr SplitCompressionPieceV3( } case kCommandRepeatingBytes: { piece.argument_length = kMaxLengthCompression; - uint offset = piece.argument[0] + (piece.argument[1] << 8); + unsigned int offset = piece.argument[0] + (piece.argument[1] << 8); new_piece = CompressionPiece(piece.command, length_left, piece.argument, piece.argument_length); if (mode == kNintendoMode2) { @@ -1242,7 +1243,7 @@ absl::StatusOr SplitCompressionPieceV3( } void FinalizeCompression(CompressionContext& context) { - uint pos = 0; + unsigned int pos = 0; for (CompressionPiece& piece : context.compression_pieces) { if (piece.length <= kMaxLengthNormalHeader) { // Normal Header @@ -1252,7 +1253,7 @@ void FinalizeCompression(CompressionContext& context) { } else { if (piece.length <= kMaxLengthCompression) { context.compression_string.push_back( - kCompressionStringMod | ((uchar)piece.command << 2) | + kCompressionStringMod | ((uint8_t)piece.command << 2) | (((piece.length - 1) & 0xFF00) >> 8)); pos++; std::cout << "Building extended header : cmd: " << piece.command @@ -1340,7 +1341,7 @@ absl::StatusOr> CompressV3( context.compressed_data.end()); } -std::string SetBuffer(const uchar* data, int src_pos, int comp_accumulator) { +std::string SetBuffer(const uint8_t* data, int src_pos, int comp_accumulator) { std::string buffer; for (int i = 0; i < comp_accumulator; ++i) { buffer.push_back(data[i + src_pos - comp_accumulator]); @@ -1357,7 +1358,7 @@ std::string SetBuffer(const std::vector& data, int src_pos, return buffer; } -void memfill(const uchar* data, std::vector& buffer, int buffer_pos, +void memfill(const uint8_t* data, std::vector& buffer, int buffer_pos, int offset, int length) { auto a = data[offset]; auto b = data[offset + 1]; @@ -1367,17 +1368,18 @@ void memfill(const uchar* data, std::vector& buffer, int buffer_pos, } } -absl::StatusOr> DecompressV2(const uchar* data, int offset, - int size, int mode) { +absl::StatusOr> DecompressV2(const uint8_t* data, + int offset, int size, + int mode) { if (size == 0) { return std::vector(); } std::vector buffer(size, 0); - uint length = 0; - uint buffer_pos = 0; - uchar command = 0; - uchar header = data[offset]; + unsigned int length = 0; + unsigned int buffer_pos = 0; + uint8_t command = 0; + uint8_t header = data[offset]; while (header != kSnesByteMax) { if ((header & kExpandedMod) == kExpandedMod) { @@ -1418,8 +1420,8 @@ absl::StatusOr> DecompressV2(const uchar* data, int offset, offset += 1; // Advance 1 byte in the ROM } break; case kCommandRepeatingBytes: { - ushort s1 = ((data[offset + 1] & kSnesByteMax) << 8); - ushort s2 = (data[offset] & kSnesByteMax); + uint16_t s1 = ((data[offset + 1] & kSnesByteMax) << 8); + uint16_t s2 = (data[offset] & kSnesByteMax); int addr = (s1 | s2); if (mode == kNintendoMode1) { // Reversed byte order for // overworld maps @@ -1454,12 +1456,12 @@ absl::StatusOr> DecompressV2(const uchar* data, int offset, return buffer; } -absl::StatusOr> DecompressGraphics(const uchar* data, +absl::StatusOr> DecompressGraphics(const uint8_t* data, int pos, int size) { return DecompressV2(data, pos, size, kNintendoMode2); } -absl::StatusOr> DecompressOverworld(const uchar* data, +absl::StatusOr> DecompressOverworld(const uint8_t* data, int pos, int size) { return DecompressV2(data, pos, size, kNintendoMode1); } diff --git a/src/app/gfx/compression.h b/src/app/gfx/compression.h index f074a788..dd51ad19 100644 --- a/src/app/gfx/compression.h +++ b/src/app/gfx/compression.h @@ -1,13 +1,14 @@ #ifndef YAZE_APP_GFX_COMPRESSION_H #define YAZE_APP_GFX_COMPRESSION_H +#include #include #include #include #include "absl/status/status.h" #include "absl/status/statusor.h" -#include "app/core/constants.h" +#include "util/macro.h" #define BUILD_HEADER(command, length) (command << 5) + (length - 1) @@ -94,27 +95,27 @@ void PrintCompressionChain(const CompressionPiecePointer& chain_head); // Compression V1 -void CheckByteRepeat(const uchar* rom_data, DataSizeArray& data_size_taken, +void CheckByteRepeat(const uint8_t* rom_data, DataSizeArray& data_size_taken, CommandArgumentArray& cmd_args, uint& src_data_pos, - const uint last_pos); + const unsigned int last_pos); -void CheckWordRepeat(const uchar* rom_data, DataSizeArray& data_size_taken, +void CheckWordRepeat(const uint8_t* rom_data, DataSizeArray& data_size_taken, CommandArgumentArray& cmd_args, uint& src_data_pos, - const uint last_pos); + const unsigned int last_pos); -void CheckIncByte(const uchar* rom_data, DataSizeArray& data_size_taken, +void CheckIncByte(const uint8_t* rom_data, DataSizeArray& data_size_taken, CommandArgumentArray& cmd_args, uint& src_data_pos, - const uint last_pos); + const unsigned int last_pos); -void CheckIntraCopy(const uchar* rom_data, DataSizeArray& data_size_taken, +void CheckIntraCopy(const uint8_t* rom_data, DataSizeArray& data_size_taken, CommandArgumentArray& cmd_args, uint& src_data_pos, - const uint last_pos, uint start); + const unsigned int last_pos, unsigned int start); void ValidateForByteGain(const DataSizeArray& data_size_taken, const CommandSizeArray& cmd_size, uint& max_win, uint& cmd_with_max); -void CompressionCommandAlternative(const uchar* rom_data, +void CompressionCommandAlternative(const uint8_t* rom_data, CompressionPiecePointer& compressed_chain, const CommandSizeArray& cmd_size, const CommandArgumentArray& cmd_args, @@ -123,22 +124,22 @@ void CompressionCommandAlternative(const uchar* rom_data, // Compression V2 -void CheckByteRepeatV2(const uchar* data, uint& src_pos, const uint last_pos, +void CheckByteRepeatV2(const uint8_t* data, uint& src_pos, const unsigned int last_pos, CompressionCommand& cmd); -void CheckWordRepeatV2(const uchar* data, uint& src_pos, const uint last_pos, +void CheckWordRepeatV2(const uint8_t* data, uint& src_pos, const unsigned int last_pos, CompressionCommand& cmd); -void CheckIncByteV2(const uchar* data, uint& src_pos, const uint last_pos, +void CheckIncByteV2(const uint8_t* data, uint& src_pos, const unsigned int last_pos, CompressionCommand& cmd); -void CheckIntraCopyV2(const uchar* data, uint& src_pos, const uint last_pos, - uint start, CompressionCommand& cmd); +void CheckIntraCopyV2(const uint8_t* data, uint& src_pos, const unsigned int last_pos, + unsigned int start, CompressionCommand& cmd); void ValidateForByteGainV2(const CompressionCommand& cmd, uint& max_win, uint& cmd_with_max); -void CompressionCommandAlternativeV2(const uchar* data, +void CompressionCommandAlternativeV2(const uint8_t* data, const CompressionCommand& cmd, CompressionPiecePointer& compressed_chain, uint& src_pos, uint& comp_accumulator, @@ -148,15 +149,15 @@ void CompressionCommandAlternativeV2(const uchar* data, * @brief Compresses a buffer of data using the LC_LZ2 algorithm. * \deprecated Use HyruleMagicDecompress instead. */ -absl::StatusOr> CompressV2(const uchar* data, +absl::StatusOr> CompressV2(const uint8_t* data, const int start, const int length, int mode = 1, bool check = false); -absl::StatusOr> CompressGraphics(const uchar* data, +absl::StatusOr> CompressGraphics(const uint8_t* data, const int pos, const int length); -absl::StatusOr> CompressOverworld(const uchar* data, +absl::StatusOr> CompressOverworld(const uint8_t* data, const int pos, const int length); absl::StatusOr> CompressOverworld( @@ -178,12 +179,12 @@ struct CompressionContext { std::vector compressed_data; std::vector compression_pieces; std::vector compression_string; - uint src_pos; - uint last_pos; - uint start; - uint comp_accumulator = 0; - uint cmd_with_max = kCommandDirectCopy; - uint max_win = 0; + unsigned int src_pos; + unsigned int last_pos; + unsigned int start; + unsigned int comp_accumulator = 0; + unsigned int cmd_with_max = kCommandDirectCopy; + unsigned int max_win = 0; CompressionCommand current_cmd = {}; int mode; @@ -227,8 +228,8 @@ absl::StatusOr> CompressV3( std::string SetBuffer(const std::vector& data, int src_pos, int comp_accumulator); -std::string SetBuffer(const uchar* data, int src_pos, int comp_accumulator); -void memfill(const uchar* data, std::vector& buffer, int buffer_pos, +std::string SetBuffer(const uint8_t* data, int src_pos, int comp_accumulator); +void memfill(const uint8_t* data, std::vector& buffer, int buffer_pos, int offset, int length); /** @@ -236,12 +237,12 @@ void memfill(const uchar* data, std::vector& buffer, int buffer_pos, * @note Works well for graphics but not overworld data. Prefer Hyrule Magic * routines for overworld data. */ -absl::StatusOr> DecompressV2(const uchar* data, int offset, - int size = 0x800, +absl::StatusOr> DecompressV2(const uint8_t* data, + int offset, int size = 0x800, int mode = 1); -absl::StatusOr> DecompressGraphics(const uchar* data, +absl::StatusOr> DecompressGraphics(const uint8_t* data, int pos, int size); -absl::StatusOr> DecompressOverworld(const uchar* data, +absl::StatusOr> DecompressOverworld(const uint8_t* data, int pos, int size); absl::StatusOr> DecompressOverworld( const std::vector data, int pos, int size); diff --git a/src/app/gfx/scad_format.cc b/src/app/gfx/scad_format.cc index 06b6b2a2..0012c7b7 100644 --- a/src/app/gfx/scad_format.cc +++ b/src/app/gfx/scad_format.cc @@ -8,8 +8,8 @@ #include #include "absl/status/status.h" -#include "app/core/constants.h" #include "app/gfx/snes_tile.h" +#include "util/macro.h" namespace yaze { namespace gfx { @@ -90,11 +90,11 @@ absl::Status LoadScr(std::string_view filename, uint8_t input_value, i += 2) { auto b1_pos = (i - (input_value * 0x400)); map_data[b1_pos] = gfx::TileInfoToShort( - gfx::GetTilesInfo((ushort)scr_data[md + (i * 2)])); + gfx::GetTilesInfo((uint16_t)scr_data[md + (i * 2)])); auto b2_pos = (i - (input_value * 0x400) + 1); map_data[b2_pos] = gfx::TileInfoToShort( - gfx::GetTilesInfo((ushort)scr_data[md + (i * 2) + 2])); + gfx::GetTilesInfo((uint16_t)scr_data[md + (i * 2) + 2])); } // 0x900 @@ -111,7 +111,7 @@ absl::Status LoadScr(std::string_view filename, uint8_t input_value, for (int i = 0; i < 0x1000 - offset; i++) { map_data[i] = gfx::TileInfoToShort( - gfx::GetTilesInfo((ushort)scr_data[((i + offset) * 2)])); + gfx::GetTilesInfo((uint16_t)scr_data[((i + offset) * 2)])); } } return absl::OkStatus(); @@ -144,9 +144,9 @@ absl::Status DrawScrWithCgx(uint8_t bpp, std::vector& map_data, if (bpp != 8) { map_bitmap_data[index] = - (uchar)((pixel & 0xFF) + t.palette_ * 16); + (uint8_t)((pixel & 0xFF) + t.palette_ * 16); } else { - map_bitmap_data[index] = (uchar)(pixel & 0xFF); + map_bitmap_data[index] = (uint8_t)(pixel & 0xFF); } } } diff --git a/src/app/gfx/snes_palette.cc b/src/app/gfx/snes_palette.cc index 7a63af0e..e565ca47 100644 --- a/src/app/gfx/snes_palette.cc +++ b/src/app/gfx/snes_palette.cc @@ -10,9 +10,9 @@ #include "absl/container/flat_hash_map.h" #include "absl/status/status.h" #include "absl/status/statusor.h" -#include "app/core/constants.h" #include "app/gfx/snes_color.h" #include "imgui/imgui.h" +#include "util/macro.h" namespace yaze { namespace gfx { @@ -224,8 +224,8 @@ SnesPalette::SnesPalette(char *data) { assert((sizeof(data) % 4 == 0) && (sizeof(data) <= 32)); for (unsigned i = 0; i < sizeof(data); i += 2) { SnesColor col; - col.set_snes(static_cast(data[i + 1]) << 8); - col.set_snes(col.snes() | static_cast(data[i])); + col.set_snes(static_cast(data[i + 1]) << 8); + col.set_snes(col.snes() | static_cast(data[i])); snes_color mColor = ConvertSnesToRgb(col.snes()); col.set_rgb(ImVec4(mColor.red, mColor.green, mColor.blue, 1.f)); colors.push_back(col); @@ -271,7 +271,7 @@ SnesPalette ReadPaletteFromRom(int offset, int num_colors, const uint8_t *rom) { std::vector colors(num_colors); while (color_offset < num_colors) { - short color = (ushort)((rom[offset + 1]) << 8) | rom[offset]; + short color = (uint16_t)((rom[offset + 1]) << 8) | rom[offset]; snes_color new_color; new_color.red = (color & 0x1F) * 8; new_color.green = ((color >> 5) & 0x1F) * 8; diff --git a/src/app/gfx/snes_palette.h b/src/app/gfx/snes_palette.h index 8cf03fe5..507a730e 100644 --- a/src/app/gfx/snes_palette.h +++ b/src/app/gfx/snes_palette.h @@ -9,10 +9,10 @@ #include "absl/status/status.h" #include "absl/status/statusor.h" -#include "app/core/constants.h" #include "app/gfx/snes_color.h" #include "imgui/imgui.h" #include "snes_color.h" +#include "util/macro.h" namespace yaze { namespace gfx { diff --git a/src/app/gfx/snes_tile.cc b/src/app/gfx/snes_tile.cc index 86fc13c7..0363d729 100644 --- a/src/app/gfx/snes_tile.cc +++ b/src/app/gfx/snes_tile.cc @@ -5,22 +5,22 @@ #include #include -#include "app/core/constants.h" +#include "util/macro.h" namespace yaze { namespace gfx { // Bit set for object priority -constexpr ushort TilePriorityBit = 0x2000; +constexpr uint16_t TilePriorityBit = 0x2000; // Bit set for object hflip -constexpr ushort TileHFlipBit = 0x4000; +constexpr uint16_t TileHFlipBit = 0x4000; // Bit set for object vflip -constexpr ushort TileVFlipBit = 0x8000; +constexpr uint16_t TileVFlipBit = 0x8000; // Bits used for tile name -constexpr ushort TileNameMask = 0x03FF; +constexpr uint16_t TileNameMask = 0x03FF; snes_tile8 UnpackBppTile(const std::vector& data, const uint32_t offset, const uint32_t bpp) { diff --git a/src/app/rom.cc b/src/app/rom.cc index 6e6bd5c5..133475d0 100644 --- a/src/app/rom.cc +++ b/src/app/rom.cc @@ -16,19 +16,19 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" -#include "app/core/constants.h" #include "app/core/platform/renderer.h" #include "app/gfx/compression.h" #include "app/gfx/snes_color.h" #include "app/gfx/snes_palette.h" #include "app/gfx/snes_tile.h" +#include "util/macro.h" namespace yaze { using core::Renderer; constexpr int Uncompressed3BPPSize = 0x0600; namespace { -int GetGraphicsAddress(const uchar *data, uint8_t addr, uint32_t ptr1, +int GetGraphicsAddress(const uint8_t *data, uint8_t addr, uint32_t ptr1, uint32_t ptr2, uint32_t ptr3) { return core::SnesToPc(core::AddressFromBytes( data[ptr1 + addr], data[ptr2 + addr], data[ptr3 + addr])); @@ -373,8 +373,8 @@ absl::Status Rom::LoadZelda3() { constexpr size_t kBaseRomSize = 1048576; // 1MB constexpr size_t kHeaderSize = 0x200; // 512 bytes if (size_ % kBaseRomSize == kHeaderSize) { - auto header = - std::vector(rom_data_.begin(), rom_data_.begin() + kHeaderSize); + auto header = std::vector(rom_data_.begin(), + rom_data_.begin() + kHeaderSize); rom_data_.erase(rom_data_.begin(), rom_data_.begin() + kHeaderSize); size_ -= 0x200; } diff --git a/src/app/rom.h b/src/app/rom.h index 078adedb..eb6e15a4 100644 --- a/src/app/rom.h +++ b/src/app/rom.h @@ -20,11 +20,11 @@ #include "absl/strings/str_format.h" #include "absl/strings/string_view.h" #include "app/core/common.h" -#include "app/core/constants.h" #include "app/core/project.h" #include "app/gfx/bitmap.h" #include "app/gfx/snes_palette.h" #include "app/gfx/snes_tile.h" +#include "util/macro.h" namespace yaze { @@ -68,7 +68,7 @@ class Rom { */ absl::Status LoadFromFile(const std::string& filename, bool z3_load = true); absl::Status LoadFromData(const std::vector& data, - bool z3_load = true); + bool z3_load = true); /** * @brief Saves the Rom data to a file diff --git a/src/app/zelda3/dungeon/room.cc b/src/app/zelda3/dungeon/room.cc index 97f04f60..3878db26 100644 --- a/src/app/zelda3/dungeon/room.cc +++ b/src/app/zelda3/dungeon/room.cc @@ -6,11 +6,11 @@ #include #include "absl/strings/str_cat.h" -#include "app/core/constants.h" #include "app/rom.h" #include "app/zelda3/dungeon/room_object.h" #include "app/zelda3/dungeon/room_tag.h" #include "app/zelda3/sprite/sprite.h" +#include "util/macro.h" namespace yaze { namespace zelda3 { @@ -27,8 +27,7 @@ void Room::LoadHeader() { auto header_location = core::SnesToPc(address); - bg2_ = (background2)((rom()->data()[header_location] >> 5) & - 0x07); + bg2_ = (background2)((rom()->data()[header_location] >> 5) & 0x07); collision_ = (CollisionKey)((rom()->data()[header_location] >> 2) & 0x07); is_light_ = ((rom()->data()[header_location]) & 0x01) == 1; @@ -163,12 +162,12 @@ void Room::LoadRoomFromROM() { b = rom_data[hpos]; - pits_.target_layer = (uchar)(b & 0x03); - stair1_.target_layer = (uchar)((b >> 2) & 0x03); - stair2_.target_layer = (uchar)((b >> 4) & 0x03); - stair3_.target_layer = (uchar)((b >> 6) & 0x03); + pits_.target_layer = (uint8_t)(b & 0x03); + stair1_.target_layer = (uint8_t)((b >> 2) & 0x03); + stair2_.target_layer = (uint8_t)((b >> 4) & 0x03); + stair3_.target_layer = (uint8_t)((b >> 6) & 0x03); hpos++; - stair4_.target_layer = (uchar)(rom_data[hpos] & 0x03); + stair4_.target_layer = (uint8_t)(rom_data[hpos] & 0x03); hpos++; pits_.target = rom_data[hpos]; @@ -193,7 +192,7 @@ void Room::LoadRoomFromROM() { // core::SnesToPc(dungeon_spr_ptrs | spr_ptr + (room_id_ * 2)); } -void Room::LoadRoomGraphics(uchar entrance_blockset) { +void Room::LoadRoomGraphics(uint8_t entrance_blockset) { const auto &main_gfx = rom()->main_blockset_ids; const auto &room_gfx = rom()->room_blockset_ids; const auto &sprite_gfx = rom()->spriteset_ids; @@ -216,7 +215,7 @@ void Room::LoadRoomGraphics(uchar entrance_blockset) { blocks_[10] = 115 + 6; blocks_[11] = 115 + 7; for (int i = 0; i < 4; i++) { - blocks_[12 + i] = (uchar)(sprite_gfx[spriteset + 64][i] + 115); + blocks_[12 + i] = (uint8_t)(sprite_gfx[spriteset + 64][i] + 115); } // 12-16 sprites } @@ -238,7 +237,7 @@ void Room::CopyRoomGraphicsToBuffer() { int data = 0; int block_offset = blocks_[i] * kGfxBufferRoomOffset; while (data < kGfxBufferRoomOffset) { - uchar map_byte = gfx_buffer_data[data + block_offset]; + uint8_t map_byte = gfx_buffer_data[data + block_offset]; if (i < 4) { map_byte += kGfxBufferRoomSpriteLastLineOffset; } @@ -260,7 +259,7 @@ void Room::LoadAnimatedGraphics() { auto rom_data = rom()->vector(); int data = 0; while (data < 512) { - uchar map_byte = + uint8_t map_byte = gfx_buffer_data[data + (92 * 2048) + (512 * animated_frame_)]; current_gfx16_[data + (7 * 2048)] = map_byte; @@ -382,8 +381,7 @@ void Room::LoadObjects() { } else { tile_objects_.back().set_options(ObjectOption::Stairs | tile_objects_.back().options()); - z3_staircases_.push_back( - staircase(posX, posY, "To ???")); + z3_staircases_.push_back(staircase(posX, posY, "To ???")); } } } @@ -393,7 +391,7 @@ void Room::LoadObjects() { tile_objects_.back().set_options(ObjectOption::Chest | tile_objects_.back().options()); // chest_list_.push_back( - // z3_chest(posX, posY, chests_in_room_.front().itemIn, false)); + // z3_chest(posX, posY, chests_in_room_.front().itemIn, false)); chests_in_room_.erase(chests_in_room_.begin()); } } else if (oid == 0xFB1) { @@ -401,12 +399,14 @@ void Room::LoadObjects() { tile_objects_.back().set_options(ObjectOption::Chest | tile_objects_.back().options()); // chest_list_.push_back( - // z3_chest(posX + 1, posY, chests_in_room_.front().item_in, true)); + // z3_chest(posX + 1, posY, chests_in_room_.front().item_in, + // true)); chests_in_room_.erase(chests_in_room_.begin()); } } } else { - // tile_objects_.push_back(z3_object_door(static_cast((b2 << 8) + b1), + // tile_objects_.push_back(z3_object_door(static_cast((b2 << 8) + + // b1), // 0, 0, 0, // static_cast(layer))); } diff --git a/src/app/zelda3/dungeon/room.h b/src/app/zelda3/dungeon/room.h index 7c97befd..bce924ec 100644 --- a/src/app/zelda3/dungeon/room.h +++ b/src/app/zelda3/dungeon/room.h @@ -7,12 +7,12 @@ #include #include -#include "app/core/constants.h" #include "app/gfx/bitmap.h" #include "app/rom.h" #include "app/zelda3/dungeon/room_object.h" #include "app/zelda3/dungeon/room_tag.h" #include "app/zelda3/sprite/sprite.h" +#include "util/macro.h" namespace yaze { namespace zelda3 { @@ -79,7 +79,7 @@ constexpr int dungeon_spr_ptrs = 0x090000; constexpr int NumberOfRooms = 296; -constexpr ushort stairsObjects[] = {0x139, 0x138, 0x13B, 0x12E, 0x12D}; +constexpr uint16_t stairsObjects[] = {0x139, 0x138, 0x13B, 0x12E, 0x12D}; struct LayerMergeType { uint8_t ID; @@ -121,7 +121,7 @@ class Room : public SharedRom { void CalculateRoomSize(); void LoadRoomFromROM(); - void LoadRoomGraphics(uchar entrance_blockset = 0xFF); + void LoadRoomGraphics(uint8_t entrance_blockset = 0xFF); void CopyRoomGraphicsToBuffer(); void LoadAnimatedGraphics(); diff --git a/src/app/zelda3/dungeon/room_entrance.h b/src/app/zelda3/dungeon/room_entrance.h index 361c4430..507e5ff6 100644 --- a/src/app/zelda3/dungeon/room_entrance.h +++ b/src/app/zelda3/dungeon/room_entrance.h @@ -104,22 +104,22 @@ class RoomEntrance { room_ = static_cast((rom[kEntranceRoom + (entrance_id * 2) + 1] << 8) + rom[kEntranceRoom + (entrance_id * 2)]); - y_position_ = static_cast( + y_position_ = static_cast( (rom[kEntranceYPosition + (entrance_id * 2) + 1] << 8) + rom[kEntranceYPosition + (entrance_id * 2)]); - x_position_ = static_cast( + x_position_ = static_cast( (rom[kEntranceXPosition + (entrance_id * 2) + 1] << 8) + rom[kEntranceXPosition + (entrance_id * 2)]); - camera_x_ = static_cast( + camera_x_ = static_cast( (rom[kEntranceXScroll + (entrance_id * 2) + 1] << 8) + rom[kEntranceXScroll + (entrance_id * 2)]); - camera_y_ = static_cast( + camera_y_ = static_cast( (rom[kEntranceYScroll + (entrance_id * 2) + 1] << 8) + rom[kEntranceYScroll + (entrance_id * 2)]); - camera_trigger_y_ = static_cast( + camera_trigger_y_ = static_cast( (rom[(kEntranceCameraYTrigger + (entrance_id * 2)) + 1] << 8) + rom[kEntranceCameraYTrigger + (entrance_id * 2)]); - camera_trigger_x_ = static_cast( + camera_trigger_x_ = static_cast( (rom[(kEntranceCameraXTrigger + (entrance_id * 2)) + 1] << 8) + rom[kEntranceCameraXTrigger + (entrance_id * 2)]); blockset_ = rom[kEntranceBlockset + entrance_id]; @@ -148,27 +148,27 @@ class RoomEntrance { (rom[kStartingEntranceroom + (entrance_id * 2) + 1] << 8) + rom[kStartingEntranceroom + (entrance_id * 2)]); - y_position_ = static_cast( + y_position_ = static_cast( (rom[kStartingEntranceYPosition + (entrance_id * 2) + 1] << 8) + rom[kStartingEntranceYPosition + (entrance_id * 2)]); - x_position_ = static_cast( + x_position_ = static_cast( (rom[kStartingEntranceXPosition + (entrance_id * 2) + 1] << 8) + rom[kStartingEntranceXPosition + (entrance_id * 2)]); - camera_x_ = static_cast( + camera_x_ = static_cast( (rom[kStartingEntranceXScroll + (entrance_id * 2) + 1] << 8) + rom[kStartingEntranceXScroll + (entrance_id * 2)]); - camera_y_ = static_cast( + camera_y_ = static_cast( (rom[kStartingEntranceYScroll + (entrance_id * 2) + 1] << 8) + rom[kStartingEntranceYScroll + (entrance_id * 2)]); - camera_trigger_y_ = static_cast( + camera_trigger_y_ = static_cast( (rom[kStartingEntranceCameraYTrigger + (entrance_id * 2) + 1] << 8) + rom[kStartingEntranceCameraYTrigger + (entrance_id * 2)]); - camera_trigger_x_ = static_cast( + camera_trigger_x_ = static_cast( (rom[kStartingEntranceCameraXTrigger + (entrance_id * 2) + 1] << 8) + rom[kStartingEntranceCameraXTrigger + (entrance_id * 2)]); diff --git a/src/app/zelda3/dungeon/room_object.cc b/src/app/zelda3/dungeon/room_object.cc index a6a3a2b3..c01d5a4f 100644 --- a/src/app/zelda3/dungeon/room_object.cc +++ b/src/app/zelda3/dungeon/room_object.cc @@ -52,7 +52,7 @@ void RoomObject::DrawTile(gfx::Tile16 t, int xx, int yy, std::vector& current_gfx16, std::vector& tiles_bg1_buffer, std::vector& tiles_bg2_buffer, - ushort tileUnder) { + uint16_t tileUnder) { bool preview = false; if (width_ < xx + 8) { width_ = xx + 8; @@ -99,7 +99,7 @@ void RoomObject::DrawTile(gfx::Tile16 t, int xx, int yy, 0x1000 && ((xx / 8) + nx_ + offset_x_) + ((ny_ + offset_y_ + (yy / 8)) * 0x40) >= 0) { - ushort td = 0; // gfx::GetTilesInfo(); + uint16_t td = 0; // gfx::GetTilesInfo(); // collisionPoint.Add( // new Point(xx + ((nx + offsetX) * 8), yy + ((ny + +offsetY) * 8))); diff --git a/src/app/zelda3/dungeon/room_object.h b/src/app/zelda3/dungeon/room_object.h index 40d94c39..9d6c5f3f 100644 --- a/src/app/zelda3/dungeon/room_object.h +++ b/src/app/zelda3/dungeon/room_object.h @@ -81,7 +81,7 @@ class RoomObject : public SharedRom { std::vector& current_gfx16, std::vector& tiles_bg1_buffer, std::vector& tiles_bg2_buffer, - ushort tile_under = 0xFFFF); + uint16_t tile_under = 0xFFFF); auto options() const { return options_; } void set_options(ObjectOption options) { options_ = options; } diff --git a/src/app/zelda3/music/tracker.cc b/src/app/zelda3/music/tracker.cc index 082d8d61..33b42a1a 100644 --- a/src/app/zelda3/music/tracker.cc +++ b/src/app/zelda3/music/tracker.cc @@ -13,8 +13,8 @@ #include #include -#include "app/core/constants.h" #include "app/rom.h" +#include "util/macro.h" namespace yaze { namespace zelda3 { @@ -43,8 +43,8 @@ SongSpcBlock *Tracker::AllocSpcBlock(int len, int bank) { ss_num++; sbl->start = ss_next; sbl->len = len; - sbl->buf = (uchar *)malloc(len); - sbl->relocs = (ushort *)malloc(32); + sbl->buf = (uint8_t *)malloc(len); + sbl->relocs = (uint16_t *)malloc(32); sbl->relsz = 16; sbl->relnum = 0; sbl->bank = bank & 7; diff --git a/src/app/zelda3/music/tracker.h b/src/app/zelda3/music/tracker.h index 23088ac6..9087d81a 100644 --- a/src/app/zelda3/music/tracker.h +++ b/src/app/zelda3/music/tracker.h @@ -3,8 +3,8 @@ #include -#include "app/core/constants.h" #include "app/rom.h" +#include "util/macro.h" namespace yaze { namespace zelda3 { @@ -61,8 +61,8 @@ struct SongRange { }; struct SongPart { - uchar flag; - uchar inst; + uint8_t flag; + uint8_t inst; short tbl[8]; unsigned short addr; }; diff --git a/src/app/zelda3/overworld/overworld.cc b/src/app/zelda3/overworld/overworld.cc index d5d9600a..4a7c6502 100644 --- a/src/app/zelda3/overworld/overworld.cc +++ b/src/app/zelda3/overworld/overworld.cc @@ -6,10 +6,10 @@ #include #include "absl/status/status.h" -#include "app/core/constants.h" #include "app/gfx/compression.h" #include "app/gfx/snes_tile.h" #include "app/rom.h" +#include "util/macro.h" namespace yaze { namespace zelda3 { diff --git a/src/app/zelda3/overworld/overworld_entrance.h b/src/app/zelda3/overworld/overworld_entrance.h index ef7e219e..5956b56b 100644 --- a/src/app/zelda3/overworld/overworld_entrance.h +++ b/src/app/zelda3/overworld/overworld_entrance.h @@ -3,9 +3,9 @@ #include -#include "app/core/constants.h" #include "app/rom.h" #include "app/zelda3/common.h" +#include "util/macro.h" namespace yaze { namespace zelda3 { @@ -49,14 +49,14 @@ constexpr int kOverworldHoleEntrance = 0xDB84C; class OverworldEntrance : public GameEntity { public: uint16_t map_pos_; - uchar entrance_id_; - uchar area_x_; - uchar area_y_; + uint8_t entrance_id_; + uint8_t area_x_; + uint8_t area_y_; bool is_hole_ = false; bool deleted = false; OverworldEntrance() = default; - OverworldEntrance(int x, int y, uchar entrance_id, short map_id, + OverworldEntrance(int x, int y, uint8_t entrance_id, short map_id, uint16_t map_pos, bool hole) : map_pos_(map_pos), entrance_id_(entrance_id), is_hole_(hole) { x_ = x; @@ -67,8 +67,8 @@ class OverworldEntrance : public GameEntity { int mapX = (map_id_ - ((map_id_ / 8) * 8)); int mapY = (map_id_ / 8); - area_x_ = (uchar)((std::abs(x - (mapX * 512)) / 16)); - area_y_ = (uchar)((std::abs(y - (mapY * 512)) / 16)); + area_x_ = (uint8_t)((std::abs(x - (mapX * 512)) / 16)); + area_y_ = (uint8_t)((std::abs(y - (mapY * 512)) / 16)); } void UpdateMapProperties(uint16_t map_id) override { @@ -81,8 +81,8 @@ class OverworldEntrance : public GameEntity { int mapX = (map_id_ - ((map_id_ / 8) * 8)); int mapY = (map_id_ / 8); - area_x_ = (uchar)((std::abs(x_ - (mapX * 512)) / 16)); - area_y_ = (uchar)((std::abs(y_ - (mapY * 512)) / 16)); + area_x_ = (uint8_t)((std::abs(x_ - (mapX * 512)) / 16)); + area_y_ = (uint8_t)((std::abs(y_ - (mapY * 512)) / 16)); map_pos_ = (uint16_t)((((area_y_) << 6) | (area_x_ & 0x3F)) << 1); } diff --git a/src/app/zelda3/overworld/overworld_exit.h b/src/app/zelda3/overworld/overworld_exit.h index b83f3afb..6c7db95a 100644 --- a/src/app/zelda3/overworld/overworld_exit.h +++ b/src/app/zelda3/overworld/overworld_exit.h @@ -4,8 +4,8 @@ #include #include -#include "app/core/constants.h" #include "app/zelda3/common.h" +#include "util/macro.h" namespace yaze { namespace zelda3 { @@ -44,30 +44,31 @@ class OverworldExit : public GameEntity { public: uint16_t y_scroll_; uint16_t x_scroll_; - uchar y_player_; - uchar x_player_; - uchar y_camera_; - uchar x_camera_; - uchar scroll_mod_y_; - uchar scroll_mod_x_; + uint8_t y_player_; + uint8_t x_player_; + uint8_t y_camera_; + uint8_t x_camera_; + uint8_t scroll_mod_y_; + uint8_t scroll_mod_x_; uint16_t door_type_1_; uint16_t door_type_2_; uint16_t room_id_; uint16_t map_pos_; // Position in the vram - uchar entrance_id_; - uchar area_x_; - uchar area_y_; + uint8_t entrance_id_; + uint8_t area_x_; + uint8_t area_y_; bool is_hole_ = false; bool deleted_ = false; bool is_automatic_ = false; bool large_map_ = false; OverworldExit() = default; - OverworldExit(uint16_t room_id, uchar map_id, uint16_t vram_location, + OverworldExit(uint16_t room_id, uint8_t map_id, uint16_t vram_location, uint16_t y_scroll, uint16_t x_scroll, uint16_t player_y, uint16_t player_x, uint16_t camera_y, uint16_t camera_x, - uchar scroll_mod_y, uchar scroll_mod_x, uint16_t door_type_1, - uint16_t door_type_2, bool deleted = false) + uint8_t scroll_mod_y, uint8_t scroll_mod_x, + uint16_t door_type_1, uint16_t door_type_2, + bool deleted = false) : map_pos_(vram_location), entrance_id_(0), area_x_(0), @@ -94,19 +95,19 @@ class OverworldExit : public GameEntity { int mapX = (map_id_ - ((map_id_ / 8) * 8)); int mapY = (map_id_ / 8); - area_x_ = (uchar)((std::abs(x_ - (mapX * 512)) / 16)); - area_y_ = (uchar)((std::abs(y_ - (mapY * 512)) / 16)); + area_x_ = (uint8_t)((std::abs(x_ - (mapX * 512)) / 16)); + area_y_ = (uint8_t)((std::abs(y_ - (mapY * 512)) / 16)); if (door_type_1 != 0) { int p = (door_type_1 & 0x7FFF) >> 1; - entrance_id_ = (uchar)(p % 64); - area_y_ = (uchar)(p >> 6); + entrance_id_ = (uint8_t)(p % 64); + area_y_ = (uint8_t)(p >> 6); } if (door_type_2 != 0) { int p = (door_type_2 & 0x7FFF) >> 1; - entrance_id_ = (uchar)(p % 64); - area_y_ = (uchar)(p >> 6); + entrance_id_ = (uint8_t)(p % 64); + area_y_ = (uint8_t)(p >> 6); } if (map_id_ >= 64) { @@ -116,8 +117,8 @@ class OverworldExit : public GameEntity { mapX = (map_id_ - ((map_id_ / 8) * 8)); mapY = (map_id_ / 8); - area_x_ = (uchar)((std::abs(x_ - (mapX * 512)) / 16)); - area_y_ = (uchar)((std::abs(y_ - (mapY * 512)) / 16)); + area_x_ = (uint8_t)((std::abs(x_ - (mapX * 512)) / 16)); + area_y_ = (uint8_t)((std::abs(y_ - (mapY * 512)) / 16)); map_pos_ = (uint16_t)((((area_y_) << 6) | (area_x_ & 0x3F)) << 1); } @@ -139,8 +140,8 @@ class OverworldExit : public GameEntity { int mapX = map_id - ((map_id / 8) * 8); int mapY = map_id / 8; - area_x_ = (uchar)((std::abs(x_ - (mapX * 512)) / 16)); - area_y_ = (uchar)((std::abs(y_ - (mapY * 512)) / 16)); + area_x_ = (uint8_t)((std::abs(x_ - (mapX * 512)) / 16)); + area_y_ = (uint8_t)((std::abs(y_ - (mapY * 512)) / 16)); if (map_id >= 64) { map_id -= 64; diff --git a/src/app/zelda3/overworld/overworld_map.cc b/src/app/zelda3/overworld/overworld_map.cc index bfc24f75..be203123 100644 --- a/src/app/zelda3/overworld/overworld_map.cc +++ b/src/app/zelda3/overworld/overworld_map.cc @@ -423,7 +423,7 @@ void OverworldMap::DrawAnimatedTiles() { void OverworldMap::LoadAreaGraphicsBlocksets() { for (int i = 0; i < 4; i++) { - uchar value = rom_[rom_.version_constants().kOverworldGfxGroups1 + + uint8_t value = rom_[rom_.version_constants().kOverworldGfxGroups1 + (area_graphics_ * 4) + i]; if (value != 0) { static_graphics_[3 + i] = value; @@ -595,16 +595,16 @@ absl::Status OverworldMap::LoadPalette() { area_palette_ = std::min((int)area_palette_, 0xA3); - uchar pal0 = 0; - uchar pal1 = rom_[rom_.version_constants().kOverworldMapPaletteGroup + + uint8_t pal0 = 0; + uint8_t pal1 = rom_[rom_.version_constants().kOverworldMapPaletteGroup + (area_palette_ * 4)]; - uchar pal2 = rom_[rom_.version_constants().kOverworldMapPaletteGroup + + uint8_t pal2 = rom_[rom_.version_constants().kOverworldMapPaletteGroup + (area_palette_ * 4) + 1]; - uchar pal3 = rom_[rom_.version_constants().kOverworldMapPaletteGroup + + uint8_t pal3 = rom_[rom_.version_constants().kOverworldMapPaletteGroup + (area_palette_ * 4) + 2]; - uchar pal4 = + uint8_t pal4 = rom_[kOverworldSpritePaletteGroup + (sprite_palette_[game_state_] * 2)]; - uchar pal5 = rom_[kOverworldSpritePaletteGroup + + uint8_t pal5 = rom_[kOverworldSpritePaletteGroup + (sprite_palette_[game_state_] * 2) + 1]; auto grass_pal_group = rom_.palette_group().grass; diff --git a/src/app/zelda3/screen/title_screen.cc b/src/app/zelda3/screen/title_screen.cc index fd92dba2..89839f02 100644 --- a/src/app/zelda3/screen/title_screen.cc +++ b/src/app/zelda3/screen/title_screen.cc @@ -18,7 +18,7 @@ void TitleScreen::Create() { } void TitleScreen::BuildTileset() { - uchar staticgfx[16] = {0}; + uint8_t staticgfx[16] = {0}; // Main Blocksets @@ -37,13 +37,13 @@ void TitleScreen::BuildTileset() { staticgfx[15] = 112; // Loaded gfx for the current screen (empty at this point) - uchar* currentmapgfx8Data = tiles8Bitmap.mutable_data().data(); + uint8_t* currentmapgfx8Data = tiles8Bitmap.mutable_data().data(); // All gfx of the game pack of 2048 bytes (4bpp) - uchar* allgfxData = nullptr; + uint8_t* allgfxData = nullptr; for (int i = 0; i < 16; i++) { for (int j = 0; j < 2048; j++) { - uchar mapByte = allgfxData[j + (staticgfx[i] * 2048)]; + uint8_t mapByte = allgfxData[j + (staticgfx[i] * 2048)]; switch (i) { case 0: case 3: @@ -83,7 +83,7 @@ void TitleScreen::LoadTitleScreen() { int jj = 0; int posB = pos; while (j < (length / 2) + 1) { - ushort tiledata = (ushort)pos; + uint16_t tiledata = (uint16_t)pos; if (dest_addr >= 0x1000) { // destAddr -= 0x1000; if (dest_addr < 0x2000) { diff --git a/src/app/zelda3/screen/title_screen.h b/src/app/zelda3/screen/title_screen.h index 9b5c5193..ad753e96 100644 --- a/src/app/zelda3/screen/title_screen.h +++ b/src/app/zelda3/screen/title_screen.h @@ -43,12 +43,12 @@ class TitleScreen { int addressesgfx[7] = {0x53ee0, 0x53f04, 0x53ef2, 0x53f16, 0x53f28, 0x53f3a, 0x53f4c}; - ushort bossRoom = 0x000F; - ushort selected_tile = 0; - ushort tilesBG1Buffer[0x1000]; // 0x1000 - ushort tilesBG2Buffer[0x1000]; // 0x1000 - uchar mapdata; // 64 * 64 - uchar dwmapdata; // 64 * 64 + uint16_t bossRoom = 0x000F; + uint16_t selected_tile = 0; + uint16_t tilesBG1Buffer[0x1000]; // 0x1000 + uint16_t tilesBG2Buffer[0x1000]; // 0x1000 + uint8_t mapdata; // 64 * 64 + uint8_t dwmapdata; // 64 * 64 bool mDown = false; bool swordSelected = false; diff --git a/src/cli/z3ed.cc b/src/cli/z3ed.cc index 56579d8d..f0f2ef87 100644 --- a/src/cli/z3ed.cc +++ b/src/cli/z3ed.cc @@ -1,3 +1,5 @@ +#include "cli/z3ed.h" + #include #include #include @@ -5,9 +7,8 @@ #include #include -#include "app/core/constants.h" -#include "cli/z3ed.h" #include "cli/tui.h" +#include "util/macro.h" namespace yaze { /** diff --git a/src/cli/z3ed.h b/src/cli/z3ed.h index 670c943f..fe8d7c13 100644 --- a/src/cli/z3ed.h +++ b/src/cli/z3ed.h @@ -11,8 +11,8 @@ #include "absl/status/status.h" #include "app/core/common.h" -#include "app/core/constants.h" #include "app/rom.h" +#include "util/macro.h" namespace yaze { namespace cli { diff --git a/src/app/core/constants.h b/src/util/macro.h similarity index 94% rename from src/app/core/constants.h rename to src/util/macro.h index 4594aae6..8e192fb3 100644 --- a/src/app/core/constants.h +++ b/src/util/macro.h @@ -1,5 +1,5 @@ -#ifndef YAZE_APP_CORE_CONSTANTS_H -#define YAZE_APP_CORE_CONSTANTS_H +#ifndef YAZE_UTIL_MACRO_H +#define YAZE_UTIL_MACRO_H #define TAB_ITEM(w) if (ImGui::BeginTabItem(w)) { #define END_TAB_ITEM() \ @@ -109,8 +109,9 @@ return temp; \ } -using ushort = unsigned short; -using uint = unsigned int; -using uchar = unsigned char; +#define SDL_RETURN_IF_ERROR() \ + if (SDL_GetError() != nullptr) { \ + return absl::InternalError(SDL_GetError()); \ + } -#endif \ No newline at end of file +#endif // YAZE_UTIL_MACRO_H \ No newline at end of file diff --git a/test/gfx/compression_test.cc b/test/gfx/compression_test.cc index 1579b949..44e9b652 100644 --- a/test/gfx/compression_test.cc +++ b/test/gfx/compression_test.cc @@ -3,6 +3,7 @@ #include #include +#include #include #include "absl/status/statusor.h" @@ -32,7 +33,7 @@ using ::testing::TypedEq; namespace { -std::vector ExpectCompressOk(Rom& rom, uchar* in, int in_size) { +std::vector ExpectCompressOk(Rom& rom, uint8_t* in, int in_size) { std::vector data(in, in + in_size); auto load_status = rom.LoadFromData(data, false); EXPECT_TRUE(load_status.ok()); @@ -52,7 +53,7 @@ std::vector ExpectDecompressBytesOk(Rom& rom, return decompressed_bytes; } -std::vector ExpectDecompressOk(Rom& rom, uchar* in, int in_size) { +std::vector ExpectDecompressOk(Rom& rom, uint8_t* in, int in_size) { std::vector data(in, in + in_size); auto load_status = rom.LoadFromData(data, false); EXPECT_TRUE(load_status.ok()); @@ -161,8 +162,8 @@ TEST(LC_LZ2_CompressionTest, NewDecompressionPieceOk) { // 0x25 instead of 0x24 TEST(LC_LZ2_CompressionTest, CompressionSingleSet) { Rom rom; - uchar single_set[5] = {0x2A, 0x2A, 0x2A, 0x2A, 0x2A}; - uchar single_set_expected[3] = {BUILD_HEADER(1, 5), 0x2A, 0xFF}; + uint8_t single_set[5] = {0x2A, 0x2A, 0x2A, 0x2A, 0x2A}; + uint8_t single_set_expected[3] = {BUILD_HEADER(1, 5), 0x2A, 0xFF}; auto comp_result = ExpectCompressOk(rom, single_set, 5); EXPECT_THAT(single_set_expected, ElementsAreArray(comp_result.data(), 3)); @@ -170,8 +171,8 @@ TEST(LC_LZ2_CompressionTest, CompressionSingleSet) { TEST(LC_LZ2_CompressionTest, CompressionSingleWord) { Rom rom; - uchar single_word[6] = {0x2A, 0x01, 0x2A, 0x01, 0x2A, 0x01}; - uchar single_word_expected[4] = {BUILD_HEADER(0x02, 0x06), 0x2A, 0x01, 0xFF}; + uint8_t single_word[6] = {0x2A, 0x01, 0x2A, 0x01, 0x2A, 0x01}; + uint8_t single_word_expected[4] = {BUILD_HEADER(0x02, 0x06), 0x2A, 0x01, 0xFF}; auto comp_result = ExpectCompressOk(rom, single_word, 6); EXPECT_THAT(single_word_expected, ElementsAreArray(comp_result.data(), 4)); @@ -179,16 +180,16 @@ TEST(LC_LZ2_CompressionTest, CompressionSingleWord) { TEST(LC_LZ2_CompressionTest, CompressionSingleIncrement) { Rom rom; - uchar single_inc[3] = {0x01, 0x02, 0x03}; - uchar single_inc_expected[3] = {BUILD_HEADER(0x03, 0x03), 0x01, 0xFF}; + uint8_t single_inc[3] = {0x01, 0x02, 0x03}; + uint8_t single_inc_expected[3] = {BUILD_HEADER(0x03, 0x03), 0x01, 0xFF}; auto comp_result = ExpectCompressOk(rom, single_inc, 3); EXPECT_THAT(single_inc_expected, ElementsAreArray(comp_result.data(), 3)); } TEST(LC_LZ2_CompressionTest, CompressionSingleCopy) { Rom rom; - uchar single_copy[4] = {0x03, 0x0A, 0x07, 0x14}; - uchar single_copy_expected[6] = { + uint8_t single_copy[4] = {0x03, 0x0A, 0x07, 0x14}; + uint8_t single_copy_expected[6] = { BUILD_HEADER(0x00, 0x04), 0x03, 0x0A, 0x07, 0x14, 0xFF}; auto comp_result = ExpectCompressOk(rom, single_copy, 4); EXPECT_THAT(single_copy_expected, ElementsAreArray(comp_result.data(), 6)); @@ -303,12 +304,12 @@ TEST(LC_LZ2_CompressionTest, LengthBorderCompression) { TEST(LC_LZ2_CompressionTest, CompressionExtendedWordCopy) { // ROM rom; - // uchar buffer[3000]; + // uint8_t buffer[3000]; // for (unsigned int i = 0; i < 3000; i += 2) { // buffer[i] = 0x05; // buffer[i + 1] = 0x06; // } - // uchar hightlength_word_1050[] = { + // uint8_t hightlength_word_1050[] = { // 0b11101011, 0xFF, 0x05, 0x06, BUILD_HEADER(0x02, 0x1A), 0x05, 0x06, // 0xFF}; @@ -340,9 +341,9 @@ TEST(LC_LZ2_CompressionTest, CompressionMixedPatterns) { TEST(LC_LZ2_CompressionTest, CompressionLongIntraCopy) { ROM rom; - uchar long_data[15] = {0x05, 0x06, 0x07, 0x08, 0x05, 0x06, 0x07, 0x08, + uint8_t long_data[15] = {0x05, 0x06, 0x07, 0x08, 0x05, 0x06, 0x07, 0x08, 0x05, 0x06, 0x07, 0x08, 0x05, 0x06, 0x07}; - uchar long_expected[] = {BUILD_HEADER(0x00, 0x04), 0x05, 0x06, 0x07, 0x08, + uint8_t long_expected[] = {BUILD_HEADER(0x00, 0x04), 0x05, 0x06, 0x07, 0x08, BUILD_HEADER(0x04, 0x0C), 0x00, 0x00, 0xFF}; auto comp_result = ExpectCompressOk(rom, long_data, 15); @@ -403,14 +404,14 @@ TEST(LC_LZ2_CompressionTest, DecompressionValidCommand) { Rom rom; std::vector simple_copy_input = {BUILD_HEADER(0x00, 0x02), 0x2A, 0x45, 0xFF}; - uchar simple_copy_output[2] = {0x2A, 0x45}; + uint8_t simple_copy_output[2] = {0x2A, 0x45}; auto decomp_result = ExpectDecompressBytesOk(rom, simple_copy_input); EXPECT_THAT(simple_copy_output, ElementsAreArray(decomp_result.data(), 2)); } TEST(LC_LZ2_CompressionTest, DecompressionMixingCommand) { Rom rom; - uchar random1_i[11] = {BUILD_HEADER(0x01, 0x03), + uint8_t random1_i[11] = {BUILD_HEADER(0x01, 0x03), 0x2A, BUILD_HEADER(0x00, 0x04), 0x01, @@ -421,7 +422,7 @@ TEST(LC_LZ2_CompressionTest, DecompressionMixingCommand) { 0x0B, 0x16, 0xFF}; - uchar random1_o[9] = {42, 42, 42, 1, 2, 3, 4, 11, 22}; + uint8_t random1_o[9] = {42, 42, 42, 1, 2, 3, 4, 11, 22}; auto decomp_result = ExpectDecompressOk(rom, random1_i, 11); EXPECT_THAT(random1_o, ElementsAreArray(decomp_result.data(), 9)); }