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

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

@@ -4,6 +4,9 @@
#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/gfx/snes_palette.h"
@@ -80,8 +83,8 @@ absl::StatusOr<std::vector<Bitmap>> Bitmap::CreateTiles() {
auto surface = bmp.GetSurface();
SDL_Rect src_rect = {i, j, 8, 8};
if (SDL_BlitSurface(surface_.get(), &src_rect, surface, nullptr) != 0)
return absl::InvalidArgumentError(
"Failed to blit surface for Bitmap Tilesheet");
return absl::InternalError(
absl::StrCat("Failed to blit surface: ", SDL_GetError()));
tiles.push_back(bmp);
}
}
@@ -90,15 +93,17 @@ absl::StatusOr<std::vector<Bitmap>> Bitmap::CreateTiles() {
// Converts a vector of 8x8 tiles into a tilesheet.
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 dest_rect = {0, 0, 8, 8};
for (const auto &tile : tiles) {
auto src = tile.GetSurface();
if (SDL_BlitSurface(src, &tile_rect, surface_.get(), &dest_rect) != 0)
return absl::InvalidArgumentError(
"Failed to blit surface for Bitmap Tilesheet");
return absl::InternalError(
absl::StrCat("Failed to blit surface: ", SDL_GetError()));
dest_rect.x++;
if (dest_rect.x == 15) {

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

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

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

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

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

@@ -17,46 +17,50 @@ namespace app {
namespace zelda3 {
OverworldMap::OverworldMap(int index, ROM& rom,
const std::vector<gfx::Tile16>& tiles16)
: parent_(index), index_(index), tiles16_(tiles16), rom_(rom) {
const std::vector<gfx::Tile16>& tiles16,
const OWMapTiles& map_tiles)
: parent_(index),
index_(index),
rom_(rom),
tiles16_(tiles16),
map_tiles_(map_tiles) {
LoadAreaInfo();
bitmap_.Create(512, 512, 8, 512 * 512);
}
void OverworldMap::LoadAreaInfo() {
auto z3data = rom_.data();
if (index_ != 0x80 && index_ <= 150 &&
rom_.data()[core::overworldMapSize + (index_ & 0x3F)] != 0) {
rom_[core::overworldMapSize + (index_ & 0x3F)] != 0) {
large_map_ = true;
}
if (index_ < 64) {
area_graphics_ = z3data[core::mapGfx + parent_];
area_palette_ = z3data[core::overworldMapPalette + parent_];
area_graphics_ = rom_[core::mapGfx + parent_];
area_palette_ = rom_[core::overworldMapPalette + parent_];
area_music_[0] = z3data[core::overworldMusicBegining + parent_];
area_music_[1] = z3data[core::overworldMusicZelda + parent_];
area_music_[2] = z3data[core::overworldMusicMasterSword + parent_];
area_music_[3] = z3data[core::overworldMusicAgahim + parent_];
area_music_[0] = rom_[core::overworldMusicBegining + parent_];
area_music_[1] = rom_[core::overworldMusicZelda + parent_];
area_music_[2] = rom_[core::overworldMusicMasterSword + parent_];
area_music_[3] = rom_[core::overworldMusicAgahim + parent_];
sprite_graphics_[0] = z3data[core::overworldSpriteset + parent_];
sprite_graphics_[1] = z3data[core::overworldSpriteset + parent_ + 64];
sprite_graphics_[2] = z3data[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[0] = rom_[core::overworldSpriteset + parent_];
sprite_graphics_[1] = rom_[core::overworldSpriteset + parent_ + 64];
sprite_graphics_[2] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_palette_[0] = z3data[core::overworldSpritePalette + parent_];
sprite_palette_[1] = z3data[core::overworldSpritePalette + parent_ + 64];
sprite_palette_[2] = z3data[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[0] = rom_[core::overworldSpritePalette + parent_];
sprite_palette_[1] = rom_[core::overworldSpritePalette + parent_ + 64];
sprite_palette_[2] = rom_[core::overworldSpritePalette + parent_ + 128];
} else if (index_ < 128) {
area_graphics_ = z3data[core::mapGfx + parent_];
area_palette_ = z3data[core::overworldMapPalette + parent_];
area_music_[0] = z3data[core::overworldMusicDW + (parent_ - 64)];
area_graphics_ = rom_[core::mapGfx + parent_];
area_palette_ = rom_[core::overworldMapPalette + parent_];
area_music_[0] = rom_[core::overworldMusicDW + (parent_ - 64)];
sprite_graphics_[0] = z3data[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[1] = z3data[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[2] = z3data[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[0] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[1] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[2] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_palette_[0] = z3data[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[1] = z3data[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[2] = z3data[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[0] = rom_[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[1] = rom_[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[2] = rom_[core::overworldSpritePalette + parent_ + 128];
} else {
if (index_ == 0x94) {
parent_ = 128;
@@ -78,28 +82,28 @@ void OverworldMap::LoadAreaInfo() {
parent_ = 136;
}
area_palette_ = z3data[core::overworldSpecialPALGroup + parent_ - 128];
area_palette_ = rom_[core::overworldSpecialPALGroup + parent_ - 128];
if (index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) {
area_graphics_ = z3data[core::overworldSpecialGFXGroup + (parent_ - 128)];
area_palette_ = z3data[core::overworldSpecialPALGroup + 1];
area_graphics_ = rom_[core::overworldSpecialGFXGroup + (parent_ - 128)];
area_palette_ = rom_[core::overworldSpecialPALGroup + 1];
} else if (index_ == 0x88) {
area_graphics_ = 81;
area_palette_ = 0;
} else {
// pyramid bg use 0x5B map
area_graphics_ = z3data[core::mapGfx + parent_];
area_palette_ = z3data[core::overworldMapPalette + parent_];
area_graphics_ = rom_[core::mapGfx + 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_[1] = z3data[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[2] = z3data[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[0] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[1] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_graphics_[2] = rom_[core::overworldSpriteset + parent_ + 128];
sprite_palette_[0] = z3data[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[1] = z3data[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[2] = z3data[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[0] = rom_[core::overworldSpritePalette + parent_ + 128];
sprite_palette_[1] = rom_[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);
BuildTiles16Gfx(count, ow_blockset); // build on GFX.mapgfx16Ptr
int world = 0;
if (index_ < 64) {
tiles_used_ = map_tiles.light_world;
} else if (index_ < 128 && index_ >= 64) {
tiles_used_ = map_tiles.dark_world;
world = 1;
} else {
tiles_used_ = map_tiles.special_world;
world = 2;
}
// int world = 0;
// if (index_ < 64) {
// map_tiles_ = map_tiles.light_world;
// } else if (index_ < 128 && index_ >= 64) {
// map_tiles_ = map_tiles.dark_world;
// world = 1;
// } else {
// map_tiles_ = map_tiles.special_world;
// world = 2;
// }
int superY = ((index_ - (world * 64)) / 8);
int superX = index_ - (world * 64) - (superY * 8);
for (int y = 0; y < 32; y++) {
for (int x = 0; x < 32; x++) {
auto xt = x + (superX * 32);
auto yt = y + (superY * 32);
CopyTile8bpp16((x * 16), (y * 16), tiles_used_[xt][yt], ow_blockset);
}
}
// int superY = ((index_ - (world * 64)) / 8);
// int superX = index_ - (world * 64) - (superY * 8);
// for (int y = 0; y < 32; y++) {
// for (int x = 0; x < 32; x++) {
// auto xt = x + (superX * 32);
// auto yt = y + (superY * 32);
// 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_) {
parent_ = map_parent[index_];
if (parent_ != index_ && !initialized_) {
if (index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) {
area_graphics_ =
rom_.data()[core::overworldSpecialGFXGroup + (parent_ - 128)];
area_palette_ = rom_.data()[core::overworldSpecialPALGroup + 1];
area_graphics_ = rom_[core::overworldSpecialGFXGroup + (parent_ - 128)];
area_palette_ = rom_[core::overworldSpecialPALGroup + 1];
} else if (index_ == 0x88) {
area_graphics_ = 81;
area_palette_ = 0;
} else {
area_graphics_ = rom_.data()[core::mapGfx + parent_];
area_palette_ = rom_.data()[core::overworldMapPalette + parent_];
area_graphics_ = rom_[core::mapGfx + parent_];
area_palette_ = rom_[core::overworldMapPalette + parent_];
}
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) {
@@ -277,7 +294,7 @@ absl::Status OverworldMap::BuildTiles16GfxV2(int count) {
// number of tiles16 3748?
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];
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 {
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,
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 GetCurrentGraphicsSet() { return current_graphics_sheet_set; }
@@ -53,6 +54,7 @@ class OverworldMap {
int parent_ = 0;
int index_ = 0;
int world_ = 0;
int message_id_ = 0;
int area_graphics_ = 0;
int area_palette_ = 0;
@@ -65,14 +67,13 @@ class OverworldMap {
bool initialized_ = false;
bool large_map_ = false;
ROM rom_;
OWMapTiles map_tiles_;
gfx::Bitmap bitmap_;
std::vector<gfx::Tile16> tiles16_;
std::vector<std::vector<ushort>> tiles_used_;
absl::flat_hash_map<int, gfx::Bitmap> current_graphics_sheet_set;
ROM rom_;
};
} // namespace zelda3