merge everything

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "GameResources"]
 	path = GameResources
-	url = https://github.com/Estrol/O2GameResources
+	url = https://github.com/AlberttFrgk/O2GameResources

Engine/include/Game.h

@@ -89,5 +89,5 @@ class Game
     GameThread mLocalThread;
 
     std::mutex m_mutex;
-    std::condition_variable m_conditionVariable;
+    std::condition_variable m_cv;
 };

Engine/include/Rendering/Window.h

@@ -26,7 +26,7 @@ class GameWindow
     float       GetHeightScale();
 
     void SetScaleOutput(bool value);
-    bool IsScaleOutput();
+    bool IsScaleOutput() const;
 
     void SetWindowTitle(std::string &title);
     void SetWindowSubTitle(std::string &subTitle);

Engine/include/Texture/Sprite2D.h

@@ -18,10 +18,10 @@ class Sprite2D
 public:
     Sprite2D() = default;
 
-    Sprite2D(std::vector<Texture2D *> textures, float delay = 1.0f);
-    Sprite2D(std::vector<std::string> textures, float delay = 1.0f);
-    Sprite2D(std::vector<std::filesystem::path> textures, float delay = 1.0f);
-    Sprite2D(std::vector<SDL_Texture *> textures, float delay = 1.0f);
+    Sprite2D(std::vector<Texture2D *> textures, double delay = 1.0);
+    Sprite2D(std::vector<std::string> textures, double delay = 1.0);
+    Sprite2D(std::vector<std::filesystem::path> textures, double delay = 1.0);
+    Sprite2D(std::vector<SDL_Texture *> textures, double delay = 1.0);
 
     ~Sprite2D();
 
@@ -37,15 +37,18 @@ class Sprite2D
     void DrawOnce(double delta, bool manual = false);
 
     Texture2D *GetTexture();
-    void       SetFPS(float fps);
+    void       SetFPS(double fps);
     void       Reset();
 
-private:
     double m_spritespeed = 1.0;
+
+private:
     float  m_currentTime = 0;
     int    m_currentIndex = 0;
 
     bool m_drawOnce = false;
 
     std::vector<Texture2D *> m_textures;
+
+    void DrawInternal(double delta, bool playOnce, Rect* rect, bool manual);
 };

Engine/include/Texture/Texture2D.h

@@ -20,9 +20,9 @@ class Texture2D
 
 public:
     Texture2D();
-    Texture2D(std::string fileName);
-    Texture2D(std::filesystem::path path);
-    Texture2D(uint8_t *fileData, size_t size);
+    Texture2D(const std::string& fileName);
+    Texture2D(const std::filesystem::path& path);
+    Texture2D(const uint8_t *fileData, size_t size);
     Texture2D(SDL_Texture *texture);
     Texture2D(Texture2D_Vulkan *texture);
     ~Texture2D();
@@ -51,7 +51,7 @@ class Texture2D
     Rect GetOriginalRECT();
     void SetOriginalRECT(Rect size);
 
-    static Texture2D *FromTexture2D(Texture2D *tex);
+    // static Texture2D *FromTexture2D(Texture2D *tex);
 
     static Texture2D *FromBMP(uint8_t *fileData, size_t size);
     static Texture2D *FromBMP(std::string fileName);

Engine/src/Configuration.cpp

@@ -86,7 +86,7 @@ void Configuration::Set(std::string key, std::string prop, std::string value)
 
 void Configuration::Font_SetPath(std::filesystem::path path)
 {
-    FontPath = path;
+    FontPath = std::filesystem::current_path() / "Resources";
 }
 
 std::filesystem::path Configuration::Font_GetPath()

Engine/src/Fonts/FontResources.cpp

@@ -1,4 +1,4 @@
-#pragma warning(disable : 4838) // Goddamit
+#pragma warning(disable : 4838) // Goddamit
 #pragma warning(disable : 4309)
 
 #include <Misc/md5.h>
@@ -25,9 +25,9 @@
 // BEGIN FONT FALLBACK
 
 #include "FallbackFonts/arial.ttf.h"
-#include "FallbackFonts/ch.ttf.h"
-#include "FallbackFonts/jp.ttf.h"
-#include "FallbackFonts/kr.ttf.h"
+//#include "FallbackFonts/ch.ttf.h"
+//#include "FallbackFonts/jp.ttf.h"
+//#include "FallbackFonts/kr.ttf.h"
 #include <Logs.h>
 
 // END FONT FALLBACK
