refactor editing

src/app/editor/dungeon_editor.cc

@@ -9,7 +9,7 @@ namespace editor {
 void DungeonEditor::Update() {
   DrawToolset();
   canvas_.DrawBackground();
-  canvas_.UpdateContext();
+  canvas_.DrawContextMenu();
   canvas_.DrawGrid();
   canvas_.DrawOverlay();
 }

src/app/editor/overworld_editor.cc

@@ -107,7 +107,14 @@ absl::Status OverworldEditor::DrawToolset() {
     // Load Overworld
     ImGui::TableNextColumn();
     if (ImGui::Button(ICON_MD_UPDATE)) {
-      RETURN_IF_ERROR(overworld_.Load(rom_, tile16_blockset_bmp_.GetData()))
+      RETURN_IF_ERROR(overworld_.Load(rom_))
+      current_gfx_bmp_.Create(128, 512, 8,
+                              overworld_.GetCurrentGraphics().data(), 32768);
+      tile16_blockset_bmp_.Create(128 * 2, 8192 * 2, 8,
+                                  (uchar *)overworld_.GetCurrentBlockset(),
+                                  1048576);
+      rom_.RenderBitmap(current_gfx_bmp_);
+      rom_.RenderBitmap(tile16_blockset_bmp_);
     }
 
     ImGui::TableNextColumn();
@@ -179,18 +186,11 @@ void OverworldEditor::DrawOverworldCanvas() {
   DrawOverworldMapSettings();
   ImGui::Separator();
   overworld_map_canvas_.DrawBackground();
-  overworld_map_canvas_.UpdateContext();
+  overworld_map_canvas_.DrawContextMenu();
   if (overworld_.isLoaded()) {
     auto map = overworld_.GetOverworldMap(0);
     if (map.IsInitialized() && map.IsBuilt()) {
-      overworld_map_canvas_.GetDrawList()->AddImage(
-          (void *)map.GetBitmap().GetTexture(),
-          ImVec2(overworld_map_canvas_.GetZeroPoint().x + 2,
-                 overworld_map_canvas_.GetZeroPoint().y + 2),
-          ImVec2(overworld_map_canvas_.GetZeroPoint().x +
-                     (map.GetBitmap().GetWidth() * 2),
-                 overworld_map_canvas_.GetZeroPoint().y +
-                     (map.GetBitmap().GetHeight() * 2)));
+      overworld_map_canvas_.DrawBitmap(map.GetBitmap(), 2);
     }
   }
   overworld_map_canvas_.DrawGrid(64.f);
@@ -230,16 +230,9 @@ void OverworldEditor::DrawTileSelector() {
 
 void OverworldEditor::DrawTile16Selector() {
   blockset_canvas_.DrawBackground(ImVec2(256 + 1, kNumSheetsToLoad * 64 + 1));
-  blockset_canvas_.UpdateContext();
+  blockset_canvas_.DrawContextMenu();
   if (map_blockset_loaded_) {
-    blockset_canvas_.GetDrawList()->AddImage(
-        (void *)tile16_blockset_bmp_.GetTexture(),
-        ImVec2(blockset_canvas_.GetZeroPoint().x + 2,
-               blockset_canvas_.GetZeroPoint().y + 2),
-        ImVec2(blockset_canvas_.GetZeroPoint().x +
-                   (tile16_blockset_bmp_.GetWidth() * 2),
-               blockset_canvas_.GetZeroPoint().y +
-                   (tile16_blockset_bmp_.GetHeight() * 2)));
+    blockset_canvas_.DrawBitmap(tile16_blockset_bmp_, 2);
   }
   blockset_canvas_.DrawGrid(32.0f);
   blockset_canvas_.DrawOverlay();
@@ -248,7 +241,7 @@ void OverworldEditor::DrawTile16Selector() {
 void OverworldEditor::DrawTile8Selector() {
   graphics_bin_canvas_.DrawBackground(
       ImVec2(256 + 1, kNumSheetsToLoad * 64 + 1));
-  graphics_bin_canvas_.UpdateContext();
+  graphics_bin_canvas_.DrawContextMenu();
   if (all_gfx_loaded_) {
     for (const auto &[key, value] : graphics_bin_) {
       int offset = 64 * (key + 1);
@@ -276,7 +269,7 @@ void OverworldEditor::DrawAreaGraphics() {
       set_loaded = true;
     }
     current_gfx_canvas_.DrawBackground(ImVec2(256 + 1, 16 * 64 + 1));
-    current_gfx_canvas_.UpdateContext();
+    current_gfx_canvas_.DrawContextMenu();
     for (const auto &[key, value] : current_graphics_set_) {
       int offset = 64 * (key + 1);
       int top_left_y = current_gfx_canvas_.GetZeroPoint().y + 2;
@@ -302,13 +295,8 @@ void OverworldEditor::LoadGraphics() {
     current_palette_[i].w = 1.f;
   }
 
-  absl::Status graphics_data_status = rom_.LoadAllGraphicsData();
-  if (!graphics_data_status.ok()) {
-    std::cout << "Error " << graphics_data_status.ToString() << std::endl;
-  }
+  PRINT_IF_ERROR(rom_.LoadAllGraphicsData());
   graphics_bin_ = rom_.GetGraphicsBin();
-
-  tile16_blockset_bmp_.Create(128 * 2, 8192 * 2, 8, 1048576);
 }
 
 }  // namespace editor

src/app/editor/overworld_editor.h

@@ -4,6 +4,7 @@
 #include <imgui/imgui.h>
 
 #include <cmath>
+#include <unordered_map>
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
@@ -78,8 +79,8 @@ class OverworldEditor {
                                   ImGuiTableFlags_Resizable |
                                   ImGuiTableFlags_SizingStretchSame;
 
-  absl::flat_hash_map<int, gfx::Bitmap> graphics_bin_;
-  absl::flat_hash_map<int, gfx::Bitmap> current_graphics_set_;
+  std::unordered_map<int, gfx::Bitmap> graphics_bin_;
+  std::unordered_map<int, gfx::Bitmap> current_graphics_set_;
 
   ROM rom_;
   zelda3::Overworld overworld_;

src/app/editor/screen_editor.cc

@@ -121,7 +121,7 @@ void ScreenEditor::DrawHUDEditor() {
 
 void ScreenEditor::DrawCanvas() {
   screen_canvas_.DrawBackground();
-  screen_canvas_.UpdateContext();
+  screen_canvas_.DrawContextMenu();
 
   screen_canvas_.DrawGrid();
   screen_canvas_.DrawOverlay();

src/app/rom.cc

@@ -353,7 +353,8 @@ absl::Status ValidateCompressionResult(
     ROM temp_rom;
     RETURN_IF_ERROR(temp_rom.LoadFromBytes(
         CreateCompressionString(compressed_chain_start->next, mode)))
-    ASSIGN_OR_RETURN(auto decomp_data, temp_rom.Decompress(0, temp_rom.GetSize()))
+    ASSIGN_OR_RETURN(auto decomp_data,
+                     temp_rom.Decompress(0, temp_rom.GetSize()))
     if (!std::equal(decomp_data.begin() + start, decomp_data.end(),
                     temp_rom.begin())) {
       return absl::InternalError(absl::StrFormat(
@@ -606,8 +607,16 @@ absl::Status ROM::LoadAllGraphicsData() {
       auto converted_sheet = SNES3bppTo8bppSheet(sheet);
       graphics_bin_[i] =
           gfx::Bitmap(core::kTilesheetWidth, core::kTilesheetHeight,
-                      core::kTilesheetDepth, converted_sheet.data());
+                      core::kTilesheetDepth, converted_sheet.data(), 0x1000);
       graphics_bin_.at(i).CreateTexture(renderer_);
+
+      for (int j = 0; j < graphics_bin_.at(i).GetSize(); ++j) {
+        graphics_buffer_.push_back(graphics_bin_.at(i).GetByte(j));
+      }
+    } else {
+      for (int j = 0; j < 0x1000; ++j) {
+        graphics_buffer_.push_back(0xFF);
+      }
     }
   }
   return absl::OkStatus();

src/app/rom.h

@@ -10,9 +10,9 @@
 #include <iostream>
 #include <memory>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
-#include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -87,7 +87,8 @@ class ROM {
   auto GetSize() const { return size_; }
   auto GetTitle() const { return title; }
   auto GetGraphicsBin() const { return graphics_bin_; }
-  auto GetRenderer() const { return renderer_; }
+  auto GetGraphicsBuffer() const { return graphics_buffer_; }
+  void RenderBitmap(gfx::Bitmap& bitmap) { bitmap.CreateTexture(renderer_); }
   void SetupRenderer(std::shared_ptr<SDL_Renderer> renderer) {
     renderer_ = renderer;
   }
@@ -119,8 +120,9 @@ class ROM {
   std::string filename_;
 
   Bytes rom_data_;
+  Bytes graphics_buffer_;
   std::shared_ptr<SDL_Renderer> renderer_;
-  absl::flat_hash_map<int, gfx::Bitmap> graphics_bin_;
+  std::unordered_map<int, gfx::Bitmap> graphics_bin_;
 };
 
 }  // namespace app