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

palettes and overworld drawing

Browse Source
This commit is contained in:
scawful
2022-09-10 16:33:59 -05:00
parent 8cc9adf41a
commit 1244e6855c
14 changed files with 168 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/app/core/controller.cc
View File

@@ -23,6 +23,7 @@ namespace {
void InitializeKeymap() {
ImGuiIO &io = ImGui::GetIO();
io.KeyMap[ImGuiKey_Backspace] = SDL_GetScancodeFromKey(SDLK_BACKSPACE);
io.KeyMap[ImGuiKey_LeftShift] = SDL_GetScancodeFromKey(SDLK_LSHIFT);
io.KeyMap[ImGuiKey_Enter] = SDL_GetScancodeFromKey(SDLK_RETURN);
io.KeyMap[ImGuiKey_UpArrow] = SDL_GetScancodeFromKey(SDLK_UP);
io.KeyMap[ImGuiKey_DownArrow] = SDL_GetScancodeFromKey(SDLK_DOWN);
@@ -37,6 +38,8 @@ void HandleKeyDown(SDL_Event &event) {
case SDLK_DOWN:
case SDLK_RETURN:
case SDLK_BACKSPACE:
case SDLK_LSHIFT:
case SDLK_LCTRL:
case SDLK_TAB:
io.KeysDown[event.key.keysym.scancode] = (event.type == SDL_KEYDOWN);
break;

70
src/app/editor/overworld_editor.cc
View File

@@ -16,25 +16,26 @@
#include "gui/canvas.h"
#include "gui/icons.h"
/**
* Drawing the Overworld
* Tips by Zarby
*
* 1) Find the graphics pointers (constants.h)
* 2) Convert the 3bpp SNES data into PC 4bpp (Hard)
* 3) Get the tiles32 data
* 4) Get the tiles16 data
* 5) Get the map32 data using lz2 variant decompression
* 6) Get the graphics data of the map
* 7) Load 4bpp into Pseudo VRAM for rendering tiles to screen
* 8) Render the tiles to a bitmap with a B&W palette to start
* 9) Get the palette data and find how it's loaded in game
*
*/
namespace yaze {
namespace app {
namespace editor {
namespace {
void UpdateSelectedTile16(int selected, gfx::Bitmap &tile16_blockset,
gfx::Bitmap &selected_tile) {
auto blockset = tile16_blockset.GetData();
auto bitmap = selected_tile.GetData();
int src_pos = ((selected - ((selected / 0x08) * 0x08)) * 0x10) +
((selected / 0x08) * 2048);
for (int yy = 0; yy < 0x10; yy++) {
for (int xx = 0; xx < 0x10; xx++) {
bitmap[xx + (yy * 0x10)] = blockset[src_pos + xx + (yy * 0x80)];
}
}
}
} // namespace
void OverworldEditor::SetupROM(ROM &rom) { rom_ = rom; }
absl::Status OverworldEditor::Update() {
@@ -46,20 +47,40 @@ absl::Status OverworldEditor::Update() {
current_gfx_bmp_.Create(128, 512, 64, overworld_.GetCurrentGraphics());
rom_.RenderBitmap(&current_gfx_bmp_);
auto tile16_palette = overworld_.GetCurrentPalette();
tile16_blockset_bmp_.Create(128, 8192, 128,
overworld_.GetCurrentBlockset());
for (int j = 0; j < tile16_palette.colors.size(); j++) {
tile16_blockset_bmp_.SetPaletteColor(j, tile16_palette.GetColor(j));
}
rom_.RenderBitmap(&tile16_blockset_bmp_);
map_blockset_loaded_ = true;
for (int i = 0; i < core::kNumOverworldMaps; ++i) {
overworld_.SetCurrentMap(i);
auto palette = overworld_.GetCurrentPalette();
maps_bmp_[i].Create(512, 512, 512, overworld_.GetCurrentBitmapData());
maps_bmp_[i].ApplyPalette(palette);
for (int j = 0; j < palette.colors.size(); j++) {
maps_bmp_[i].SetPaletteColor(j, palette.GetColor(j));
}
rom_.RenderBitmap(&(maps_bmp_[i]));
}
}
if (update_selected_tile_ && all_gfx_loaded_) {
if (!selected_tile_loaded_) {
selected_tile_bmp_.Create(16, 16, 64, 256);
}
UpdateSelectedTile16(selected_tile_, tile16_blockset_bmp_,
selected_tile_bmp_);
auto palette = overworld_.GetCurrentPalette();
for (int j = 0; j < palette.colors.size(); j++) {
selected_tile_bmp_.SetPaletteColor(j, palette.GetColor(j));
}
rom_.RenderBitmap(&selected_tile_bmp_);
update_selected_tile_ = false;
}
auto toolset_status = DrawToolset();
RETURN_IF_ERROR(toolset_status)
@@ -81,7 +102,7 @@ absl::Status OverworldEditor::Update() {
}
absl::Status OverworldEditor::DrawToolset() {
if (ImGui::BeginTable("OWToolset", 17, toolset_table_flags, ImVec2(0, 0))) {
if (ImGui::BeginTable("OWToolset", 15, toolset_table_flags, ImVec2(0, 0))) {
for (const auto &name : kToolsetColumnNames)
ImGui::TableSetupColumn(name.data());
@@ -119,19 +140,6 @@ absl::Status OverworldEditor::DrawToolset() {
// Music
ImGui::TableNextColumn();
ImGui::Button(ICON_MD_MUSIC_NOTE);
ImGui::TableNextColumn();
ImGui::Text(ICON_MD_MORE_VERT);
ImGui::TableNextColumn();
ImGui::Text("Palette:");
for (int i = 0; i < 8; i++) {
std::string id = "##PaletteColor" + std::to_string(i);
ImGui::SameLine();
ImGui::ColorEdit4(id.c_str(), &current_palette_[i].x,
ImGuiColorEditFlags_NoInputs |
ImGuiColorEditFlags_DisplayRGB |
ImGuiColorEditFlags_DisplayHex);
}
ImGui::EndTable();
}

6
src/app/editor/overworld_editor.h
View File

@@ -32,7 +32,7 @@ static constexpr absl::string_view kToolsetColumnNames[] = {
"#undoTool", "#redoTool", "#drawTool", "#separator2",
"#zoomOutTool", "#zoomInTool", "#separator", "#history",
"#entranceTool", "#exitTool", "#itemTool", "#spriteTool",
"#transportTool", "#musicTool", "#separator3", "#reloadTool"};
"#transportTool", "#musicTool" };
static constexpr absl::string_view kOverworldSettingsColumnNames[] = {
"##1stCol", "##gfxCol", "##palCol", "##sprgfxCol",
@@ -60,6 +60,7 @@ class OverworldEditor {
int current_world_ = 0;
int current_map_ = 0;
int selected_tile_ = 0;
char map_gfx_[3] = "";
char map_palette_[3] = "";
char spr_gfx_[3] = "";
@@ -70,6 +71,8 @@ class OverworldEditor {
bool opt_enable_grid = true;
bool all_gfx_loaded_ = false;
bool map_blockset_loaded_ = false;
bool selected_tile_loaded_ = false;
bool update_selected_tile_ = true;
ImVec4 current_palette_[8];
@@ -90,6 +93,7 @@ class OverworldEditor {
gfx::Bitmap tile16_blockset_bmp_; // pointer size 1048576
gfx::Bitmap current_gfx_bmp_; // pointer size 32768
gfx::Bitmap all_gfx_bmp; // pointer size 456704
gfx::Bitmap selected_tile_bmp_;
gui::Canvas overworld_map_canvas_;
gui::Canvas current_gfx_canvas_;

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

@@ -103,15 +103,17 @@ void Bitmap::CreateTexture(std::shared_ptr<SDL_Renderer> renderer) {
}
// Convert SNESPalette to SDL_Palette for surface.
void Bitmap::ApplyPalette(SNESPalette palette) {
void Bitmap::ApplyPalette(const SNESPalette & palette) {
palette_ = palette;
surface_->format->palette = palette_.GetSDL_Palette();
SDL_SetPaletteColors(surface_->format->palette,
palette_.GetSDL_Palette()->colors,
0, 256);
}
void Bitmap::SetPaletteColor(int id, gfx::snes_color color) {
surface_->format->palette->colors[id].r = color.red;
surface_->format->palette->colors[id].b = color.blue;
surface_->format->palette->colors[id].g = color.green;
void Bitmap::SetPaletteColor(int id, gfx::SNESColor color) {
surface_->format->palette->colors[id].r = color.rgb.x;
surface_->format->palette->colors[id].g = color.rgb.y;
surface_->format->palette->colors[id].b = color.rgb.z;
}
// Creates a vector of bitmaps which are individual 8x8 tiles.

4
src/app/gfx/bitmap.h
View File

@@ -30,8 +30,8 @@ class Bitmap {
void CreateTexture(std::shared_ptr<SDL_Renderer> renderer);
void ApplyPalette(SNESPalette palette);
void SetPaletteColor(int id, gfx::snes_color color);
void ApplyPalette(const SNESPalette &palette);
void SetPaletteColor(int id, gfx::SNESColor color);
absl::StatusOr<std::vector<Bitmap>> CreateTiles();
absl::Status CreateFromTiles(const std::vector<Bitmap> &tiles);

20
src/app/gfx/snes_palette.cc
View File

@@ -64,7 +64,11 @@ char* Convert(const snes_palette pal) {
SNESColor::SNESColor() : rgb(ImVec4(0.f, 0.f, 0.f, 0.f)) {}
SNESColor::SNESColor(snes_color val) { snes = ConvertRGBtoSNES(val); }
SNESColor::SNESColor(snes_color val) {
rgb.x = val.red;
rgb.y = val.blue;
rgb.z = val.green;
}
SNESColor::SNESColor(ImVec4 val) : rgb(val) {
snes_color col;
@@ -83,7 +87,9 @@ void SNESColor::setRgb(ImVec4 val) {
snes = ConvertRGBtoSNES(col);
}
void SNESColor::setRgb(snes_color val) { snes = ConvertRGBtoSNES(val); }
void SNESColor::setSNES(snes_color val) {
rgb = ImVec4(val.red, val.green, val.blue, 1.f);
}
void SNESColor::setSNES(uint16_t val) {
snes = val;
@@ -137,7 +143,7 @@ SNESPalette::SNESPalette(const std::vector<ImVec4>& cols) {
SNESPalette::SNESPalette(const std::vector<snes_color>& cols) {
for (const auto& each : cols) {
SNESColor scol;
scol.setRgb(each);
scol.setSNES(each);
colors.push_back(scol);
}
size_ = cols.size();
@@ -151,7 +157,7 @@ SNESPalette::SNESPalette(const std::vector<SNESColor>& cols) {
}
void SNESPalette::Create(const std::vector<SNESColor>& cols) {
for (const auto& each : cols) {
for (const auto each : cols) {
colors.push_back(each);
}
size_ = cols.size();
@@ -176,6 +182,7 @@ SDL_Palette* SNESPalette::GetSDL_Palette() {
color[i].r = (uint8_t)colors[i].rgb.x * 100;
color[i].g = (uint8_t)colors[i].rgb.y * 100;
color[i].b = (uint8_t)colors[i].rgb.z * 100;
color[i].a = 0;
std::cout << "Color " << i << " added (R:" << color[i].r
<< " G:" << color[i].g << " B:" << color[i].b << ")" << std::endl;
}
@@ -183,10 +190,7 @@ SDL_Palette* SNESPalette::GetSDL_Palette() {
return sdl_palette.get();
}
PaletteGroup::PaletteGroup(uint8_t mSize) {
size = mSize;
palettes.reserve(size);
}
PaletteGroup::PaletteGroup(uint8_t mSize) : size(mSize) {}
} // namespace gfx
} // namespace app

21
src/app/gfx/snes_palette.h
View File

@@ -41,11 +41,13 @@ struct SNESColor {
SNESColor();
explicit SNESColor(ImVec4);
explicit SNESColor(snes_color);
void setRgb(ImVec4);
void setSNES(snes_color);
void setSNES(uint16_t);
uint16_t snes = 0;
ImVec4 rgb;
void setRgb(ImVec4);
void setRgb(snes_color);
void setSNES(uint16_t);
};
class SNESPalette {
@@ -59,7 +61,7 @@ class SNESPalette {
explicit SNESPalette(const std::vector<SNESColor>&);
void Create(const std::vector<SNESColor>&);
void AddColor(SNESColor color) { colors.push_back(color); }
auto GetColor(int i) const { return colors[i]; }
SNESColor operator[](int i) {
@@ -80,6 +82,17 @@ class SNESPalette {
struct PaletteGroup {
PaletteGroup() = default;
explicit PaletteGroup(uint8_t mSize);
void AddPalette(SNESPalette pal) {
palettes.emplace_back(pal);
size = palettes.size();
}
void AddColor(SNESColor color) {
if (size == 0) {
SNESPalette empty_pal;
palettes.emplace_back(empty_pal);
}
palettes[0].AddColor(color);
}
SNESPalette operator[](int i) {
if (i > size) {
std::cout << "PaletteGroup: Index out of bounds" << std::endl;

75
src/app/rom.cc
View File

@@ -19,7 +19,6 @@
#include "app/core/common.h"
#include "app/core/constants.h"
#include "app/gfx/bitmap.h"
#include "app/zelda3/palettes.h"
#define COMPRESSION_STRING_MOD 7 << 5
@@ -535,8 +534,8 @@ absl::StatusOr<Bytes> ROM::Decompress(int offset, int size, int mode) {
if (mode == kNintendoMode1) { // Reversed byte order for overworld maps
// addr = (s2 | s1);
addr = (rom_data_[offset + 2]) | ((rom_data_[offset + 1]) << 8);
memcpy(buffer.data() + buffer_pos, rom_data_.data() + offset, length);
addr = (rom_data_[offset + 1]) | ((rom_data_[offset]) << 8);
memcpy(buffer.data() + buffer_pos, buffer.data() + addr, length);
buffer_pos += length;
offset += 2;
break;
@@ -699,7 +698,7 @@ gfx::SNESColor ROM::ReadColor(int offset) {
gfx::SNESPalette ROM::ReadPalette(int offset, int num_colors) {
int color_offset = 0;
std::vector<gfx::snes_color> colors(num_colors);
std::vector<gfx::SNESColor> colors(num_colors);
while (color_offset < num_colors) {
short color = (short)((rom_data_[offset + 1] << 8) + rom_data_[offset]);
@@ -707,7 +706,7 @@ gfx::SNESPalette ROM::ReadPalette(int offset, int num_colors) {
new_color.red = (color & 0x1F) * 8;
new_color.green = ((color >> 5) & 0x1F) * 8;
new_color.blue = ((color >> 10) & 0x1F) * 8;
colors[color_offset] = new_color;
colors[color_offset].setSNES(new_color);
color_offset++;
offset += 2;
}
@@ -719,66 +718,70 @@ gfx::SNESPalette ROM::ReadPalette(int offset, int num_colors) {
void ROM::LoadAllPalettes() {
// 35 colors each, 7x5 (0,2 on grid)
for (int i = 0; i < 6; i++) {
zelda3::overworld_MainPalettes[i] =
ReadPalette(core::overworldPaletteMain + (i * (35 * 2)), 35);
palette_groups_["ow_main"].AddPalette(
ReadPalette(core::overworldPaletteMain + (i * (35 * 2)), 35));
}
// 21 colors each, 7x3 (8,2 and 8,5 on grid)
for (int i = 0; i < 20; i++) {
zelda3::overworld_AuxPalettes[i] =
ReadPalette(core::overworldPaletteAuxialiary + (i * (21 * 2)), 21);
palette_groups_["ow_aux"].AddPalette(
ReadPalette(core::overworldPaletteAuxialiary + (i * (21 * 2)), 21));
}
// 7 colors each 7x1 (0,7 on grid)
for (int i = 0; i < 14; i++) {
zelda3::overworld_AnimatedPalettes[i] =
ReadPalette(core::overworldPaletteAnimated + (i * (7 * 2)), 7);
palette_groups_["ow_animated"].AddPalette(
ReadPalette(core::overworldPaletteAnimated + (i * (7 * 2)), 7));
}
// 32 colors each 16x2 (0,0 on grid)
for (int i = 0; i < 2; i++) {
zelda3::HudPalettes[i] = ReadPalette(core::hudPalettes + (i * 64), 32);
palette_groups_["hud"].AddPalette(
ReadPalette(core::hudPalettes + (i * 64), 32));
}
zelda3::globalSprite_Palettes[0] =
ReadPalette(core::globalSpritePalettesLW, 60);
zelda3::globalSprite_Palettes[1] =
ReadPalette(core::globalSpritePalettesDW, 60);
palette_groups_["global_sprites"].AddPalette(
ReadPalette(core::globalSpritePalettesLW, 60));
palette_groups_["global_sprites"].AddPalette(
ReadPalette(core::globalSpritePalettesDW, 60));
for (int i = 0; i < 5; i++) {
zelda3::armors_Palettes[i] =
ReadPalette(core::armorPalettes + (i * 30), 15);
palette_groups_["armors"].AddPalette(
ReadPalette(core::armorPalettes + (i * 30), 15));
}
for (int i = 0; i < 4; i++) {
zelda3::swords_Palettes[i] = ReadPalette(core::swordPalettes + (i * 6), 3);
palette_groups_["swords"].AddPalette(
ReadPalette(core::swordPalettes + (i * 6), 3));
}
for (int i = 0; i < 3; i++) {
zelda3::shields_Palettes[i] =
ReadPalette(core::shieldPalettes + (i * 8), 4);
palette_groups_["shields"].AddPalette(
ReadPalette(core::shieldPalettes + (i * 8), 4));
}
for (int i = 0; i < 12; i++) {
zelda3::spritesAux1_Palettes[i] =
ReadPalette(core::spritePalettesAux1 + (i * 14), 7);
palette_groups_["sprites_aux1"].AddPalette(
ReadPalette(core::spritePalettesAux1 + (i * 14), 7));
}
for (int i = 0; i < 11; i++) {
zelda3::spritesAux2_Palettes[i] =
ReadPalette(core::spritePalettesAux2 + (i * 14), 7);
palette_groups_["sprites_aux2"].AddPalette(
ReadPalette(core::spritePalettesAux2 + (i * 14), 7));
}
for (int i = 0; i < 24; i++) {
zelda3::spritesAux3_Palettes[i] =
ReadPalette(core::spritePalettesAux3 + (i * 14), 7);
palette_groups_["sprites_aux3"].AddPalette(
ReadPalette(core::spritePalettesAux3 + (i * 14), 7));
}
for (int i = 0; i < 20; i++) {
zelda3::dungeonsMain_Palettes[i] =
ReadPalette(core::dungeonMainPalettes + (i * 180), 90);
palette_groups_["dungeon_main"].AddPalette(
ReadPalette(core::dungeonMainPalettes + (i * 180), 90));
}
zelda3::overworld_GrassPalettes[0] = ReadColor(core::hardcodedGrassLW);
zelda3::overworld_GrassPalettes[1] = ReadColor(core::hardcodedGrassDW);
zelda3::overworld_GrassPalettes[2] = ReadColor(core::hardcodedGrassSpecial);
palette_groups_["grass"].AddColor(ReadColor(core::hardcodedGrassLW));
palette_groups_["grass"].AddColor(ReadColor(core::hardcodedGrassDW));
palette_groups_["grass"].AddColor(ReadColor(core::hardcodedGrassSpecial));
zelda3::object3D_Palettes[0] = ReadPalette(core::triforcePalette, 8);
zelda3::object3D_Palettes[1] = ReadPalette(core::crystalPalette, 8);
palette_groups_["3d_object"].AddPalette(
ReadPalette(core::triforcePalette, 8));
palette_groups_["3d_object"].AddPalette(ReadPalette(core::crystalPalette, 8));
for (int i = 0; i < 2; i++) {
zelda3::overworld_Mini_Map_Palettes[i] =
ReadPalette(core::overworldMiniMapPalettes + (i * 256), 128);
palette_groups_["ow_mini_map"].AddPalette(
ReadPalette(core::overworldMiniMapPalettes + (i * 256), 128));
}
// TODO: check for the paletts in the empty bank space that kan will allocate

3
src/app/rom.h
View File

@@ -20,7 +20,6 @@
#include "app/core/common.h"
#include "app/core/constants.h"
#include "app/gfx/bitmap.h"
#include "app/zelda3/palettes.h"
#define BUILD_HEADER(command, length) (command << 5) + (length - 1)
@@ -94,6 +93,7 @@ class ROM {
auto GetTitle() const { return title; }
auto GetGraphicsBin() const { return graphics_bin_; }
auto GetGraphicsBuffer() const { return graphics_buffer_; }
auto GetPaletteGroup(std::string group) { return palette_groups_[group]; }
void SetupRenderer(std::shared_ptr<SDL_Renderer> renderer) {
renderer_ = renderer;
}
@@ -133,6 +133,7 @@ class ROM {
Bytes graphics_buffer_;
std::shared_ptr<SDL_Renderer> renderer_;
std::unordered_map<int, gfx::Bitmap> graphics_bin_;
std::unordered_map<std::string, gfx::PaletteGroup> palette_groups_;
};
} // namespace app

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

@@ -31,11 +31,11 @@ void CopyTile8bpp16(int x, int y, int tile, Bytes& bitmap, Bytes& blockset) {
}
}
void SetColorsPalette(int index, gfx::SNESPalette& current, gfx::SNESPalette main,
gfx::SNESPalette animated, gfx::SNESPalette aux1,
gfx::SNESPalette aux2, gfx::SNESPalette hud,
gfx::SNESColor bgrcolor, gfx::SNESPalette spr,
gfx::SNESPalette spr2) {
void SetColorsPalette(ROM& rom, int index, gfx::SNESPalette& current,
gfx::SNESPalette main, gfx::SNESPalette animated,
gfx::SNESPalette aux1, gfx::SNESPalette aux2,
gfx::SNESPalette hud, gfx::SNESColor bgrcolor,
gfx::SNESPalette spr, gfx::SNESPalette spr2) {
// Palettes infos, color 0 of a palette is always transparent (the arrays
// contains 7 colors width wide) There is 16 color per line so 16*Y
@@ -88,7 +88,7 @@ void SetColorsPalette(int index, gfx::SNESPalette& current, gfx::SNESPalette mai
k = 0;
for (int y = 8; y < 9; y++) {
for (int x = 1; x < 8; x++) {
new_palette[x + (16 * y)] = spritesAux1_Palettes[1][k++];
new_palette[x + (16 * y)] = rom.GetPaletteGroup("sprites_aux1")[1][k++];
}
}
@@ -96,7 +96,7 @@ void SetColorsPalette(int index, gfx::SNESPalette& current, gfx::SNESPalette mai
k = 0;
for (int y = 8; y < 9; y++) {
for (int x = 9; x < 16; x++) {
new_palette[x + (16 * y)] = spritesAux3_Palettes[0][k++];
new_palette[x + (16 * y)] = rom.GetPaletteGroup("sprites_aux3")[0][k++];
}
}
@@ -104,7 +104,7 @@ void SetColorsPalette(int index, gfx::SNESPalette& current, gfx::SNESPalette mai
k = 0;
for (int y = 9; y < 13; y++) {
for (int x = 1; x < 16; x++) {
new_palette[x + (16 * y)] = globalSprite_Palettes[0][k++];
new_palette[x + (16 * y)] = rom.GetPaletteGroup("global_sprites")[0][k++];
}
}
@@ -128,7 +128,7 @@ void SetColorsPalette(int index, gfx::SNESPalette& current, gfx::SNESPalette mai
k = 0;
for (int y = 15; y < 16; y++) {
for (int x = 1; x < 16; x++) {
new_palette[x + (16 * y)] = armors_Palettes[0][k++];
new_palette[x + (16 * y)] = rom.GetPaletteGroup("armors")[0][k++];
}
}
@@ -345,8 +345,14 @@ void OverworldMap::LoadPalette() {
uchar pal5 = rom_[core::overworldSpritePaletteGroup +
(sprite_palette_[game_state_] * 2) + 1]; // spr4
gfx::SNESPalette aux1, aux2, main, animated, hud, spr, spr2;
gfx::SNESColor bgr = overworld_GrassPalettes[0];
gfx::SNESPalette aux1;
gfx::SNESPalette aux2;
gfx::SNESPalette main;
gfx::SNESPalette animated;
gfx::SNESPalette hud;
gfx::SNESPalette spr;
gfx::SNESPalette spr2;
gfx::SNESColor bgr = rom_.GetPaletteGroup("grass")[0].GetColor(0);
if (pal1 == 255) {
pal1 = rom_[core::overworldMapPaletteGroup + (previousPalId * 4)];
@@ -356,9 +362,9 @@ void OverworldMap::LoadPalette() {
pal1 = 19;
}
aux1 = overworld_AuxPalettes[pal1];
aux1 = rom_.GetPaletteGroup("ow_aux")[pal1];
} else {
aux1 = overworld_AuxPalettes[0];
aux1 = rom_.GetPaletteGroup("ow_aux")[0];
}
if (pal2 == 255) {
@@ -369,9 +375,9 @@ void OverworldMap::LoadPalette() {
pal2 = 19;
}
aux2 = overworld_AuxPalettes[pal2];
aux2 = rom_.GetPaletteGroup("ow_aux")[pal2];
} else {
aux2 = overworld_AuxPalettes[0];
aux2 = rom_.GetPaletteGroup("ow_aux")[0];
}
if (pal3 == 255) {
@@ -382,37 +388,20 @@ void OverworldMap::LoadPalette() {
// Default LW Palette
pal0 = 0;
// TODO CHECK ME FOR NECESSITY
// if (OverworldEditor.UseAreaSpecificBgColor) {
// bgr = overworld_BackgroundPalette[parent_];
// } else {
// bgr = overworld_GrassPalettes[0];
// }
if (parent_ == 0x03 || parent_ == 0x05 || parent_ == 0x07) {
pal0 = 2;
}
} else if (parent_ >= 0x40 && parent_ < 0x80) {
// Default DW Palette
pal0 = 1;
// if (OverworldEditor.UseAreaSpecificBgColor) {
// bgr = Palettes.overworld_BackgroundPalette[parent_];
// } else {
// bgr = Palettes.overworld_GrassPalettes[1];
// }
bgr = rom_.GetPaletteGroup("grass")[0].GetColor(1);
if (parent_ == 0x43 || parent_ == 0x45 || parent_ == 0x47) {
pal0 = 3;
}
} else if (parent_ >= 128 && parent_ < core::kNumOverworldMaps) {
// Default SP Palette
pal0 = 0;
// if (OverworldEditor.UseAreaSpecificBgColor) {
// bgr = overworld_BackgroundPalette[parent_];
// } else {
// bgr = overworld_GrassPalettes[2];
// }
bgr = rom_.GetPaletteGroup("grass")[0].GetColor(2);
}
if (parent_ == 0x88) {
@@ -420,17 +409,17 @@ void OverworldMap::LoadPalette() {
}
if (pal0 != 255) {
main = overworld_MainPalettes[pal0];
main = rom_.GetPaletteGroup("ow_main")[pal0];
} else {
main = overworld_MainPalettes[0];
main = rom_.GetPaletteGroup("ow_main")[0];
}
if (pal3 >= 14) {
pal3 = 13;
}
animated = overworld_AnimatedPalettes[(pal3)];
animated = rom_.GetPaletteGroup("ow_animated")[(pal3)];
hud = HudPalettes[0];
hud = rom_.GetPaletteGroup("hud")[0];
if (pal4 == 255) {
pal4 = rom_[core::overworldSpritePaletteGroup +
(previousSprPalId * 2)]; // spr3
@@ -441,7 +430,7 @@ void OverworldMap::LoadPalette() {
if (pal4 >= 24) {
pal4 = 23;
}
spr = spritesAux3_Palettes[pal4];
spr = rom_.GetPaletteGroup("sprites_aux3")[pal4];
if (pal5 == 255) {
pal5 = rom_[core::overworldSpritePaletteGroup + (previousSprPalId * 2) +
@@ -453,9 +442,10 @@ void OverworldMap::LoadPalette() {
if (pal5 >= 24) {
pal5 = 23;
}
spr2 = spritesAux3_Palettes[pal5];
spr2 = rom_.GetPaletteGroup("sprites_aux3")[pal5];
SetColorsPalette(parent_, current_palette_, main, animated, aux1, aux2, hud, bgr, spr, spr2);
SetColorsPalette(rom_, parent_, current_palette_, main, animated, aux1, aux2,
hud, bgr, spr, spr2);
}
absl::Status OverworldMap::BuildTileset() {
@@ -505,7 +495,8 @@ absl::Status OverworldMap::BuildTiles16Gfx(int count) {
int source = ypos + xpos + (x + (y * 0x80));
auto destination = xx + yy + offset + (mx + (my * 0x80));
current_blockset_[destination] = current_gfx_[source];
current_blockset_[destination] =
current_gfx_[source] + (info.palette_ * 0x10);
}
}
}

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

@@ -13,7 +13,6 @@
#include "app/core/common.h"
#include "app/gfx/bitmap.h"
#include "app/gfx/snes_tile.h"
#include "app/zelda3/palettes.h"
#include "app/rom.h"
namespace yaze {

45
src/app/zelda3/palettes.h
View File

@@ -1,45 +0,0 @@
#ifndef YAZE_APP_ZELDA3_PALETTES_H
#define YAZE_APP_ZELDA3_PALETTES_H
#include <cstdint>
#include "app/core/common.h"
#include "app/gfx/bitmap.h"
#include "app/gfx/snes_tile.h"
#include "app/rom.h"
namespace yaze {
namespace app {
namespace zelda3 {
// 32 (0,0)
static gfx::PaletteGroup HudPalettes(2);
// 35 colors each, 7x5 (0,2 on grid)
static gfx::PaletteGroup overworld_MainPalettes(6);
// 21 colors each, 7x3 (8,2 and 8,5 on grid)
static gfx::PaletteGroup overworld_AuxPalettes(20);
// 7 colors each 7x1 (0,7 on grid)
static gfx::PaletteGroup overworld_AnimatedPalettes(14);
static gfx::PaletteGroup globalSprite_Palettes(2); // 60 (1,9)
static gfx::PaletteGroup armors_Palettes(5); // 15
static gfx::PaletteGroup swords_Palettes(4); // 3
static gfx::PaletteGroup spritesAux1_Palettes(12); // 7
static gfx::PaletteGroup spritesAux2_Palettes(11); // 7
static gfx::PaletteGroup spritesAux3_Palettes(24); // 7
static gfx::PaletteGroup shields_Palettes(3); // 4
static gfx::PaletteGroup dungeonsMain_Palettes(20); // 15*6
// 8*20
static gfx::PaletteGroup overworld_BackgroundPalette(core::kNumOverworldMaps);
// 3 hardcoded grass colors
static gfx::SNESPalette overworld_GrassPalettes(3);
static gfx::PaletteGroup object3D_Palettes(2); // 15*6
static gfx::PaletteGroup overworld_Mini_Map_Palettes(2); // 16*8
} // namespace zelda3
} // namespace app
} // namespace yaze
#endif

19
src/gui/canvas.cc
View File

@@ -37,15 +37,14 @@ void Canvas::DrawContextMenu() {
io.MousePos.y - origin.y);
// Add first and second point
if (is_hovered && !dragging_select_ &&
ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
points_.push_back(mouse_pos_in_canvas);
points_.push_back(mouse_pos_in_canvas);
dragging_select_ = true;
}
if (dragging_select_) {
points_.back() = mouse_pos_in_canvas;
if (!ImGui::IsMouseDown(ImGuiMouseButton_Left)) dragging_select_ = false;
if (is_hovered && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
ImVec2 draw_tile_outline_pos;
draw_tile_outline_pos.x = std::round((double)mouse_pos_in_canvas.x / 32) * 32;
draw_tile_outline_pos.y = std::round((double)mouse_pos_in_canvas.y / 32) * 32;
points_.push_back(draw_tile_outline_pos);
points_.push_back(
ImVec2(draw_tile_outline_pos.x + 32, draw_tile_outline_pos.y + 32));
}
// Pan (we use a zero mouse threshold when there's no context menu)
@@ -62,8 +61,6 @@ void Canvas::DrawContextMenu() {
ImGui::OpenPopupOnItemClick("context", ImGuiPopupFlags_MouseButtonRight);
if (ImGui::BeginPopup("context")) {
if (dragging_select_) points_.resize(points_.size() - 2);
dragging_select_ = false;
if (ImGui::MenuItem("Remove all", nullptr, false, points_.Size > 0)) {
points_.clear();
}

2
src/gui/canvas.h
View File

@@ -23,7 +23,6 @@ class Canvas {
void DrawContextMenu();
void DrawBitmap(const Bitmap& bitmap, int border_offset = 0);
void DrawBitmap(const Bitmap& bitmap, int x_offset, int y_offset);
// void DrawLargeBitmap(const Bitmap& tl, const Bitmap& tr, const Bitmap& bl, const Bitmap& br);
void DrawOutline(int x, int y, int w, int h);
void DrawGrid(float grid_step = 64.0f);
void DrawOverlay(); // last
@@ -38,7 +37,6 @@ class Canvas {
private:
bool enable_grid_ = true;
bool enable_context_menu_ = true;
bool dragging_select_ = false;
bool custom_canvas_size_ = false;
ImDrawList* draw_list_;