Fixes

Src/Editor/imp/cpp/UI/View/Asset.cpp

@@ -16,13 +16,13 @@
 
 #include <UI/View/Asset.hpp>
 
+#include <IAEngine/Asset/AssetManager.hpp>
+#include <RenderCore/RenderCore.hpp>
+
+#include <Editor.hpp>
+
 namespace ia::iae
 {
-    struct AssetCacheEntry
-    {
-        
-    };
-
     VOID View_Asset::Initialize()
     {
         SetName("Asset");
@@ -37,13 +37,47 @@ namespace ia::iae
     {
         PreRender();
 
-        if(m_assetPath.empty())
+        if (!m_asset)
         {
             PostRender();
             return;
         }
 
-        ImGui::Text("%s", m_assetPath.filename().string().c_str());
+        STATIC CHAR NAME_BUFFER[256];
+
+        memcpy(NAME_BUFFER, m_assetName.c_str(), m_assetName.size() + 1);
+        ImGui::Text("Name: ");
+        ImGui::SameLine();
+        ImGui::InputText("##name", NAME_BUFFER, sizeof(NAME_BUFFER));
+        m_assetName = NAME_BUFFER;
+
+        DrawAssetTypePicker();
+
+        switch (m_asset->GetType())
+        {
+        case EAssetType::TEXTURE:
+            RenderTextureAsset();
+            break;
+
+        case EAssetType::SPRITE:
+            RenderSpriteAsset();
+            break;
+
+        case EAssetType::TILESHEET:
+            RenderTileSheetAsset();
+            break;
+
+        case EAssetType::SPRITESHEET:
+            RenderSpriteSheetAsset();
+            break;
+
+        case EAssetType::INVALID:
+        case EAssetType::SOUND:
+        case EAssetType::SCENE:
+        case EAssetType::PLUGIN:
+        case EAssetType::PACKAGE:
+            break;
+        }
 
         PostRender();
     }
@@ -56,14 +90,125 @@ namespace ia::iae
     {
     }
 
-    VOID View_Asset::Open(IN Path path)
+    VOID View_Asset::Open(IN String assetName)
     {
-        Close();
-        m_assetPath = path;
+        m_assetName = assetName;
+        const auto asset = AssetManager::GetAssetByName<Asset_Texture>(m_assetName);
+        m_assetImageHandle = RDC::BakeTexture(asset->GetHandle()->ImagePtr);
+        m_assetImageExtent = {asset->GetHandle()->ImagePtr->Width, asset->GetHandle()->ImagePtr->Height};
+        m_asset = asset;
+        m_assetType = asset->GetType();
     }
 
     VOID View_Asset::Close()
     {
-        m_assetPath = Path();
+        m_assetName = "";
+        m_asset = nullptr;
+        m_assetImageHandle = 0;
+        m_assetImageExtent = {};
+        m_assetType = EAssetType::INVALID;
+    }
+
+    VOID View_Asset::RenderTextureAsset()
+    {
+        const auto asset = (Asset_Texture *) m_asset;
+        DrawAssetImage(0.75f, {0, 0});
+    }
+
+    VOID View_Asset::RenderSpriteAsset()
+    {
+        const auto asset = (Asset_Sprite *) m_asset;
+        DrawAssetImage(0.75f, {0, 0});
+    }
+
+    VOID View_Asset::RenderTileSheetAsset()
+    {
+        const auto asset = (Asset_TileSheet *) m_asset;
+
+        ImGui::Text("Tile Width: ");
+        ImGui::SameLine();
+        ImGui::InputInt("##TileWidth", &asset->TileWidth());
+        if (asset->TileWidth() < 1)
+            asset->TileWidth() = 1;
+        if (asset->TileWidth() > m_assetImageExtent.x)
+            asset->TileWidth() = m_assetImageExtent.x;
+
+        ImGui::Text("Tile Height: ");
+        ImGui::SameLine();
+        ImGui::InputInt("##TileHeight", &asset->TileHeight());
+        if (asset->TileHeight() < 1)
+            asset->TileHeight() = 1;
+        if (asset->TileHeight() > m_assetImageExtent.y)
+            asset->TileHeight() = m_assetImageExtent.y;
+
+        DrawAssetImage(0.75f, {asset->TileWidth(), asset->TileHeight()});
+    }
+
+    VOID View_Asset::RenderSpriteSheetAsset()
+    {
+        const auto asset = (Asset_SpriteSheet *) m_asset;
+    }
+
+    VOID View_Asset::DrawAssetImage(IN FLOAT32 relativeWidth, IN IVec2 gridSize)
+    {
+        ImVec2 base_pos = ImGui::GetCursorScreenPos();
+
+        const auto ImageWidth = m_extent.x * relativeWidth;
+        const auto aspectRatio =
+            static_cast<FLOAT32>(m_assetImageExtent.y) / static_cast<FLOAT32>(m_assetImageExtent.x);
+        const auto ImageHeight = aspectRatio * ImageWidth;
+
+        ImGui::Image((ImTextureRef) m_assetImageHandle, {ImageWidth, ImageHeight});
+
+        if((!gridSize.x) || (!gridSize.y))
+            return;
+
+        gridSize.x *= ImageWidth/m_assetImageExtent.x;
+        gridSize.y *= ImageHeight/m_assetImageExtent.y;
+
+        ImDrawList *draw_list = ImGui::GetWindowDrawList();
+
+        auto gridCountX = ImageWidth / gridSize.x;
+        auto gridCountY = ImageHeight / gridSize.y;
+
+        ImU32 grid_color = IM_COL32(200, 200, 200, 50);
+        float grid_thickness = 1.0f;
+
+        ImGui::Dummy(ImVec2(ImageWidth, ImageHeight));
+
+        for (int i = 0; i <= gridCountX; ++i)
+        {
+            ImVec2 p1 = ImVec2(base_pos.x + i * gridSize.x, base_pos.y);
+            ImVec2 p2 = ImVec2(base_pos.x + i * gridSize.x, base_pos.y + ImageHeight);
+            draw_list->AddLine(p1, p2, grid_color, grid_thickness);
+        }
+
+        for (int i = 0; i <= gridCountY; ++i)
+        {
+            ImVec2 p1 = ImVec2(base_pos.x, base_pos.y + i * gridSize.y);
+            ImVec2 p2 = ImVec2(base_pos.x + ImageWidth, base_pos.y + i * gridSize.y);
+            draw_list->AddLine(p1, p2, grid_color, grid_thickness);
+        }
+    }
+
+    VOID View_Asset::DrawAssetTypePicker()
+    {
+        ImGui::Text("Asset Type: ");
+        ImGui::SameLine();
+        ImGui::Combo("##", (INT32 *) &m_assetType, "None\0Texture\0Sprite\0TileSheet\0SpriteSheet\0");
+        if (m_assetType != m_asset->GetType())
+        {
+            ImGui::SameLine();
+            if (ImGui::Button("Apply"))
+            {
+                if (m_assetType == EAssetType::INVALID)
+                {
+                    Editor::Instance().RemoveFromAssets(m_assetName);
+                    Close();
+                    UI::CloseAssetView();
+                }
+                m_asset = AssetManager::ChangeAssetType(m_assetName, m_assetType);
+            }
+        }
     }
 } // namespace ia::iae