Merge branch 'main' into json-as-a-resource

Author: briaguya-ai

extern/CMakeLists.txt

@@ -118,7 +118,7 @@ elseif (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
         XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES 
     )
 elseif (CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    if (DEFINED USE_OPENGLES)
+    if (USE_OPENGLES)
         target_link_libraries(ImGui PUBLIC ${OPENGL_GLESv2_LIBRARY})
         add_compile_definitions(IMGUI_IMPL_OPENGL_ES3)
     else()

src/CMakeLists.txt

@@ -251,6 +251,10 @@ set(Source_Files__Window__Gui
     ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/resource/Font.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/resource/FontFactory.h
     ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/resource/FontFactory.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/resource/GuiTexture.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/resource/GuiTexture.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/resource/GuiTextureFactory.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/resource/GuiTextureFactory.cpp
 )
 
 source_group("window/gui" FILES ${Source_Files__Window__Gui})

src/window/gui/GameOverlay.cpp

@@ -26,7 +26,7 @@ void GameOverlay::LoadFont(const std::string& name, const std::string& path, flo
     std::shared_ptr<Font> font = std::static_pointer_cast<Font>(
         Context::GetInstance()->GetResourceManager()->LoadResource(path, false, initData));
     if (font != nullptr) {
-        mFonts[name] = io.Fonts->AddFontFromMemoryTTF(font->Data.data(), font->Data.size(), fontSize);
+        mFonts[name] = io.Fonts->AddFontFromMemoryTTF(font->Data, font->DataSize, fontSize);
     }
 }
 

src/window/gui/Gui.cpp

@@ -15,6 +15,7 @@
 #include "resource/File.h"
 #include <stb/stb_image.h>
 #include "window/gui/Fonts.h"
+#include "window/gui/resource/GuiTextureFactory.h"
 
 #ifdef __WIIU__
 #include <gx2/registers.h> // GX2SetViewport / GX2SetScissor
@@ -150,6 +151,10 @@ void Gui::Init(GuiWindowInitData windowImpl) {
     GetGuiWindow("Console")->Init();
     GetGameOverlay()->Init();
 
+    Context::GetInstance()->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(
+        std::make_shared<ResourceFactoryBinaryGuiTextureV0>(), RESOURCE_FORMAT_BINARY, "GuiTexture",
+        static_cast<uint32_t>(RESOURCE_TYPE_GUI_TEXTURE), 0);
+
     ImGuiWMInit();
     ImGuiBackendInit();
 #ifdef __SWITCH__
@@ -230,39 +235,22 @@ void Gui::ImGuiBackendInit() {
 }
 
 void Gui::LoadTextureFromRawImage(const std::string& name, const std::string& path) {
-    // GuiTexture (put in Gui)
-    const auto res = Context::GetInstance()->GetResourceManager()->GetArchiveManager()->LoadFileRaw(path);
-
-    if (!res) {
-        SPDLOG_ERROR("Failed to load resource");
-        return;
-    }
-    if (!res->Buffer || res->Buffer->empty()) {
-        SPDLOG_ERROR("Buffer is null or empty");
-        return;
-    }
-
-    GuiTexture asset;
-    asset.Width = 0;
-    asset.Height = 0;
-    uint8_t* imgData = stbi_load_from_memory(reinterpret_cast<const stbi_uc*>(res->Buffer->data()), res->Buffer->size(),
-                                             &asset.Width, &asset.Height, nullptr, 4);
-
-    if (imgData == nullptr) {
-        SPDLOG_ERROR("Error loading imgui texture {}", stbi_failure_reason());
-        return;
-    }
+    auto initData = std::make_shared<ResourceInitData>();
+    initData->Format = RESOURCE_FORMAT_BINARY;
+    initData->Type = static_cast<uint32_t>(RESOURCE_TYPE_GUI_TEXTURE);
+    initData->ResourceVersion = 0;
+    auto guiTexture = std::static_pointer_cast<GuiTexture>(
+        Context::GetInstance()->GetResourceManager()->LoadResource(path, false, initData));
 
     GfxRenderingAPI* api = gfx_get_current_rendering_api();
 
     // TODO: Nothing ever unloads the texture from Fast3D here.
-    asset.RendererTextureId = api->new_texture();
-    api->select_texture(0, asset.RendererTextureId);
+    guiTexture->Metadata.RendererTextureId = api->new_texture();
+    api->select_texture(0, guiTexture->Metadata.RendererTextureId);
     api->set_sampler_parameters(0, false, 0, 0);
-    api->upload_texture(imgData, asset.Width, asset.Height);
+    api->upload_texture(guiTexture->Data, guiTexture->Metadata.Width, guiTexture->Metadata.Height);
 
-    mGuiTextures[name] = asset;
-    stbi_image_free(imgData);
+    mGuiTextures[name] = guiTexture->Metadata;
 }
 
 bool Gui::SupportsViewports() {
@@ -832,7 +820,7 @@ void Gui::LoadGuiTexture(const std::string& name, const std::string& path, const
         texBuffer[pixel * 4 + 3] *= tint.w;
     }
 
-    GuiTexture asset;
+    GuiTextureMetadata asset;
     asset.RendererTextureId = api->new_texture();
     asset.Width = res->Width;
     asset.Height = res->Height;

src/window/gui/Gui.h

@@ -18,6 +18,7 @@
 #include "window/gui/GuiWindow.h"
 #include "window/gui/GuiMenuBar.h"
 #include "libultraship/libultra/controller.h"
+#include "window/gui/resource/GuiTexture.h"
 
 namespace LUS {
 
@@ -100,18 +101,12 @@ class Gui {
     int16_t GetIntegerScaleFactor();
 
   private:
-    struct GuiTexture {
-        uint32_t RendererTextureId;
-        int32_t Width;
-        int32_t Height;
-    };
-
     GuiWindowInitData mImpl;
     ImGuiIO* mImGuiIo;
     bool mNeedsConsoleVariableSave;
     std::shared_ptr<GameOverlay> mGameOverlay;
     std::shared_ptr<GuiMenuBar> mMenuBar;
-    std::map<std::string, GuiTexture> mGuiTextures;
+    std::map<std::string, GuiTextureMetadata> mGuiTextures;
     std::map<std::string, std::shared_ptr<GuiWindow>> mGuiWindows;
 };
 } // namespace LUS

src/window/gui/resource/Font.cpp

@@ -4,11 +4,17 @@ namespace LUS {
 Font::Font() : Resource(std::shared_ptr<ResourceInitData>()) {
 }
 
+Font::~Font() {
+    if (Data != nullptr) {
+        delete Data;
+    }
+}
+
 void* Font::GetPointer() {
-    return Data.data();
+    return Data;
 }
 
 size_t Font::GetPointerSize() {
-    return Data.size() * sizeof(char);
+    return DataSize * sizeof(char);
 }
 } // namespace LUS

src/window/gui/resource/Font.h

@@ -3,17 +3,19 @@
 #include "resource/Resource.h"
 
 namespace LUS {
-#define RESOURCE_TYPE_FONT 0x464F4E54
+#define RESOURCE_TYPE_FONT 0x464F4E54 // FONT
 
 class Font : public Resource<void> {
   public:
     using Resource::Resource;
 
     Font();
+    ~Font();
 
     void* GetPointer() override;
     size_t GetPointerSize() override;
 
-    std::vector<char> Data;
+    char* Data = nullptr;
+    size_t DataSize;
 };
 }; // namespace LUS

src/window/gui/resource/FontFactory.cpp

@@ -11,13 +11,10 @@ std::shared_ptr<IResource> ResourceFactoryBinaryFontV0::ReadResource(std::shared
     auto font = std::make_shared<Font>(file->InitData);
     auto reader = std::get<std::shared_ptr<BinaryReader>>(file->Reader);
 
-    uint32_t dataSize = file->Buffer->size();
+    font->DataSize = file->Buffer->size();
 
-    font->Data.reserve(dataSize);
-
-    for (uint32_t i = 0; i < dataSize; i++) {
-        font->Data.push_back(reader->ReadChar());
-    }
+    font->Data = new char[font->DataSize];
+    reader->Read(font->Data, font->DataSize);
 
     return font;
 }

src/window/gui/resource/GuiTexture.cpp

@@ -0,0 +1,20 @@
+#include "GuiTexture.h"
+
+namespace LUS {
+GuiTexture::GuiTexture() : Resource(std::shared_ptr<ResourceInitData>()) {
+}
+
+GuiTexture::~GuiTexture() {
+    if (Data != nullptr) {
+        stbi_image_free(Data);
+    }
+}
+
+void* GuiTexture::GetPointer() {
+    return Data;
+}
+
+size_t GuiTexture::GetPointerSize() {
+    return DataSize * sizeof(uint8_t);
+}
+} // namespace LUS

src/window/gui/resource/GuiTexture.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "resource/Resource.h"
+#include <stb/stb_image.h>
+
+namespace LUS {
+#define RESOURCE_TYPE_GUI_TEXTURE 0x47544558 // GTEX
+
+struct GuiTextureMetadata {
+    uint32_t RendererTextureId;
+    int32_t Width;
+    int32_t Height;
+};
+
+class GuiTexture : public Resource<void> {
+  public:
+    using Resource::Resource;
+
+    GuiTexture();
+    ~GuiTexture();
+
+    void* GetPointer() override;
+    size_t GetPointerSize() override;
+
+    uint8_t* Data;
+    size_t DataSize;
+    GuiTextureMetadata Metadata;
+};
+}; // namespace LUS

src/window/gui/resource/GuiTextureFactory.cpp

@@ -0,0 +1,28 @@
+#include "window/gui/resource/GuiTextureFactory.h"
+#include "window/gui/resource/GuiTexture.h"
+#include "spdlog/spdlog.h"
+
+namespace LUS {
+std::shared_ptr<IResource> ResourceFactoryBinaryGuiTextureV0::ReadResource(std::shared_ptr<File> file) {
+    if (!FileHasValidFormatAndReader(file)) {
+        return nullptr;
+    }
+
+    auto guiTexture = std::make_shared<GuiTexture>(file->InitData);
+    auto reader = std::get<std::shared_ptr<BinaryReader>>(file->Reader);
+
+    guiTexture->DataSize = file->Buffer->size();
+    guiTexture->Metadata.Width = 0;
+    guiTexture->Metadata.Height = 0;
+    guiTexture->Data =
+        stbi_load_from_memory(reinterpret_cast<const stbi_uc*>(file->Buffer->data()), guiTexture->DataSize,
+                              &guiTexture->Metadata.Width, &guiTexture->Metadata.Height, nullptr, 4);
+
+    if (guiTexture->Data == nullptr) {
+        SPDLOG_ERROR("Error loading imgui texture {}", stbi_failure_reason());
+        return nullptr;
+    }
+
+    return guiTexture;
+}
+} // namespace LUS

src/window/gui/resource/GuiTextureFactory.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "resource/Resource.h"
+#include "resource/ResourceFactoryBinary.h"
+
+namespace LUS {
+class ResourceFactoryBinaryGuiTextureV0 : public ResourceFactoryBinary {
+  public:
+    std::shared_ptr<IResource> ReadResource(std::shared_ptr<File> file) override;
+};
+}; // namespace LUS