[chore]: MASSIVE refactor + more vulkan bs

1 files changed, 108 insertions, 108 deletions

diff --git a/src/Core/Application.cpp b/src/Core/Application.cpp
index c73dc6d..667fc73 100644
--- a/src/Core/Application.cpp
+++ b/src/Core/Application.cpp
@@ -1,87 +1,87 @@
-#include "Application.h"
+#include "application.h"
 
-#include "Rendering/Renderer.h"
-#include "SettingsManager.h"
+#include "rendering/renderer.h"
+#include "settings_manager.h"
 
-#include "States/SimulationState.h"
-#include "States/ConfigState.h"
-#include "States/WorldBuilderState.h"
+#include "states/simulation_state.h"
+#include "states/config_state.h"
+#include "states/world_builder_state.h"
 
 #include <GLFW/glfw3.h>
 #include <imgui.h>
 #include <ImGuizmo.h>
 
-#include "Platform/Vulkan/VulkanRenderer.h"
+#include "platform/vulkan/vulkan_renderer.h"
 
 #ifdef __APPLE__
-#include "Platform/Metal/MetalContext.h"
-#include "Platform/Vulkan/VulkanContext.h"
+#include "platform/metal/metal_context.h"
+#include "platform/vulkan/vulkan_context.h"
 #endif
 
 namespace Donut
 {
-    Application* Application::s_Instance = nullptr;
+    Application* Application::s_instance = nullptr;
 
     Application::Application(const std::string& name, int width, int height)
-        : m_Running(true), m_Minimized(false)
+        : m_running(true), m_minimized(false)
     {
-        s_Instance = this;
+        s_instance = this;
 
         // Select the render API before the window is created: the window is
         // built differently for Vulkan (GLFW_NO_API) than for OpenGL.
-        Logger::Init();
-        SettingsManager::Initialize();
+        Logger::init();
+        SettingsManager::initialize();
         {
-            const auto& settings = SettingsManager::GetSettingsConst();
-            RendererAPI::SetAPI(settings.graphics.renderAPI == "Vulkan"
+            const auto& settings = SettingsManager::get_settings_const();
+            RendererAPI::set_api(settings.graphics.render_api == "Vulkan"
                                 ? RendererAPI::API::Vulkan : RendererAPI::API::OpenGL);
         }
 
-        if (RendererAPI::GetAPI() == RendererAPI::API::Vulkan)
-            VulkanPrepareGLFW(); // must precede glfwInit() inside the Window ctor
+        if (RendererAPI::get_api() == RendererAPI::API::Vulkan)
+            vulkan_prepare_glfw(); // must precede glfwInit() inside the Window ctor
 
-        m_Window = CreateScope<Window>(name, width, height);
-        m_Window->SetEventCallback([this](Event& event)
+        m_window = create_scope<Window>(name, width, height);
+        m_window->set_event_callback([this](Event& event)
         {
-            OnEvent(event);
+            on_event(event);
         });
 
-        OnInit();
+        on_init();
     }
 
     Application::~Application()
     {
-        OnShutdown();
-        s_Instance = nullptr;
+        on_shutdown();
+        s_instance = nullptr;
     }
 
-    void Application::Run()
+    auto Application::run() -> void
     {
-        while (m_Running)
+        while (m_running)
         {
-            if (m_VulkanRenderer)
+            if (m_vulkan_renderer)
             {
                 glfwPollEvents(); // before the ImGui frame so input is current
-                if (!m_Minimized)
-                    m_VulkanRenderer->DrawFrame(glm::vec4(0.05f, 0.06f, 0.10f, 1.0f),
-                                                [this] { BuildVulkanUI(); });
+                if (!m_minimized)
+                    m_vulkan_renderer->draw_frame(glm::vec4(0.05f, 0.06f, 0.10f, 1.0f),
+                                                [this] { build_vulkan_ui(); });
             }
             else
             {
-                if (!m_Minimized)
+                if (!m_minimized)
                 {
-                    OnUpdate();
-                    OnRender();
+                    on_update();
+                    on_render();
                 }
-                m_Window->OnUpdate(); // polls events + swaps buffers (OpenGL)
+                m_window->on_update(); // polls events + swaps buffers (OpenGL)
             }
         }
     }
 
-    void Application::BuildVulkanUI()
+    auto Application::build_vulkan_ui() -> void
     {
         // Placeholder UI proving the ImGui Vulkan backend renders. The real
-        // application UI (states' OnImUIRender) moves here once the scene is
+        // application UI (states' on_im_ui_render) moves here once the scene is
         // ported to Vulkan (B-3).
         ImGui::Begin("Donut - Vulkan backend");
         ImGui::Text("Geodesic black hole through Vulkan (MoltenVK).");
@@ -92,145 +92,145 @@ namespace Donut
         ImGui::End();
     }
 
-    void Application::Close()
+    auto Application::close() -> void
     {
-        m_Running = false;
+        m_running = false;
     }
 
-    void Application::OnEvent(Event& event)
+    auto Application::on_event(Event& event) -> void
     {
         EventDispatcher dispatcher(event);
-        dispatcher.Dispatch<WindowCloseEvent>([this, &event](WindowCloseEvent& e) 
+        dispatcher.dispatch<WindowCloseEvent>([this, &event](WindowCloseEvent& e)
         {
-            m_Running = false;
-            event.Handled = true;
+            m_running = false;
+            event.handled = true;
             return true;
         });
-        
-        dispatcher.Dispatch<WindowResizeEvent>([this, &event](WindowResizeEvent& e) 
+
+        dispatcher.dispatch<WindowResizeEvent>([this, &event](WindowResizeEvent& e)
         {
-            if (e.GetWidth() == 0 || e.GetHeight() == 0)
-                m_Minimized = true;
+            if (e.get_width() == 0 || e.get_height() == 0)
+                m_minimized = true;
             else
-                m_Minimized = false;
+                m_minimized = false;
 
-            if (m_VulkanRenderer)
+            if (m_vulkan_renderer)
             {
-                m_VulkanRenderer->OnResize(e.GetWidth(), e.GetHeight());
+                m_vulkan_renderer->on_resize(e.get_width(), e.get_height());
             }
             else
             {
-                Renderer::OnWindowResize(e.GetWidth(), e.GetHeight());
-                if (m_Engine) m_Engine->SetWindowDimensions(e.GetWidth(), e.GetHeight());
+                Renderer::on_window_resize(e.get_width(), e.get_height());
+                if (m_engine) m_engine->set_window_dimensions(e.get_width(), e.get_height());
             }
-            event.Handled = true;
+            event.handled = true;
             return true;
         });
-        
-        dispatcher.Dispatch<KeyPressedEvent>([this, &event](KeyPressedEvent& e)
+
+        dispatcher.dispatch<KeyPressedEvent>([this, &event](KeyPressedEvent& e)
         {
-            if (!m_StateManager)
+            if (!m_state_manager)
                 return true;
-            if (e.GetKeyCode() == GLFW_KEY_1)
+            if (e.get_key_code() == GLFW_KEY_1)
             {
-                m_StateManager->SwitchToState("Config");
-                event.Handled = true;
+                m_state_manager->switch_to_state("Config");
+                event.handled = true;
                 return true;
             }
-            else if (e.GetKeyCode() == GLFW_KEY_2)
+            else if (e.get_key_code() == GLFW_KEY_2)
             {
-                m_StateManager->SwitchToState("Simulation");
-                event.Handled = true;
+                m_state_manager->switch_to_state("Simulation");
+                event.handled = true;
                 return true;
             }
-            else if (e.GetKeyCode() == GLFW_KEY_3)
+            else if (e.get_key_code() == GLFW_KEY_3)
             {
-                m_StateManager->SwitchToState("WorldBuilder");
-                event.Handled = true;
+                m_state_manager->switch_to_state("WorldBuilder");
+                event.handled = true;
                 return true;
             }
-            
+
             return true;
         });
 
-        if (m_StateManager)
-            m_StateManager->OnEvent(event);
+        if (m_state_manager)
+            m_state_manager->on_event(event);
     }
 
-    void Application::OnInit()
+    auto Application::on_init() -> void
     {
         // (Logger, settings and API selection happen in the constructor.)
 
-        if (RendererAPI::GetAPI() == RendererAPI::API::Vulkan)
+        if (RendererAPI::get_api() == RendererAPI::API::Vulkan)
         {
             int w = 0, h = 0;
-            glfwGetFramebufferSize((GLFWwindow*)m_Window->GetNativeWindow(), &w, &h);
-            m_VulkanRenderer = CreateScope<VulkanRenderer>();
-            if (!m_VulkanRenderer->Init(m_Window->GetNativeWindow(), w, h))
+            glfwGetFramebufferSize((GLFWwindow*)m_window->get_native_window(), &w, &h);
+            m_vulkan_renderer = create_scope<VulkanRenderer>();
+            if (!m_vulkan_renderer->init(m_window->get_native_window(), w, h))
                 DONUT_ERROR("Vulkan renderer initialization failed");
             else
-                m_VulkanRenderer->InitImGui();
+                m_vulkan_renderer->init_im_gui();
             // Scene rendering hooks in here in the B-3 phase; the Vulkan path now
             // clears, presents, and draws the ImGui UI.
             return;
         }
 
-        Renderer::Init();
-        m_Window->InitImGui();
+        Renderer::init();
+        m_window->init_im_gui();
 
-        Renderer::OnWindowResize(1280, 720);
-        RenderCommand::SetFaceCulling(false);
+        Renderer::on_window_resize(1280, 720);
+        RenderCommand::set_face_culling(false);
 
-        m_Engine = CreateScope<Engine>();
-        m_Engine->SetWindowDimensions(1280, 720);
+        m_engine = create_scope<Engine>();
+        m_engine->set_window_dimensions(1280, 720);
 
-        m_StateManager = CreateScope<StateManager>();
-        m_StateManager->RegisterState("Config",       CreateScope<ConfigState>());
-        m_StateManager->RegisterState("Simulation",   CreateScope<SimulationState>());
-        m_StateManager->RegisterState("WorldBuilder", CreateScope<WorldBuilderState>());
-        m_StateManager->SwitchToState("Config");
+        m_state_manager = create_scope<StateManager>();
+        m_state_manager->register_state("Config",       create_scope<ConfigState>());
+        m_state_manager->register_state("Simulation",   create_scope<SimulationState>());
+        m_state_manager->register_state("WorldBuilder", create_scope<WorldBuilderState>());
+        m_state_manager->switch_to_state("Config");
     }
 
-    void Application::OnShutdown()
+    auto Application::on_shutdown() -> void
     {
-        if (m_VulkanRenderer)
+        if (m_vulkan_renderer)
         {
-            m_VulkanRenderer->Shutdown();
-            m_VulkanRenderer.reset();
+            m_vulkan_renderer->shutdown();
+            m_vulkan_renderer.reset();
         }
         else
         {
-            if (m_StateManager)
-                m_StateManager->Shutdown();
-            Renderer::Shutdown();
+            if (m_state_manager)
+                m_state_manager->shutdown();
+            Renderer::shutdown();
         }
-        SettingsManager::Shutdown();
-        Logger::Shutdown();
+        SettingsManager::shutdown();
+        Logger::shutdown();
     }
 
-    void Application::OnUpdate()
+    auto Application::on_update() -> void
     {
-        float currentFrame = (float)glfwGetTime();
-        m_DeltaTime = currentFrame - m_LastFrame;
-        m_LastFrame = currentFrame;
+        float current_frame = (float)glfwGetTime();
+        m_delta_time = current_frame - m_last_frame;
+        m_last_frame = current_frame;
 
-        m_StateManager->Update(m_DeltaTime);
+        m_state_manager->update(m_delta_time);
     }
 
-    void Application::OnRender()
+    auto Application::on_render() -> void
     {
-        m_StateManager->Render();
-        m_Window->BeginImGuiFrame();
-        
+        m_state_manager->render();
+        m_window->begin_im_gui_frame();
+
         ImGuizmo::BeginFrame();
         ImGuizmo::SetOrthographic(false);
-        
-        SetupDockingLayout();
-        m_StateManager->OnImUIRender();
-        m_Window->EndImGuiFrame();
+
+        setup_docking_layout();
+        m_state_manager->on_im_ui_render();
+        m_window->end_im_gui_frame();
     }
-    
-    void Application::SetupDockingLayout()
+
+    auto Application::setup_docking_layout() -> void
     {
         ImGuiViewport* viewport = ImGui::GetMainViewport();
         ImGui::DockSpaceOverViewport(0, viewport, ImGuiDockNodeFlags_PassthruCentralNode);