Move LoadAllPalettes and palette_group_internal to snes_palette

src/app/gfx/snes_palette.cc

@@ -18,6 +18,170 @@
 
 namespace yaze {
 namespace app {
+
+/**
+ * @namespace yaze::app::palette_group_internal
+ * @brief Internal functions for loading palettes by group.
+ */
+namespace palette_group_internal {
+absl::Status LoadOverworldMainPalettes(const Bytes& rom_data,
+                                       gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 6; i++) {
+    RETURN_IF_ERROR(palette_groups.overworld_main.AddPalette(
+        gfx::ReadPaletteFromRom(core::overworldPaletteMain + (i * (35 * 2)),
+                                /*num_colors*/ 35, data)))
+  }
+  return absl::OkStatus();
+}
+
+absl::Status LoadOverworldAuxiliaryPalettes(
+    const Bytes& rom_data, gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 20; i++) {
+    RETURN_IF_ERROR(
+        palette_groups.overworld_aux.AddPalette(gfx::ReadPaletteFromRom(
+            core::overworldPaletteAuxialiary + (i * (21 * 2)),
+            /*num_colors*/ 21, data)))
+  }
+  return absl::OkStatus();
+}
+
+absl::Status LoadOverworldAnimatedPalettes(
+    const Bytes& rom_data, gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 14; i++) {
+    RETURN_IF_ERROR(
+        palette_groups.overworld_animated.AddPalette(gfx::ReadPaletteFromRom(
+            core::overworldPaletteAnimated + (i * (7 * 2)), 7, data)))
+  }
+  return absl::OkStatus();
+}
+
+absl::Status LoadHUDPalettes(const Bytes& rom_data,
+                             gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 2; i++) {
+    RETURN_IF_ERROR(palette_groups.hud.AddPalette(
+        gfx::ReadPaletteFromRom(core::hudPalettes + (i * 64), 32, data)))
+  }
+  return absl::OkStatus();
+}
+
+absl::Status LoadGlobalSpritePalettes(const Bytes& rom_data,
+                                      gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  RETURN_IF_ERROR(palette_groups.global_sprites.AddPalette(
+      gfx::ReadPaletteFromRom(core::globalSpritePalettesLW, 60, data)))
+  RETURN_IF_ERROR(palette_groups.global_sprites.AddPalette(
+      gfx::ReadPaletteFromRom(core::globalSpritePalettesDW, 60, data)))
+  return absl::OkStatus();
+}
+
+absl::Status LoadArmorPalettes(const Bytes& rom_data,
+                               gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 5; i++) {
+    RETURN_IF_ERROR(palette_groups.armors.AddPalette(
+        gfx::ReadPaletteFromRom(core::armorPalettes + (i * 30), 15, data)))
+  }
+  return absl::OkStatus();
+}
+
+absl::Status LoadSwordPalettes(const Bytes& rom_data,
+                               gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 4; i++) {
+    RETURN_IF_ERROR(palette_groups.swords.AddPalette(
+        gfx::ReadPaletteFromRom(core::swordPalettes + (i * 6), 3, data)))
+  }
+  return absl::OkStatus();
+}
+
+absl::Status LoadShieldPalettes(const Bytes& rom_data,
+                                gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 3; i++) {
+    RETURN_IF_ERROR(palette_groups.shields.AddPalette(
+        gfx::ReadPaletteFromRom(core::shieldPalettes + (i * 8), 4, data)))
+  }
+  return absl::OkStatus();
+}
+
+absl::Status LoadSpriteAux1Palettes(const Bytes& rom_data,
+                                    gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 12; i++) {
+    RETURN_IF_ERROR(palette_groups.sprites_aux1.AddPalette(
+        gfx::ReadPaletteFromRom(core::spritePalettesAux1 + (i * 14), 7, data)))
+  }
+  return absl::OkStatus();
+}
+
+absl::Status LoadSpriteAux2Palettes(const Bytes& rom_data,
+                                    gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 11; i++) {
+    RETURN_IF_ERROR(palette_groups.sprites_aux2.AddPalette(
+        gfx::ReadPaletteFromRom(core::spritePalettesAux2 + (i * 14), 7, data)))
+  }
+  return absl::OkStatus();
+}
+
+absl::Status LoadSpriteAux3Palettes(const Bytes& rom_data,
+                                    gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 24; i++) {
+    RETURN_IF_ERROR(palette_groups.sprites_aux3.AddPalette(
+        gfx::ReadPaletteFromRom(core::spritePalettesAux3 + (i * 14), 7, data)))
+  }
+  return absl::OkStatus();
+}
+
+absl::Status LoadDungeonMainPalettes(const Bytes& rom_data,
+                                     gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 20; i++) {
+    RETURN_IF_ERROR(
+        palette_groups.dungeon_main.AddPalette(gfx::ReadPaletteFromRom(
+            core::dungeonMainPalettes + (i * 180), 90, data)))
+  }
+  return absl::OkStatus();
+}
+
+absl::Status LoadGrassColors(const Bytes& rom_data,
+                             gfx::PaletteGroupMap& palette_groups) {
+  RETURN_IF_ERROR(palette_groups.grass.AddColor(
+      gfx::ReadColorFromRom(core::hardcodedGrassLW, rom_data.data())))
+  RETURN_IF_ERROR(palette_groups.grass.AddColor(
+      gfx::ReadColorFromRom(core::hardcodedGrassDW, rom_data.data())))
+  RETURN_IF_ERROR(palette_groups.grass.AddColor(
+      gfx::ReadColorFromRom(core::hardcodedGrassSpecial, rom_data.data())))
+  return absl::OkStatus();
+}
+
+absl::Status Load3DObjectPalettes(const Bytes& rom_data,
+                                  gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  RETURN_IF_ERROR(palette_groups.object_3d.AddPalette(
+      gfx::ReadPaletteFromRom(core::triforcePalette, 8, data)))
+  RETURN_IF_ERROR(palette_groups.object_3d.AddPalette(
+      gfx::ReadPaletteFromRom(core::crystalPalette, 8, data)))
+  return absl::OkStatus();
+}
+
+absl::Status LoadOverworldMiniMapPalettes(
+    const Bytes& rom_data, gfx::PaletteGroupMap& palette_groups) {
+  auto data = rom_data.data();
+  for (int i = 0; i < 2; i++) {
+    RETURN_IF_ERROR(
+        palette_groups.overworld_mini_map.AddPalette(gfx::ReadPaletteFromRom(
+            core::overworldMiniMapPalettes + (i * 256), 128, data)))
+  }
+  return absl::OkStatus();
+}
+}  // namespace palette_group_internal
+
 namespace gfx {
 
 const absl::flat_hash_map<std::string, uint32_t> kPaletteGroupAddressMap = {
@@ -194,11 +358,10 @@ absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
   for (int i = 0; i < palette.size(); i += 8) {
     SnesPalette new_palette;
     if (i + 8 < palette.size()) {
-      //new_palette.AddColor(SnesColor(ImVec4(0,0,0,0)));
+      // new_palette.AddColor(SnesColor(ImVec4(0,0,0,0)));
       for (int j = 0; j < 8; j++) {
         new_palette.AddColor(palette[i + j]);
       }
-
     }
 
     RETURN_IF_ERROR(toret.AddPalette(new_palette));
@@ -206,6 +369,27 @@ absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
   return toret;
 }
 
+using namespace palette_group_internal;
+
+absl::Status LoadAllPalettes(const Bytes& 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))
+  RETURN_IF_ERROR(LoadHUDPalettes(rom_data, groups))
+  RETURN_IF_ERROR(LoadGlobalSpritePalettes(rom_data, groups))
+  RETURN_IF_ERROR(LoadArmorPalettes(rom_data, groups))
+  RETURN_IF_ERROR(LoadSwordPalettes(rom_data, groups))
+  RETURN_IF_ERROR(LoadShieldPalettes(rom_data, groups))
+  RETURN_IF_ERROR(LoadSpriteAux1Palettes(rom_data, groups))
+  RETURN_IF_ERROR(LoadSpriteAux2Palettes(rom_data, groups))
+  RETURN_IF_ERROR(LoadSpriteAux3Palettes(rom_data, groups))
+  RETURN_IF_ERROR(LoadDungeonMainPalettes(rom_data, groups))
+  RETURN_IF_ERROR(LoadGrassColors(rom_data, groups))
+  RETURN_IF_ERROR(Load3DObjectPalettes(rom_data, groups))
+  RETURN_IF_ERROR(LoadOverworldMiniMapPalettes(rom_data, groups))
+  return absl::OkStatus();
+}
+
 }  // namespace gfx
 }  // namespace app
 }  // namespace yaze

