-Dev: added a proper logger

AEspinosaDev · AEspinosaDev · commit 3ac9169065a3 · 2025-07-15T21:36:18.000+02:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -50,6 +50,7 @@ add_subdirectory(thirdparty/tiny_obj_loader)
 add_subdirectory(thirdparty/tinyply)	
 add_subdirectory(thirdparty/tinyxml)	
 add_subdirectory(thirdparty/optick-1.4.0)	
+add_subdirectory(thirdparty/logger)	
 add_subdirectory(thirdparty/ImGuiFileDialog)	
 target_link_libraries(ImGuiFileDialog PUBLIC imgui )
 
@@ -85,6 +86,7 @@ target_link_libraries(VulkanEngine PUBLIC
     tinyply
     tinyxml
     optick
+    logger
     ImGuiFileDialog)
 
 # Set dependencies inside folder
diff --git a/include/engine/common.h b/include/engine/common.h
@@ -52,6 +52,7 @@
 #include <vector>
 #include <vma/vk_mem_alloc.h>
 #include <memory>
+#include <logger.h>
 
 // ENGINE DEFINITIONS
 
@@ -66,25 +67,14 @@
 #define PROFILING_FRAME()
 #endif
 
-#define _LOG(msg)                                                                                                                                              \
-    {                                                                                                                                                          \
-        std::cout << "[VKEngine Log] " << msg << std::endl;                                                                                                    \
-    }
-#define DEBUG_LOG(msg)                                                                                                                                         \
-    {                                                                                                                                                          \
-        std::cout << "[VKEngine Debug] " << msg << std::endl;                                                                                                  \
-    }
-#define ERR_LOG(msg)                                                                                                                                           \
-    {                                                                                                                                                          \
-        std::cerr << "[VKEngine Error] " << msg << std::endl;                                                                                                  \
-    }
+
 #define VK_CHECK(x)                                                                                                                                            \
     do                                                                                                                                                         \
     {                                                                                                                                                          \
         VkResult err = x;                                                                                                                                      \
         if (err)                                                                                                                                               \
         {                                                                                                                                                      \
-            std::cout << "VKEngine detected a Vulkan error: " << err << std::endl;                                                                             \
+            LOG_ERROR("VKEngine detected a Vulkan error: " + std::to_string(err));                                                                            \
             abort();                                                                                                                                           \
         }                                                                                                                                                      \
     } while (0)
diff --git a/include/engine/graphics/utilities/bootstrap.h b/include/engine/graphics/utilities/bootstrap.h
@@ -29,7 +29,7 @@ inline static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSe
                                                            const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
                                                            void*                                       pUserData) {
 
-    DEBUG_LOG("(Validation Layer) " << pCallbackData->pMessage);
+    LOG_DEBUG("(Validation Layer) " + std::string(pCallbackData->pMessage));
 
     return VK_FALSE;
 }
