Proliferate use of SharedROM

src/app/editor/dungeon_editor.cc

@@ -1,6 +1,13 @@
 #include "dungeon_editor.h"
 
+#include <imgui/imgui.h>
+
+#include "app/core/common.h"
+#include "app/gui/canvas.h"
 #include "app/gui/icons.h"
+#include "app/rom.h"
+#include "app/zelda3/dungeon/room_names.h"
+#include "zelda3/dungeon/room.h"
 
 namespace yaze {
 namespace app {
@@ -10,13 +17,27 @@ void DungeonEditor::Update() {
   DrawToolset();
 
   ImGui::Separator();
-  if (ImGui::BeginTable("#DungeonEditTable", 2, toolset_table_flags_,
+  if (ImGui::BeginTable("#DungeonEditTable", 3, toolset_table_flags_,
                         ImVec2(0, 0))) {
+    ImGui::TableSetupColumn("Room Selector");
+
     ImGui::TableSetupColumn("Canvas", ImGuiTableColumnFlags_WidthStretch,
                             ImGui::GetContentRegionAvail().x);
     ImGui::TableSetupColumn("Object Selector");
     ImGui::TableHeadersRow();
     ImGui::TableNextRow();
+    ImGui::TableNextColumn();
+    if (rom()->isLoaded()) {
+      if (ImGuiID child_id = ImGui::GetID((void *)(intptr_t)9);
+          ImGui::BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
+                            ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
+        for (const auto each_room_name : zelda3::dungeon::kRoomNames) {
+          ImGui::Button(each_room_name.data());
+        }
+      }
+      ImGui::EndChild();
+    }
+
     ImGui::TableNextColumn();
     DrawDungeonCanvas();
     ImGui::TableNextColumn();

src/app/editor/dungeon_editor.h

@@ -6,12 +6,13 @@
 #include "app/core/common.h"
 #include "app/gui/canvas.h"
 #include "app/gui/icons.h"
-#include "rom.h"
+#include "app/rom.h"
 #include "zelda3/dungeon/room.h"
 
 namespace yaze {
 namespace app {
 namespace editor {
+
 class DungeonEditor : public SharedROM {
  public:
   void Update();
@@ -31,8 +32,11 @@ class DungeonEditor : public SharedROM {
 
   gui::Canvas canvas_;
   gui::Canvas room_gfx_canvas_;
-  ImGuiTableFlags toolset_table_flags_ = ImGuiTableFlags_SizingFixedFit;
+  ImGuiTableFlags toolset_table_flags_ = ImGuiTableFlags_SizingFixedFit |
+                                         ImGuiTableFlags_Reorderable |
+                                         ImGuiTableFlags_Resizable;
 };
+
 }  // namespace editor
 }  // namespace app
 }  // namespace yaze

src/app/editor/graphics_editor.cc

@@ -60,7 +60,7 @@ absl::Status GraphicsEditor::Update() {
       for (int i = 0; i < graphics_bin_.size(); i++) {
         graphics_bin_[i].ApplyPalette(
             col_file_palette_group_[current_palette_index_]);
-        rom_.UpdateBitmap(&graphics_bin_[i]);
+        rom()->UpdateBitmap(&graphics_bin_[i]);
       }
       refresh_graphics_ = false;
     }
@@ -130,7 +130,7 @@ absl::Status GraphicsEditor::DrawCgxImport() {
     cgx_bitmap_.Create(0x80, 0x200, 8, decoded_cgx_);
     if (col_file_) {
       cgx_bitmap_.ApplyPalette(decoded_col_);
-      rom_.RenderBitmap(&cgx_bitmap_);
+      rom()->RenderBitmap(&cgx_bitmap_);
     }
   });
 
@@ -140,16 +140,17 @@ absl::Status GraphicsEditor::DrawCgxImport() {
 absl::Status GraphicsEditor::DrawScrImport() {
   ImGui::InputText("##ScrFile", scr_file_name_, sizeof(scr_file_name_));
 
-  core::FileDialogPipeline("ImportScrKey", ".SCR,.scr\0", "Open SCR", [this]() {
+  core::FileDialogPipeline(
-    strncpy(scr_file_path_,
+      "ImportScrKey", ".SCR,.scr,.BAK\0", "Open SCR", [this]() {
-            ImGuiFileDialog::Instance()->GetFilePathName().c_str(),
+        strncpy(scr_file_path_,
-            sizeof(scr_file_path_));
+                ImGuiFileDialog::Instance()->GetFilePathName().c_str(),
-    strncpy(scr_file_name_,
+                sizeof(scr_file_path_));
-            ImGuiFileDialog::Instance()->GetCurrentFileName().c_str(),
+        strncpy(scr_file_name_,
-            sizeof(scr_file_name_));
+                ImGuiFileDialog::Instance()->GetCurrentFileName().c_str(),
-    is_open_ = true;
+                sizeof(scr_file_name_));
-    scr_loaded_ = true;
+        is_open_ = true;
-  });
+        scr_loaded_ = true;
+      });
 
   ImGui::InputInt("SCR Mod", &scr_mod_value_);
 
@@ -163,7 +164,7 @@ absl::Status GraphicsEditor::DrawScrImport() {
     scr_bitmap_.Create(0x100, 0x100, 8, decoded_scr_data_);
     if (scr_loaded_) {
       scr_bitmap_.ApplyPalette(decoded_col_);
-      rom_.RenderBitmap(&scr_bitmap_);
+      rom()->RenderBitmap(&scr_bitmap_);
     }
   });
 
@@ -201,7 +202,7 @@ absl::Status GraphicsEditor::DrawPaletteControls() {
   core::ButtonPipe("Copy COL Path",
                    [this]() { ImGui::SetClipboardText(col_file_path_); });
 
-  if (rom_.isLoaded()) {
+  if (rom()->isLoaded()) {
     gui::TextWithSeparators("ROM Palette");
     gui::InputHex("Palette Index", &current_palette_index_);
     ImGui::Combo("Palette", &current_palette_, kPaletteGroupAddressesKeys,
@@ -311,8 +312,8 @@ absl::Status GraphicsEditor::DecompressImportData(int size) {
   bitmap_.Create(core::kTilesheetWidth, 0x2000, core::kTilesheetDepth,
                  converted_sheet.data(), size);
 
-  if (rom_.isLoaded()) {
+  if (rom()->isLoaded()) {
-    auto palette_group = rom_.GetPaletteGroup("ow_main");
+    auto palette_group = rom()->GetPaletteGroup("ow_main");
     palette_ = palette_group[current_palette_];
     if (col_file_) {
       bitmap_.ApplyPalette(col_file_palette_);
@@ -321,7 +322,7 @@ absl::Status GraphicsEditor::DecompressImportData(int size) {
     }
   }
 
-  rom_.RenderBitmap(&bitmap_);
+  rom()->RenderBitmap(&bitmap_);
   gfx_loaded_ = true;
 
   return absl::OkStatus();
@@ -345,12 +346,12 @@ absl::Status GraphicsEditor::DecompressSuperDonkey() {
     } else {
       // ROM palette
       auto palette_group =
-          rom_.GetPaletteGroup(kPaletteGroupAddressesKeys[current_palette_]);
+          rom()->GetPaletteGroup(kPaletteGroupAddressesKeys[current_palette_]);
       palette_ = palette_group[current_palette_index_];
       graphics_bin_[i].ApplyPalette(palette_);
     }
 
-    rom_.RenderBitmap(&graphics_bin_[i]);
+    rom()->RenderBitmap(&graphics_bin_[i]);
     i++;
   }
 
@@ -370,12 +371,12 @@ absl::Status GraphicsEditor::DecompressSuperDonkey() {
     } else {
       // ROM palette
       auto palette_group =
-          rom_.GetPaletteGroup(kPaletteGroupAddressesKeys[current_palette_]);
+          rom()->GetPaletteGroup(kPaletteGroupAddressesKeys[current_palette_]);
       palette_ = palette_group[current_palette_index_];
       graphics_bin_[i].ApplyPalette(palette_);
     }
 
-    rom_.RenderBitmap(&graphics_bin_[i]);
+    rom()->RenderBitmap(&graphics_bin_[i]);
     i++;
   }
   super_donkey_ = true;

src/app/editor/graphics_editor.h

@@ -59,10 +59,9 @@ constexpr ImGuiTableFlags kGfxEditFlags = ImGuiTableFlags_Reorderable |
                                           ImGuiTableFlags_Resizable |
                                           ImGuiTableFlags_SizingStretchSame;
 
-class GraphicsEditor {
+class GraphicsEditor : public SharedROM {
  public:
   absl::Status Update();
-  void SetupROM(ROM& rom) { rom_ = rom; }
 
  private:
   absl::Status DrawToolset();
@@ -113,7 +112,6 @@ class GraphicsEditor {
   char scr_file_path_[256] = "";
   char scr_file_name_[256] = "";
 
-  ROM rom_;
   ROM temp_rom_;
   Bytes import_data_;
   Bytes graphics_buffer_;

src/app/editor/master_editor.cc

@@ -59,12 +59,7 @@ bool BeginCentered(const char *name) {
 
 void MasterEditor::SetupScreen(std::shared_ptr<SDL_Renderer> renderer) {
   sdl_renderer_ = renderer;
-  rom_.SetupRenderer(renderer);
+  rom()->SetupRenderer(renderer);
-  overworld_editor_.SetupROM(rom_);
-  graphics_editor_.SetupROM(rom_);
-  screen_editor_.SetupROM(rom_);
-  palette_editor_.SetupROM(rom_);
-  music_editor_.SetupROM(rom_);
 }
 
 void MasterEditor::UpdateScreen() {
@@ -94,7 +89,7 @@ void MasterEditor::DrawFileDialog() {
                            [&]() {
                              std::string filePathName =
                                  ImGuiFileDialog::Instance()->GetFilePathName();
-                             status_ = rom_.LoadFromFile(filePathName);
+                             status_ = rom()->LoadFromFile(filePathName);
                            });
 }
 
@@ -141,8 +136,8 @@ void MasterEditor::DrawInfoPopup() {
   if (rom_info_) ImGui::OpenPopup("ROM Information");
   if (ImGui::BeginPopupModal("ROM Information", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
-    ImGui::Text("Title: %s", rom_.title());
+    ImGui::Text("Title: %s", rom()->title());
-    ImGui::Text("ROM Size: %ld", rom_.size());
+    ImGui::Text("ROM Size: %ld", rom()->size());
 
     if (ImGui::Button("Close", gui::kDefaultModalSize)) {
       rom_info_ = false;
@@ -170,7 +165,7 @@ void MasterEditor::DrawFileMenu() {
                                               ".sfc,.smc", ".");
     }
 
-    MENU_ITEM2("Save", "Ctrl+S") { status_ = rom_.SaveToFile(backup_rom_); }
+    MENU_ITEM2("Save", "Ctrl+S") { status_ = rom()->SaveToFile(backup_rom_); }
     MENU_ITEM("Save As..") { save_as_menu = true; }
 
     ImGui::Separator();
@@ -187,7 +182,7 @@ void MasterEditor::DrawFileMenu() {
     ImGui::Begin("Save As..", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
     ImGui::InputText("Filename", &save_as_filename);
     if (ImGui::Button("Save", gui::kDefaultModalSize)) {
-      status_ = rom_.SaveToFile(backup_rom_, save_as_filename);
+      status_ = rom()->SaveToFile(backup_rom_, save_as_filename);
     }
     if (ImGui::Button("Cancel", gui::kDefaultModalSize)) {
       save_as_menu = false;
@@ -227,7 +222,7 @@ void MasterEditor::DrawViewMenu() {
 
   if (show_memory_editor) {
     static MemoryEditor mem_edit;
-    mem_edit.DrawWindow("Memory Editor", (void *)&rom_, rom_.size());
+    mem_edit.DrawWindow("Memory Editor", (void *)&(*rom()), rom()->size());
   }
 
   if (show_imgui_demo) {

src/app/editor/master_editor.h

@@ -29,7 +29,7 @@ namespace yaze {
 namespace app {
 namespace editor {
 
-class MasterEditor {
+class MasterEditor : public SharedROM {
  public:
   void SetupScreen(std::shared_ptr<SDL_Renderer> renderer);
   void UpdateScreen();
@@ -72,7 +72,6 @@ class MasterEditor {
   PaletteEditor palette_editor_;
   ScreenEditor screen_editor_;
   SpriteEditor sprite_editor_;
-  ROM rom_;
 };
 
 }  // namespace editor

src/app/editor/music_editor.cc

@@ -274,7 +274,7 @@ void MusicEditor::DrawToolset() {
     BUTTON_COLUMN(ICON_MD_FAST_FORWARD)
     BUTTON_COLUMN(ICON_MD_VOLUME_UP)
     if (ImGui::Button(ICON_MD_ACCESS_TIME)) {
-      music_tracker_.LoadSongs(rom_);
+      music_tracker_.LoadSongs(*rom());
     }
     ImGui::TableNextColumn();
     ImGui::SliderInt("Volume", &current_volume, 0, 100);

src/app/editor/music_editor.h

@@ -54,10 +54,9 @@ static const char* kGameSongs[] = {"Title",
 static constexpr absl::string_view kSongNotes[] = {
     "C",  "C#", "D",  "D#", "E", "F",  "F#", "G",  "G#", "A",  "A#", "B", "C",
     "C#", "D",  "D#", "E",  "F", "F#", "G",  "G#", "A",  "A#", "B",  "C"};
-class MusicEditor {
+class MusicEditor : public SharedROM {
  public:
   void Update();
-  void SetupROM(ROM& rom) { rom_ = rom; }
 
  private:
   void DrawChannels();
@@ -67,7 +66,6 @@ class MusicEditor {
   void DrawToolset();
 
   zelda3::Tracker music_tracker_;
-  ROM rom_;
 
   // Mix_Music* current_song_ = NULL;
 

src/app/editor/overworld_editor.cc

@@ -27,7 +27,7 @@ namespace editor {
 
 absl::Status OverworldEditor::Update() {
   // Initialize overworld graphics, maps, and palettes
-  if (rom_.isLoaded() && !all_gfx_loaded_) {
+  if (rom()->isLoaded() && !all_gfx_loaded_) {
     RETURN_IF_ERROR(LoadGraphics())
     all_gfx_loaded_ = true;
   }
@@ -289,21 +289,21 @@ void OverworldEditor::DrawTileSelector() {
 
 absl::Status OverworldEditor::LoadGraphics() {
   // Load all of the graphics data from the game.
-  PRINT_IF_ERROR(rom_.LoadAllGraphicsData())
+  PRINT_IF_ERROR(rom()->LoadAllGraphicsData())
-  graphics_bin_ = rom_.GetGraphicsBin();
+  graphics_bin_ = rom()->GetGraphicsBin();
 
   // Load the Link to the Past overworld.
-  RETURN_IF_ERROR(overworld_.Load(rom_))
+  RETURN_IF_ERROR(overworld_.Load(*rom()))
   palette_ = overworld_.AreaPalette();
 
   // Create the area graphics image
   core::BuildAndRenderBitmapPipeline(0x80, 0x200, 0x40,
-                                     overworld_.AreaGraphics(), rom_,
+                                     overworld_.AreaGraphics(), *rom(),
                                      current_gfx_bmp_, palette_);
 
   // Create the tile16 blockset image
   core::BuildAndRenderBitmapPipeline(0x80, 0x2000, 0x80,
-                                     overworld_.Tile16Blockset(), rom_,
+                                     overworld_.Tile16Blockset(), *rom(),
                                      tile16_blockset_bmp_, palette_);
   map_blockset_loaded_ = true;
 
@@ -333,7 +333,7 @@ absl::Status OverworldEditor::LoadGraphics() {
   for (int id = 0; id < 4096; id++) {
     tile16_individual_.emplace_back();
     core::BuildAndRenderBitmapPipeline(0x10, 0x10, 0x80,
-                                       tile16_individual_data_[id], rom_,
+                                       tile16_individual_data_[id], *rom(),
                                        tile16_individual_[id], palette_);
   }
 
@@ -342,7 +342,7 @@ absl::Status OverworldEditor::LoadGraphics() {
     overworld_.SetCurrentMap(i);
     auto palette = overworld_.AreaPalette();
     core::BuildAndRenderBitmapPipeline(0x200, 0x200, 0x200,
-                                       overworld_.BitmapData(), rom_,
+                                       overworld_.BitmapData(), *rom(),
                                        maps_bmp_[i], palette);
   }
 
@@ -359,7 +359,7 @@ absl::Status OverworldEditor::LoadSpriteGraphics() {
       auto spr_gfx = sprite.PreviewGraphics();
       sprite_previews_[sprite.id()].Create(width, height, depth, spr_gfx);
       sprite_previews_[sprite.id()].ApplyPalette(palette_);
-      rom_.RenderBitmap(&(sprite_previews_[sprite.id()]));
+      rom()->RenderBitmap(&(sprite_previews_[sprite.id()]));
     }
   return absl::OkStatus();
 }

src/app/editor/overworld_editor.h

@@ -63,11 +63,6 @@ class OverworldEditor : public Editor, public SharedROM {
   absl::Status Copy() { return absl::UnimplementedError("Copy"); }
   absl::Status Paste() { return absl::UnimplementedError("Paste"); }
 
-  void SetupROM(ROM &rom) {
-    rom_ = rom;
-    shared_rom_ = std::make_shared<ROM>(rom_);
-  }
-
  private:
   absl::Status DrawToolset();
   void DrawOverworldMapSettings();
@@ -105,7 +100,6 @@ class OverworldEditor : public Editor, public SharedROM {
   std::vector<Bytes> tile16_individual_data_;
   std::vector<gfx::Bitmap> tile16_individual_;
 
-  ROM rom_;
   PaletteEditor palette_editor_;
   zelda3::Overworld overworld_;
 

src/app/editor/palette_editor.cc

@@ -44,8 +44,8 @@ absl::Status PaletteEditor::Update() {
 }
 
 absl::Status PaletteEditor::DrawPaletteGroup(int i) {
-  auto size = rom_.GetPaletteGroup(kPaletteGroupNames[i].data()).size();
+  auto size = rom()->GetPaletteGroup(kPaletteGroupNames[i].data()).size();
-  auto palettes = rom_.GetPaletteGroup(kPaletteGroupNames[i].data());
+  auto palettes = rom()->GetPaletteGroup(kPaletteGroupNames[i].data());
   for (int j = 0; j < size; j++) {
     ImGui::Text("%d", j);
 
@@ -73,8 +73,8 @@ absl::Status PaletteEditor::DrawPaletteGroup(int i) {
         if (ImGui::ColorEdit4(
                 "Edit Color", col.data(),
                 ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoAlpha)) {
-          RETURN_IF_ERROR(rom_.UpdatePaletteColor(kPaletteGroupNames[i].data(),
+          RETURN_IF_ERROR(rom()->UpdatePaletteColor(
-                                                  j, n, palette[n]))
+              kPaletteGroupNames[i].data(), j, n, palette[n]))
         }
         if (ImGui::Button("Copy as..", ImVec2(-1, 0))) ImGui::OpenPopup("Copy");
         if (ImGui::BeginPopup("Copy")) {

src/app/editor/palette_editor.h

@@ -5,9 +5,10 @@
 
 #include "absl/status/status.h"
 #include "app/gfx/snes_palette.h"
-#include "app/rom.h"
 #include "app/gui/canvas.h"
 #include "app/gui/icons.h"
+#include "app/rom.h"
+
 
 namespace yaze {
 namespace app {
@@ -25,22 +26,18 @@ static constexpr absl::string_view kPaletteGroupNames[] = {
     "ow_aux",      "global_sprites", "dungeon_main", "ow_mini_map",
     "ow_mini_map", "3d_object",      "3d_object"};
 
-
+class PaletteEditor : public SharedROM {
-class PaletteEditor {
  public:
   absl::Status Update();
   void DisplayPalette(gfx::SNESPalette& palette, bool loaded);
 
   void DrawPortablePalette(gfx::SNESPalette& palette);
 
-  auto SetupROM(ROM& rom) { rom_ = rom; }
-
  private:
   absl::Status DrawPaletteGroup(int i);
 
   ImVec4 saved_palette_[256] = {};
   ImVec4 current_color_;
-  ROM rom_;
 
   ImGuiColorEditFlags palette_button_flags =
       ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoTooltip;

src/app/editor/screen_editor.cc

@@ -63,7 +63,7 @@ void ScreenEditor::DrawInventoryMenuEditor() {
   TAB_ITEM("Inventory Menu")
 
   static bool create = false;
-  if (!create && rom_.isLoaded()) {
+  if (!create && rom()->isLoaded()) {
     inventory_.Create();
     palette_ = inventory_.Palette();
     create = true;

src/app/editor/screen_editor.h

@@ -21,13 +21,9 @@ namespace editor {
 
 using MosaicArray = std::array<int, core::kNumOverworldMaps>;
 
-class ScreenEditor {
+class ScreenEditor : public SharedROM {
  public:
   ScreenEditor();
-  void SetupROM(ROM &rom) {
-    rom_ = rom;
-    inventory_.SetupROM(rom_);
-  }
   void Update();
 
  private:
@@ -44,7 +40,6 @@ class ScreenEditor {
 
   char mosaic_tiles_[core::kNumOverworldMaps];
 
-  ROM rom_;
   Bytes all_gfx_;
   zelda3::Inventory inventory_;
   gfx::SNESPalette palette_;

src/app/rom.cc

@@ -388,5 +388,7 @@ uint32_t ROM::GetPaletteAddress(const std::string& groupName,
   return address;
 }
 
+std::shared_ptr<ROM> SharedROM::shared_rom_ = nullptr;
+
 }  // namespace app
 }  // namespace yaze

src/app/rom.h

@@ -127,6 +127,7 @@ class ROM {
   auto end() { return rom_data_.end(); }
   auto data() { return rom_data_.data(); }
   auto vector() const { return rom_data_; }
+  auto filename() const { return filename_; }
   auto isLoaded() const { return is_loaded_; }
   auto char_data() { return reinterpret_cast<char*>(rom_data_.data()); }
 
@@ -199,8 +200,23 @@ class SharedROM {
   SharedROM() = default;
   virtual ~SharedROM() = default;
 
- protected:
+  std::shared_ptr<ROM> shared_rom() {
-  std::shared_ptr<ROM> shared_rom_;
+    if (!shared_rom_) {
+      shared_rom_ = std::make_shared<ROM>();
+    }
+    return shared_rom_;
+  }
+
+  auto rom() {
+    if (!shared_rom_) {
+      shared_rom_ = std::make_shared<ROM>();
+    }
+    ROM *rom = shared_rom_.get();
+    return rom;
+  }
+
+ private:
+  static std::shared_ptr<ROM> shared_rom_;
 };
 
 }  // namespace app