scawful/yaze
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Overworld and Bitmap refactoring

Browse Source
This commit is contained in:
Justin Scofield
2022-07-24 01:34:16 -04:00
parent 8844778ef4
commit 7d08970a19
6 changed files with 113 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/app/editor/master_editor.cc
View File

@@ -189,10 +189,6 @@ void MasterEditor::DrawViewMenu() {
ImGui::MenuItem("HEX Editor", nullptr, &show_memory_editor); ImGui::MenuItem("HEX Editor", nullptr, &show_memory_editor);
ImGui::MenuItem("ASM Editor", nullptr, &show_asm_editor); ImGui::MenuItem("ASM Editor", nullptr, &show_asm_editor);
ImGui::MenuItem("ImGui Demo", nullptr, &show_imgui_demo); ImGui::MenuItem("ImGui Demo", nullptr, &show_imgui_demo);
if (ImGui::MenuItem("Invalid Argument Popup")) {
status_ = absl::InvalidArgumentError("Invalid Argument Status");
}
ImGui::Separator(); ImGui::Separator();
if (ImGui::BeginMenu("GUI Tools")) { if (ImGui::BeginMenu("GUI Tools")) {
ImGui::MenuItem("Metrics (ImGui)", nullptr, &show_imgui_metrics); ImGui::MenuItem("Metrics (ImGui)", nullptr, &show_imgui_metrics);
@@ -217,7 +213,7 @@ void MasterEditor::DrawHelpMenu() const {
void MasterEditor::DrawOverworldEditor() { void MasterEditor::DrawOverworldEditor() {
TAB_ITEM("Overworld") TAB_ITEM("Overworld")
overworld_editor_.Update(); status_ = overworld_editor_.Update();
END_TAB_ITEM() END_TAB_ITEM()
} }

15
src/app/gfx/bitmap.cc
View File

@@ -4,6 +4,9 @@
#include <memory> #include <memory>
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_cat.h"
#include "app/core/constants.h" #include "app/core/constants.h"
#include "app/gfx/snes_palette.h" #include "app/gfx/snes_palette.h"
@@ -80,8 +83,8 @@ absl::StatusOr<std::vector<Bitmap>> Bitmap::CreateTiles() {
auto surface = bmp.GetSurface(); auto surface = bmp.GetSurface();
SDL_Rect src_rect = {i, j, 8, 8}; SDL_Rect src_rect = {i, j, 8, 8};
if (SDL_BlitSurface(surface_.get(), &src_rect, surface, nullptr) != 0) if (SDL_BlitSurface(surface_.get(), &src_rect, surface, nullptr) != 0)
return absl::InvalidArgumentError( return absl::InternalError(
"Failed to blit surface for Bitmap Tilesheet"); absl::StrCat("Failed to blit surface: ", SDL_GetError()));
tiles.push_back(bmp); tiles.push_back(bmp);
} }
} }
@@ -90,15 +93,17 @@ absl::StatusOr<std::vector<Bitmap>> Bitmap::CreateTiles() {
// Converts a vector of 8x8 tiles into a tilesheet. // Converts a vector of 8x8 tiles into a tilesheet.
absl::Status Bitmap::CreateFromTiles(const std::vector<Bitmap> &tiles) { absl::Status Bitmap::CreateFromTiles(const std::vector<Bitmap> &tiles) {
if (tiles.empty()) return absl::InvalidArgumentError("Empty tiles"); if (tiles.empty())
return absl::InvalidArgumentError(
"Failed to create bitmap: `tiles` is empty.");
SDL_Rect tile_rect = {0, 0, 8, 8}; SDL_Rect tile_rect = {0, 0, 8, 8};
SDL_Rect dest_rect = {0, 0, 8, 8}; SDL_Rect dest_rect = {0, 0, 8, 8};
for (const auto &tile : tiles) { for (const auto &tile : tiles) {
auto src = tile.GetSurface(); auto src = tile.GetSurface();
if (SDL_BlitSurface(src, &tile_rect, surface_.get(), &dest_rect) != 0) if (SDL_BlitSurface(src, &tile_rect, surface_.get(), &dest_rect) != 0)
return absl::InvalidArgumentError( return absl::InternalError(
"Failed to blit surface for Bitmap Tilesheet"); absl::StrCat("Failed to blit surface: ", SDL_GetError()));
dest_rect.x++; dest_rect.x++;
if (dest_rect.x == 15) { if (dest_rect.x == 15) {

20
src/app/zelda3/overworld.cc
View File

@@ -7,25 +7,29 @@ namespace yaze {
namespace app { namespace app {
namespace zelda3 { namespace zelda3 {
void Overworld::Load(ROM &rom, uchar *ow_blockset) { absl::Status Overworld::Load(ROM &rom, uchar *ow_blockset) {
rom_ = rom; rom_ = rom;
AssembleMap32Tiles(); AssembleMap32Tiles();
AssembleMap16Tiles(); AssembleMap16Tiles();
DecompressAllMapTiles(); DecompressAllMapTiles();
for (int i = 0; i < core::NumberOfOWMaps; i++) { for (int map_index = 0; map_index < core::NumberOfOWMaps; ++map_index)
overworld_maps_.emplace_back(i, rom_, tiles16); overworld_maps_.emplace_back(map_index, rom_, tiles16, map_tiles_);
}
FetchLargeMaps(); FetchLargeMaps();
for (int i = 0; i < core::NumberOfOWMaps; i++) { auto size = tiles16.size();
// overworld_maps_[i].BuildMap(tiles16.size(), game_state_, map_parent_, for (int i = 0; i < core::NumberOfOWMaps; ++i) {
// ow_blockset, map_tiles_); auto map_status = overworld_maps_[i].BuildMapV2(size, game_state_,
overworld_maps_[i].BuildMapV2(tiles16.size(), game_state_, map_parent_); map_parent_);
if (!map_status.ok()) {
return map_status;
}
} }
is_loaded_ = true; is_loaded_ = true;
return absl::OkStatus();
} }
ushort Overworld::GenerateTile32(int i, int k, int dimension) { ushort Overworld::GenerateTile32(int i, int k, int dimension) {

3
src/app/zelda3/overworld.h
View File

@@ -7,6 +7,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "absl/status/status.h"
#include "app/core/constants.h" #include "app/core/constants.h"
#include "app/gfx/bitmap.h" #include "app/gfx/bitmap.h"
#include "app/gfx/pseudo_vram.h" #include "app/gfx/pseudo_vram.h"
@@ -20,7 +21,7 @@ namespace zelda3 {
class Overworld { class Overworld {
public: public:
void Load(ROM &rom, uchar *ow_blockset); absl::Status Load(ROM &rom, uchar *ow_blockset);
auto GetTiles16() const { return tiles16; } auto GetTiles16() const { return tiles16; }
auto GetOverworldMap(uint index) { return overworld_maps_[index]; } auto GetOverworldMap(uint index) { return overworld_maps_[index]; }
auto isLoaded() const { return is_loaded_; } auto isLoaded() const { return is_loaded_; }

145
src/app/zelda3/overworld_map.cc
View File

@@ -17,46 +17,50 @@ namespace app {
namespace zelda3 { namespace zelda3 {
OverworldMap::OverworldMap(int index, ROM& rom, OverworldMap::OverworldMap(int index, ROM& rom,
const std::vector<gfx::Tile16>& tiles16) const std::vector<gfx::Tile16>& tiles16,
: parent_(index), index_(index), tiles16_(tiles16), rom_(rom) { const OWMapTiles& map_tiles)
: parent_(index),
index_(index),
rom_(rom),
tiles16_(tiles16),
map_tiles_(map_tiles) {
LoadAreaInfo(); LoadAreaInfo();
bitmap_.Create(512, 512, 8, 512 * 512); bitmap_.Create(512, 512, 8, 512 * 512);
} }
void OverworldMap::LoadAreaInfo() { void OverworldMap::LoadAreaInfo() {
auto z3data = rom_.data();
if (index_ != 0x80 && index_ <= 150 && if (index_ != 0x80 && index_ <= 150 &&
rom_.data()[core::overworldMapSize + (index_ & 0x3F)] != 0) { rom_[core::overworldMapSize + (index_ & 0x3F)] != 0) {
large_map_ = true; large_map_ = true;
} }
if (index_ < 64) { if (index_ < 64) {
area_graphics_ = z3data[core::mapGfx + parent_]; area_graphics_ = rom_[core::mapGfx + parent_];
area_palette_ = z3data[core::overworldMapPalette + parent_]; area_palette_ = rom_[core::overworldMapPalette + parent_];
area_music_[0] = z3data[core::overworldMusicBegining + parent_]; area_music_[0] = rom_[core::overworldMusicBegining + parent_];
area_music_[1] = z3data[core::overworldMusicZelda + parent_]; area_music_[1] = rom_[core::overworldMusicZelda + parent_];
area_music_[2] = z3data[core::overworldMusicMasterSword + parent_]; area_music_[2] = rom_[core::overworldMusicMasterSword + parent_];
area_music_[3] = z3data[core::overworldMusicAgahim + parent_]; area_music_[3] = rom_[core::overworldMusicAgahim + parent_];
sprite_graphics_[0] = z3data[core::overworldSpriteset + parent_]; sprite_graphics_[0] = rom_[core::overworldSpriteset + parent_];
sprite_graphics_[1] = z3data[core::overworldSpriteset + parent_ + 64]; sprite_graphics_[1] = rom_[core::overworldSpriteset + parent_ + 64];
sprite_graphics_[2] = z3data[core::overworldSpriteset + parent_ + 128]; sprite_graphics_[2] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_palette_[0] = z3data[core::overworldSpritePalette + parent_]; sprite_palette_[0] = rom_[core::overworldSpritePalette + parent_];
sprite_palette_[1] = z3data[core::overworldSpritePalette + parent_ + 64]; sprite_palette_[1] = rom_[core::overworldSpritePalette + parent_ + 64];
sprite_palette_[2] = z3data[core::overworldSpritePalette + parent_ + 128]; sprite_palette_[2] = rom_[core::overworldSpritePalette + parent_ + 128];
} else if (index_ < 128) { } else if (index_ < 128) {
area_graphics_ = z3data[core::mapGfx + parent_]; area_graphics_ = rom_[core::mapGfx + parent_];
area_palette_ = z3data[core::overworldMapPalette + parent_]; area_palette_ = rom_[core::overworldMapPalette + parent_];
area_music_[0] = z3data[core::overworldMusicDW + (parent_ - 64)]; area_music_[0] = rom_[core::overworldMusicDW + (parent_ - 64)];
sprite_graphics_[0] = z3data[core::overworldSpriteset + parent_ + 128]; sprite_graphics_[0] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[1] = z3data[core::overworldSpriteset + parent_ + 128]; sprite_graphics_[1] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[2] = z3data[core::overworldSpriteset + parent_ + 128]; sprite_graphics_[2] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_palette_[0] = z3data[core::overworldSpritePalette + parent_ + 128]; sprite_palette_[0] = rom_[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[1] = z3data[core::overworldSpritePalette + parent_ + 128]; sprite_palette_[1] = rom_[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[2] = z3data[core::overworldSpritePalette + parent_ + 128]; sprite_palette_[2] = rom_[core::overworldSpritePalette + parent_ + 128];
} else { } else {
if (index_ == 0x94) { if (index_ == 0x94) {
parent_ = 128; parent_ = 128;
@@ -78,28 +82,28 @@ void OverworldMap::LoadAreaInfo() {
parent_ = 136; parent_ = 136;
} }
area_palette_ = z3data[core::overworldSpecialPALGroup + parent_ - 128]; area_palette_ = rom_[core::overworldSpecialPALGroup + parent_ - 128];
if (index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) { if (index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) {
area_graphics_ = z3data[core::overworldSpecialGFXGroup + (parent_ - 128)]; area_graphics_ = rom_[core::overworldSpecialGFXGroup + (parent_ - 128)];
area_palette_ = z3data[core::overworldSpecialPALGroup + 1]; area_palette_ = rom_[core::overworldSpecialPALGroup + 1];
} else if (index_ == 0x88) { } else if (index_ == 0x88) {
area_graphics_ = 81; area_graphics_ = 81;
area_palette_ = 0; area_palette_ = 0;
} else { } else {
// pyramid bg use 0x5B map // pyramid bg use 0x5B map
area_graphics_ = z3data[core::mapGfx + parent_]; area_graphics_ = rom_[core::mapGfx + parent_];
area_palette_ = z3data[core::overworldMapPalette + parent_]; area_palette_ = rom_[core::overworldMapPalette + parent_];
} }
message_id_ = z3data[core::overworldMessages + parent_]; message_id_ = rom_[core::overworldMessages + parent_];
sprite_graphics_[0] = z3data[core::overworldSpriteset + parent_ + 128]; sprite_graphics_[0] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[1] = z3data[core::overworldSpriteset + parent_ + 128]; sprite_graphics_[1] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[2] = z3data[core::overworldSpriteset + parent_ + 128]; sprite_graphics_[2] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_palette_[0] = z3data[core::overworldSpritePalette + parent_ + 128]; sprite_palette_[0] = rom_[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[1] = z3data[core::overworldSpritePalette + parent_ + 128]; sprite_palette_[1] = rom_[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[2] = z3data[core::overworldSpritePalette + parent_ + 128]; sprite_palette_[2] = rom_[core::overworldSpritePalette + parent_ + 128];
} }
} }
@@ -127,49 +131,62 @@ void OverworldMap::BuildMap(int count, int game_state, uchar* map_parent,
BuildTileset(game_state); BuildTileset(game_state);
BuildTiles16Gfx(count, ow_blockset); // build on GFX.mapgfx16Ptr BuildTiles16Gfx(count, ow_blockset); // build on GFX.mapgfx16Ptr
int world = 0; // int world = 0;
if (index_ < 64) { // if (index_ < 64) {
tiles_used_ = map_tiles.light_world; // map_tiles_ = map_tiles.light_world;
} else if (index_ < 128 && index_ >= 64) { // } else if (index_ < 128 && index_ >= 64) {
tiles_used_ = map_tiles.dark_world; // map_tiles_ = map_tiles.dark_world;
world = 1; // world = 1;
} else { // } else {
tiles_used_ = map_tiles.special_world; // map_tiles_ = map_tiles.special_world;
world = 2; // world = 2;
} // }
int superY = ((index_ - (world * 64)) / 8); // int superY = ((index_ - (world * 64)) / 8);
int superX = index_ - (world * 64) - (superY * 8); // int superX = index_ - (world * 64) - (superY * 8);
for (int y = 0; y < 32; y++) { // for (int y = 0; y < 32; y++) {
for (int x = 0; x < 32; x++) { // for (int x = 0; x < 32; x++) {
auto xt = x + (superX * 32); // auto xt = x + (superX * 32);
auto yt = y + (superY * 32); // auto yt = y + (superY * 32);
CopyTile8bpp16((x * 16), (y * 16), tiles_used_[xt][yt], ow_blockset); // CopyTile8bpp16((x * 16), (y * 16), map_tiles_[xt][yt], ow_blockset);
} // }
} // }
} }
void OverworldMap::BuildMapV2(int count, int game_state, uchar* map_parent) { absl::Status OverworldMap::BuildMapV2(int count, int game_state,
uchar* map_parent) {
if (large_map_) { if (large_map_) {
parent_ = map_parent[index_]; parent_ = map_parent[index_];
if (parent_ != index_ && !initialized_) { if (parent_ != index_ && !initialized_) {
if (index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) { if (index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) {
area_graphics_ = area_graphics_ = rom_[core::overworldSpecialGFXGroup + (parent_ - 128)];
rom_.data()[core::overworldSpecialGFXGroup + (parent_ - 128)]; area_palette_ = rom_[core::overworldSpecialPALGroup + 1];
area_palette_ = rom_.data()[core::overworldSpecialPALGroup + 1];
} else if (index_ == 0x88) { } else if (index_ == 0x88) {
area_graphics_ = 81; area_graphics_ = 81;
area_palette_ = 0; area_palette_ = 0;
} else { } else {
area_graphics_ = rom_.data()[core::mapGfx + parent_]; area_graphics_ = rom_[core::mapGfx + parent_];
area_palette_ = rom_.data()[core::overworldMapPalette + parent_]; area_palette_ = rom_[core::overworldMapPalette + parent_];
} }
initialized_ = true; initialized_ = true;
} }
} }
BuildTileset(game_state); auto tileset_status = BuildTileset(game_state);
if (!tileset_status.ok()) {
return tileset_status;
}
// if (index_ < 64) {
// world_ = 0;
// } else if (index_ < 128 && index_ >= 64) {
// world_ = 1;
// } else {
// world_ = 2;
// }
return absl::OkStatus();
} }
absl::Status OverworldMap::BuildTileset(int game_state) { absl::Status OverworldMap::BuildTileset(int game_state) {
@@ -277,7 +294,7 @@ absl::Status OverworldMap::BuildTiles16GfxV2(int count) {
// number of tiles16 3748? // number of tiles16 3748?
for (auto i = 0; i < count; i++) { for (auto i = 0; i < count; i++) {
// 8x8 tile draw, gfx8 = 4bpp so everyting is /2F // 8x8 tile draw, gfx8 = 4bpp so everyting is /2F
auto tiles = tiles16_[i]; auto tiles = tiles16_[i];
for (auto tile = 0; tile < 4; tile++) { for (auto tile = 0; tile < 4; tile++) {

13
src/app/zelda3/overworld_map.h
View File

@@ -22,12 +22,13 @@ static constexpr int kTileOffsets[] = {0, 8, 4096, 4104};
class OverworldMap { class OverworldMap {
public: public:
OverworldMap(int index, ROM& rom, const std::vector<gfx::Tile16>& tiles16); OverworldMap(int index, ROM& rom, const std::vector<gfx::Tile16>& tiles16,
const OWMapTiles& map_tiles);
void BuildMap(int count, int game_state, uchar* map_parent, void BuildMap(int count, int game_state, uchar* map_parent,
uchar* ow_blockset, OWMapTiles& map_tiles); uchar* ow_blockset, OWMapTiles& map_tiles);
void BuildMapV2(int count, int game_state, uchar* map_parent); absl::Status BuildMapV2(int count, int game_state, uchar* map_parent);
auto GetBitmap() { return bitmap_; } auto GetBitmap() { return bitmap_; }
auto GetCurrentGraphicsSet() { return current_graphics_sheet_set; } auto GetCurrentGraphicsSet() { return current_graphics_sheet_set; }
@@ -53,6 +54,7 @@ class OverworldMap {
int parent_ = 0; int parent_ = 0;
int index_ = 0; int index_ = 0;
int world_ = 0;
int message_id_ = 0; int message_id_ = 0;
int area_graphics_ = 0; int area_graphics_ = 0;
int area_palette_ = 0; int area_palette_ = 0;
@@ -65,14 +67,13 @@ class OverworldMap {
bool initialized_ = false; bool initialized_ = false;
bool large_map_ = false; bool large_map_ = false;
ROM rom_;
OWMapTiles map_tiles_;
gfx::Bitmap bitmap_; gfx::Bitmap bitmap_;
std::vector<gfx::Tile16> tiles16_; std::vector<gfx::Tile16> tiles16_;
std::vector<std::vector<ushort>> tiles_used_;
absl::flat_hash_map<int, gfx::Bitmap> current_graphics_sheet_set; absl::flat_hash_map<int, gfx::Bitmap> current_graphics_sheet_set;
ROM rom_;
}; };
} // namespace zelda3 } // namespace zelda3