@@ -92,14 +92,37 @@ void FontResources::PreloadFontCaches()
 
     GameWindow *wnd = GameWindow::GetInstance();
 
-    auto skinPath = Configuration::Font_GetPath();
-    auto fontPath = skinPath / "Fonts";
+    auto path = Configuration::Font_GetPath();
+    auto fontPath = path / "Fonts";
 
     auto normalfont = fontPath / "normal.ttf";
     auto jpFont = fontPath / "jp.ttf";
     auto krFont = fontPath / "kr.ttf";
     auto chFont = fontPath / "ch.ttf";
 
+    static const ImWchar glyphRanges[] = { // Optimized
+        (ImWchar)0x0020, (ImWchar)0x052F,
+        (ImWchar)0x2000, (ImWchar)0x27BF,
+        (ImWchar)0x2E80, (ImWchar)0x2FA1,
+        (ImWchar)0x1F300, (ImWchar)0x1FAFF,
+        (ImWchar)0x2660, (ImWchar)0x2663,
+        (ImWchar)0x2665, (ImWchar)0x2666,
+        (ImWchar)0x2600, (ImWchar)0x2606,
+        (ImWchar)0x2618, (ImWchar)0x2619,
+        (ImWchar)0x263A, (ImWchar)0x263B,
+        (ImWchar)0x2708, (ImWchar)0x2714,
+        (ImWchar)0x2728, (ImWchar)0x2734,
+        (ImWchar)0x2740, (ImWchar)0x274B,
+        (ImWchar)0x2756, (ImWchar)0x2758,
+        (ImWchar)0x2764, (ImWchar)0x2767,
+        (ImWchar)0x2794, (ImWchar)0x27BE,
+        (ImWchar)0x27F0, (ImWchar)0x27FF,
+        (ImWchar)0x2900, (ImWchar)0x297F,
+        (ImWchar)0x2A00, (ImWchar)0x2AFF,
+        (ImWchar)0x0000, (ImWchar)0x0000
+    };
+
+
     {
         float originScale = (wnd->GetBufferWidth() + wnd->GetBufferHeight()) / 15.6f;
         float targetScale = (wnd->GetWidth() + wnd->GetHeight()) / 15.6f;
@@ -118,9 +141,9 @@ void FontResources::PreloadFontCaches()
 
         {
             if (std::filesystem::exists(normalfont)) {
-                Font.Font = io.Fonts->AddFontFromFileTTF((const char *)normalfont.u8string().c_str(), fontSize, &conf);
+                Font.Font = io.Fonts->AddFontFromFileTTF((const char *)normalfont.u8string().c_str(), fontSize, &conf, glyphRanges); // glyphRanges, fixing missing fonts
             } else {
-                Font.Font = io.Fonts->AddFontFromMemoryTTF((void *)get_arial_font_data(), get_arial_font_size(), fontSize, &conf);
+                Font.Font = io.Fonts->AddFontFromMemoryTTF((void *)get_arial_font_data(), get_arial_font_size(), fontSize, &conf, glyphRanges);
             }
         }
 
@@ -151,7 +174,7 @@ void FontResources::PreloadFontCaches()
                         case TextRegion::Chinese:
                         {
                             if (std::filesystem::exists(chFont)) {
-                                io.Fonts->AddFontFromFileTTF((const char *)chFont.u8string().c_str(), fontSize, &conf, io.Fonts->GetGlyphRangesChineseSimplifiedCommon());
+                                io.Fonts->AddFontFromFileTTF((const char *)chFont.u8string().c_str(), fontSize, &conf, io.Fonts->GetGlyphRangesChineseFull());
                             }
 
                             break;

Engine/src/Game.cpp

@@ -16,7 +16,7 @@
 
 constexpr auto kInputDefaultRate = 1000.0;
 constexpr auto kMenuDefaultRate = 60.0;
-constexpr auto kAudioDefaultRate = 24.0;
+constexpr auto kAudioDefaultRate = 60.0;
 
 namespace {
 
@@ -42,13 +42,14 @@ namespace {
     {
         const double targetFrameTime = 1000.0 / MaxFrameRate;
 
-        double newTick = SDL_GetTicks();
+        double newTick = static_cast<double>(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count());
         double frameTime = newTick - curTick;
 
         if (frameTime < targetFrameTime)
         {
             double delayTime = targetFrameTime - frameTime;
-            SDL_Delay(static_cast<Uint32>(delayTime));
+            std::this_thread::sleep_for(std::chrono::milliseconds(static_cast<long long>(delayTime)));
+            std::this_thread::yield();
             newTick += delayTime;
         }
 
@@ -83,7 +84,7 @@ Game::~Game()
 
         if (m_notify) {
             std::unique_lock<std::mutex> lock(m_mutex);
-            m_conditionVariable.wait(lock, [this] { return !m_notify; });
+            m_cv.wait(lock, [this] { return !m_notify; });
         }
     }
 
@@ -369,13 +370,12 @@ void Game::CheckFont()
 void Game::Stop()
 {
     if (m_running) {
-        m_running = false;
-
         {
-            std::lock_guard<std::mutex> lock(m_mutex); // TODO: Fix game does not properly exit while crash (if not just revert back to SDL_Delay Sleep)
+            std::unique_lock<std::mutex> lock(m_mutex);
+            m_running = false;
             m_notify = true;
         }
-        m_conditionVariable.notify_one();
+        m_cv.notify_one();
     }
 }
 

Engine/src/Rendering/GameWindow.cpp

@@ -193,7 +193,7 @@ void GameWindow::SetScaleOutput(bool value)
     m_scaleOutput = value;
 }
 
-bool GameWindow::IsScaleOutput()
+bool GameWindow::IsScaleOutput() const
 {
     return m_scaleOutput;
 }

Engine/src/Rendering/Renderer.cpp

@@ -52,11 +52,11 @@ bool Renderer::Create(RendererMode mode, GameWindow *window, bool failed)
                 break;
             }
 
-            case RendererMode::DIRECTX11:
+            /*case RendererMode::DIRECTX11:
             {
                 rendererName = "direct3d11";
                 break;
-            }
+            }*/
 
             case RendererMode::DIRECTX12:
             {
@@ -96,10 +96,10 @@ bool Renderer::Create(RendererMode mode, GameWindow *window, bool failed)
                 }
 
                 SDL_SetHint(SDL_HINT_RENDER_DRIVER, rendererName.c_str());
-                SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0"); // STOP CHANGING THIS, LEAVE IT "as is"
+                SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "best");
             }
 
