[chore]: MASSIVE refactor + more vulkan bs

1 files changed, 77 insertions, 77 deletions

diff --git a/src/Core/Log.cpp b/src/Core/Log.cpp
index f2f3e44..5a0434f 100644
--- a/src/Core/Log.cpp
+++ b/src/Core/Log.cpp
@@ -1,4 +1,4 @@
-#include "Log.h"
+#include "log.h"
 
 #include <filesystem>
 
@@ -6,148 +6,148 @@
     #include <windows.h>
 #endif
 
-namespace Donut 
+namespace Donut
 {
-    Ref<Logger> Logger::s_Logger;
+    Ref<Logger> Logger::s_logger;
 
-    void Logger::Init()
+    auto Logger::init() -> void
     {
-        s_Logger = CreateRef<Logger>();
-        s_Logger->SetLogLevel(LogLevel::INFO);
-        s_Logger->EnableConsoleOutput(true);
-        s_Logger->EnableFileOutput(true);
-        s_Logger->SetLogFile("logs/donut.log");
-        
-        s_Logger->LogMessage(LogLevel::INFO, "Logging system initialized");
+        s_logger = create_ref<Logger>();
+        s_logger->set_log_level(LogLevel::Info);
+        s_logger->enable_console_output(true);
+        s_logger->enable_file_output(true);
+        s_logger->set_log_file("logs/donut.log");
+
+        s_logger->log_message(LogLevel::Info, "Logging system initialized");
     }
 
-    void Logger::Shutdown()
+    auto Logger::shutdown() -> void
     {
-        if (s_Logger)
-            s_Logger->LogMessage(LogLevel::INFO, "Shutting down logging system");
-        s_Logger.reset();
+        if (s_logger)
+            s_logger->log_message(LogLevel::Info, "Shutting down logging system");
+        s_logger.reset();
     }
 
-    Ref<Logger> Logger::GetLogger()
+    auto Logger::get_logger() -> Ref<Logger>
     {
-        return s_Logger;
+        return s_logger;
     }
 
     Logger::Logger()
-        : m_LogLevel(LogLevel::INFO), 
-          m_ConsoleOutput(true), 
-          m_FileOutput(false) { }
+        : m_log_level(LogLevel::Info),
+          m_console_output(true),
+          m_file_output(false) { }
 
-    Logger::~Logger() 
+    Logger::~Logger()
     {
-        if (m_LogFile.is_open())
-            m_LogFile.close();
+        if (m_log_file.is_open())
+            m_log_file.close();
     }
 
-    void Logger::SetLogFile(const std::string& filename)
+    auto Logger::set_log_file(const std::string& filename) -> void
     {
-        std::filesystem::path logPath(filename);
-        std::filesystem::create_directories(logPath.parent_path());
-        
-        m_LogFile.open(filename, std::ios::app);
-        if (!m_LogFile.is_open())
+        std::filesystem::path log_path(filename);
+        std::filesystem::create_directories(log_path.parent_path());
+
+        m_log_file.open(filename, std::ios::app);
+        if (!m_log_file.is_open())
             std::cerr << "Failed to open log file: " << filename << std::endl;
     }
 
-    std::string Logger::GetTimeStamp() 
+    auto Logger::get_time_stamp() -> std::string
     {
         auto now = std::chrono::system_clock::now();
-        auto time_t = std::chrono::system_clock::to_time_t(now);
-        
+        auto time = std::chrono::system_clock::to_time_t(now);
+
         std::stringstream ss;
-        ss << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S");
-        
+        ss << std::put_time(std::localtime(&time), "%Y-%m-%d %H:%M:%S");
+
         return ss.str();
     }
 
-    std::string Logger::GetLogLevelString(LogLevel level) 
+    auto Logger::get_log_level_string(LogLevel level) -> std::string
     {
-        switch (level) 
+        switch (level)
         {
-            case LogLevel::TRACE: return "TRACE";
-            case LogLevel::INFO:  return "INFO";
-            case LogLevel::WARN:  return "WARN";
-            case LogLevel::ERR:   return "ERROR";
-            case LogLevel::FATAL: return "FATAL";
+            case LogLevel::trace: return "TRACE";
+            case LogLevel::Info:  return "INFO";
+            case LogLevel::Warn:  return "WARN";
+            case LogLevel::Err:   return "ERROR";
+            case LogLevel::Fatal: return "FATAL";
             default:              return "UNKNOWN";
         }
     }
 
-    void Logger::SetConsoleColor(LogLevel level) 
+    auto Logger::set_console_color(LogLevel level) -> void
     {
 #if defined(DONUT_WINDOWS)
-        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+        HANDLE h_console = GetStdHandle(STD_OUTPUT_HANDLE);
         WORD color;
-        
+
         switch (level) {
-            case LogLevel::TRACE:
+            case LogLevel::trace:
                 color = FOREGROUND_RED   |
-                        FOREGROUND_GREEN | 
+                        FOREGROUND_GREEN |
                         FOREGROUND_BLUE;
                 break;
-            case LogLevel::INFO:
-                color = FOREGROUND_GREEN | 
+            case LogLevel::Info:
+                color = FOREGROUND_GREEN |
                         FOREGROUND_INTENSITY;
                 break;
-            case LogLevel::WARN:
-                color = FOREGROUND_RED   | 
-                        FOREGROUND_GREEN | 
+            case LogLevel::Warn:
+                color = FOREGROUND_RED   |
+                        FOREGROUND_GREEN |
                         FOREGROUND_INTENSITY;
                 break;
-            case LogLevel::ERR:
-                color = FOREGROUND_RED | 
+            case LogLevel::Err:
+                color = FOREGROUND_RED |
                         FOREGROUND_INTENSITY;
                 break;
-            case LogLevel::FATAL:
-                color = FOREGROUND_RED  | 
-                        FOREGROUND_BLUE | 
+            case LogLevel::Fatal:
+                color = FOREGROUND_RED  |
+                        FOREGROUND_BLUE |
                         FOREGROUND_INTENSITY;
                 break;
             default:
-                color = FOREGROUND_RED   | 
-                        FOREGROUND_GREEN | 
+                color = FOREGROUND_RED   |
+                        FOREGROUND_GREEN |
                         FOREGROUND_BLUE;
                 break;
         }
-        
-        SetConsoleTextAttribute(hConsole, color);
+
+        SetConsoleTextAttribute(h_console, color);
 #else
-        const char* colorCode;
+        const char* color_code;
         switch (level) {
-            case LogLevel::TRACE:
-                colorCode = "\033[37m";
+            case LogLevel::trace:
+                color_code = "\033[37m";
                 break;
-            case LogLevel::INFO:
-                colorCode = "\033[32;1m";
+            case LogLevel::Info:
+                color_code = "\033[32;1m";
                 break;
-            case LogLevel::WARN:
-                colorCode = "\033[33;1m";
+            case LogLevel::Warn:
+                color_code = "\033[33;1m";
                 break;
-            case LogLevel::ERR:
-                colorCode = "\033[31;1m";
+            case LogLevel::Err:
+                color_code = "\033[31;1m";
                 break;
-            case LogLevel::FATAL:
-                colorCode = "\033[35;1m";
+            case LogLevel::Fatal:
+                color_code = "\033[35;1m";
                 break;
             default:
-                colorCode = "\033[37m";
+                color_code = "\033[37m";
                 break;
         }
-        std::cout << colorCode;
+        std::cout << color_code;
 #endif
     }
 
-    void Logger::ResetConsoleColor() 
+    auto Logger::reset_console_color() -> void
     {
 #if defined(DONUT_WINDOWS)
-        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
-        SetConsoleTextAttribute(hConsole, FOREGROUND_RED   | 
-                                          FOREGROUND_GREEN | 
+        HANDLE h_console = GetStdHandle(STD_OUTPUT_HANDLE);
+        SetConsoleTextAttribute(h_console, FOREGROUND_RED   |
+                                          FOREGROUND_GREEN |
                                           FOREGROUND_BLUE);
 #else
         std::cout << "\033[0m";