Refactor Renderer access and enhance graphics loading functionality

- Replaced instances of Renderer::GetInstance() with Renderer::Get() for consistency across the codebase. - Updated various rendering methods to streamline bitmap updates and enhance performance. - Removed unused includes and comments to improve code clarity and maintainability.
2025-05-08 19:37:48 -04:00
parent fb015523dc
commit 11504ca4c1
18 changed files with 147 additions and 177 deletions
--- a/src/app/core/controller.cc
+++ b/src/app/core/controller.cc
@@ -149,10 +149,10 @@ absl::Status Controller::OnLoad() {

 void Controller::DoRender() const {
  ImGui::Render();
-  SDL_RenderClear(Renderer::GetInstance().renderer());
+  SDL_RenderClear(Renderer::Get().renderer());
  ImGui_ImplSDLRenderer2_RenderDrawData(ImGui::GetDrawData(),
-                                        Renderer::GetInstance().renderer());
-  SDL_RenderPresent(Renderer::GetInstance().renderer());
+                                        Renderer::Get().renderer());
+  SDL_RenderPresent(Renderer::Get().renderer());
 }

 void Controller::OnExit() {
@@ -193,7 +193,7 @@ absl::Status Controller::CreateWindow() {
 }

 absl::Status Controller::CreateRenderer() {
-  return Renderer::GetInstance().CreateRenderer(window_.get());
+  return Renderer::Get().CreateRenderer(window_.get());
 }

 absl::Status Controller::CreateGuiContext() {
@@ -206,8 +206,8 @@ absl::Status Controller::CreateGuiContext() {

  // Initialize ImGui based on the backend
  ImGui_ImplSDL2_InitForSDLRenderer(window_.get(),
-                                    Renderer::GetInstance().renderer());
-  ImGui_ImplSDLRenderer2_Init(Renderer::GetInstance().renderer());
+                                    Renderer::Get().renderer());
+  ImGui_ImplSDLRenderer2_Init(Renderer::Get().renderer());

  RETURN_IF_ERROR(LoadPackageFonts());

--- a/src/app/core/controller.h
+++ b/src/app/core/controller.h
@@ -7,13 +7,7 @@

 #include "absl/status/status.h"
 #include "app/core/platform/backend.h"
-#include "app/core/platform/file_dialog.h"
-#include "app/core/platform/renderer.h"
 #include "app/editor/editor_manager.h"
-#include "imgui/backends/imgui_impl_sdl2.h"
-#include "imgui/backends/imgui_impl_sdlrenderer2.h"
-#include "imgui/imconfig.h"
-#include "imgui/imgui.h"

 int main(int argc, char **argv);

--- a/src/app/core/platform/backend.h
+++ b/src/app/core/platform/backend.h
@@ -56,13 +56,13 @@ class Sdl2Backend : public PlatformBackend<Sdl2Backend> {
      throw std::runtime_error("Failed to create window");
    }

-    if (!Renderer::GetInstance().CreateRenderer(window.get()).ok()) {
+    if (!Renderer::Get().CreateRenderer(window.get()).ok()) {
      throw std::runtime_error("Failed to create renderer");
    }

    ImGui_ImplSDL2_InitForSDLRenderer(window.get(),
-                                      Renderer::GetInstance().renderer());
-    ImGui_ImplSDLRenderer2_Init(Renderer::GetInstance().renderer());
+                                      Renderer::Get().renderer());
+    ImGui_ImplSDLRenderer2_Init(Renderer::Get().renderer());
  }

  void init_audio() {
@@ -91,7 +91,7 @@ class Sdl2Backend : public PlatformBackend<Sdl2Backend> {
  void shutdown() {
    ImGui_ImplSDL2_Shutdown();
    ImGui_ImplSDLRenderer2_Shutdown();
-    SDL_DestroyRenderer(Renderer::GetInstance().renderer());
+    SDL_DestroyRenderer(Renderer::Get().renderer());
    SDL_DestroyWindow(window.get());
    SDL_Quit();
  }
@@ -103,10 +103,10 @@ class Sdl2Backend : public PlatformBackend<Sdl2Backend> {

  void render() {
    ImGui::Render();
-    SDL_RenderClear(Renderer::GetInstance().renderer());
+    SDL_RenderClear(Renderer::Get().renderer());
    ImGui_ImplSDLRenderer2_RenderDrawData(ImGui::GetDrawData(),
-                                          Renderer::GetInstance().renderer());
-    SDL_RenderPresent(Renderer::GetInstance().renderer());
+                                          Renderer::Get().renderer());
+    SDL_RenderPresent(Renderer::Get().renderer());
  }

  auto window_ptr() -> SDL_Window * { return window.get(); }
--- a/src/app/core/platform/renderer.h
+++ b/src/app/core/platform/renderer.h
@@ -23,7 +23,7 @@ namespace core {
 */
 class Renderer {
 public:
-  static Renderer &GetInstance() {
+  static Renderer &Get() {
    static Renderer instance;
    return instance;
  }
--- a/src/app/editor/code/memory_editor.h
+++ b/src/app/editor/code/memory_editor.h
@@ -4,6 +4,7 @@
 #include "app/core/platform/file_dialog.h"
 #include "app/gui/input.h"
 #include "app/rom.h"
+#include "app/snes.h"
 #include "imgui/imgui.h"
 #include "imgui_memory_editor.h"
 #include "util/macro.h"
--- a/src/app/editor/dungeon/dungeon_editor.cc
+++ b/src/app/editor/dungeon/dungeon_editor.cc
@@ -116,7 +116,7 @@ absl::Status DungeonEditor::RefreshGraphics() {
      [this](int block) -> absl::Status {
        gfx::Arena::Get().gfx_sheets()[block].SetPaletteWithTransparent(
            current_palette_group_[current_palette_id_], 0);
-        Renderer::GetInstance().UpdateBitmap(
+        Renderer::Get().UpdateBitmap(
            &gfx::Arena::Get().gfx_sheets()[block]);
        return absl::OkStatus();
      });
@@ -127,7 +127,7 @@ absl::Status DungeonEditor::RefreshGraphics() {
      [this, &sprites_aux1_pal_group](int block) -> absl::Status {
        gfx::Arena::Get().gfx_sheets()[block].SetPaletteWithTransparent(
            sprites_aux1_pal_group[current_palette_id_], 0);
-        Renderer::GetInstance().UpdateBitmap(
+        Renderer::Get().UpdateBitmap(
            &gfx::Arena::Get().gfx_sheets()[block]);
        return absl::OkStatus();
      });
@@ -563,10 +563,9 @@ void DungeonEditor::DrawObjectRenderer() {
    for (const auto object_name : zelda3::Type1RoomObjectNames) {
      if (ImGui::Selectable(object_name.data(), selected_object == i)) {
        selected_object = i;
-        object_renderer_.LoadObject(i,
-                                    rooms_[current_room_id_].mutable_blocks());
-        Renderer::GetInstance().RenderBitmap(object_renderer_.bitmap());
-        object_loaded_ = true;
+        // object_renderer_.LoadObject(i,
+        //                             rooms_[current_room_id_].mutable_blocks());
+        // object_loaded_ = true;
      }
      i += 1;
    }
@@ -580,9 +579,6 @@ void DungeonEditor::DrawObjectRenderer() {
    object_canvas_.DrawBackground(ImVec2(256 + 1, 0x10 * 0x40 + 1));
    object_canvas_.DrawContextMenu();
    object_canvas_.DrawTileSelector(32);
-    if (object_loaded_) {
-      object_canvas_.DrawBitmap(*object_renderer_.bitmap(), 0, 0);
-    }
    object_canvas_.DrawGrid(32.0f);
    object_canvas_.DrawOverlay();

@@ -593,8 +589,8 @@ void DungeonEditor::DrawObjectRenderer() {
  if (object_loaded_) {
    ImGui::Begin("Memory Viewer", &object_loaded_, 0);
    static MemoryEditor mem_edit;
-    mem_edit.DrawContents((void *)object_renderer_.mutable_memory(),
-                          object_renderer_.mutable_memory()->size());
+    // mem_edit.DrawContents(object_renderer_.mutable_memory()->data(),
+    // object_renderer_.mutable_memory()->size());
    ImGui::End();
  }
 }
--- a/src/app/editor/graphics/graphics_editor.cc
+++ b/src/app/editor/graphics/graphics_editor.cc
@@ -137,7 +137,7 @@ void GraphicsEditor::DrawGfxEditToolset() {
            .mutable_gfx_sheets()
            ->at(current_sheet_)
            .Create(width, height, 8, png_data);
-        Renderer::GetInstance().UpdateBitmap(
+        Renderer::Get().UpdateBitmap(
            &gfx::Arena::Get().mutable_gfx_sheets()->at(current_sheet_));
      }
    }
@@ -292,7 +292,7 @@ absl::Status GraphicsEditor::UpdateGfxTabView() {
        auto draw_tile_event = [&]() {
          current_sheet_canvas_.DrawTileOnBitmap(tile_size_, &current_bitmap,
                                                 current_color_);
-          Renderer::GetInstance().UpdateBitmap(&current_bitmap);
+          Renderer::Get().UpdateBitmap(&current_bitmap);
        };

        current_sheet_canvas_.UpdateColorPainter(
@@ -369,7 +369,7 @@ absl::Status GraphicsEditor::UpdatePaletteColumn() {
          .mutable_gfx_sheets()
          ->data()[current_sheet_]
          .SetPaletteWithTransparent(palette, edit_palette_sub_index_);
-      Renderer::GetInstance().UpdateBitmap(
+      Renderer::Get().UpdateBitmap(
          &gfx::Arena::Get().mutable_gfx_sheets()->data()[current_sheet_]);
      refresh_graphics_ = false;
    }
@@ -468,7 +468,7 @@ absl::Status GraphicsEditor::UpdateScadView() {
    //   for (int i = 0; i < kNumGfxSheets; i++) {
    //     status_ = graphics_bin_[i].SetPalette(
    //         col_file_palette_group_[current_palette_index_]);
-    //     Renderer::GetInstance().UpdateBitmap(&graphics_bin_[i]);
+    //     Renderer::Get().UpdateBitmap(&graphics_bin_[i]);
    //   }
    //   refresh_graphics_ = false;
    // }
@@ -540,7 +540,7 @@ absl::Status GraphicsEditor::DrawCgxImport() {
    cgx_bitmap_.Create(0x80, 0x200, 8, decoded_cgx_);
    if (col_file_) {
      cgx_bitmap_.SetPalette(decoded_col_);
-      Renderer::GetInstance().RenderBitmap(&cgx_bitmap_);
+      Renderer::Get().RenderBitmap(&cgx_bitmap_);
    }
  }

@@ -570,7 +570,7 @@ absl::Status GraphicsEditor::DrawScrImport() {
    scr_bitmap_.Create(0x100, 0x100, 8, decoded_scr_data_);
    if (scr_loaded_) {
      scr_bitmap_.SetPalette(decoded_col_);
-      Renderer::GetInstance().RenderBitmap(&scr_bitmap_);
+      Renderer::Get().RenderBitmap(&scr_bitmap_);
    }
  }

@@ -772,7 +772,7 @@ absl::Status GraphicsEditor::DecompressImportData(int size) {
    }
  }

-  Renderer::GetInstance().RenderBitmap(&bin_bitmap_);
+  Renderer::Get().RenderBitmap(&bin_bitmap_);
  gfx_loaded_ = true;

  return absl::OkStatus();
@@ -801,7 +801,7 @@ absl::Status GraphicsEditor::DecompressSuperDonkey() {
      gfx_sheets_[i].SetPalette(z3_rom_palette_);
    }

-    Renderer::GetInstance().RenderBitmap(&gfx_sheets_[i]);
+    Renderer::Get().RenderBitmap(&gfx_sheets_[i]);
    i++;
  }

@@ -825,7 +825,7 @@ absl::Status GraphicsEditor::DecompressSuperDonkey() {
      gfx_sheets_[i].SetPalette(z3_rom_palette_);
    }

-    Renderer::GetInstance().RenderBitmap(&gfx_sheets_[i]);
+    Renderer::Get().RenderBitmap(&gfx_sheets_[i]);
    i++;
  }
  super_donkey_ = true;
--- a/src/app/editor/graphics/screen_editor.cc
+++ b/src/app/editor/graphics/screen_editor.cc
@@ -8,6 +8,7 @@
 #include "absl/strings/string_view.h"
 #include "app/core/platform/file_dialog.h"
 #include "app/core/platform/renderer.h"
+#include "app/gfx/arena.h"
 #include "app/gfx/bitmap.h"
 #include "app/gfx/snes_tile.h"
 #include "app/gfx/tilesheet.h"
@@ -15,6 +16,7 @@
 #include "app/gui/color.h"
 #include "app/gui/icons.h"
 #include "app/gui/input.h"
+#include "app/snes.h"
 #include "imgui/imgui.h"
 #include "util/hex.h"
 #include "util/macro.h"
@@ -28,14 +30,37 @@ constexpr uint32_t kRedPen = 0xFF0000FF;

 void ScreenEditor::Initialize() {}

-absl::Status ScreenEditor::Load() { return absl::OkStatus(); }
+absl::Status ScreenEditor::Load() {
+  RETURN_IF_ERROR(LoadDungeonMaps());
+  RETURN_IF_ERROR(LoadDungeonMapTile16(rom()->graphics_buffer()));
+  // TODO: Load roomset gfx based on dungeon ID
+  sheets_.emplace(0, gfx::Arena::Get().gfx_sheets()[212]);
+  sheets_.emplace(1, gfx::Arena::Get().gfx_sheets()[213]);
+  sheets_.emplace(2, gfx::Arena::Get().gfx_sheets()[214]);
+  sheets_.emplace(3, gfx::Arena::Get().gfx_sheets()[215]);
+  // int current_tile8 = 0;
+  // int tile_data_offset = 0;
+  // for (int i = 0; i < 4; ++i) {
+  //   for (int j = 0; j < 32; j++) {
+  //     std::vector<uint8_t> tile_data(64, 0);  // 8x8 tile (64 bytes
+  //     int tile_index = current_tile8 + j;
+  //     int x = (j % 8) * 8;
+  //     int y = (j / 8) * 8;
+  //     sheets_[i].Get8x8Tile(tile_index, 0, 0, tile_data,
+  //     tile_data_offset); tile8_individual_.emplace_back(gfx::Bitmap(8, 8,
+  //     4, tile_data)); tile8_individual_.back().SetPalette(
+  //         *rom()->mutable_dungeon_palette(3));
+  //     Renderer::Get().RenderBitmap(&tile8_individual_.back());
+  //   }
+  //   tile_data_offset = 0;
+  // }
+  return absl::OkStatus();
+}

 absl::Status ScreenEditor::Update() {
  if (ImGui::BeginTabBar("##ScreenEditorTabBar")) {
    if (ImGui::BeginTabItem("Dungeon Maps")) {
-      if (rom()->is_loaded()) {
-        DrawDungeonMapsEditor();
-      }
+      DrawDungeonMapsEditor();
      ImGui::EndTabItem();
    }
    DrawInventoryMenuEditor();
@@ -226,6 +251,9 @@ absl::Status ScreenEditor::SaveDungeonMaps() {

 absl::Status ScreenEditor::LoadDungeonMapTile16(
    const std::vector<uint8_t> &gfx_data, bool bin_mode) {
+  tile16_blockset_.tile_size = {16, 16};
+  tile16_blockset_.map_size = {186, 186};
+  tile16_blockset_.atlas.Create(256, 192, 8, gfx_data);
  tile16_sheet_.Init(256, 192, gfx::TileType::Tile16);

  for (int i = 0; i < 186; i++) {
@@ -250,18 +278,21 @@ absl::Status ScreenEditor::LoadDungeonMapTile16(
    if (bin_mode) {
      sheet_offset = 0;
    }
+    ComposeTile16(tile16_blockset_, gfx_data, t1, t2, t3, t4, sheet_offset);
    tile16_sheet_.ComposeTile16(gfx_data, t1, t2, t3, t4, sheet_offset);
  }

  tile16_sheet_.mutable_bitmap()->SetPalette(
      *rom()->mutable_dungeon_palette(3));
-  Renderer::GetInstance().RenderBitmap(&*tile16_sheet_.mutable_bitmap().get());
+  tile16_blockset_.atlas.SetPalette(*rom()->mutable_dungeon_palette(3));
+  Renderer::Get().RenderBitmap(&tile16_blockset_.atlas);
+  Renderer::Get().RenderBitmap(&*tile16_sheet_.mutable_bitmap().get());

  for (int i = 0; i < tile16_sheet_.num_tiles(); ++i) {
    auto tile = tile16_sheet_.GetTile16(i);
    tile16_individual_[i] = tile;
    tile16_individual_[i].SetPalette(*rom()->mutable_dungeon_palette(3));
-    Renderer::GetInstance().RenderBitmap(&tile16_individual_[i]);
+    Renderer::Get().RenderBitmap(&tile16_individual_[i]);
  }

  return absl::OkStatus();
@@ -319,14 +350,9 @@ void ScreenEditor::DrawDungeonMapsTabs() {
            int posX = ((j % 5) * 32);
            int posY = ((j / 5) * 32);

-            if (tile16_individual_.count(tile16_id) == 0) {
-              tile16_individual_[tile16_id] =
-                  tile16_sheet_.GetTile16(tile16_id);
-              Renderer::GetInstance().RenderBitmap(
-                  &tile16_individual_[tile16_id]);
-            }
-            screen_canvas_.DrawBitmap(tile16_individual_[tile16_id], (posX * 2),
-                                      (posY * 2), 4.0f);
+            gfx::RenderTile(tile16_blockset_, tile16_id);
+            screen_canvas_.DrawBitmap(tile16_blockset_.tile_bitmaps[tile16_id],
+                                      (posX * 2), (posY * 2), 4.0f);

            if (current_dungeon.floor_rooms[floor_number][j] == boss_room) {
              screen_canvas_.DrawOutlineWithColor((posX * 2), (posY * 2), 64,
@@ -423,10 +449,11 @@ void ScreenEditor::DrawDungeonMapsRoomGfx() {
    ImGui::Separator();
    current_tile_canvas_.DrawBackground();  // ImVec2(64 * 2 + 2, 64 * 2 + 4));
    current_tile_canvas_.DrawContextMenu();
-    if (current_tile_canvas_.DrawTilePainter(tile8_individual_[selected_tile8_],
-                                             16)) {
-      // Modify the tile16 based on the selected tile and current_tile16_info
-    }
+    // if
+    // (current_tile_canvas_.DrawTilePainter(tile8_individual_[selected_tile8_],
+    //  16)) {
+    // Modify the tile16 based on the selected tile and current_tile16_info
+    // }
    current_tile_canvas_.DrawBitmap(tile16_individual_[selected_tile16_], 2,
                                    4.0f);
    current_tile_canvas_.DrawGrid(16.f);
@@ -448,7 +475,7 @@ void ScreenEditor::DrawDungeonMapsRoomGfx() {
          tile16_sheet_.GetTile16(selected_tile16_);
      tile16_individual_[selected_tile16_].SetPalette(
          *rom()->mutable_dungeon_palette(3));
-      Renderer::GetInstance().RenderBitmap(
+      Renderer::Get().RenderBitmap(
          &tile16_individual_[selected_tile16_]);
    }
  }
@@ -456,39 +483,6 @@ void ScreenEditor::DrawDungeonMapsRoomGfx() {
 }

 void ScreenEditor::DrawDungeonMapsEditor() {
-  if (!dungeon_maps_loaded_) {
-    if (!LoadDungeonMaps().ok()) {
-      ImGui::Text("Failed to load dungeon maps");
-    }
-
-    if (LoadDungeonMapTile16(rom()->graphics_buffer()).ok()) {
-      // TODO: Load roomset gfx based on dungeon ID
-      sheets_.emplace(0, GraphicsSheetManager::GetInstance().gfx_sheets()[212]);
-      sheets_.emplace(1, GraphicsSheetManager::GetInstance().gfx_sheets()[213]);
-      sheets_.emplace(2, GraphicsSheetManager::GetInstance().gfx_sheets()[214]);
-      sheets_.emplace(3, GraphicsSheetManager::GetInstance().gfx_sheets()[215]);
-      int current_tile8 = 0;
-      int tile_data_offset = 0;
-      for (int i = 0; i < 4; ++i) {
-        for (int j = 0; j < 32; j++) {
-          std::vector<uint8_t> tile_data(64, 0);  // 8x8 tile (64 bytes
-          int tile_index = current_tile8 + j;
-          int x = (j % 8) * 8;
-          int y = (j / 8) * 8;
-          sheets_[i].Get8x8Tile(tile_index, 0, 0, tile_data, tile_data_offset);
-          tile8_individual_.emplace_back(gfx::Bitmap(8, 8, 4, tile_data));
-          tile8_individual_.back().SetPalette(
-              *rom()->mutable_dungeon_palette(3));
-          Renderer::GetInstance().RenderBitmap(&tile8_individual_.back());
-        }
-        tile_data_offset = 0;
-      }
-      dungeon_maps_loaded_ = true;
-    } else {
-      ImGui::Text("Failed to load dungeon map tile16");
-    }
-  }
-
  if (ImGui::BeginTable("##DungeonMapToolset", 2,
                        ImGuiTableFlags_SizingFixedFit)) {
    ImGui::TableSetupColumn("Draw Mode");
@@ -569,7 +563,6 @@ void ScreenEditor::LoadBinaryGfx() {
      std::vector<uint8_t> bin_data((std::istreambuf_iterator<char>(file)),
                                    std::istreambuf_iterator<char>());
      auto converted_bin = gfx::SnesTo8bppSheet(bin_data, 4, 4);
-      gfx_bin_data_ = converted_bin;
      tile16_sheet_.clear();
      if (LoadDungeonMapTile16(converted_bin, true).ok()) {
        sheets_.clear();
@@ -579,7 +572,7 @@ void ScreenEditor::LoadBinaryGfx() {
                                  converted_bin.begin() + ((i + 1) * 0x1000));
          sheets_.emplace(i, gfx::Bitmap(128, 32, 8, gfx_sheets[i]));
          sheets_[i].SetPalette(*rom()->mutable_dungeon_palette(3));
-          Renderer::GetInstance().RenderBitmap(&sheets_[i]);
+          Renderer::Get().RenderBitmap(&sheets_[i]);
        }
        binary_gfx_loaded_ = true;
      } else {
--- a/src/app/editor/graphics/screen_editor.h
+++ b/src/app/editor/graphics/screen_editor.h
@@ -7,6 +7,7 @@
 #include "app/editor/editor.h"
 #include "app/gfx/bitmap.h"
 #include "app/gfx/snes_palette.h"
+#include "app/gfx/tilemap.h"
 #include "app/gfx/tilesheet.h"
 #include "app/gui/canvas.h"
 #include "app/rom.h"
@@ -46,17 +47,12 @@ class ScreenEditor : public Editor {
  absl::Status Paste() override { return absl::UnimplementedError("Paste"); }
  absl::Status Find() override { return absl::UnimplementedError("Find"); }
  absl::Status Save() override { return absl::UnimplementedError("Save"); }
-  
-  // Set the ROM pointer
  void set_rom(Rom* rom) { rom_ = rom; }
-  
-  // Get the ROM pointer
  Rom* rom() const { return rom_; }

  absl::Status SaveDungeonMaps();

 private:
-  Rom* rom_;
  void DrawTitleScreenEditor();
  void DrawNamingScreenEditor();
  void DrawOverworldMapEditor();
@@ -66,7 +62,7 @@ class ScreenEditor : public Editor {
  void DrawInventoryToolset();

  absl::Status LoadDungeonMaps();
-  absl::Status LoadDungeonMapTile16(const std::vector<uint8_t> &gfx_data,
+  absl::Status LoadDungeonMapTile16(const std::vector<uint8_t>& gfx_data,
                                    bool bin_mode = false);
  absl::Status SaveDungeonMapTile16();

@@ -80,7 +76,6 @@ class ScreenEditor : public Editor {

  EditingMode current_mode_ = EditingMode::DRAW;

-  bool dungeon_maps_loaded_ = false;
  bool binary_gfx_loaded_ = false;

  uint8_t selected_room = 0;
@@ -94,19 +89,15 @@ class ScreenEditor : public Editor {
  bool copy_button_pressed = false;
  bool paste_button_pressed = false;

-  std::array<uint16_t, 4> current_tile16_data_;
  std::unordered_map<int, gfx::Bitmap> tile16_individual_;
  std::vector<gfx::Bitmap> tile8_individual_;
-  std::vector<uint8_t> all_gfx_;
-  std::vector<uint8_t> gfx_bin_data_;
  std::vector<zelda3::DungeonMap> dungeon_maps_;
  std::vector<std::vector<std::array<std::string, 25>>> dungeon_map_labels_;

-  absl::Status status_;
-
  gfx::SnesPalette palette_;
  gfx::BitmapTable sheets_;
  gfx::Tilesheet tile16_sheet_;
+  gfx::Tilemap tile16_blockset_;
  gfx::InternalTile16 current_tile16_info;

  gui::Canvas current_tile_canvas_{"##CurrentTileCanvas", ImVec2(32, 32),
@@ -117,6 +108,8 @@ class ScreenEditor : public Editor {
                              gui::CanvasGridSize::k8x8, 2.f};

  zelda3::Inventory inventory_;
+  Rom* rom_;
+  absl::Status status_;
 };

 }  // namespace editor
--- a/src/app/editor/overworld/overworld_editor.cc
+++ b/src/app/editor/overworld/overworld_editor.cc
@@ -609,7 +609,7 @@ absl::Status OverworldEditor::CheckForCurrentMap() {
      ImGui::IsMouseClicked(ImGuiMouseButton_Right)) {
    RefreshOverworldMap();
    RETURN_IF_ERROR(RefreshTile16Blockset());
-    Renderer::GetInstance().UpdateBitmap(&maps_bmp_[current_map_]);
+    Renderer::Get().UpdateBitmap(&maps_bmp_[current_map_]);
    maps_bmp_[current_map_].set_modified(false);
  }

@@ -743,7 +743,7 @@ absl::Status OverworldEditor::DrawAreaGraphics() {
    overworld_.set_current_map(current_map_);
    palette_ = overworld_.current_area_palette();
    gfx::Bitmap bmp;
-    Renderer::GetInstance().CreateAndRenderBitmap(0x80, kOverworldMapSize, 0x08,
+    Renderer::Get().CreateAndRenderBitmap(0x80, kOverworldMapSize, 0x08,
                                                  overworld_.current_graphics(),
                                                  bmp, palette_);
    current_graphics_set_[current_map_] = bmp;
@@ -1038,13 +1038,13 @@ absl::Status OverworldEditor::LoadGraphics() {

  util::logf("Loading overworld graphics.");
  // Create the area graphics image
-  Renderer::GetInstance().CreateAndRenderBitmap(0x80, kOverworldMapSize, 0x40,
+  Renderer::Get().CreateAndRenderBitmap(0x80, kOverworldMapSize, 0x40,
                                                overworld_.current_graphics(),
                                                current_gfx_bmp_, palette_);

  util::logf("Loading overworld tileset.");
  // Create the tile16 blockset image
-  Renderer::GetInstance().CreateAndRenderBitmap(
+  Renderer::Get().CreateAndRenderBitmap(
      0x80, 0x2000, 0x08, overworld_.tile16_blockset_data(),
      tile16_blockset_bmp_, palette_);
  map_blockset_loaded_ = true;
@@ -1063,7 +1063,7 @@ absl::Status OverworldEditor::LoadGraphics() {
    overworld_.set_current_map(i);
    auto palette = overworld_.current_area_palette();
    try {
-      Renderer::GetInstance().CreateAndRenderBitmap(
+      Renderer::Get().CreateAndRenderBitmap(
          kOverworldMapSize, kOverworldMapSize, 0x80,
          overworld_.current_map_bitmap_data(), maps_bmp_[i], palette);
    } catch (const std::bad_alloc &e) {
@@ -1095,7 +1095,7 @@ absl::Status OverworldEditor::LoadSpriteGraphics() {
      sprite_previews_[sprite.id()].Create(width, height, depth,
                                           *sprite.preview_graphics());
      sprite_previews_[sprite.id()].SetPalette(palette_);
-      Renderer::GetInstance().RenderBitmap(&(sprite_previews_[sprite.id()]));
+      Renderer::Get().RenderBitmap(&(sprite_previews_[sprite.id()]));
    }
  return absl::OkStatus();
 }
@@ -1147,7 +1147,7 @@ void OverworldEditor::RefreshOverworldMap() {
  int n = is_large ? 4 : 1;
  // We do texture updating on the main thread
  for (int i = 0; i < n; ++i) {
-    Renderer::GetInstance().UpdateBitmap(&maps_bmp_[indices[i]]);
+    Renderer::Get().UpdateBitmap(&maps_bmp_[indices[i]]);
  }
 }

--- a/src/app/editor/overworld/tile16_editor.cc
+++ b/src/app/editor/overworld/tile16_editor.cc
@@ -28,20 +28,13 @@ absl::Status Tile16Editor::Initialize(
  current_gfx_bmp_.Create(current_gfx_bmp.width(), current_gfx_bmp.height(),
                          current_gfx_bmp.depth(), current_gfx_bmp.vector());
  current_gfx_bmp_.SetPalette(current_gfx_bmp.palette());
-  core::Renderer::GetInstance().RenderBitmap(&current_gfx_bmp_);
+  core::Renderer::Get().RenderBitmap(&current_gfx_bmp_);
  tile16_blockset_bmp_.Create(
      tile16_blockset_bmp.width(), tile16_blockset_bmp.height(),
      tile16_blockset_bmp.depth(), tile16_blockset_bmp.vector());
  tile16_blockset_bmp_.SetPalette(tile16_blockset_bmp.palette());
-  core::Renderer::GetInstance().RenderBitmap(&tile16_blockset_bmp_);
-  RETURN_IF_ERROR(LoadTile8());
-  // current_gfx_individual_ = gfx::ExtractTile8Bitmaps(
-  //     current_gfx_bmp_, rom()->palette_group().overworld_main[0],
-  //     current_palette_);
-  // for (auto &bmp : current_gfx_individual_) {
-  //   core::Renderer::GetInstance().RenderBitmap(&bmp);
-  // }
-  // map_blockset_loaded_ = true;
+  core::Renderer::Get().RenderBitmap(&tile16_blockset_bmp_);
+  // RETURN_IF_ERROR(LoadTile8());
  ImVector<std::string> tile16_names;
  for (int i = 0; i < 0x200; ++i) {
    std::string str = util::HexByte(all_tiles_types_[i]);
@@ -191,7 +184,7 @@ absl::Status Tile16Editor::UpdateBlockset() {
      current_tile16_bmp_ = tile16_blockset_->tile_bitmaps[notify_tile16];
      auto ow_main_pal_group = rom()->palette_group().overworld_main;
      current_tile16_bmp_.SetPalette(ow_main_pal_group[current_palette_]);
-      Renderer::GetInstance().UpdateBitmap(&current_tile16_bmp_);
+      Renderer::Get().UpdateBitmap(&current_tile16_bmp_);
    }
  }

@@ -277,7 +270,7 @@ absl::Status Tile16Editor::UpdateTile16Edit() {
          if (tile8_source_canvas_.DrawTileSelector(32)) {
            current_gfx_individual_[current_tile8_].SetPaletteWithTransparent(
                ow_main_pal_group[0], current_palette_);
-            Renderer::GetInstance().UpdateBitmap(
+            Renderer::Get().UpdateBitmap(
                &current_gfx_individual_[current_tile8_]);
          }
          tile8_source_canvas_.DrawBitmap(current_gfx_bmp_, 0, 0, 4.0f);
@@ -297,7 +290,7 @@ absl::Status Tile16Editor::UpdateTile16Edit() {
                    current_gfx_individual_[current_tile8_], 16, 2.0f)) {
              RETURN_IF_ERROR(DrawToCurrentTile16(
                  tile16_edit_canvas_.drawn_tile_position()));
-              Renderer::GetInstance().UpdateBitmap(&current_tile16_bmp_);
+              Renderer::Get().UpdateBitmap(&current_tile16_bmp_);
            }
          }
          tile16_edit_canvas_.DrawGrid();
@@ -346,10 +339,10 @@ absl::Status Tile16Editor::UpdateTile16Edit() {

          if (value > 0x00) {
            current_gfx_bmp_.SetPaletteWithTransparent(palette, value);
-            Renderer::GetInstance().UpdateBitmap(&current_gfx_bmp_);
+            Renderer::Get().UpdateBitmap(&current_gfx_bmp_);

            current_tile16_bmp_.SetPaletteWithTransparent(palette, value);
-            Renderer::GetInstance().UpdateBitmap(&current_tile16_bmp_);
+            Renderer::Get().UpdateBitmap(&current_tile16_bmp_);
          }
        }

@@ -426,8 +419,7 @@ absl::Status Tile16Editor::UpdateTile16Edit() {
    current_tile8_ = x + (y * 8);
    current_gfx_individual_[current_tile8_].SetPaletteWithTransparent(
        ow_main_pal_group[0], current_palette_);
-    Renderer::GetInstance().UpdateBitmap(
-        &current_gfx_individual_[current_tile8_]);
+    Renderer::Get().UpdateBitmap(&current_gfx_individual_[current_tile8_]);
  }

  return absl::OkStatus();
@@ -478,7 +470,7 @@ absl::Status Tile16Editor::LoadTile8() {
    tile_bitmap.Create(0x08, 0x08, 0x08, tile_data);
    tile_bitmap.SetPaletteWithTransparent(ow_main_pal_group[0],
                                          current_palette_);
-    Renderer::GetInstance().RenderBitmap(&tile_bitmap);
+    Renderer::Get().RenderBitmap(&tile_bitmap);
  }

  map_blockset_loaded_ = true;
@@ -492,7 +484,7 @@ absl::Status Tile16Editor::SetCurrentTile(int id) {
  current_tile16_bmp_ = tile16_blockset_->tile_bitmaps[current_tile16_];
  auto ow_main_pal_group = rom()->palette_group().overworld_main;
  current_tile16_bmp_.SetPalette(ow_main_pal_group[current_palette_]);
-  Renderer::GetInstance().UpdateBitmap(&current_tile16_bmp_);
+  Renderer::Get().UpdateBitmap(&current_tile16_bmp_);
  return absl::OkStatus();
 }

@@ -543,7 +535,7 @@ absl::Status Tile16Editor::UpdateTransferTileCanvas() {
    palette_ = transfer_overworld_.current_area_palette();

    // Create the tile16 blockset image
-    Renderer::GetInstance().CreateAndRenderBitmap(
+    Renderer::Get().CreateAndRenderBitmap(
        0x80, 0x2000, 0x80, transfer_overworld_.tile16_blockset_data(),
        transfer_blockset_bmp_, palette_);
    transfer_blockset_loaded_ = true;
@@ -565,10 +557,10 @@ absl::Status Tile16Editor::CopyTile16ToClipboard(int tile_id) {
  // Create a copy of the tile16 bitmap
  gfx::RenderTile(*tile16_blockset_, tile_id);
  clipboard_tile16_.Create(16, 16, 8,
-                            tile16_blockset_->tile_bitmaps[tile_id].vector());
+                           tile16_blockset_->tile_bitmaps[tile_id].vector());
  clipboard_tile16_.SetPalette(
      tile16_blockset_->tile_bitmaps[tile_id].palette());
-  core::Renderer::GetInstance().RenderBitmap(&clipboard_tile16_);
+  core::Renderer::Get().RenderBitmap(&clipboard_tile16_);

  clipboard_has_data_ = true;
  return absl::OkStatus();
@@ -582,7 +574,7 @@ absl::Status Tile16Editor::PasteTile16FromClipboard() {
  // Copy the clipboard data to the current tile16
  current_tile16_bmp_.Create(16, 16, 8, clipboard_tile16_.vector());
  current_tile16_bmp_.SetPalette(clipboard_tile16_.palette());
-  core::Renderer::GetInstance().RenderBitmap(&current_tile16_bmp_);
+  core::Renderer::Get().RenderBitmap(&current_tile16_bmp_);

  return absl::OkStatus();
 }
@@ -595,7 +587,7 @@ absl::Status Tile16Editor::SaveTile16ToScratchSpace(int slot) {
  // Create a copy of the current tile16 bitmap
  scratch_space_[slot].Create(16, 16, 8, current_tile16_bmp_.vector());
  scratch_space_[slot].SetPalette(current_tile16_bmp_.palette());
-  core::Renderer::GetInstance().RenderBitmap(&scratch_space_[slot]);
+  core::Renderer::Get().RenderBitmap(&scratch_space_[slot]);

  scratch_space_used_[slot] = true;
  return absl::OkStatus();
@@ -613,7 +605,7 @@ absl::Status Tile16Editor::LoadTile16FromScratchSpace(int slot) {
  // Copy the scratch space data to the current tile16
  current_tile16_bmp_.Create(16, 16, 8, scratch_space_[slot].vector());
  current_tile16_bmp_.SetPalette(scratch_space_[slot].palette());
-  core::Renderer::GetInstance().RenderBitmap(&current_tile16_bmp_);
+  core::Renderer::Get().RenderBitmap(&current_tile16_bmp_);

  return absl::OkStatus();
 }
--- a/src/app/gui/canvas.cc
+++ b/src/app/gui/canvas.cc
@@ -150,20 +150,17 @@ void Canvas::DrawContextMenu() {
      if (BeginMenu("Bitmap Format")) {
        if (MenuItem("Indexed")) {
          bitmap_->Reformat(gfx::BitmapFormat::kIndexed);
-          Renderer::GetInstance().UpdateBitmap(bitmap_);
-        }
-        if (MenuItem("2BPP")) {
-          bitmap_->Reformat(gfx::BitmapFormat::k2bpp);
-          Renderer::GetInstance().UpdateBitmap(bitmap_);
+          Renderer::Get().UpdateBitmap(bitmap_);
        }
        if (MenuItem("4BPP")) {
          bitmap_->Reformat(gfx::BitmapFormat::k4bpp);
-          Renderer::GetInstance().UpdateBitmap(bitmap_);
+          Renderer::Get().UpdateBitmap(bitmap_);
        }
        if (MenuItem("8BPP")) {
          bitmap_->Reformat(gfx::BitmapFormat::k8bpp);
-          Renderer::GetInstance().UpdateBitmap(bitmap_);
+          Renderer::Get().UpdateBitmap(bitmap_);
        }
+
        EndMenu();
      }
      if (BeginMenu("View Palette")) {
@@ -192,7 +189,7 @@ void Canvas::DrawContextMenu() {
            if (refresh_graphics_) {
              bitmap_->SetPaletteWithTransparent(*palette,
                                                 edit_palette_sub_index_);
-              Renderer::GetInstance().UpdateBitmap(bitmap_);
+              Renderer::Get().UpdateBitmap(bitmap_);
              refresh_graphics_ = false;
            }
            ImGui::EndChild();
@@ -302,7 +299,7 @@ bool Canvas::DrawTilemapPainter(gfx::Tilemap &tilemap, int current_tile) {
        tilemap.tile_size.x, tilemap.tile_size.y, 8,
        gfx::GetTilemapData(tilemap, current_tile), tilemap.atlas.palette());
    auto bitmap_ptr = &tilemap.tile_bitmaps[current_tile];
-    Renderer::GetInstance().RenderBitmap(bitmap_ptr);
+    Renderer::Get().RenderBitmap(bitmap_ptr);
  }

  draw_list_->AddImage(
@@ -511,17 +508,6 @@ void Canvas::DrawSelectRect(int current_map, int tile_size, float scale) {
  }
 }

-void Canvas::DrawBitmap(Bitmap &bitmap, int border_offset, bool ready) {
-  if (ready) {
-    bitmap_ = &bitmap;
-    draw_list_->AddImage(
-        (ImTextureID)(intptr_t)bitmap.texture(),
-        ImVec2(canvas_p0_.x + border_offset, canvas_p0_.y + border_offset),
-        ImVec2(canvas_p0_.x + (bitmap.width() * 2),
-               canvas_p0_.y + (bitmap.height() * 2)));
-  }
-}
-
 void Canvas::DrawBitmap(Bitmap &bitmap, int border_offset, float scale) {
  if (!bitmap.is_active()) {
    return;
@@ -550,6 +536,22 @@ void Canvas::DrawBitmap(Bitmap &bitmap, int x_offset, int y_offset, float scale,
      ImVec2(0, 0), ImVec2(1, 1), IM_COL32(255, 255, 255, alpha));
 }

+void Canvas::DrawBitmap(Bitmap &bitmap, ImVec2 dest_pos, ImVec2 dest_size,
+                        ImVec2 src_pos, ImVec2 src_size) {
+  if (!bitmap.is_active()) {
+    return;
+  }
+  bitmap_ = &bitmap;
+  draw_list_->AddImage(
+      (ImTextureID)(intptr_t)bitmap.texture(),
+      ImVec2(canvas_p0_.x + dest_pos.x, canvas_p0_.y + dest_pos.y),
+      ImVec2(canvas_p0_.x + dest_pos.x + dest_size.x,
+             canvas_p0_.y + dest_pos.y + dest_size.y),
+      ImVec2(src_pos.x / bitmap.width(), src_pos.y / bitmap.height()),
+      ImVec2((src_pos.x + src_size.x) / bitmap.width(),
+             (src_pos.y + src_size.y) / bitmap.height()));
+}
+
 // TODO: Add parameters for sizing and positioning
 void Canvas::DrawBitmapTable(const BitmapTable &gfx_bin) {
  for (const auto &[key, value] : gfx_bin) {
@@ -630,8 +632,8 @@ void Canvas::DrawBitmapGroup(std::vector<int> &group, gfx::Tilemap &tilemap,
      int tile_id = group[i];

      // Check if tile_id is within the range of tile16_individual_
-      auto tilemap_size = tilemap.atlas.width() * tilemap.atlas.height() /
-                          tilemap.map_size.x;
+      auto tilemap_size =
+          tilemap.atlas.width() * tilemap.atlas.height() / tilemap.map_size.x;
      if (tile_id >= 0 && tile_id < tilemap_size) {
        // Calculate the position of the tile within the rectangle
        int tile_pos_x = (x + start_tile_x) * tile_size * scale;
--- a/src/app/gui/canvas.h
+++ b/src/app/gui/canvas.h
@@ -110,14 +110,14 @@ class Canvas : public SharedRom {
                      float scale = 1.0f);

  // Draws the contents of the Bitmap image to the Canvas
-  void DrawBitmap(Bitmap &bitmap, int border_offset = 0, bool ready = true);
  void DrawBitmap(Bitmap &bitmap, int border_offset, float scale);
-  void DrawBitmap(Bitmap &bitmap, int x_offset = 0, int y_offset = 0,
-                  float scale = 1.0f, int alpha = 255);
+  void DrawBitmap(Bitmap &bitmap, int x_offset, int y_offset, float scale = 1.0f,
+                  int alpha = 255);
+  void DrawBitmap(Bitmap &bitmap, ImVec2 dest_pos, ImVec2 dest_size,
+                  ImVec2 src_pos, ImVec2 src_size);
  void DrawBitmapTable(const BitmapTable &gfx_bin);

-  void DrawBitmapGroup(std::vector<int> &group,
-                       gfx::Tilemap &tilemap,
+  void DrawBitmapGroup(std::vector<int> &group, gfx::Tilemap &tilemap,
                       int tile_size, float scale = 1.0f);

  bool DrawTilemapPainter(gfx::Tilemap &tilemap, int current_tile);
--- a/src/app/rom.cc
+++ b/src/app/rom.cc
@@ -22,6 +22,7 @@
 #include "app/gfx/snes_color.h"
 #include "app/gfx/snes_palette.h"
 #include "app/gfx/snes_tile.h"
+#include "app/snes.h"
 #include "util/hex.h"
 #include "util/log.h"
 #include "util/macro.h"
@@ -69,7 +70,7 @@ absl::StatusOr<std::array<gfx::Bitmap, kNumLinkSheets>> LoadLinkGraphics(
    link_graphics[i].Create(gfx::kTilesheetWidth, gfx::kTilesheetHeight,
                            gfx::kTilesheetDepth, link_sheet_8bpp);
    link_graphics[i].SetPalette(rom.palette_group().armors[0]);
-    Renderer::GetInstance().RenderBitmap(&link_graphics[i]);
+    Renderer::Get().RenderBitmap(&link_graphics[i]);
  }
  return link_graphics;
 }
@@ -117,7 +118,7 @@ absl::StatusOr<std::array<gfx::Bitmap, kNumGfxSheets>> LoadAllGraphicsData(
      }

      if (!defer_render) {
-        graphics_sheets[i].CreateTexture(Renderer::GetInstance().renderer());
+        graphics_sheets[i].CreateTexture(Renderer::Get().renderer());
      }

      for (int j = 0; j < graphics_sheets[i].size(); ++j) {
--- a/src/app/rom.h
+++ b/src/app/rom.h
@@ -22,7 +22,6 @@
 #include "app/gfx/bitmap.h"
 #include "app/gfx/snes_palette.h"
 #include "app/gfx/snes_tile.h"
-#include "app/snes.h"
 #include "util/macro.h"

 namespace yaze {
--- a/src/app/zelda3/dungeon/room.cc
+++ b/src/app/zelda3/dungeon/room.cc
@@ -9,6 +9,7 @@
 #include "app/core/platform/renderer.h"
 #include "app/gfx/arena.h"
 #include "app/rom.h"
+#include "app/snes.h"
 #include "app/zelda3/dungeon/room_object.h"
 #include "app/zelda3/sprite/sprite.h"
 #include "util/log.h"
@@ -261,18 +262,16 @@ void Room::RenderRoomGraphics() {
      rom()->mutable_palette_group()->get_group("dungeon_main")[0].palette(0);

  if (!gfx::Arena::Get().bg1().bitmap().is_active()) {
-    core::Renderer::GetInstance().CreateAndRenderBitmap(
+    core::Renderer::Get().CreateAndRenderBitmap(
        0x200, 0x200, 0x200, gfx::Arena::Get().bg1().bitmap().vector(),
        gfx::Arena::Get().bg1().bitmap(), bg1_palette);
-    core::Renderer::GetInstance().CreateAndRenderBitmap(
+    core::Renderer::Get().CreateAndRenderBitmap(
        0x200, 0x200, 0x200, gfx::Arena::Get().bg2().bitmap().vector(),
        gfx::Arena::Get().bg2().bitmap(), bg1_palette);
  } else {
    // Update the bitmap
-    core::Renderer::GetInstance().UpdateBitmap(
-        &gfx::Arena::Get().bg1().bitmap());
-    core::Renderer::GetInstance().UpdateBitmap(
-        &gfx::Arena::Get().bg2().bitmap());
+    core::Renderer::Get().UpdateBitmap(&gfx::Arena::Get().bg1().bitmap());
+    core::Renderer::Get().UpdateBitmap(&gfx::Arena::Get().bg2().bitmap());
  }
 }

--- a/src/app/zelda3/screen/dungeon_map.cc
+++ b/src/app/zelda3/screen/dungeon_map.cc
@@ -35,7 +35,7 @@ absl::Status LoadDungeonMapGfxFromBinary(Rom &rom,
                                converted_bin.begin() + ((i + 1) * 0x1000));
        sheets[i] = gfx::Bitmap(128, 32, 8, gfx_sheets[i]);
        sheets[i].SetPalette(*rom.mutable_dungeon_palette(3));
-        core::Renderer::GetInstance().RenderBitmap(&sheets[i]);
+        core::Renderer::Get().RenderBitmap(&sheets[i]);
      }
    } else {
      return absl::InternalError("Failed to load dungeon map tile16");
--- a/src/app/zelda3/screen/inventory.cc
+++ b/src/app/zelda3/screen/inventory.cc
@@ -69,7 +69,7 @@ absl::Status Inventory::Create() {

  bitmap_.Create(256, 256, 8, data_);
  bitmap_.SetPalette(palette_);
-  Renderer::GetInstance().RenderBitmap(&bitmap_);
+  Renderer::Get().RenderBitmap(&bitmap_);
  return absl::OkStatus();
 }

@@ -88,7 +88,7 @@ absl::Status Inventory::BuildTileset() {
  auto hud_pal_group = rom()->palette_group().hud;
  palette_ = hud_pal_group[0];
  tilesheets_bmp_.SetPalette(palette_);
-  Renderer::GetInstance().RenderBitmap(&tilesheets_bmp_);
+  Renderer::Get().RenderBitmap(&tilesheets_bmp_);
  return absl::OkStatus();
 }