yaze 0.2.2
Link to the Past ROM Editor
 
Loading...
Searching...
No Matches
snes_palette.cc
Go to the documentation of this file.
1#include "snes_palette.h"
2
3#include <SDL.h>
4
5#include <cstdint>
6#include <cstdlib>
7#include <cstring>
8#include <vector>
9
10#include "absl/container/flat_hash_map.h"
11#include "absl/status/status.h"
12#include "absl/status/statusor.h"
13#include "app/gfx/snes_color.h"
14#include "imgui/imgui.h"
15#include "util/macro.h"
16
17namespace yaze::gfx {
18
20 assert((sizeof(data) % 4 == 0) && (sizeof(data) <= 32));
21 for (unsigned i = 0; i < sizeof(data); i += 2) {
22 SnesColor col;
23 col.set_snes(static_cast<uint8_t>(data[i + 1]) << 8);
24 col.set_snes(col.snes() | static_cast<uint8_t>(data[i]));
25 snes_color mColor = ConvertSnesToRgb(col.snes());
26 col.set_rgb(ImVec4(mColor.red, mColor.green, mColor.blue, 1.f));
27 colors_[size_++] = col;
28 }
29}
30
31SnesPalette::SnesPalette(const unsigned char *snes_pal) {
32 assert((sizeof(snes_pal) % 4 == 0) && (sizeof(snes_pal) <= 32));
33 for (unsigned i = 0; i < sizeof(snes_pal); i += 2) {
34 SnesColor col;
35 col.set_snes(snes_pal[i + 1] << (uint16_t)8);
36 col.set_snes(col.snes() | snes_pal[i]);
37 snes_color mColor = ConvertSnesToRgb(col.snes());
38 col.set_rgb(ImVec4(mColor.red, mColor.green, mColor.blue, 1.f));
39 colors_[size_++] = col;
40 }
41}
42
43SnesPalette::SnesPalette(const char *data, size_t length) : size_(0) {
44 for (size_t i = 0; i < length && size_ < kMaxColors; i += 2) {
45 uint16_t color = (static_cast<uint8_t>(data[i + 1]) << 8) |
46 static_cast<uint8_t>(data[i]);
47 colors_[size_++] = SnesColor(color);
48 }
49}
50
51SnesPalette::SnesPalette(const std::vector<uint16_t> &colors) : size_(0) {
52 for (const auto &color : colors) {
53 if (size_ < kMaxColors) {
54 colors_[size_++] = SnesColor(color);
55 }
56 }
57}
58
59SnesPalette::SnesPalette(const std::vector<SnesColor> &colors) : size_(0) {
60 for (const auto &color : colors) {
61 if (size_ < kMaxColors) {
62 colors_[size_++] = color;
63 }
64 }
65}
66
67SnesPalette::SnesPalette(const std::vector<ImVec4> &colors) : size_(0) {
68 for (const auto &color : colors) {
69 if (size_ < kMaxColors) {
70 colors_[size_++] = SnesColor(color);
71 }
72 }
73}
74
79namespace palette_group_internal {
80absl::Status LoadOverworldMainPalettes(const std::vector<uint8_t> &rom_data,
81 gfx::PaletteGroupMap &palette_groups) {
82 auto data = rom_data.data();
83 for (int i = 0; i < 6; i++) {
84 palette_groups.overworld_main.AddPalette(
86 /*num_colors=*/35, data));
87 }
88 return absl::OkStatus();
89}
90
92 const std::vector<uint8_t> &rom_data,
93 gfx::PaletteGroupMap &palette_groups) {
94 auto data = rom_data.data();
95 for (int i = 0; i < 20; i++) {
96 palette_groups.overworld_aux.AddPalette(
98 /*num_colors=*/21, data));
99 }
100 return absl::OkStatus();
101}
102
104 const std::vector<uint8_t> &rom_data,
105 gfx::PaletteGroupMap &palette_groups) {
106 auto data = rom_data.data();
107 for (int i = 0; i < 14; i++) {
109 kOverworldPaletteAnimated + (i * (7 * 2)), /*num_colors=*/7, data));
110 }
111 return absl::OkStatus();
112}
113
114absl::Status LoadHUDPalettes(const std::vector<uint8_t> &rom_data,
115 gfx::PaletteGroupMap &palette_groups) {
116 auto data = rom_data.data();
117 for (int i = 0; i < 2; i++) {
119 kHudPalettes + (i * 64), /*num_colors=*/32, data));
120 }
121 return absl::OkStatus();
122}
123
124absl::Status LoadGlobalSpritePalettes(const std::vector<uint8_t> &rom_data,
125 gfx::PaletteGroupMap &palette_groups) {
126 auto data = rom_data.data();
127 palette_groups.global_sprites.AddPalette(
128 gfx::ReadPaletteFromRom(kGlobalSpritesLW, /*num_colors=*/60, data));
130 kGlobalSpritePalettesDW, /*num_colors=*/60, data));
131 return absl::OkStatus();
132}
133
134absl::Status LoadArmorPalettes(const std::vector<uint8_t> &rom_data,
135 gfx::PaletteGroupMap &palette_groups) {
136 auto data = rom_data.data();
137 for (int i = 0; i < 5; i++) {
139 kArmorPalettes + (i * 30), /*num_colors=*/15, data));
140 }
141 return absl::OkStatus();
142}
143
144absl::Status LoadSwordPalettes(const std::vector<uint8_t> &rom_data,
145 gfx::PaletteGroupMap &palette_groups) {
146 auto data = rom_data.data();
147 for (int i = 0; i < 4; i++) {
149 kSwordPalettes + (i * 6), /*num_colors=*/3, data));
150 }
151 return absl::OkStatus();
152}
153
154absl::Status LoadShieldPalettes(const std::vector<uint8_t> &rom_data,
155 gfx::PaletteGroupMap &palette_groups) {
156 auto data = rom_data.data();
157 for (int i = 0; i < 3; i++) {
159 kShieldPalettes + (i * 8), /*num_colors=*/4, data));
160 }
161 return absl::OkStatus();
162}
163
164absl::Status LoadSpriteAux1Palettes(const std::vector<uint8_t> &rom_data,
165 gfx::PaletteGroupMap &palette_groups) {
166 auto data = rom_data.data();
167 for (int i = 0; i < 12; i++) {
169 kSpritesPalettesAux1 + (i * 14), /*num_colors=*/7, data));
170 }
171 return absl::OkStatus();
172}
173
174absl::Status LoadSpriteAux2Palettes(const std::vector<uint8_t> &rom_data,
175 gfx::PaletteGroupMap &palette_groups) {
176 auto data = rom_data.data();
177 for (int i = 0; i < 11; i++) {
179 kSpritesPalettesAux2 + (i * 14), /*num_colors=*/7, data));
180 }
181 return absl::OkStatus();
182}
183
184absl::Status LoadSpriteAux3Palettes(const std::vector<uint8_t> &rom_data,
185 gfx::PaletteGroupMap &palette_groups) {
186 auto data = rom_data.data();
187 for (int i = 0; i < 24; i++) {
189 kSpritesPalettesAux3 + (i * 14), /*num_colors=*/7, data));
190 }
191 return absl::OkStatus();
192}
193
194absl::Status LoadDungeonMainPalettes(const std::vector<uint8_t> &rom_data,
195 gfx::PaletteGroupMap &palette_groups) {
196 auto data = rom_data.data();
197 for (int i = 0; i < 20; i++) {
199 kDungeonMainPalettes + (i * 180), /*num_colors=*/90, data));
200 }
201 return absl::OkStatus();
202}
203
204absl::Status LoadGrassColors(const std::vector<uint8_t> &rom_data,
205 gfx::PaletteGroupMap &palette_groups) {
206 palette_groups.grass.AddColor(
207 gfx::ReadColorFromRom(kHardcodedGrassLW, rom_data.data()));
208 palette_groups.grass.AddColor(
209 gfx::ReadColorFromRom(kHardcodedGrassDW, rom_data.data()));
210 palette_groups.grass.AddColor(
212 return absl::OkStatus();
213}
214
215absl::Status Load3DObjectPalettes(const std::vector<uint8_t> &rom_data,
216 gfx::PaletteGroupMap &palette_groups) {
217 auto data = rom_data.data();
218 palette_groups.object_3d.AddPalette(
220 palette_groups.object_3d.AddPalette(
222 return absl::OkStatus();
223}
224
226 const std::vector<uint8_t> &rom_data,
227 gfx::PaletteGroupMap &palette_groups) {
228 auto data = rom_data.data();
229 for (int i = 0; i < 2; i++) {
231 kOverworldMiniMapPalettes + (i * 256), /*num_colors=*/128, data));
232 }
233 return absl::OkStatus();
234}
235} // namespace palette_group_internal
236
237const absl::flat_hash_map<std::string, uint32_t> kPaletteGroupAddressMap = {
238 {"ow_main", kOverworldPaletteMain},
239 {"ow_aux", kOverworldPaletteAux},
240 {"ow_animated", kOverworldPaletteAnimated},
241 {"hud", kHudPalettes},
242 {"global_sprites", kGlobalSpritesLW},
243 {"armors", kArmorPalettes},
244 {"swords", kSwordPalettes},
245 {"shields", kShieldPalettes},
246 {"sprites_aux1", kSpritesPalettesAux1},
247 {"sprites_aux2", kSpritesPalettesAux2},
248 {"sprites_aux3", kSpritesPalettesAux3},
249 {"dungeon_main", kDungeonMainPalettes},
250 {"grass", kHardcodedGrassLW},
251 {"3d_object", kTriforcePalette},
252 {"ow_mini_map", kOverworldMiniMapPalettes},
253};
254
255const absl::flat_hash_map<std::string, uint32_t> kPaletteGroupColorCounts = {
256 {"ow_main", 35}, {"ow_aux", 21}, {"ow_animated", 7},
257 {"hud", 32}, {"global_sprites", 60}, {"armors", 15},
258 {"swords", 3}, {"shields", 4}, {"sprites_aux1", 7},
259 {"sprites_aux2", 7}, {"sprites_aux3", 7}, {"dungeon_main", 90},
260 {"grass", 1}, {"3d_object", 8}, {"ow_mini_map", 128},
261};
262
263uint32_t GetPaletteAddress(const std::string &group_name, size_t palette_index,
264 size_t color_index) {
265 // Retrieve the base address for the palette group
266 uint32_t base_address = kPaletteGroupAddressMap.at(group_name);
267
268 // Retrieve the number of colors for each palette in the group
269 uint32_t colors_per_palette = kPaletteGroupColorCounts.at(group_name);
270
271 // Calculate the address for thes specified color in the ROM
272 uint32_t address = base_address + (palette_index * colors_per_palette * 2) +
273 (color_index * 2);
274
275 return address;
276}
277
278SnesPalette ReadPaletteFromRom(int offset, int num_colors, const uint8_t *rom) {
279 int color_offset = 0;
280 std::vector<gfx::SnesColor> colors(num_colors);
281
282 while (color_offset < num_colors) {
283 short color = (uint16_t)((rom[offset + 1]) << 8) | rom[offset];
284 snes_color new_color;
285 new_color.red = (color & 0x1F) * 8;
286 new_color.green = ((color >> 5) & 0x1F) * 8;
287 new_color.blue = ((color >> 10) & 0x1F) * 8;
288 colors[color_offset].set_snes(ConvertRgbToSnes(new_color));
289 if (color_offset == 0) {
290 colors[color_offset].set_transparent(true);
291 }
292 color_offset++;
293 offset += 2;
294 }
295
296 return gfx::SnesPalette(colors);
297}
298
299std::array<float, 4> ToFloatArray(const SnesColor &color) {
300 std::array<float, 4> colorArray;
301 colorArray[0] = color.rgb().x / 255.0f;
302 colorArray[1] = color.rgb().y / 255.0f;
303 colorArray[2] = color.rgb().z / 255.0f;
304 colorArray[3] = color.rgb().w;
305 return colorArray;
306}
307
308absl::StatusOr<PaletteGroup> CreatePaletteGroupFromColFile(
309 std::vector<SnesColor> &palette_rows) {
310 PaletteGroup palette_group;
311 for (int i = 0; i < palette_rows.size(); i += 8) {
312 SnesPalette palette;
313 for (int j = 0; j < 8; j++) {
314 palette.AddColor(palette_rows[i + j]);
315 }
316 palette_group.AddPalette(palette);
317 }
318 return palette_group;
319}
320
321absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
322 SnesPalette &palette, int num_colors) {
323 PaletteGroup palette_group;
324 for (int i = 0; i < palette.size(); i += num_colors) {
325 SnesPalette new_palette;
326 if (i + num_colors < palette.size()) {
327 for (int j = 0; j < num_colors; j++) {
328 new_palette.AddColor(palette[i + j]);
329 }
330 }
331 palette_group.AddPalette(new_palette);
332 }
333 return palette_group;
334}
335
336using namespace palette_group_internal;
337
338// TODO: Refactor LoadAllPalettes to use group names, move to zelda3 namespace
339absl::Status LoadAllPalettes(const std::vector<uint8_t> &rom_data,
340 PaletteGroupMap &groups) {
344 RETURN_IF_ERROR(LoadHUDPalettes(rom_data, groups))
346 RETURN_IF_ERROR(LoadArmorPalettes(rom_data, groups))
347 RETURN_IF_ERROR(LoadSwordPalettes(rom_data, groups))
348 RETURN_IF_ERROR(LoadShieldPalettes(rom_data, groups))
349 RETURN_IF_ERROR(LoadSpriteAux1Palettes(rom_data, groups))
350 RETURN_IF_ERROR(LoadSpriteAux2Palettes(rom_data, groups))
351 RETURN_IF_ERROR(LoadSpriteAux3Palettes(rom_data, groups))
353 RETURN_IF_ERROR(LoadGrassColors(rom_data, groups))
354 RETURN_IF_ERROR(Load3DObjectPalettes(rom_data, groups))
356 return absl::OkStatus();
357}
358
359std::unordered_map<uint8_t, gfx::Paletteset> GfxContext::palettesets_;
360
361} // namespace yaze::gfx
static std::unordered_map< uint8_t, gfx::Paletteset > palettesets_
SNES Color container.
Definition snes_color.h:38
constexpr ImVec4 rgb() const
Definition snes_color.h:74
void set_snes(uint16_t val)
constexpr uint16_t snes() const
Definition snes_color.h:76
void set_rgb(const ImVec4 val)
Represents a palette of colors for the Super Nintendo Entertainment System (SNES).
void AddColor(const SnesColor &color)
static constexpr size_t kMaxColors
#define RETURN_IF_ERROR(expression)
Definition macro.h:51
Internal functions for loading palettes by group.
absl::Status LoadDungeonMainPalettes(const std::vector< uint8_t > &rom_data, gfx::PaletteGroupMap &palette_groups)
absl::Status LoadOverworldMiniMapPalettes(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)
absl::Status LoadOverworldMainPalettes(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)
absl::Status LoadGlobalSpritePalettes(const std::vector< uint8_t > &rom_data, gfx::PaletteGroupMap &palette_groups)
absl::Status LoadOverworldAnimatedPalettes(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)
absl::Status LoadGrassColors(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)
absl::Status LoadHUDPalettes(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)
absl::Status LoadOverworldAuxiliaryPalettes(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)
absl::Status LoadSwordPalettes(const std::vector< uint8_t > &rom_data, gfx::PaletteGroupMap &palette_groups)
Contains classes for handling graphical data.
Definition arena.cc:8
constexpr int kHardcodedGrassSpecial
constexpr int kHudPalettes
constexpr int kOverworldPaletteAux
SnesPalette ReadPaletteFromRom(int offset, int num_colors, const uint8_t *rom)
constexpr int kHardcodedGrassLW
constexpr int kArmorPalettes
constexpr int kCrystalPalette
const absl::flat_hash_map< std::string, uint32_t > kPaletteGroupAddressMap
uint16_t ConvertRgbToSnes(const snes_color &color)
Definition snes_color.cc:33
constexpr int kShieldPalettes
constexpr int kSpritesPalettesAux2
constexpr int kOverworldPaletteAnimated
SnesColor ReadColorFromRom(int offset, const uint8_t *rom)
Definition snes_color.cc:48
constexpr int kOverworldMiniMapPalettes
constexpr int kOverworldPaletteMain
constexpr int kSwordPalettes
constexpr int kHardcodedGrassDW
snes_color ConvertSnesToRgb(uint16_t color_snes)
Definition snes_color.cc:19
constexpr int kGlobalSpritesLW
const absl::flat_hash_map< std::string, uint32_t > kPaletteGroupColorCounts
constexpr int kSpritesPalettesAux1
std::array< float, 4 > ToFloatArray(const SnesColor &color)
constexpr int kGlobalSpritePalettesDW
constexpr int kSpritesPalettesAux3
constexpr int kDungeonMainPalettes
uint32_t GetPaletteAddress(const std::string &group_name, size_t palette_index, size_t color_index)
constexpr int kTriforcePalette
absl::Status LoadAllPalettes(const std::vector< uint8_t > &rom_data, PaletteGroupMap &groups)
Loads all the palettes for the game.
absl::StatusOr< PaletteGroup > CreatePaletteGroupFromLargePalette(SnesPalette &palette, int num_colors)
Take a SNESPalette, divide it into palettes of 8 colors.
absl::StatusOr< PaletteGroup > CreatePaletteGroupFromColFile(std::vector< SnesColor > &palette_rows)
Primitive of 16-bit RGB SNES color.
Definition yaze.h:56
uint16_t green
Definition yaze.h:59
uint16_t red
Definition yaze.h:57
uint16_t blue
Definition yaze.h:58
Represents a mapping of palette groups.
Represents a group of palettes.
void AddColor(SnesColor color)
void AddPalette(SnesPalette pal)