scawful/yaze
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor Renderer access and enhance graphics loading functionality

Browse Source 
- 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.
This commit is contained in:
scawful
2025-05-08 19:37:48 -04:00
parent fb015523dc
commit 11504ca4c1
18 changed files with 147 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/app/editor/code/memory_editor.h
View File

@@ -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"

18
src/app/editor/dungeon/dungeon_editor.cc
View File

@@ -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();
}
}

18
src/app/editor/graphics/graphics_editor.cc
View File

@@ -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;

101
src/app/editor/graphics/screen_editor.cc
View File

@@ -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 {

17
src/app/editor/graphics/screen_editor.h
View File

@@ -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

14
src/app/editor/overworld/overworld_editor.cc
View File

@@ -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]]);
}
}

42
src/app/editor/overworld/tile16_editor.cc
View File

@@ -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();
}