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

Refactor snes_palette.h for consistency and readability by adjusting reference styles and removing unnecessary includes

Browse Source
This commit is contained in:
scawful
2024-11-08 00:12:30 -05:00
parent 83949d23b5
commit fd881dc1d3
2 changed files with 74 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -25,8 +25,8 @@ namespace gfx {
* @brief Internal functions for loading palettes by group. * @brief Internal functions for loading palettes by group.
*/ */
namespace palette_group_internal { namespace palette_group_internal {
absl::Status LoadOverworldMainPalettes(const std::vector<uint8_t>& rom_data, absl::Status LoadOverworldMainPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 6; i++) { for (int i = 0; i < 6; i++) {
palette_groups.overworld_main.AddPalette( palette_groups.overworld_main.AddPalette(
@@ -37,7 +37,8 @@ absl::Status LoadOverworldMainPalettes(const std::vector<uint8_t>& rom_data,
} }
absl::Status LoadOverworldAuxiliaryPalettes( absl::Status LoadOverworldAuxiliaryPalettes(
const std::vector<uint8_t>& rom_data, gfx::PaletteGroupMap& palette_groups) { const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 20; i++) { for (int i = 0; i < 20; i++) {
palette_groups.overworld_aux.AddPalette( palette_groups.overworld_aux.AddPalette(
@@ -48,7 +49,8 @@ absl::Status LoadOverworldAuxiliaryPalettes(
} }
absl::Status LoadOverworldAnimatedPalettes( absl::Status LoadOverworldAnimatedPalettes(
const std::vector<uint8_t>& rom_data, gfx::PaletteGroupMap& palette_groups) { const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 14; i++) { for (int i = 0; i < 14; i++) {
palette_groups.overworld_animated.AddPalette(gfx::ReadPaletteFromRom( palette_groups.overworld_animated.AddPalette(gfx::ReadPaletteFromRom(
@@ -57,8 +59,8 @@ absl::Status LoadOverworldAnimatedPalettes(
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status LoadHUDPalettes(const std::vector<uint8_t>& rom_data, absl::Status LoadHUDPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
palette_groups.hud.AddPalette(gfx::ReadPaletteFromRom( palette_groups.hud.AddPalette(gfx::ReadPaletteFromRom(
@@ -67,18 +69,18 @@ absl::Status LoadHUDPalettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status LoadGlobalSpritePalettes(const std::vector<uint8_t>& rom_data, absl::Status LoadGlobalSpritePalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
palette_groups.global_sprites.AddPalette( palette_groups.global_sprites.AddPalette(
gfx::ReadPaletteFromRom(kGlobalSpritesLW, /*num_colors=*/60, data)); gfx::ReadPaletteFromRom(kGlobalSpritesLW, /*num_colors=*/60, data));
palette_groups.global_sprites.AddPalette( palette_groups.global_sprites.AddPalette(gfx::ReadPaletteFromRom(
gfx::ReadPaletteFromRom(kGlobalSpritePalettesDW, /*num_colors=*/60, data)); kGlobalSpritePalettesDW, /*num_colors=*/60, data));
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status LoadArmorPalettes(const std::vector<uint8_t>& rom_data, absl::Status LoadArmorPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
palette_groups.armors.AddPalette(gfx::ReadPaletteFromRom( palette_groups.armors.AddPalette(gfx::ReadPaletteFromRom(
@@ -87,8 +89,8 @@ absl::Status LoadArmorPalettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status LoadSwordPalettes(const std::vector<uint8_t>& rom_data, absl::Status LoadSwordPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
palette_groups.swords.AddPalette(gfx::ReadPaletteFromRom( palette_groups.swords.AddPalette(gfx::ReadPaletteFromRom(
@@ -97,8 +99,8 @@ absl::Status LoadSwordPalettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status LoadShieldPalettes(const std::vector<uint8_t>& rom_data, absl::Status LoadShieldPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
palette_groups.shields.AddPalette(gfx::ReadPaletteFromRom( palette_groups.shields.AddPalette(gfx::ReadPaletteFromRom(
@@ -107,8 +109,8 @@ absl::Status LoadShieldPalettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status LoadSpriteAux1Palettes(const std::vector<uint8_t>& rom_data, absl::Status LoadSpriteAux1Palettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 12; i++) { for (int i = 0; i < 12; i++) {
palette_groups.sprites_aux1.AddPalette(gfx::ReadPaletteFromRom( palette_groups.sprites_aux1.AddPalette(gfx::ReadPaletteFromRom(
@@ -117,8 +119,8 @@ absl::Status LoadSpriteAux1Palettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status LoadSpriteAux2Palettes(const std::vector<uint8_t>& rom_data, absl::Status LoadSpriteAux2Palettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 11; i++) { for (int i = 0; i < 11; i++) {
palette_groups.sprites_aux2.AddPalette(gfx::ReadPaletteFromRom( palette_groups.sprites_aux2.AddPalette(gfx::ReadPaletteFromRom(
@@ -127,8 +129,8 @@ absl::Status LoadSpriteAux2Palettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status LoadSpriteAux3Palettes(const std::vector<uint8_t>& rom_data, absl::Status LoadSpriteAux3Palettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 24; i++) { for (int i = 0; i < 24; i++) {
palette_groups.sprites_aux3.AddPalette(gfx::ReadPaletteFromRom( palette_groups.sprites_aux3.AddPalette(gfx::ReadPaletteFromRom(
@@ -137,8 +139,8 @@ absl::Status LoadSpriteAux3Palettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status LoadDungeonMainPalettes(const std::vector<uint8_t>& rom_data, absl::Status LoadDungeonMainPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 20; i++) { for (int i = 0; i < 20; i++) {
palette_groups.dungeon_main.AddPalette(gfx::ReadPaletteFromRom( palette_groups.dungeon_main.AddPalette(gfx::ReadPaletteFromRom(
@@ -147,8 +149,8 @@ absl::Status LoadDungeonMainPalettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status LoadGrassColors(const std::vector<uint8_t>& rom_data, absl::Status LoadGrassColors(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
palette_groups.grass.AddColor( palette_groups.grass.AddColor(
gfx::ReadColorFromRom(kHardcodedGrassLW, rom_data.data())); gfx::ReadColorFromRom(kHardcodedGrassLW, rom_data.data()));
palette_groups.grass.AddColor( palette_groups.grass.AddColor(
@@ -158,8 +160,8 @@ absl::Status LoadGrassColors(const std::vector<uint8_t>& rom_data,
return absl::OkStatus(); return absl::OkStatus();
} }
absl::Status Load3DObjectPalettes(const std::vector<uint8_t>& rom_data, absl::Status Load3DObjectPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap& palette_groups) { gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
palette_groups.object_3d.AddPalette( palette_groups.object_3d.AddPalette(
gfx::ReadPaletteFromRom(kTriforcePalette, 8, data)); gfx::ReadPaletteFromRom(kTriforcePalette, 8, data));
@@ -169,7 +171,8 @@ absl::Status Load3DObjectPalettes(const std::vector<uint8_t>& rom_data,
} }
absl::Status LoadOverworldMiniMapPalettes( absl::Status LoadOverworldMiniMapPalettes(
const std::vector<uint8_t>& rom_data, gfx::PaletteGroupMap& palette_groups) { const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data(); auto data = rom_data.data();
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
palette_groups.overworld_mini_map.AddPalette(gfx::ReadPaletteFromRom( palette_groups.overworld_mini_map.AddPalette(gfx::ReadPaletteFromRom(
@@ -205,7 +208,7 @@ const absl::flat_hash_map<std::string, uint32_t> kPaletteGroupColorCounts = {
{"grass", 1}, {"3d_object", 8}, {"ow_mini_map", 128}, {"grass", 1}, {"3d_object", 8}, {"ow_mini_map", 128},
}; };
uint32_t GetPaletteAddress(const std::string& group_name, size_t palette_index, uint32_t GetPaletteAddress(const std::string &group_name, size_t palette_index,
size_t color_index) { size_t color_index) {
// Retrieve the base address for the palette group // Retrieve the base address for the palette group
uint32_t base_address = kPaletteGroupAddressMap.at(group_name); uint32_t base_address = kPaletteGroupAddressMap.at(group_name);
@@ -220,7 +223,7 @@ uint32_t GetPaletteAddress(const std::string& group_name, size_t palette_index,
return address; return address;
} }
SnesPalette::SnesPalette(char* data) { SnesPalette::SnesPalette(char *data) {
assert((sizeof(data) % 4 == 0) && (sizeof(data) <= 32)); assert((sizeof(data) % 4 == 0) && (sizeof(data) <= 32));
for (unsigned i = 0; i < sizeof(data); i += 2) { for (unsigned i = 0; i < sizeof(data); i += 2) {
SnesColor col; SnesColor col;
@@ -232,7 +235,7 @@ SnesPalette::SnesPalette(char* data) {
} }
} }
SnesPalette::SnesPalette(const unsigned char* snes_pal) { SnesPalette::SnesPalette(const unsigned char *snes_pal) {
assert((sizeof(snes_pal) % 4 == 0) && (sizeof(snes_pal) <= 32)); assert((sizeof(snes_pal) % 4 == 0) && (sizeof(snes_pal) <= 32));
for (unsigned i = 0; i < sizeof(snes_pal); i += 2) { for (unsigned i = 0; i < sizeof(snes_pal); i += 2) {
SnesColor col; SnesColor col;
@@ -244,29 +247,29 @@ SnesPalette::SnesPalette(const unsigned char* snes_pal) {
} }
} }
SnesPalette::SnesPalette(const std::vector<ImVec4>& cols) { SnesPalette::SnesPalette(const std::vector<ImVec4> &cols) {
for (const auto& each : cols) { for (const auto &each : cols) {
SnesColor scol; SnesColor scol;
scol.set_rgb(each); scol.set_rgb(each);
colors.push_back(scol); colors.push_back(scol);
} }
} }
SnesPalette::SnesPalette(const std::vector<snes_color>& cols) { SnesPalette::SnesPalette(const std::vector<snes_color> &cols) {
for (const auto& each : cols) { for (const auto &each : cols) {
SnesColor scol; SnesColor scol;
scol.set_snes(ConvertRGBtoSNES(each)); scol.set_snes(ConvertRGBtoSNES(each));
colors.push_back(scol); colors.push_back(scol);
} }
} }
SnesPalette::SnesPalette(const std::vector<SnesColor>& cols) { SnesPalette::SnesPalette(const std::vector<SnesColor> &cols) {
for (const auto& each : cols) { for (const auto &each : cols) {
colors.push_back(each); colors.push_back(each);
} }
} }
SnesPalette ReadPaletteFromRom(int offset, int num_colors, const uint8_t* rom) { SnesPalette ReadPaletteFromRom(int offset, int num_colors, const uint8_t *rom) {
int color_offset = 0; int color_offset = 0;
std::vector<gfx::SnesColor> colors(num_colors); std::vector<gfx::SnesColor> colors(num_colors);
@@ -287,7 +290,7 @@ SnesPalette ReadPaletteFromRom(int offset, int num_colors, const uint8_t* rom) {
return gfx::SnesPalette(colors); return gfx::SnesPalette(colors);
} }
std::array<float, 4> ToFloatArray(const SnesColor& color) { std::array<float, 4> ToFloatArray(const SnesColor &color) {
std::array<float, 4> colorArray; std::array<float, 4> colorArray;
colorArray[0] = color.rgb().x / 255.0f; colorArray[0] = color.rgb().x / 255.0f;
colorArray[1] = color.rgb().y / 255.0f; colorArray[1] = color.rgb().y / 255.0f;
@@ -297,7 +300,7 @@ std::array<float, 4> ToFloatArray(const SnesColor& color) {
} }
absl::StatusOr<PaletteGroup> CreatePaletteGroupFromColFile( absl::StatusOr<PaletteGroup> CreatePaletteGroupFromColFile(
std::vector<SnesColor>& palette_rows) { std::vector<SnesColor> &palette_rows) {
PaletteGroup palette_group; PaletteGroup palette_group;
for (int i = 0; i < palette_rows.size(); i += 8) { for (int i = 0; i < palette_rows.size(); i += 8) {
SnesPalette palette; SnesPalette palette;
@@ -310,7 +313,7 @@ absl::StatusOr<PaletteGroup> CreatePaletteGroupFromColFile(
} }
absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette( absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
SnesPalette& palette, int num_colors) { SnesPalette &palette, int num_colors) {
PaletteGroup palette_group; PaletteGroup palette_group;
for (int i = 0; i < palette.size(); i += num_colors) { for (int i = 0; i < palette.size(); i += num_colors) {
SnesPalette new_palette; SnesPalette new_palette;
@@ -327,7 +330,8 @@ absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
using namespace palette_group_internal; using namespace palette_group_internal;
// TODO: Refactor LoadAllPalettes to use group names, move to zelda3 namespace // TODO: Refactor LoadAllPalettes to use group names, move to zelda3 namespace
absl::Status LoadAllPalettes(const std::vector<uint8_t>& rom_data, PaletteGroupMap& groups) { absl::Status LoadAllPalettes(const std::vector<uint8_t> &rom_data,
PaletteGroupMap &groups) {
RETURN_IF_ERROR(LoadOverworldMainPalettes(rom_data, groups)) RETURN_IF_ERROR(LoadOverworldMainPalettes(rom_data, groups))
RETURN_IF_ERROR(LoadOverworldAuxiliaryPalettes(rom_data, groups)) RETURN_IF_ERROR(LoadOverworldAuxiliaryPalettes(rom_data, groups))
RETURN_IF_ERROR(LoadOverworldAnimatedPalettes(rom_data, groups)) RETURN_IF_ERROR(LoadOverworldAnimatedPalettes(rom_data, groups))

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

@@ -5,16 +5,14 @@
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <iostream> #include <iostream>
#include <memory>
#include <vector> #include <vector>
#include "absl/base/casts.h"
#include "absl/status/status.h" #include "absl/status/status.h"
#include "absl/status/statusor.h" #include "absl/status/statusor.h"
#include "app/core/constants.h" #include "app/core/constants.h"
#include "app/gfx/snes_color.h" #include "app/gfx/snes_color.h"
#include "incl/snes_color.h"
#include "imgui/imgui.h" #include "imgui/imgui.h"
#include "incl/snes_color.h"
namespace yaze { namespace yaze {
namespace app { namespace app {
@@ -51,7 +49,7 @@ static constexpr absl::string_view kPaletteGroupNames[] = {
"sprites_aux3", "dungeon_main", "ow_mini_map", "ow_mini_map", "sprites_aux3", "dungeon_main", "ow_mini_map", "ow_mini_map",
"3d_object", "3d_object"}; "3d_object", "3d_object"};
constexpr const char* kPaletteGroupAddressesKeys[] = { constexpr const char *kPaletteGroupAddressesKeys[] = {
"ow_main", "ow_aux", "ow_animated", "hud", "ow_main", "ow_aux", "ow_animated", "hud",
"global_sprites", "armors", "swords", "shields", "global_sprites", "armors", "swords", "shields",
"sprites_aux1", "sprites_aux2", "sprites_aux3", "dungeon_main", "sprites_aux1", "sprites_aux2", "sprites_aux3", "dungeon_main",
@@ -91,7 +89,7 @@ constexpr int CustomAreaSpecificBGASM = 0x140150;
// 1 byte, not 0 if enabled // 1 byte, not 0 if enabled
constexpr int kCustomAreaSpecificBGEnabled = 0x140140; constexpr int kCustomAreaSpecificBGEnabled = 0x140140;
uint32_t GetPaletteAddress(const std::string& group_name, size_t palette_index, uint32_t GetPaletteAddress(const std::string &group_name, size_t palette_index,
size_t color_index); size_t color_index);
/** /**
@@ -109,27 +107,27 @@ uint32_t GetPaletteAddress(const std::string& group_name, size_t palette_index,
class SnesPalette { class SnesPalette {
public: public:
template <typename T> template <typename T>
explicit SnesPalette(const std::vector<T>& data) { explicit SnesPalette(const std::vector<T> &data) {
for (const auto& item : data) { for (const auto &item : data) {
colors.emplace_back(SnesColor(item)); colors.emplace_back(SnesColor(item));
} }
} }
SnesPalette() = default; SnesPalette() = default;
explicit SnesPalette(char* snesPal); explicit SnesPalette(char *snesPal);
explicit SnesPalette(const unsigned char* snes_pal); explicit SnesPalette(const unsigned char *snes_pal);
explicit SnesPalette(const std::vector<ImVec4>&); explicit SnesPalette(const std::vector<ImVec4> &);
explicit SnesPalette(const std::vector<snes_color>&); explicit SnesPalette(const std::vector<snes_color> &);
explicit SnesPalette(const std::vector<SnesColor>&); explicit SnesPalette(const std::vector<SnesColor> &);
void Create(const std::vector<SnesColor>& cols) { void Create(const std::vector<SnesColor> &cols) {
for (const auto& each : cols) { for (const auto &each : cols) {
colors.emplace_back(each); colors.emplace_back(each);
} }
} }
void AddColor(const SnesColor& color) { colors.emplace_back(color); } void AddColor(const SnesColor &color) { colors.emplace_back(color); }
void AddColor(const snes_color& color) { colors.emplace_back(color); } void AddColor(const snes_color &color) { colors.emplace_back(color); }
void AddColor(uint16_t color) { colors.emplace_back(color); } void AddColor(uint16_t color) { colors.emplace_back(color); }
absl::StatusOr<SnesColor> GetColor(int i) const { absl::StatusOr<SnesColor> GetColor(int i) const {
@@ -145,7 +143,7 @@ class SnesPalette {
auto size() const { return colors.size(); } auto size() const { return colors.size(); }
auto empty() const { return colors.empty(); } auto empty() const { return colors.empty(); }
SnesColor& operator[](int i) { SnesColor &operator[](int i) {
if (i > colors.size()) { if (i > colors.size()) {
std::cout << "SNESPalette: Index out of bounds" << std::endl; std::cout << "SNESPalette: Index out of bounds" << std::endl;
return colors[0]; return colors[0];
@@ -153,14 +151,14 @@ class SnesPalette {
return colors[i]; return colors[i];
} }
void operator()(int i, const SnesColor& color) { void operator()(int i, const SnesColor &color) {
if (i >= colors.size()) { if (i >= colors.size()) {
std::cout << "SNESPalette: Index out of bounds" << std::endl; std::cout << "SNESPalette: Index out of bounds" << std::endl;
} }
colors[i] = color; colors[i] = color;
} }
void operator()(int i, const ImVec4& color) { void operator()(int i, const ImVec4 &color) {
if (i >= colors.size()) { if (i >= colors.size()) {
std::cout << "SNESPalette: Index out of bounds" << std::endl; std::cout << "SNESPalette: Index out of bounds" << std::endl;
return; return;
@@ -181,9 +179,9 @@ class SnesPalette {
std::vector<SnesColor> colors; /**< The colors in the palette. */ std::vector<SnesColor> colors; /**< The colors in the palette. */
}; };
SnesPalette ReadPaletteFromRom(int offset, int num_colors, const uint8_t* rom); SnesPalette ReadPaletteFromRom(int offset, int num_colors, const uint8_t *rom);
std::array<float, 4> ToFloatArray(const SnesColor& color); std::array<float, 4> ToFloatArray(const SnesColor &color);
/** /**
* @brief Represents a group of palettes. * @brief Represents a group of palettes.
@@ -204,7 +202,7 @@ struct PaletteGroup {
} }
void clear() { palettes.clear(); } void clear() { palettes.clear(); }
void SetName(const std::string& name) { name_ = name; } void SetName(const std::string &name) { name_ = name; }
auto name() const { return name_; } auto name() const { return name_; }
auto size() const { return palettes.size(); } auto size() const { return palettes.size(); }
auto mutable_palette(int i) { return &palettes[i]; } auto mutable_palette(int i) { return &palettes[i]; }
@@ -218,7 +216,7 @@ struct PaletteGroup {
return palettes[i]; return palettes[i];
} }
const SnesPalette& operator[](int i) const { const SnesPalette &operator[](int i) const {
if (i > palettes.size()) { if (i > palettes.size()) {
std::cout << "PaletteGroup: Index out of bounds" << std::endl; std::cout << "PaletteGroup: Index out of bounds" << std::endl;
return palettes[0]; return palettes[0];
@@ -255,7 +253,7 @@ struct PaletteGroupMap {
PaletteGroup object_3d; PaletteGroup object_3d;
PaletteGroup overworld_mini_map; PaletteGroup overworld_mini_map;
auto get_group(const std::string& group_name) { auto get_group(const std::string &group_name) {
if (group_name == "ow_main") { if (group_name == "ow_main") {
return &overworld_main; return &overworld_main;
} else if (group_name == "ow_aux") { } else if (group_name == "ow_aux") {
@@ -292,7 +290,7 @@ struct PaletteGroupMap {
} }
template <typename Func> template <typename Func>
absl::Status for_each(Func&& func) { absl::Status for_each(Func &&func) {
RETURN_IF_ERROR(func(overworld_aux)); RETURN_IF_ERROR(func(overworld_aux));
RETURN_IF_ERROR(func(overworld_animated)); RETURN_IF_ERROR(func(overworld_animated));
RETURN_IF_ERROR(func(hud)); RETURN_IF_ERROR(func(hud));
@@ -341,13 +339,13 @@ struct PaletteGroupMap {
}; };
absl::StatusOr<PaletteGroup> CreatePaletteGroupFromColFile( absl::StatusOr<PaletteGroup> CreatePaletteGroupFromColFile(
std::vector<SnesColor>& colors); std::vector<SnesColor> &colors);
/** /**
* @brief Take a SNESPalette, divide it into palettes of 8 colors * @brief Take a SNESPalette, divide it into palettes of 8 colors
*/ */
absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette( absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
SnesPalette& palette, int num_colors = 8); SnesPalette &palette, int num_colors = 8);
/** /**
* @brief Loads all the palettes for the game. * @brief Loads all the palettes for the game.
@@ -358,8 +356,8 @@ absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
* groups. * groups.
* *
*/ */
absl::Status LoadAllPalettes(const std::vector<uint8_t>& rom_data, absl::Status LoadAllPalettes(const std::vector<uint8_t> &rom_data,
PaletteGroupMap& groups); PaletteGroupMap &groups);
/** /**
* @brief Represents a set of palettes used in a SNES graphics system. * @brief Represents a set of palettes used in a SNES graphics system.