diff --git a/src/core/scene/mesh.cpp b/src/core/scene/mesh.cpp
@@ -51,7 +51,7 @@ bool AABB::is_on_frustrum(const Frustum& frustum) const {
 IMaterial* Mesh::change_material(IMaterial* m, size_t id) {
     if (m_material.size() < id + 1)
     {
-        ERR_LOG("Not enough material slots");
+        LOG_ERROR("Not enough material slots");
         return nullptr;
     }
 
diff --git a/src/core/windows/windowGLFW.cpp b/src/core/windows/windowGLFW.cpp
@@ -14,7 +14,7 @@ void WindowGLFW::init() {
     if (!m_handle)
     {
         glfwTerminate();
-        ERR_LOG("Failed to create GLFW window");
+        LOG_ERROR("Failed to create GLFW window");
     }
 
     glfwSetWindowPos(m_handle, (int)m_screenPos.x, (int)m_screenPos.y);
@@ -86,7 +86,7 @@ void WindowGLFW::set_window_icon(const char* iconPath) {
     unsigned char* pixels = stbi_load(iconPath, &width, &height, &channels, 4); // Force 4 channels (RGBA)
     if (!pixels)
     {
-        ERR_LOG("failed to load window ICON");
+        LOG_ERROR("failed to load window ICON");
         return;
     }
 
diff --git a/src/graphics/extensions.cpp b/src/graphics/extensions.cpp
@@ -16,64 +16,64 @@ void load_extensions(VkDevice& device, VkInstance& instance) {
 
     if (!vkCmdSetPolygonMode)
     {
-        ERR_LOG("Failed to load vkCmdSetPolygonModeEXT!");
+        LOG_ERROR("Failed to load vkCmdSetPolygonModeEXT!");
     }
 
     vkCmdSetRasterizationSamples =
         (PFN_vkCmdSetRasterizationSamplesEXT)vkGetDeviceProcAddr(device, "vkCmdSetRasterizationSamplesEXT");
 
     if (!vkCmdSetRasterizationSamples)
     {
-        ERR_LOG("Failed to load vkCmdSetRasterizationSamplesEXT!");
+        LOG_ERROR("Failed to load vkCmdSetRasterizationSamplesEXT!");
     }
 
     vkCreateAccelerationStructure = reinterpret_cast<PFN_vkCreateAccelerationStructureKHR>(
         vkGetDeviceProcAddr(device, "vkCreateAccelerationStructureKHR"));
 
     if (!vkCreateAccelerationStructure)
     {
-        ERR_LOG("Failed to load vkCreateAccelerationStructureKHR!");
+        LOG_ERROR("Failed to load vkCreateAccelerationStructureKHR!");
     }
     vkDestroyAccelerationStructure = reinterpret_cast<PFN_vkDestroyAccelerationStructureKHR>(
         vkGetDeviceProcAddr(device, "vkDestroyAccelerationStructureKHR"));
 
     if (!vkDestroyAccelerationStructure)
     {
-        ERR_LOG("Failed to load vkDestroyAccelerationStructureKHR!");
+        LOG_ERROR("Failed to load vkDestroyAccelerationStructureKHR!");
     }
     vkGetAccelerationStructureBuildSizes = reinterpret_cast<PFN_vkGetAccelerationStructureBuildSizesKHR>(
         vkGetDeviceProcAddr(device, "vkGetAccelerationStructureBuildSizesKHR"));
 
     if (!vkGetAccelerationStructureBuildSizes)
     {
-        ERR_LOG("Failed to load vkGetAccelerationStructureBuildSizesKHR!");
+        LOG_ERROR("Failed to load vkGetAccelerationStructureBuildSizesKHR!");
     }
     vkGetAccelerationStructureDeviceAddress = reinterpret_cast<PFN_vkGetAccelerationStructureDeviceAddressKHR>(
         vkGetDeviceProcAddr(device, "vkGetAccelerationStructureDeviceAddressKHR"));
 
     if (!vkGetAccelerationStructureDeviceAddress)
     {
-        ERR_LOG("Failed to load vkGetAccelerationStructureDeviceAddressKHR!");
+        LOG_ERROR("Failed to load vkGetAccelerationStructureDeviceAddressKHR!");
     }
     vkCmdBuildAccelerationStructures = reinterpret_cast<PFN_vkCmdBuildAccelerationStructuresKHR>(
         vkGetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresKHR"));
 
     if (!vkCmdBuildAccelerationStructures)
     {
-        ERR_LOG("Failed to load vkCmdBuildAccelerationStructuresKHR!");
+        LOG_ERROR("Failed to load vkCmdBuildAccelerationStructuresKHR!");
     }
     vkBuildAccelerationStructures = reinterpret_cast<PFN_vkBuildAccelerationStructuresKHR>(
         vkGetDeviceProcAddr(device, "vkBuildAccelerationStructuresKHR"));
 
     if (!vkBuildAccelerationStructures)
     {
-        ERR_LOG("Failed to load vkBuildAccelerationStructuresKHR!");
+        LOG_ERROR("Failed to load vkBuildAccelerationStructuresKHR!");
     }
 
     vkSetDebugUtilsObjectName =
         reinterpret_cast<PFN_vkSetDebugUtilsObjectNameEXT>(vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT"));
     if (!vkSetDebugUtilsObjectName)
     {
-        ERR_LOG("Failed to load vkSetDebugUtilsObjectNameEXT!");
+        LOG_ERROR("Failed to load vkSetDebugUtilsObjectNameEXT!");
     }
 }
diff --git a/src/graphics/shaderpass.cpp b/src/graphics/shaderpass.cpp
@@ -93,7 +93,7 @@ ShaderSource::compile_shader(const std::string src, const std::string shaderName
     shaderc::SpvCompilationResult result = compiler.CompileGlslToSpv(src, kind, shaderName.c_str(), options);
     if (result.GetCompilationStatus() != shaderc_compilation_status_success)
     {
-        DEBUG_LOG("Error compiling module - " << result.GetErrorMessage());
+        LOG_ERROR("Error compiling module - " + std::string(result.GetErrorMessage()));
     }
 
     std::vector<uint32_t> spirv = {result.cbegin(), result.cend()};
diff --git a/src/graphics/utilities/bootstrap.cpp b/src/graphics/utilities/bootstrap.cpp
@@ -518,26 +518,26 @@ bool Booter::is_device_extension_supported(VkPhysicalDevice physicalDevice, cons
     return false;
 }
 void Booter::log_available_extensions(std::vector<VkExtensionProperties> ext) {
-    DEBUG_LOG("---------------------");
-    DEBUG_LOG("Available extensions");
-    DEBUG_LOG("---------------------");
+    LOG_DEBUG("---------------------");
+    LOG_DEBUG("Available extensions");
+    LOG_DEBUG("---------------------");
     for (const auto& extension : ext)
     {
-        DEBUG_LOG(extension.extensionName);
+        LOG_DEBUG(extension.extensionName);
     }
-    DEBUG_LOG("---------------------");
+    LOG_DEBUG("---------------------");
 }
 void Booter::log_available_gpus(std::multimap<int, VkPhysicalDevice> candidates) {
-    DEBUG_LOG("---------------------");
-    DEBUG_LOG("Suitable Devices");
-    DEBUG_LOG("---------------------");
+    LOG_DEBUG("---------------------");
+    LOG_DEBUG("Suitable Devices");
+    LOG_DEBUG("---------------------");
     for (const auto& candidate : candidates)
     {
         VkPhysicalDeviceProperties deviceProperties;
         vkGetPhysicalDeviceProperties(candidate.second, &deviceProperties);
-        DEBUG_LOG(deviceProperties.deviceName);
+        LOG_DEBUG(deviceProperties.deviceName);
     }
-    DEBUG_LOG("---------------------");
+    LOG_DEBUG("---------------------");
 }
 
 } // namespace Graphics
diff --git a/src/tools/loaders.cpp b/src/tools/loaders.cpp
@@ -17,12 +17,12 @@ void VKFW::Tools::Loaders::load_OBJ(Core::Mesh* const mesh, const std::string fi
     // Check for errors
     if (!warn.empty())
     {
-        DEBUG_LOG("WARN: " + warn);
+        LOG_WARN("WARN: " + warn);
     }
     if (!err.empty())
     {
-        ERR_LOG(err);
-        DEBUG_LOG("ERROR: Couldn't load mesh");
+        LOG_ERROR(err);
+        LOG_ERROR("ERROR: Couldn't load mesh");
         return;
     }
 
@@ -154,12 +154,12 @@ void VKFW::Tools::Loaders::load_OBJ_topology(Core::Mesh* const mesh,
     // Check for errors
     if (!warn.empty())
     {
-        DEBUG_LOG("WARN: " + warn);
+        LOG_WARN("WARN: " + warn);
     }
     if (!err.empty())
     {
-        ERR_LOG(err);
-        DEBUG_LOG("ERROR: Couldn't load mesh");
+        LOG_ERROR(err);
+        LOG_ERROR("ERROR: Couldn't load mesh");
         return;
     }
 
@@ -838,12 +838,12 @@ void VKFW::Tools::Loaders::load_PNG(Core::TextureLDR* const texture, const std::
     } else
     {
 #ifndef NDEBUG
-        ERR_LOG("Failed to load texture PNG file" + fileName);
+        LOG_ERROR("Failed to load texture PNG file" + fileName);
 #endif
         return;
     };
 #ifndef NDEBUG
-    DEBUG_LOG("PNG Texture loaded successfully");
+    LOG_DEBUG("PNG Texture loaded successfully");
 #endif // DEBUG
 }
 
@@ -860,12 +860,12 @@ void VKFW::Tools::Loaders::load_HDRi(Core::TextureHDR* const texture, const std:
     } else
     {
 #ifndef NDEBUG
-        ERR_LOG("Failed to load texture HDRi file" + fileName);
+        LOG_ERROR("Failed to load texture HDRi file" + fileName);
 #endif
         return;
     };
 #ifndef NDEBUG
-    DEBUG_LOG("HDRi Texture loaded successfully");
+    LOG_DEBUG("HDRi Texture loaded successfully");
 #endif // DEBUG
 }
 void VKFW::Tools::Loaders::load_3D_texture(Core::ITexture* const texture, const std::string fileName, uint16_t depth, TextureFormatType textureFormat) {
@@ -901,12 +901,12 @@ void VKFW::Tools::Loaders::load_3D_texture(Core::ITexture* const texture, const
     } else
     {
 #ifndef NDEBUG
-        ERR_LOG("Failed to load texture PNG file" + fileName);
+        LOG_ERROR("Failed to load texture PNG file" + fileName);
 #endif
         return;
     };
 #ifndef NDEBUG
-    DEBUG_LOG("PNG Texture loaded successfully");
+    LOG_DEBUG("PNG Texture loaded successfully");
 #endif // DEBUG
 }
 
diff --git a/tests/skin/main.cpp b/tests/skin/main.cpp
@@ -3,16 +3,19 @@
 
 int main(int argc, char* argv[])
 {
+    Logger::init(LogLevel::Debug, "skinTest.log");
     Application app;
     try
     {
         app.run(argc,argv);
     }
     catch (const std::exception &e)
     {
-        std::cerr << e.what() << std::endl;
+        LOG_ERROR(e.what());
+        Logger::shutdown();
         return EXIT_FAILURE;
     }
-
+    
+    Logger::shutdown();
     return EXIT_SUCCESS;
 }
diff --git a/tests/skin/test.cpp b/tests/skin/test.cpp
@@ -14,8 +14,8 @@ void Application::init(Systems::RendererSettings settings) {
 
     m_renderer = std::make_shared<Systems::DeferredRenderer>(m_window, settings);
 
-    setup();
     m_renderer->init();
+    setup();
     setup_gui();
 }
 
diff --git a/thirdparty/logger/CMakeLists.txt b/thirdparty/logger/CMakeLists.txt
@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.6)
+project(logger)
+
+
+add_library(logger INTERFACE)
+
+target_include_directories(logger INTERFACE
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
diff --git a/thirdparty/logger/include/logger.h b/thirdparty/logger/include/logger.h

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ inline static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSe`
`29`	`29`	`const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,`
`30`	`30`	`void* pUserData) {`
`31`	`31`
`32`		`- DEBUG_LOG("(Validation Layer) " << pCallbackData->pMessage);`
	`32`	`+ LOG_DEBUG("(Validation Layer) " + std::string(pCallbackData->pMessage));`
`33`	`33`
`34`	`34`	`return VK_FALSE;`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ bool AABB::is_on_frustrum(const Frustum& frustum) const {`
`51`	`51`	`IMaterial* Mesh::change_material(IMaterial* m, size_t id) {`
`52`	`52`	`if (m_material.size() < id + 1)`
`53`	`53`	`{`
`54`		`- ERR_LOG("Not enough material slots");`
	`54`	`+ LOG_ERROR("Not enough material slots");`
`55`	`55`	`return nullptr;`
`56`	`56`	`}`
`57`	`57`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ void WindowGLFW::init() {`
`14`	`14`	`if (!m_handle)`
`15`	`15`	`{`
`16`	`16`	`glfwTerminate();`
`17`		`- ERR_LOG("Failed to create GLFW window");`
	`17`	`+ LOG_ERROR("Failed to create GLFW window");`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`glfwSetWindowPos(m_handle, (int)m_screenPos.x, (int)m_screenPos.y);`
`@@ -86,7 +86,7 @@ void WindowGLFW::set_window_icon(const char* iconPath) {`
`86`	`86`	`unsigned char* pixels = stbi_load(iconPath, &width, &height, &channels, 4); // Force 4 channels (RGBA)`
`87`	`87`	`if (!pixels)`
`88`	`88`	`{`
`89`		`- ERR_LOG("failed to load window ICON");`
	`89`	`+ LOG_ERROR("failed to load window ICON");`
`90`	`90`	`return;`
`91`	`91`	`}`
`92`	`92`
Original file line number	Diff line number	Diff line change
`@@ -16,64 +16,64 @@ void load_extensions(VkDevice& device, VkInstance& instance) {`
`16`	`16`
`17`	`17`	`if (!vkCmdSetPolygonMode)`
`18`	`18`	`{`
`19`		`- ERR_LOG("Failed to load vkCmdSetPolygonModeEXT!");`
	`19`	`+ LOG_ERROR("Failed to load vkCmdSetPolygonModeEXT!");`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`vkCmdSetRasterizationSamples =`
`23`	`23`	`(PFN_vkCmdSetRasterizationSamplesEXT)vkGetDeviceProcAddr(device, "vkCmdSetRasterizationSamplesEXT");`
`24`	`24`
`25`	`25`	`if (!vkCmdSetRasterizationSamples)`
`26`	`26`	`{`
`27`		`- ERR_LOG("Failed to load vkCmdSetRasterizationSamplesEXT!");`
	`27`	`+ LOG_ERROR("Failed to load vkCmdSetRasterizationSamplesEXT!");`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`vkCreateAccelerationStructure = reinterpret_cast<PFN_vkCreateAccelerationStructureKHR>(`
`31`	`31`	`vkGetDeviceProcAddr(device, "vkCreateAccelerationStructureKHR"));`
`32`	`32`
`33`	`33`	`if (!vkCreateAccelerationStructure)`
`34`	`34`	`{`
`35`		`- ERR_LOG("Failed to load vkCreateAccelerationStructureKHR!");`
	`35`	`+ LOG_ERROR("Failed to load vkCreateAccelerationStructureKHR!");`
`36`	`36`	`}`
`37`	`37`	`vkDestroyAccelerationStructure = reinterpret_cast<PFN_vkDestroyAccelerationStructureKHR>(`
`38`	`38`	`vkGetDeviceProcAddr(device, "vkDestroyAccelerationStructureKHR"));`
`39`	`39`
`40`	`40`	`if (!vkDestroyAccelerationStructure)`
`41`	`41`	`{`
`42`		`- ERR_LOG("Failed to load vkDestroyAccelerationStructureKHR!");`
	`42`	`+ LOG_ERROR("Failed to load vkDestroyAccelerationStructureKHR!");`
`43`	`43`	`}`
`44`	`44`	`vkGetAccelerationStructureBuildSizes = reinterpret_cast<PFN_vkGetAccelerationStructureBuildSizesKHR>(`
`45`	`45`	`vkGetDeviceProcAddr(device, "vkGetAccelerationStructureBuildSizesKHR"));`
`46`	`46`
`47`	`47`	`if (!vkGetAccelerationStructureBuildSizes)`
`48`	`48`	`{`
`49`		`- ERR_LOG("Failed to load vkGetAccelerationStructureBuildSizesKHR!");`
	`49`	`+ LOG_ERROR("Failed to load vkGetAccelerationStructureBuildSizesKHR!");`
`50`	`50`	`}`
`51`	`51`	`vkGetAccelerationStructureDeviceAddress = reinterpret_cast<PFN_vkGetAccelerationStructureDeviceAddressKHR>(`
`52`	`52`	`vkGetDeviceProcAddr(device, "vkGetAccelerationStructureDeviceAddressKHR"));`
`53`	`53`
`54`	`54`	`if (!vkGetAccelerationStructureDeviceAddress)`
`55`	`55`	`{`
`56`		`- ERR_LOG("Failed to load vkGetAccelerationStructureDeviceAddressKHR!");`
	`56`	`+ LOG_ERROR("Failed to load vkGetAccelerationStructureDeviceAddressKHR!");`
`57`	`57`	`}`
`58`	`58`	`vkCmdBuildAccelerationStructures = reinterpret_cast<PFN_vkCmdBuildAccelerationStructuresKHR>(`
`59`	`59`	`vkGetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresKHR"));`
`60`	`60`
`61`	`61`	`if (!vkCmdBuildAccelerationStructures)`
`62`	`62`	`{`
`63`		`- ERR_LOG("Failed to load vkCmdBuildAccelerationStructuresKHR!");`
	`63`	`+ LOG_ERROR("Failed to load vkCmdBuildAccelerationStructuresKHR!");`
`64`	`64`	`}`
`65`	`65`	`vkBuildAccelerationStructures = reinterpret_cast<PFN_vkBuildAccelerationStructuresKHR>(`
`66`	`66`	`vkGetDeviceProcAddr(device, "vkBuildAccelerationStructuresKHR"));`
`67`	`67`
`68`	`68`	`if (!vkBuildAccelerationStructures)`
`69`	`69`	`{`
`70`		`- ERR_LOG("Failed to load vkBuildAccelerationStructuresKHR!");`
	`70`	`+ LOG_ERROR("Failed to load vkBuildAccelerationStructuresKHR!");`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`vkSetDebugUtilsObjectName =`
`74`	`74`	`reinterpret_cast<PFN_vkSetDebugUtilsObjectNameEXT>(vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT"));`
`75`	`75`	`if (!vkSetDebugUtilsObjectName)`
`76`	`76`	`{`
`77`		`- ERR_LOG("Failed to load vkSetDebugUtilsObjectNameEXT!");`
	`77`	`+ LOG_ERROR("Failed to load vkSetDebugUtilsObjectNameEXT!");`
`78`	`78`	`}`
`79`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ ShaderSource::compile_shader(const std::string src, const std::string shaderName`
`93`	`93`	`shaderc::SpvCompilationResult result = compiler.CompileGlslToSpv(src, kind, shaderName.c_str(), options);`
`94`	`94`	`if (result.GetCompilationStatus() != shaderc_compilation_status_success)`
`95`	`95`	`{`
`96`		`- DEBUG_LOG("Error compiling module - " << result.GetErrorMessage());`
	`96`	`+ LOG_ERROR("Error compiling module - " + std::string(result.GetErrorMessage()));`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`std::vector<uint32_t> spirv = {result.cbegin(), result.cend()};`
Original file line number	Diff line number	Diff line change
`@@ -518,26 +518,26 @@ bool Booter::is_device_extension_supported(VkPhysicalDevice physicalDevice, cons`
`518`	`518`	`return false;`
`519`	`519`	`}`
`520`	`520`	`void Booter::log_available_extensions(std::vector<VkExtensionProperties> ext) {`
`521`		`- DEBUG_LOG("---------------------");`
`522`		`- DEBUG_LOG("Available extensions");`
`523`		`- DEBUG_LOG("---------------------");`
	`521`	`+ LOG_DEBUG("---------------------");`
	`522`	`+ LOG_DEBUG("Available extensions");`
	`523`	`+ LOG_DEBUG("---------------------");`
`524`	`524`	`for (const auto& extension : ext)`
`525`	`525`	`{`
`526`		`- DEBUG_LOG(extension.extensionName);`
	`526`	`+ LOG_DEBUG(extension.extensionName);`
`527`	`527`	`}`
`528`		`- DEBUG_LOG("---------------------");`
	`528`	`+ LOG_DEBUG("---------------------");`
`529`	`529`	`}`
`530`	`530`	`void Booter::log_available_gpus(std::multimap<int, VkPhysicalDevice> candidates) {`
`531`		`- DEBUG_LOG("---------------------");`
`532`		`- DEBUG_LOG("Suitable Devices");`
`533`		`- DEBUG_LOG("---------------------");`
	`531`	`+ LOG_DEBUG("---------------------");`
	`532`	`+ LOG_DEBUG("Suitable Devices");`
	`533`	`+ LOG_DEBUG("---------------------");`
`534`	`534`	`for (const auto& candidate : candidates)`
`535`	`535`	`{`
`536`	`536`	`VkPhysicalDeviceProperties deviceProperties;`
`537`	`537`	`vkGetPhysicalDeviceProperties(candidate.second, &deviceProperties);`
`538`		`- DEBUG_LOG(deviceProperties.deviceName);`
	`538`	`+ LOG_DEBUG(deviceProperties.deviceName);`
`539`	`539`	`}`
`540`		`- DEBUG_LOG("---------------------");`
	`540`	`+ LOG_DEBUG("---------------------");`
`541`	`541`	`}`
`542`	`542`
`543`	`543`	`} // namespace Graphics`
Original file line number	Diff line number	Diff line change
`@@ -17,12 +17,12 @@ void VKFW::Tools::Loaders::load_OBJ(Core::Mesh* const mesh, const std::string fi`
`17`	`17`	`// Check for errors`
`18`	`18`	`if (!warn.empty())`
`19`	`19`	`{`
`20`		`- DEBUG_LOG("WARN: " + warn);`
	`20`	`+ LOG_WARN("WARN: " + warn);`
`21`	`21`	`}`
`22`	`22`	`if (!err.empty())`
`23`	`23`	`{`
`24`		`- ERR_LOG(err);`
`25`		`- DEBUG_LOG("ERROR: Couldn't load mesh");`
	`24`	`+ LOG_ERROR(err);`
	`25`	`+ LOG_ERROR("ERROR: Couldn't load mesh");`
`26`	`26`	`return;`
`27`	`27`	`}`
`28`	`28`
`@@ -154,12 +154,12 @@ void VKFW::Tools::Loaders::load_OBJ_topology(Core::Mesh* const mesh,`
`154`	`154`	`// Check for errors`
`155`	`155`	`if (!warn.empty())`
`156`	`156`	`{`
`157`		`- DEBUG_LOG("WARN: " + warn);`
	`157`	`+ LOG_WARN("WARN: " + warn);`
`158`	`158`	`}`
`159`	`159`	`if (!err.empty())`
`160`	`160`	`{`
`161`		`- ERR_LOG(err);`
`162`		`- DEBUG_LOG("ERROR: Couldn't load mesh");`
	`161`	`+ LOG_ERROR(err);`
	`162`	`+ LOG_ERROR("ERROR: Couldn't load mesh");`
`163`	`163`	`return;`
`164`	`164`	`}`
`165`	`165`
`@@ -838,12 +838,12 @@ void VKFW::Tools::Loaders::load_PNG(Core::TextureLDR* const texture, const std::`
`838`	`838`	`} else`
`839`	`839`	`{`
`840`	`840`	`#ifndef NDEBUG`
`841`		`- ERR_LOG("Failed to load texture PNG file" + fileName);`
	`841`	`+ LOG_ERROR("Failed to load texture PNG file" + fileName);`
`842`	`842`	`#endif`
`843`	`843`	`return;`
`844`	`844`	`};`
`845`	`845`	`#ifndef NDEBUG`
`846`		`- DEBUG_LOG("PNG Texture loaded successfully");`
	`846`	`+ LOG_DEBUG("PNG Texture loaded successfully");`
`847`	`847`	`#endif // DEBUG`
`848`	`848`	`}`
`849`	`849`
`@@ -860,12 +860,12 @@ void VKFW::Tools::Loaders::load_HDRi(Core::TextureHDR* const texture, const std:`
`860`	`860`	`} else`
`861`	`861`	`{`
`862`	`862`	`#ifndef NDEBUG`
`863`		`- ERR_LOG("Failed to load texture HDRi file" + fileName);`
	`863`	`+ LOG_ERROR("Failed to load texture HDRi file" + fileName);`
`864`	`864`	`#endif`
`865`	`865`	`return;`
`866`	`866`	`};`
`867`	`867`	`#ifndef NDEBUG`
`868`		`- DEBUG_LOG("HDRi Texture loaded successfully");`
	`868`	`+ LOG_DEBUG("HDRi Texture loaded successfully");`
`869`	`869`	`#endif // DEBUG`
`870`	`870`	`}`
`871`	`871`	`void VKFW::Tools::Loaders::load_3D_texture(Core::ITexture* const texture, const std::string fileName, uint16_t depth, TextureFormatType textureFormat) {`
`@@ -901,12 +901,12 @@ void VKFW::Tools::Loaders::load_3D_texture(Core::ITexture* const texture, const`
`901`	`901`	`} else`
`902`	`902`	`{`
`903`	`903`	`#ifndef NDEBUG`
`904`		`- ERR_LOG("Failed to load texture PNG file" + fileName);`
	`904`	`+ LOG_ERROR("Failed to load texture PNG file" + fileName);`
`905`	`905`	`#endif`
`906`	`906`	`return;`
`907`	`907`	`};`
`908`	`908`	`#ifndef NDEBUG`
`909`		`- DEBUG_LOG("PNG Texture loaded successfully");`
	`909`	`+ LOG_DEBUG("PNG Texture loaded successfully");`
`910`	`910`	`#endif // DEBUG`
`911`	`911`	`}`
`912`	`912`
Original file line number	Diff line number	Diff line change
`@@ -3,16 +3,19 @@`
`3`	`3`
`4`	`4`	`int main(int argc, char* argv[])`
`5`	`5`	`{`
	`6`	`+ Logger::init(LogLevel::Debug, "skinTest.log");`
`6`	`7`	`Application app;`
`7`	`8`	`try`
`8`	`9`	`{`
`9`	`10`	`app.run(argc,argv);`
`10`	`11`	`}`
`11`	`12`	`catch (const std::exception &e)`
`12`	`13`	`{`
`13`		`- std::cerr << e.what() << std::endl;`
	`14`	`+ LOG_ERROR(e.what());`
	`15`	`+ Logger::shutdown();`
`14`	`16`	`return EXIT_FAILURE;`
`15`	`17`	`}`
`16`		`-`
	`18`	`+`
	`19`	`+ Logger::shutdown();`
`17`	`20`	`return EXIT_SUCCESS;`
`18`	`21`	`}`