Refactoring tileset viewer to separate class.

include/App/EditorApp.hpp

@@ -73,7 +73,8 @@ public:
 #pragma region GUI Elements
     JUI::Scene* scene = nullptr;
     JUI::CommandLine* console = nullptr;
-    JUI::Window* tileset_viewer = nullptr;
+    TilesetView* tileset_view = nullptr;
+    //JUI::Window* tileset_viewer = nullptr;
     JUI::Rect* cell_indicator = nullptr;
     NewMapDialog* nmd = nullptr;
     LayerView* layer_view = nullptr;
@@ -98,9 +99,6 @@ public:
 
     JUI::Window * CreateAppInfoDialogWindow(JUI::Widget *parent);
 
-
-
-
     Layer* GetLayer(int index)
     {
         return loaded_level->layers[index];

include/App/Grid.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <J3ML/Geometry.hpp>
+#include <JGL/JGL.h>
+
+
+/// Draws a grid across the axis-aligned bounding-box, with a zoom level that auto-adjusts to the bounding-box's size.
+inline void DrawGrid2(const AABB2D& bounds, const Vector2& cell_size, const Color4& color, float spacing = 4, float segment_length = 4) {
+
+
+    Vector2 viewport_topleft = bounds.minPoint;
+    Vector2 viewport_bottomright = bounds.maxPoint;
+
+    int nearest_grid_left = Math::Floor(viewport_topleft.x / cell_size.x);
+    int nearest_grid_right = Math::Floor(viewport_bottomright.x / cell_size.x);
+    for (int x = nearest_grid_left; x <= nearest_grid_right; x++) {
+        auto top = Vector2(x * cell_size.x, viewport_topleft.y);
+        auto bottom = Vector2(x * cell_size.x, viewport_bottomright.y);
+        JGL::J2D::DrawDashedLine(color, top, bottom, spacing, segment_length, 1 / bounds.Width());
+    }
+    int nearest_grid_top = Math::Floor(viewport_topleft.y / cell_size.y);
+    int nearest_grid_bottom = Math::Floor(viewport_bottomright.y / cell_size.y);
+    for (int y = nearest_grid_top; y <= nearest_grid_bottom; y++) {
+        auto left = Vector2(viewport_topleft.x, y * cell_size.y);
+        auto right = Vector2(viewport_bottomright.x, y * cell_size.y);
+        JGL::J2D::DrawDashedLine(color, left, right, spacing, segment_length, 1 / bounds.Height());
+    }
+}

include/App/TilesetView.hpp

@@ -1,2 +1,53 @@
 #pragma once
 
+#include <App/Grid.hpp>
+
+class TilesetView : public JUI::Window {
+public:
+    Event<int> TileSelected;
+    TilesetView() : JUI::Window() {
+        Title("Tileset View");
+
+        SetResizable(false);
+
+        // TODO: Allow changing the background color of the tileset viewer.
+        Content()->BGColor(Colors::Black);
+
+        tilesheet = new JUI::Image(Content());
+        tilesheet->FitImageToParent(false);
+    }
+
+    TilesetView(Tileset* tileset, JGL::Texture* texture) {
+        Title(std::format("Tileset View : {}", tileset->name));
+        Size(JUI::UDim2::FromPixels(texture->GetDimensions().x, texture->GetDimensions().y));
+
+
+        auto grid_overlay_target = new JGL::RenderTarget(texture->GetDimensions());
+        J2D::Begin(grid_overlay_target);
+            AABB2D aabb({0,0}, Vector2(texture->GetDimensions()));
+            Vector2 cell_size(tileset->tile_width, tileset->tile_height);
+            DrawGrid2(aabb, cell_size, grid_overlay_color);
+        J2D::End();
+        grid_overlay = new JGL::Texture(*grid_overlay_target->GetTexture());
+
+        auto* overlay = new JUI::Image(this->Content());
+        overlay->Content(grid_overlay);
+        overlay->ZIndex(2);
+
+        //cell_indicator = new JUI::Rect(Content());
+    }
+    TilesetView(Widget* parent) {
+        Parent(parent);
+    }
+    TilesetView(Tileset* tileset, JGL::Texture* texture, Widget* parent) : TilesetView(tileset, texture) {
+        Parent(parent);
+    }
+protected:
+    JUI::Image* tilesheet;
+    JGL::Texture* grid_overlay;
+protected:
+    Color4 grid_overlay_color = {255, 255, 255, 64};
+    Color4 cell_pointer_outline_color = Colors::Blues::LightSteelBlue;
+private:
+
+};

include/Utils.hpp

@@ -6,8 +6,16 @@
 #include <filesystem>
 #include <fstream>
 
+#include "Event.h"
+#include "J3ML/LinearAlgebra/Vector2i.hpp"
+
 #pragma once
 
+inline int CellToIndex(Vector2i cell, int width)
+{
+	return cell.y*width + cell.x;
+}
+
 namespace JsonConversions
 {
     using namespace JJX;

src/App/EditorApp.cpp

@@ -6,6 +6,7 @@
 #include <Data/Format.hpp>
 
 #include "JUI/Widgets/FpsGraph.hpp"
+#include <App/Grid.hpp>
 
 
 JUI::Window* EditorApp::CreateAppInfoDialogWindow(JUI::Widget* parent)
@@ -496,7 +497,9 @@ bool EditorApp::Open()
     // 1. Initialize elements of widgets that are independent of the level itself / the level depends on.
     // 2. Initialize the level.
     // 3. Initialize widgets that are dependent on the level itself.
-    LoadTestFile();
+
+    //LoadTestFile();
+
     CreateWidgets();
 
     layer_view->UpdateComponents(loaded_level);
@@ -727,25 +730,10 @@ void EditorApp::Update(float elapsed)
 
 void EditorApp::DrawGrid(const AABB2D& bounds, const Color4& color)
 {
-    Vector2 viewport_topleft = bounds.minPoint;
-    Vector2 viewport_bottomright = bounds.maxPoint;
 
+    Vector2 cell_size (loaded_tileset->tile_width, loaded_tileset->tile_height);
+    DrawGrid2(bounds, cell_size, color);
 
-
-    int nearest_grid_left = Math::Floor(viewport_topleft.x / loaded_tileset->tile_width);
-    int nearest_grid_right = Math::Floor(viewport_bottomright.x / loaded_tileset->tile_width);
-    for (int x = nearest_grid_left; x <= nearest_grid_right; x++) {
-        auto top = Vector2(x * loaded_tileset->tile_width, viewport_topleft.y);
-        auto bottom = Vector2(x * loaded_tileset->tile_width, viewport_bottomright.y);
-        JGL::J2D::DrawDashedLine(color, top, bottom, 4, 4, 1 / bounds.Width());
-    }
-    int nearest_grid_top = Math::Floor(viewport_topleft.y / loaded_tileset->tile_height);
-    int nearest_grid_bottom = Math::Floor(viewport_bottomright.y / loaded_tileset->tile_height);
-    for (int y = nearest_grid_top; y <= nearest_grid_bottom; y++) {
-        auto left = Vector2(viewport_topleft.x, y * loaded_tileset->tile_height);
-        auto right = Vector2(viewport_bottomright.x, y * loaded_tileset->tile_height);
-        JGL::J2D::DrawDashedLine(color, left, right, 4, 4, 1 / bounds.Height());
-    }
 }
 
 void EditorApp::DrawGrid(const Color4& color)
@@ -759,7 +747,11 @@ void EditorApp::DrawGrid(const Color4& color)
     float sw = GetWidth();
     float sh = GetHeight();
 
-    DrawGrid({{0,0}, {static_cast<float>(grid_rows*grid_pixel_width), static_cast<float>(grid_cols*grid_pixel_height)}}, color);
+    AABB2D viewport = {{0,0}, {static_cast<float>(grid_rows*grid_pixel_width), static_cast<float>(grid_cols*grid_pixel_height)}};
+
+    Vector2 cell_size (loaded_tileset->tile_width, loaded_tileset->tile_height);
+
+    DrawGrid(viewport, color);
 }
 
 void EditorApp::DrawCellPointerOutline()