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.
*/
namespace palette_group_internal {
absl::Status LoadOverworldMainPalettes(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status LoadOverworldMainPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data();
for (int i = 0; i < 6; i++) {
palette_groups.overworld_main.AddPalette(
@@ -37,7 +37,8 @@ absl::Status LoadOverworldMainPalettes(const std::vector<uint8_t>& rom_data,
}
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();
for (int i = 0; i < 20; i++) {
palette_groups.overworld_aux.AddPalette(
@@ -48,7 +49,8 @@ absl::Status LoadOverworldAuxiliaryPalettes(
}
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();
for (int i = 0; i < 14; i++) {
palette_groups.overworld_animated.AddPalette(gfx::ReadPaletteFromRom(
@@ -57,8 +59,8 @@ absl::Status LoadOverworldAnimatedPalettes(
return absl::OkStatus();
}
absl::Status LoadHUDPalettes(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status LoadHUDPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data();
for (int i = 0; i < 2; i++) {
palette_groups.hud.AddPalette(gfx::ReadPaletteFromRom(
@@ -67,18 +69,18 @@ absl::Status LoadHUDPalettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus();
}
absl::Status LoadGlobalSpritePalettes(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status LoadGlobalSpritePalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data();
palette_groups.global_sprites.AddPalette(
gfx::ReadPaletteFromRom(kGlobalSpritesLW, /*num_colors=*/60, data));
palette_groups.global_sprites.AddPalette(
gfx::ReadPaletteFromRom(kGlobalSpritePalettesDW, /*num_colors=*/60, data));
palette_groups.global_sprites.AddPalette(gfx::ReadPaletteFromRom(
kGlobalSpritePalettesDW, /*num_colors=*/60, data));
return absl::OkStatus();
}
absl::Status LoadArmorPalettes(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status LoadArmorPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data();
for (int i = 0; i < 5; i++) {
palette_groups.armors.AddPalette(gfx::ReadPaletteFromRom(
@@ -87,8 +89,8 @@ absl::Status LoadArmorPalettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus();
}
absl::Status LoadSwordPalettes(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status LoadSwordPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data();
for (int i = 0; i < 4; i++) {
palette_groups.swords.AddPalette(gfx::ReadPaletteFromRom(
@@ -97,8 +99,8 @@ absl::Status LoadSwordPalettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus();
}
absl::Status LoadShieldPalettes(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status LoadShieldPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data();
for (int i = 0; i < 3; i++) {
palette_groups.shields.AddPalette(gfx::ReadPaletteFromRom(
@@ -107,8 +109,8 @@ absl::Status LoadShieldPalettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus();
}
absl::Status LoadSpriteAux1Palettes(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status LoadSpriteAux1Palettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data();
for (int i = 0; i < 12; i++) {
palette_groups.sprites_aux1.AddPalette(gfx::ReadPaletteFromRom(
@@ -117,8 +119,8 @@ absl::Status LoadSpriteAux1Palettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus();
}
absl::Status LoadSpriteAux2Palettes(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status LoadSpriteAux2Palettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data();
for (int i = 0; i < 11; i++) {
palette_groups.sprites_aux2.AddPalette(gfx::ReadPaletteFromRom(
@@ -127,8 +129,8 @@ absl::Status LoadSpriteAux2Palettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus();
}
absl::Status LoadSpriteAux3Palettes(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status LoadSpriteAux3Palettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data();
for (int i = 0; i < 24; i++) {
palette_groups.sprites_aux3.AddPalette(gfx::ReadPaletteFromRom(
@@ -137,8 +139,8 @@ absl::Status LoadSpriteAux3Palettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus();
}
absl::Status LoadDungeonMainPalettes(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status LoadDungeonMainPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data();
for (int i = 0; i < 20; i++) {
palette_groups.dungeon_main.AddPalette(gfx::ReadPaletteFromRom(
@@ -147,8 +149,8 @@ absl::Status LoadDungeonMainPalettes(const std::vector<uint8_t>& rom_data,
return absl::OkStatus();
}
absl::Status LoadGrassColors(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status LoadGrassColors(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
palette_groups.grass.AddColor(
gfx::ReadColorFromRom(kHardcodedGrassLW, rom_data.data()));
palette_groups.grass.AddColor(
@@ -158,8 +160,8 @@ absl::Status LoadGrassColors(const std::vector<uint8_t>& rom_data,
return absl::OkStatus();
}
absl::Status Load3DObjectPalettes(const std::vector<uint8_t>& rom_data,
gfx::PaletteGroupMap& palette_groups) {
absl::Status Load3DObjectPalettes(const std::vector<uint8_t> &rom_data,
gfx::PaletteGroupMap &palette_groups) {
auto data = rom_data.data();
palette_groups.object_3d.AddPalette(
gfx::ReadPaletteFromRom(kTriforcePalette, 8, data));
@@ -169,7 +171,8 @@ absl::Status Load3DObjectPalettes(const std::vector<uint8_t>& rom_data,
}
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();
for (int i = 0; i < 2; i++) {
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},
};
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) {
// Retrieve the base address for the palette group
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;
}
SnesPalette::SnesPalette(char* data) {
SnesPalette::SnesPalette(char *data) {
assert((sizeof(data) % 4 == 0) && (sizeof(data) <= 32));
for (unsigned i = 0; i < sizeof(data); i += 2) {
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));
for (unsigned i = 0; i < sizeof(snes_pal); i += 2) {
SnesColor col;
@@ -244,29 +247,29 @@ SnesPalette::SnesPalette(const unsigned char* snes_pal) {
}
}
SnesPalette::SnesPalette(const std::vector<ImVec4>& cols) {
for (const auto& each : cols) {
SnesPalette::SnesPalette(const std::vector<ImVec4> &cols) {
for (const auto &each : cols) {
SnesColor scol;
scol.set_rgb(each);
colors.push_back(scol);
}
}
SnesPalette::SnesPalette(const std::vector<snes_color>& cols) {
for (const auto& each : cols) {
SnesPalette::SnesPalette(const std::vector<snes_color> &cols) {
for (const auto &each : cols) {
SnesColor scol;
scol.set_snes(ConvertRGBtoSNES(each));
colors.push_back(scol);
}
}
SnesPalette::SnesPalette(const std::vector<SnesColor>& cols) {
for (const auto& each : cols) {
SnesPalette::SnesPalette(const std::vector<SnesColor> &cols) {
for (const auto &each : cols) {
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;
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);
}
std::array<float, 4> ToFloatArray(const SnesColor& color) {
std::array<float, 4> ToFloatArray(const SnesColor &color) {
std::array<float, 4> colorArray;
colorArray[0] = color.rgb().x / 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(
std::vector<SnesColor>& palette_rows) {
std::vector<SnesColor> &palette_rows) {
PaletteGroup palette_group;
for (int i = 0; i < palette_rows.size(); i += 8) {
SnesPalette palette;
@@ -310,7 +313,7 @@ absl::StatusOr<PaletteGroup> CreatePaletteGroupFromColFile(
}
absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
SnesPalette& palette, int num_colors) {
SnesPalette &palette, int num_colors) {
PaletteGroup palette_group;
for (int i = 0; i < palette.size(); i += num_colors) {
SnesPalette new_palette;
@@ -327,7 +330,8 @@ absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
using namespace palette_group_internal;
// 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(LoadOverworldAuxiliaryPalettes(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 <cstring>
#include <iostream>
#include <memory>
#include <vector>
#include "absl/base/casts.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/core/constants.h"
#include "app/gfx/snes_color.h"
#include "incl/snes_color.h"
#include "imgui/imgui.h"
#include "incl/snes_color.h"
namespace yaze {
namespace app {
@@ -51,7 +49,7 @@ static constexpr absl::string_view kPaletteGroupNames[] = {
"sprites_aux3", "dungeon_main", "ow_mini_map", "ow_mini_map",
"3d_object", "3d_object"};
constexpr const char* kPaletteGroupAddressesKeys[] = {
constexpr const char *kPaletteGroupAddressesKeys[] = {
"ow_main", "ow_aux", "ow_animated", "hud",
"global_sprites", "armors", "swords", "shields",
"sprites_aux1", "sprites_aux2", "sprites_aux3", "dungeon_main",
@@ -91,7 +89,7 @@ constexpr int CustomAreaSpecificBGASM = 0x140150;
// 1 byte, not 0 if enabled
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);
/**
@@ -109,27 +107,27 @@ uint32_t GetPaletteAddress(const std::string& group_name, size_t palette_index,
class SnesPalette {
public:
template <typename T>
explicit SnesPalette(const std::vector<T>& data) {
for (const auto& item : data) {
explicit SnesPalette(const std::vector<T> &data) {
for (const auto &item : data) {
colors.emplace_back(SnesColor(item));
}
}
SnesPalette() = default;
explicit SnesPalette(char* snesPal);
explicit SnesPalette(const unsigned char* snes_pal);
explicit SnesPalette(const std::vector<ImVec4>&);
explicit SnesPalette(const std::vector<snes_color>&);
explicit SnesPalette(const std::vector<SnesColor>&);
explicit SnesPalette(char *snesPal);
explicit SnesPalette(const unsigned char *snes_pal);
explicit SnesPalette(const std::vector<ImVec4> &);
explicit SnesPalette(const std::vector<snes_color> &);
explicit SnesPalette(const std::vector<SnesColor> &);
void Create(const std::vector<SnesColor>& cols) {
for (const auto& each : cols) {
void Create(const std::vector<SnesColor> &cols) {
for (const auto &each : cols) {
colors.emplace_back(each);
}
}
void AddColor(const SnesColor& color) { colors.emplace_back(color); }
void AddColor(const snes_color& 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(uint16_t color) { colors.emplace_back(color); }
absl::StatusOr<SnesColor> GetColor(int i) const {
@@ -145,7 +143,7 @@ class SnesPalette {
auto size() const { return colors.size(); }
auto empty() const { return colors.empty(); }
SnesColor& operator[](int i) {
SnesColor &operator[](int i) {
if (i > colors.size()) {
std::cout << "SNESPalette: Index out of bounds" << std::endl;
return colors[0];
@@ -153,14 +151,14 @@ class SnesPalette {
return colors[i];
}
void operator()(int i, const SnesColor& color) {
void operator()(int i, const SnesColor &color) {
if (i >= colors.size()) {
std::cout << "SNESPalette: Index out of bounds" << std::endl;
}
colors[i] = color;
}
void operator()(int i, const ImVec4& color) {
void operator()(int i, const ImVec4 &color) {
if (i >= colors.size()) {
std::cout << "SNESPalette: Index out of bounds" << std::endl;
return;
@@ -181,9 +179,9 @@ class SnesPalette {
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.
@@ -204,7 +202,7 @@ struct PaletteGroup {
}
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 size() const { return palettes.size(); }
auto mutable_palette(int i) { return &palettes[i]; }
@@ -218,7 +216,7 @@ struct PaletteGroup {
return palettes[i];
}
const SnesPalette& operator[](int i) const {
const SnesPalette &operator[](int i) const {
if (i > palettes.size()) {
std::cout << "PaletteGroup: Index out of bounds" << std::endl;
return palettes[0];
@@ -255,7 +253,7 @@ struct PaletteGroupMap {
PaletteGroup object_3d;
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") {
return &overworld_main;
} else if (group_name == "ow_aux") {
@@ -292,7 +290,7 @@ struct PaletteGroupMap {
}
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_animated));
RETURN_IF_ERROR(func(hud));
@@ -341,13 +339,13 @@ struct PaletteGroupMap {
};
absl::StatusOr<PaletteGroup> CreatePaletteGroupFromColFile(
std::vector<SnesColor>& colors);
std::vector<SnesColor> &colors);
/**
* @brief Take a SNESPalette, divide it into palettes of 8 colors
*/
absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
SnesPalette& palette, int num_colors = 8);
SnesPalette &palette, int num_colors = 8);
/**
* @brief Loads all the palettes for the game.
@@ -358,8 +356,8 @@ absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
* groups.
*
*/
absl::Status LoadAllPalettes(const std::vector<uint8_t>& rom_data,
PaletteGroupMap& groups);
absl::Status LoadAllPalettes(const std::vector<uint8_t> &rom_data,
PaletteGroupMap &groups);
/**
* @brief Represents a set of palettes used in a SNES graphics system.