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

overworld editor tile selector/painter routines

Browse Source
This commit is contained in:
scawful
2022-12-31 13:53:07 -06:00
parent 95d69bcb92
commit a8729add01
6 changed files with 173 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

211
src/app/editor/overworld_editor.cc
View File

@@ -24,15 +24,16 @@ namespace editor {
namespace {
void UpdateSelectedTile16(int selected, gfx::Bitmap &tile16_blockset,
Bytes &selected_tile) {
selected_tile.reserve(256);
gfx::Bitmap &selected_tile) {
auto blockset = tile16_blockset.GetData();
int src_pos = ((selected - ((selected / 0x08) * 0x08)) * 0x10) +
((selected / 0x08) * 2048);
for (int yy = 0; yy < 0x10; yy++) {
for (int xx = 0; xx < 0x10; xx++) {
selected_tile[xx + (yy * 0x10)] = blockset[src_pos + xx + (yy * 0x80)];
for (int yy = 0; yy < 0x20; yy++) {
for (int xx = 0; xx < 0x20; xx++) {
int position = (xx + (yy * 0x20));
uchar value = blockset[src_pos + xx + (yy * 0x80)];
selected_tile.WriteToPixel(position, value);
}
}
}
@@ -48,11 +49,11 @@ absl::Status OverworldEditor::Update() {
RETURN_IF_ERROR(overworld_.Load(rom_))
palette_ = overworld_.AreaPalette();
current_gfx_bmp_.Create(128, 512, 64, overworld_.AreaGraphics());
current_gfx_bmp_.Create(0x80, 0x200, 0x40, overworld_.AreaGraphics());
current_gfx_bmp_.ApplyPalette(palette_);
rom_.RenderBitmap(&current_gfx_bmp_);
tile16_blockset_bmp_.Create(128, 8192, 128, overworld_.Tile16Blockset());
tile16_blockset_bmp_.Create(0x80, 8192, 0x80, overworld_.Tile16Blockset());
tile16_blockset_bmp_.ApplyPalette(palette_);
rom_.RenderBitmap(&tile16_blockset_bmp_);
map_blockset_loaded_ = true;
@@ -60,23 +61,12 @@ absl::Status OverworldEditor::Update() {
for (int i = 0; i < core::kNumOverworldMaps; ++i) {
overworld_.SetCurrentMap(i);
auto palette = overworld_.AreaPalette();
maps_bmp_[i].Create(512, 512, 512, overworld_.BitmapData());
maps_bmp_[i].Create(0x200, 0x200, 0x200, overworld_.BitmapData());
maps_bmp_[i].ApplyPalette(palette);
rom_.RenderBitmap(&(maps_bmp_[i]));
}
}
if (update_selected_tile_ && all_gfx_loaded_) {
if (!selected_tile_loaded_) {
selected_tile_bmp_.Create(16, 16, 64, 256);
}
UpdateSelectedTile16(selected_tile_, tile16_blockset_bmp_,
selected_tile_data_);
selected_tile_bmp_.ApplyPalette(palette_);
rom_.RenderBitmap(&selected_tile_bmp_);
update_selected_tile_ = false;
}
auto toolset_status = DrawToolset();
RETURN_IF_ERROR(toolset_status)
@@ -97,6 +87,8 @@ absl::Status OverworldEditor::Update() {
return absl::OkStatus();
}
// ----------------------------------------------------------------------------
absl::Status OverworldEditor::DrawToolset() {
if (ImGui::BeginTable("OWToolset", 17, toolset_table_flags, ImVec2(0, 0))) {
for (const auto &name : kToolsetColumnNames)
@@ -124,6 +116,8 @@ absl::Status OverworldEditor::DrawToolset() {
return absl::OkStatus();
}
// ----------------------------------------------------------------------------
void OverworldEditor::DrawOverworldMapSettings() {
if (ImGui::BeginTable("#mapSettings", 8, ow_map_flags, ImVec2(0, 0), -1)) {
for (const auto &name : kOverworldSettingsColumnNames)
@@ -174,98 +168,91 @@ void OverworldEditor::DrawOverworldMapSettings() {
}
}
// ----------------------------------------------------------------------------
void OverworldEditor::DrawOverworldEntrances() {
for (const auto &each : overworld_.Entrances()) {
if (each.map_id_ < 0x40 + (current_world_ * 0x40) &&
each.map_id_ >= (current_world_ * 0x40)) {
overworld_map_canvas_.DrawRect(each.x_, each.y_, 16, 16,
ImVec4(210, 24, 210, 150));
std::string str = absl::StrFormat("%#x", each.entrance_id_);
overworld_map_canvas_.DrawText(str, each.x_ - 4, each.y_ - 2);
}
}
}
// ----------------------------------------------------------------------------
void OverworldEditor::DrawOverworldMaps() {
int xx = 0;
int yy = 0;
for (int i = 0; i < 0x40; i++) {
int world_index = i + (current_world_ * 0x40);
int map_x = (xx * 0x200);
int map_y = (yy * 0x200);
overworld_map_canvas_.DrawBitmap(maps_bmp_[world_index], map_x, map_y);
xx++;
if (xx >= 8) {
yy++;
xx = 0;
}
DrawOverworldEntrances();
}
}
// ----------------------------------------------------------------------------
void OverworldEditor::DrawOverworldCanvas() {
DrawOverworldMapSettings();
ImGui::Separator();
ImGuiID child_id = ImGui::GetID((void *)(intptr_t)7);
if (ImGui::BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
if (ImGuiID child_id = ImGui::GetID((void *)(intptr_t)7);
ImGui::BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar |
ImGuiWindowFlags_AlwaysHorizontalScrollbar)) {
overworld_map_canvas_.DrawBackground(ImVec2(0x200 * 8, 0x200 * 8));
overworld_map_canvas_.DrawContextMenu();
overworld_map_canvas_.DrawTilePainter(selected_tile_bmp_, 32);
if (overworld_.isLoaded()) {
int xx = 0;
int yy = 0;
for (int i = 0; i < 0x40; i++) {
overworld_map_canvas_.DrawBitmap(maps_bmp_[i + (current_world_ * 0x40)],
(xx * 0x200), (yy * 0x200));
xx++;
if (xx >= 8) {
yy++;
xx = 0;
}
}
for (const auto &each : overworld_.Entrances()) {
if (each.map_id_ < 64 + (current_world_ * 0x40) &&
each.map_id_ >= (current_world_ * 0x40)) {
overworld_map_canvas_.DrawRect(each.x_, each.y_, 16, 16,
ImVec4(210, 24, 210, 150));
std::string str = absl::StrFormat("%#x", each.entrance_id_);
overworld_map_canvas_.DrawText(str, each.x_ - 4, each.y_ - 2);
}
}
DrawOverworldMaps();
}
overworld_map_canvas_.DrawGrid(64.f);
overworld_map_canvas_.DrawGrid(64.0f);
overworld_map_canvas_.DrawOverlay();
if (!blockset_canvas_.Points().empty() && all_gfx_loaded_) {
// TODO(scawful): update selected tile by getting position from canvas
// if (!selected_tile_loaded_) {
// selected_tile_loaded_ = true;
// }
selected_tile_bmp_.Create(32, 32, 0x40, 1024);
UpdateSelectedTile16(selected_tile_, tile16_blockset_bmp_,
selected_tile_bmp_);
selected_tile_bmp_.ApplyPalette(palette_);
rom_.RenderBitmap(&selected_tile_bmp_);
update_selected_tile_ = false;
}
}
ImGui::EndChild();
}
void OverworldEditor::DrawTileSelector() {
if (ImGui::BeginTabBar("##TabBar", ImGuiTabBarFlags_FittingPolicyScroll)) {
if (ImGui::BeginTabItem("Area Graphics")) {
ImGuiID child_id = ImGui::GetID((void *)(intptr_t)3);
if (ImGui::BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
DrawAreaGraphics();
}
ImGui::EndChild();
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem("Tile16")) {
ImGuiID child_id = ImGui::GetID((void *)(intptr_t)2);
if (ImGui::BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
DrawTile16Selector();
}
ImGui::EndChild();
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem("Tile8")) {
ImGuiID child_id = ImGui::GetID((void *)(intptr_t)1);
if (ImGui::BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
DrawTile8Selector();
}
ImGui::EndChild();
ImGui::EndTabItem();
}
ImGui::EndTabBar();
}
}
void OverworldEditor::DrawAreaGraphics() {
current_gfx_canvas_.DrawBackground(ImVec2(256 + 1, 16 * 64 + 1));
current_gfx_canvas_.DrawContextMenu();
current_gfx_canvas_.DrawTileSelector(32);
current_gfx_canvas_.DrawBitmap(current_gfx_bmp_, 2, overworld_.isLoaded());
current_gfx_canvas_.DrawGrid(32.0f);
current_gfx_canvas_.DrawOverlay();
if (!current_gfx_canvas_.Points().empty()) {
// TODO(scawful): update selected tile by getting position from canvas
}
}
// ----------------------------------------------------------------------------
// Tile 16 Selector
// Displays all the tiles in the game.
void OverworldEditor::DrawTile16Selector() {
blockset_canvas_.DrawBackground(ImVec2(0x100 + 1, (8192 * 2) + 1));
blockset_canvas_.DrawContextMenu();
blockset_canvas_.DrawBitmap(tile16_blockset_bmp_, 2, map_blockset_loaded_);
blockset_canvas_.DrawTileSelector(32);
blockset_canvas_.DrawGrid(32.0f);
blockset_canvas_.DrawOverlay();
}
// ----------------------------------------------------------------------------
// Tile 8 Selector
// Displays all the individual tiles that make up a tile16.
void OverworldEditor::DrawTile8Selector() {
graphics_bin_canvas_.DrawBackground(
ImVec2(0x100 + 1, kNumSheetsToLoad * 0x40 + 1));
@@ -288,6 +275,54 @@ void OverworldEditor::DrawTile8Selector() {
graphics_bin_canvas_.DrawOverlay();
}
// ----------------------------------------------------------------------------
void OverworldEditor::DrawAreaGraphics() {
current_gfx_canvas_.DrawBackground(ImVec2(256 + 1, 0x10 * 0x40 + 1));
current_gfx_canvas_.DrawContextMenu();
current_gfx_canvas_.DrawTileSelector(32);
current_gfx_canvas_.DrawBitmap(current_gfx_bmp_, 2, overworld_.isLoaded());
current_gfx_canvas_.DrawGrid(32.0f);
current_gfx_canvas_.DrawOverlay();
}
// ----------------------------------------------------------------------------
void OverworldEditor::DrawTileSelector() {
if (ImGui::BeginTabBar("##TabBar", ImGuiTabBarFlags_FittingPolicyScroll)) {
if (ImGui::BeginTabItem("Tile16")) {
if (ImGuiID child_id = ImGui::GetID((void *)(intptr_t)2);
ImGui::BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
DrawTile16Selector();
}
ImGui::EndChild();
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem("Tile8")) {
if (ImGuiID child_id = ImGui::GetID((void *)(intptr_t)1);
ImGui::BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
DrawTile8Selector();
}
ImGui::EndChild();
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem("Area Graphics")) {
if (ImGuiID child_id = ImGui::GetID((void *)(intptr_t)3);
ImGui::BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
DrawAreaGraphics();
}
ImGui::EndChild();
ImGui::EndTabItem();
}
ImGui::EndTabBar();
}
}
// ----------------------------------------------------------------------------
void OverworldEditor::LoadGraphics() {
for (int i = 0; i < 8; i++) {
current_palette_[i].x = (i * 0.21f);

6
src/app/editor/overworld_editor.h
View File

@@ -53,11 +53,15 @@ class OverworldEditor {
private:
absl::Status DrawToolset();
void DrawOverworldMapSettings();
void DrawOverworldEntrances();
void DrawOverworldMaps();
void DrawOverworldCanvas();
void DrawTileSelector();
void DrawTile16Selector();
void DrawTile8Selector();
void DrawAreaGraphics();
void DrawTileSelector();
void LoadGraphics();
int current_world_ = 0;

5
src/app/gfx/bitmap.cc
View File

@@ -96,6 +96,11 @@ void Bitmap::Create(int width, int height, int depth, Bytes data) {
GrayscalePalette(surface_->format->palette);
}
void Bitmap::Apply(Bytes data) {
pixel_data_ = data.data();
data_ = data;
}
// Creates the texture that will be displayed to the screen.
void Bitmap::CreateTexture(std::shared_ptr<SDL_Renderer> renderer) {
texture_ = std::shared_ptr<SDL_Texture>{

6
src/app/gfx/bitmap.h
View File

@@ -28,10 +28,16 @@ class Bitmap {
void Create(int width, int height, int depth, uchar *data, int data_size);
void Create(int width, int height, int depth, Bytes data);
void Apply(Bytes data);
void CreateTexture(std::shared_ptr<SDL_Renderer> renderer);
void ApplyPalette(const SNESPalette &palette);
void WriteToPixel(int position, uchar value) {
this->pixel_data_[position] = value;
}
int GetWidth() const { return width_; }
int GetHeight() const { return height_; }
auto GetSize() const { return data_size_; }

33
src/gui/canvas.cc
View File

@@ -63,6 +63,37 @@ void Canvas::DrawContextMenu() {
}
}
void Canvas::DrawTilePainter(const Bitmap& bitmap, int size) {
const ImGuiIO &io = ImGui::GetIO();
const bool is_hovered = ImGui::IsItemHovered(); // Hovered
const ImVec2 origin(canvas_p0_.x + scrolling_.x,
canvas_p0_.y + scrolling_.y); // Lock scrolled origin
const ImVec2 mouse_pos_in_canvas(io.MousePos.x - origin.x,
io.MousePos.y - origin.y);
if (is_hovered) {
if (!points_.empty()) {
points_.clear();
}
ImVec2 draw_tile_outline_pos;
draw_tile_outline_pos.x =
std::floor((double)mouse_pos_in_canvas.x / size) * size;
draw_tile_outline_pos.y =
std::floor((double)mouse_pos_in_canvas.y / size) * size;
points_.push_back(draw_tile_outline_pos);
points_.push_back(
ImVec2(draw_tile_outline_pos.x + size, draw_tile_outline_pos.y + size));
draw_list_->AddImage((void *)bitmap.GetTexture(),
ImVec2(draw_tile_outline_pos.x, draw_tile_outline_pos.y),
ImVec2(draw_tile_outline_pos.x + (bitmap.GetWidth() * 2),
draw_tile_outline_pos.y + (bitmap.GetHeight() * 2)));
} else {
points_.clear();
}
}
void Canvas::DrawTileSelector(int size) {
const ImGuiIO &io = ImGui::GetIO();
const bool is_hovered = ImGui::IsItemHovered(); // Hovered
@@ -70,7 +101,7 @@ void Canvas::DrawTileSelector(int size) {
canvas_p0_.y + scrolling_.y); // Lock scrolled origin
const ImVec2 mouse_pos_in_canvas(io.MousePos.x - origin.x,
io.MousePos.y - origin.y);
// Add first and second point
if (is_hovered && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
if (!points_.empty()) {
points_.clear();

2
src/gui/canvas.h
View File

@@ -22,6 +22,7 @@ class Canvas {
void DrawBackground(ImVec2 canvas_size = ImVec2(0, 0));
void DrawContextMenu();
void DrawTilePainter(const Bitmap& bitmap, int size);
void DrawTileSelector(int size);
void DrawBitmap(const Bitmap& bitmap, int border_offset = 0,
bool ready = true);
@@ -55,6 +56,7 @@ class Canvas {
ImVec2 mouse_pos_in_canvas_;
std::vector<app::gfx::Bitmap> changed_tiles_;
app::gfx::Bitmap current_tile_;
std::string title_;
};