-            m_renderer = SDL_CreateRenderer(window->GetWindow(), -1, SDL_RENDERER_ACCELERATED);
+            m_renderer = SDL_CreateRenderer(window->GetWindow(), -1, SDL_RENDERER_ACCELERATED /*| SDL_RENDERER_PRESENTVSYNC*/);
             if (!m_renderer) {
                 throw SDLException();
             }

Engine/src/Rendering/Vulkan/Texture2DVulkan.cpp

@@ -17,7 +17,7 @@ static int                                                        m_textureCount
 static std::mutex                                                 m_textureMutex;
 static std::unique_ptr<Texture2D_Vulkan>                          m_dummyTexture;
 
-Texture2D_Vulkan *CreateTexture()
+Texture2D_Vulkan* CreateTexture()
 {
     // find the empty slot
     for (int i = 0; i < m_textureCount; i++) {
@@ -53,7 +53,7 @@ uint32_t vkTexture::FindMemoryType(uint32_t type_filter, uint32_t properties)
     return findMemoryType(VulkanEngine::GetInstance()->_chosenGPU, type_filter, properties);
 }
 
-Texture2D_Vulkan *vkTexture::TexLoadImage(std::filesystem::path imagePath)
+Texture2D_Vulkan* vkTexture::TexLoadImage(std::filesystem::path imagePath)
 {
     std::fstream fs(imagePath, std::ios::binary | std::ios::in);
     if (!fs.is_open()) {
@@ -79,6 +79,14 @@ void InternalLoad(
 
     size_t image_size = static_cast<size_t>(tex_data->Width) * static_cast<size_t>(tex_data->Height) * tex_data->Channels;
 
+    // Premultiply alpha
+    for (size_t i = 0; i < image_size; i += tex_data->Channels) { // Fix white line issue
+        float alpha = image_data[i + 3] / 255.0f;
+        image_data[i] = static_cast<unsigned char>(image_data[i] * alpha);
+        image_data[i + 1] = static_cast<unsigned char>(image_data[i + 1] * alpha);
+        image_data[i + 2] = static_cast<unsigned char>(image_data[i + 2] * alpha);
+    }
+
     VkResult err;
     {
         VkImageCreateInfo info = {};
@@ -135,8 +143,8 @@ void InternalLoad(
     {
         VkSamplerCreateInfo samplerInfo = {};
         samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
-        samplerInfo.magFilter = VK_FILTER_NEAREST;
-        samplerInfo.minFilter = VK_FILTER_NEAREST;
+        samplerInfo.magFilter = VK_FILTER_LINEAR;
+        samplerInfo.minFilter = VK_FILTER_LINEAR;
         samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
         samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
         samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
@@ -184,7 +192,7 @@ void InternalLoad(
     }
 
     {
-        void *map = NULL;
+        void* map = NULL;
         err = vkMapMemory(vulkan_driver->_device, tex_data->UploadBufferMemory, 0, image_size, 0, &map);
         if (err != VK_SUCCESS) {
             throw std::runtime_error("Vulkan: Failed to create mapped image memory");
@@ -240,17 +248,17 @@ void InternalLoad(
         use_barrier[0].subresourceRange.levelCount = 1;
         use_barrier[0].subresourceRange.layerCount = 1;
         vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, NULL, 0, NULL, 1, use_barrier);
-    });
+        });
 }
 
-Texture2D_Vulkan *vkTexture::TexLoadImage(void *buffer, size_t size)
+Texture2D_Vulkan* vkTexture::TexLoadImage(void* buffer, size_t size)
 {
     auto vulkan_driver = VulkanEngine::GetInstance();
     auto tex_data = CreateTexture();
     tex_data->Channels = 4;
 
-    unsigned char *image_data = stbi_load_from_memory(
-        (uint8_t *)buffer,
+    unsigned char* image_data = stbi_load_from_memory(
+        (uint8_t*)buffer,
         (int)size,
         &tex_data->Width,
         &tex_data->Height,
@@ -265,7 +273,7 @@ Texture2D_Vulkan *vkTexture::TexLoadImage(void *buffer, size_t size)
     return tex_data;
 }
 
-Texture2D_Vulkan *vkTexture::GetDummyImage()
+Texture2D_Vulkan* vkTexture::GetDummyImage()
 {
     if (m_dummyTexture) {
         return m_dummyTexture.get();
@@ -278,8 +286,8 @@ Texture2D_Vulkan *vkTexture::GetDummyImage()
         // Generate file 1 Pixel Bitmap Image, with header
         std::vector<uint8_t> buffer = ImageGenerator::GenerateImage(40, 40, { 255, 255, 255, 255 });
 
-        unsigned char *image_data = stbi_load_from_memory(
-            (uint8_t *)buffer.data(),
+        unsigned char* image_data = stbi_load_from_memory(
+            (uint8_t*)buffer.data(),
             (int)buffer.size(),
             &m_dummyTexture->Width,
             &m_dummyTexture->Height,
@@ -297,18 +305,18 @@ Texture2D_Vulkan *vkTexture::GetDummyImage()
     return m_dummyTexture.get();
 }
 
-VkDescriptorSet vkTexture::GetVkDescriptorSet(Texture2D_Vulkan *handle)
+VkDescriptorSet vkTexture::GetVkDescriptorSet(Texture2D_Vulkan* handle)
 {
     return handle->DS;
 }
 
-void vkTexture::QueryTexture(Texture2D_Vulkan *handle, int &outWidth, int &outHeight)
+void vkTexture::QueryTexture(Texture2D_Vulkan* handle, int& outWidth, int& outHeight)
 {
     outWidth = handle->Width;
     outHeight = handle->Height;
 }
 
-void vkTexture::ReleaseTexture(Texture2D_Vulkan *tex_data)
+void vkTexture::ReleaseTexture(Texture2D_Vulkan* tex_data)
 {
     if (tex_data == nullptr) {
         return;
@@ -326,14 +334,14 @@ void vkTexture::ReleaseTexture(Texture2D_Vulkan *tex_data)
 
         ImGui_ImplVulkan_RemoveTexture(tex_data->DS);
 
-        auto it = std::find_if(m_textures.begin(), m_textures.end(), [&](auto &pair) {
+        auto it = std::find_if(m_textures.begin(), m_textures.end(), [&](auto& pair) {
             return pair.second != nullptr && pair.second->Id == tex_data->Id;
-        });
+            });
 
         if (it != m_textures.end()) {
             it->second.reset();
         }
-    });
+        });
 }
 
 // This must be called from VulkanEngine!
@@ -344,7 +352,7 @@ void vkTexture::Cleanup()
 
     std::cout << "[Info] Cleaning up Vulkan textures: " << m_textures.size() << std::endl;
 
-    for (auto &[id, tex_data] : m_textures) {
+    for (auto& [id, tex_data] : m_textures) {
         if (tex_data == nullptr) {
             continue;
         }