src/app/gfx/snes_palette.h

@@ -299,6 +299,17 @@ absl::StatusOr<PaletteGroup> CreatePaletteGroupFromColFile(
 absl::StatusOr<PaletteGroup> CreatePaletteGroupFromLargePalette(
     SnesPalette& palette);
 
+/**
+ * @brief Loads all the palettes for the game.
+ *
+ * This function loads all the palettes for the game, including overworld,
+ * HUD, armor, swords, shields, sprites, dungeon, grass, and 3D object
+ * palettes. It also adds the loaded palettes to their respective palette
+ * groups.
+ *
+ */
+absl::Status LoadAllPalettes(const Bytes& rom_data, PaletteGroupMap& groups);
+
 /**
  * @brief Represents a set of palettes used in a SNES graphics system.
  */

src/app/rom.cc

@@ -29,169 +29,6 @@
 namespace yaze {
 namespace app {
 
-/**
- * @namespace yaze::app::palette_group_internal
- * @brief Internal functions for loading palettes by group.
- */
-namespace palette_group_internal {
-absl::Status LoadOverworldMainPalettes(const Bytes& rom_data,
-                                       gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 6; i++) {
-    RETURN_IF_ERROR(palette_groups.overworld_main.AddPalette(
-        gfx::ReadPaletteFromRom(core::overworldPaletteMain + (i * (35 * 2)),
-                                /*num_colors*/ 35, data)))
-  }
-  return absl::OkStatus();
-}
-
-absl::Status LoadOverworldAuxiliaryPalettes(
-    const Bytes& rom_data, gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 20; i++) {
-    RETURN_IF_ERROR(
-        palette_groups.overworld_aux.AddPalette(gfx::ReadPaletteFromRom(
-            core::overworldPaletteAuxialiary + (i * (21 * 2)),
-            /*num_colors*/ 21, data)))
-  }
-  return absl::OkStatus();
-}
-
-absl::Status LoadOverworldAnimatedPalettes(
-    const Bytes& rom_data, gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 14; i++) {
-    RETURN_IF_ERROR(
-        palette_groups.overworld_animated.AddPalette(gfx::ReadPaletteFromRom(
-            core::overworldPaletteAnimated + (i * (7 * 2)), 7, data)))
-  }
-  return absl::OkStatus();
-}
-
-absl::Status LoadHUDPalettes(const Bytes& rom_data,
-                             gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 2; i++) {
-    RETURN_IF_ERROR(palette_groups.hud.AddPalette(
-        gfx::ReadPaletteFromRom(core::hudPalettes + (i * 64), 32, data)))
-  }
-  return absl::OkStatus();
-}
-
-absl::Status LoadGlobalSpritePalettes(const Bytes& rom_data,
-                                      gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  RETURN_IF_ERROR(palette_groups.global_sprites.AddPalette(
-      gfx::ReadPaletteFromRom(core::globalSpritePalettesLW, 60, data)))
-  RETURN_IF_ERROR(palette_groups.global_sprites.AddPalette(
-      gfx::ReadPaletteFromRom(core::globalSpritePalettesDW, 60, data)))
-  return absl::OkStatus();
-}
-
-absl::Status LoadArmorPalettes(const Bytes& rom_data,
-                               gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 5; i++) {
-    RETURN_IF_ERROR(palette_groups.armors.AddPalette(
-        gfx::ReadPaletteFromRom(core::armorPalettes + (i * 30), 15, data)))
-  }
-  return absl::OkStatus();
-}
-
-absl::Status LoadSwordPalettes(const Bytes& rom_data,
-                               gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 4; i++) {
-    RETURN_IF_ERROR(palette_groups.swords.AddPalette(
-        gfx::ReadPaletteFromRom(core::swordPalettes + (i * 6), 3, data)))
-  }
-  return absl::OkStatus();
-}
-
-absl::Status LoadShieldPalettes(const Bytes& rom_data,
-                                gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 3; i++) {
-    RETURN_IF_ERROR(palette_groups.shields.AddPalette(
-        gfx::ReadPaletteFromRom(core::shieldPalettes + (i * 8), 4, data)))
-  }
-  return absl::OkStatus();
-}
-
-absl::Status LoadSpriteAux1Palettes(const Bytes& rom_data,
-                                    gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 12; i++) {
-    RETURN_IF_ERROR(palette_groups.sprites_aux1.AddPalette(
-        gfx::ReadPaletteFromRom(core::spritePalettesAux1 + (i * 14), 7, data)))
-  }
-  return absl::OkStatus();
-}
-
-absl::Status LoadSpriteAux2Palettes(const Bytes& rom_data,
-                                    gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 11; i++) {
-    RETURN_IF_ERROR(palette_groups.sprites_aux2.AddPalette(
-        gfx::ReadPaletteFromRom(core::spritePalettesAux2 + (i * 14), 7, data)))
-  }
-  return absl::OkStatus();
-}
-
-absl::Status LoadSpriteAux3Palettes(const Bytes& rom_data,
-                                    gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 24; i++) {
-    RETURN_IF_ERROR(palette_groups.sprites_aux3.AddPalette(
-        gfx::ReadPaletteFromRom(core::spritePalettesAux3 + (i * 14), 7, data)))
-  }
-  return absl::OkStatus();
-}
-
-absl::Status LoadDungeonMainPalettes(const Bytes& rom_data,
-                                     gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 20; i++) {
-    RETURN_IF_ERROR(
-        palette_groups.dungeon_main.AddPalette(gfx::ReadPaletteFromRom(
-            core::dungeonMainPalettes + (i * 180), 90, data)))
-  }
-  return absl::OkStatus();
-}
-
-absl::Status LoadGrassColors(const Bytes& rom_data,
-                             gfx::PaletteGroupMap& palette_groups) {
-  RETURN_IF_ERROR(palette_groups.grass.AddColor(
-      gfx::ReadColorFromRom(core::hardcodedGrassLW, rom_data.data())))
-  RETURN_IF_ERROR(palette_groups.grass.AddColor(
-      gfx::ReadColorFromRom(core::hardcodedGrassDW, rom_data.data())))
-  RETURN_IF_ERROR(palette_groups.grass.AddColor(
-      gfx::ReadColorFromRom(core::hardcodedGrassSpecial, rom_data.data())))
-  return absl::OkStatus();
-}
-
-absl::Status Load3DObjectPalettes(const Bytes& rom_data,
-                                  gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  RETURN_IF_ERROR(palette_groups.object_3d.AddPalette(
-      gfx::ReadPaletteFromRom(core::triforcePalette, 8, data)))
-  RETURN_IF_ERROR(palette_groups.object_3d.AddPalette(
-      gfx::ReadPaletteFromRom(core::crystalPalette, 8, data)))
-  return absl::OkStatus();
-}
-
-absl::Status LoadOverworldMiniMapPalettes(
-    const Bytes& rom_data, gfx::PaletteGroupMap& palette_groups) {
-  auto data = rom_data.data();
-  for (int i = 0; i < 2; i++) {
-    RETURN_IF_ERROR(
-        palette_groups.overworld_mini_map.AddPalette(gfx::ReadPaletteFromRom(
-            core::overworldMiniMapPalettes + (i * 256), 128, data)))
-  }
-  return absl::OkStatus();
-}
-}  // namespace palette_group_internal
-
 absl::StatusOr<Bytes> Rom::Load2BppGraphics() {
   Bytes sheet;
   const uint8_t sheets[] = {113, 114, 218, 219, 220, 221};
@@ -289,27 +126,6 @@ absl::Status Rom::LoadAllGraphicsData() {
   return absl::OkStatus();
 }
 
-using namespace palette_group_internal;
-
-absl::Status Rom::LoadAllPalettes() {
-  RETURN_IF_ERROR(LoadOverworldMainPalettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadOverworldAuxiliaryPalettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadOverworldAnimatedPalettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadHUDPalettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadGlobalSpritePalettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadArmorPalettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadSwordPalettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadShieldPalettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadSpriteAux1Palettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadSpriteAux2Palettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadSpriteAux3Palettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadDungeonMainPalettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadGrassColors(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(Load3DObjectPalettes(rom_data_, palette_groups_))
-  RETURN_IF_ERROR(LoadOverworldMiniMapPalettes(rom_data_, palette_groups_))
-  return absl::OkStatus();
-}
-
 absl::Status Rom::LoadFromFile(const absl::string_view& filename,
                                bool z3_load) {
   // Set filename
@@ -358,7 +174,7 @@ absl::Status Rom::LoadFromFile(const absl::string_view& filename,
     } else {
       version_ = Z3_Version::US;
     }
-    RETURN_IF_ERROR(LoadAllPalettes())
+    RETURN_IF_ERROR(gfx::LoadAllPalettes(rom_data_, palette_groups_));
     LoadGfxGroups();
   }
 

src/app/rom.h

@@ -164,17 +164,6 @@ class Rom : public core::ExperimentFlags {
    */
   absl::Status LoadAllGraphicsData();
 
-  /**
-   * @brief Loads all the palettes for the game.
-   *
-   * This function loads all the palettes for the game, including overworld,
-   * HUD, armor, swords, shields, sprites, dungeon, grass, and 3D object
-   * palettes. It also adds the loaded palettes to their respective palette
-   * groups.
-   *
-   */
-  absl::Status LoadAllPalettes();
-
   /**
    * Load Rom data from a file.
    *