[chore]: MASSIVE refactor + more vulkan bs

1 files changed, 78 insertions, 76 deletions

diff --git a/src/Rendering/Renderer.h b/src/Rendering/Renderer.h
index 6e87411..189723d 100644
--- a/src/Rendering/Renderer.h
+++ b/src/Rendering/Renderer.h
@@ -1,156 +1,158 @@
 #pragma once
 
-#include "Core/Memory.h"
-#include "VertexArray.h"
-#include "Shader.h"
-#include "Framebuffer.h"
+#include "core/memory.h"
+#include "vertex_array.h"
+#include "shader.h"
+#include "framebuffer.h"
 
 #include <glm/glm.hpp>
 
 namespace Donut
 {
-    class RendererAPI 
+    class RendererAPI
     {
     public:
-        enum class API 
+        enum class API
         {
-            None   = 0, 
+            None   = 0,
             OpenGL = 1,
             Vulkan = 2,
         };
+
     public:
         virtual ~RendererAPI() = default;
 
-        virtual void Init()                                               = 0;
-        virtual void SetViewport(uint32_t x, uint32_t y, 
-                                 uint32_t width, uint32_t height)         = 0;
-        virtual void SetClearColor(const glm::vec4& color)                = 0;
-        virtual void Clear()                                              = 0;
-        virtual void EnableDepthTest()                                    = 0;
-        virtual void DisableDepthTest()                                   = 0;
-        virtual void SetFaceCulling(bool enabled)                         = 0;
-        virtual void EnableBlending()                                     = 0;
-        virtual void DisableBlending()                                    = 0;
+        virtual auto init() -> void                                                = 0;
+        virtual auto set_viewport(uint32_t x, uint32_t y,
+                                  uint32_t width, uint32_t height) -> void          = 0;
+        virtual auto set_clear_color(const glm::vec4& color) -> void                = 0;
+        virtual auto clear() -> void                                               = 0;
+        virtual auto enable_depth_test() -> void                                   = 0;
+        virtual auto disable_depth_test() -> void                                  = 0;
+        virtual auto set_face_culling(bool enabled) -> void                        = 0;
+        virtual auto enable_blending() -> void                                     = 0;
+        virtual auto disable_blending() -> void                                    = 0;
+
+        virtual auto draw_indexed(const Ref<VertexArray>& vertex_array,
+                                  uint32_t index_count = 0) -> void                 = 0;
+
+        virtual auto draw_arrays(uint32_t vertex_count, uint32_t first = 0) -> void = 0;
+        virtual auto draw_lines(const Ref<VertexArray>& vertex_array,
+                                uint32_t index_count = 0) -> void                   = 0;
+        virtual auto bind_texture(uint32_t texture_id, uint32_t slot = 0) -> void   = 0;
+        virtual auto bind_image_texture(uint32_t texture_id,
+                                        uint32_t slot = 0,
+                                        bool read_only = false) -> void             = 0;
+        virtual auto read_pixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height,
+                                 uint32_t format, uint32_t type, void* pixels) -> void = 0;
 
-        virtual void DrawIndexed(const Ref<VertexArray>& vertexArray, 
-                                 uint32_t indexCount = 0)                 = 0;
-        
-        virtual void DrawArrays(uint32_t vertexCount, uint32_t first = 0) = 0;
-        virtual void DrawLines(const Ref<VertexArray>& vertexArray, 
-                               uint32_t indexCount = 0)                   = 0;
-        virtual void BindTexture(uint32_t textureID, uint32_t slot = 0)   = 0;
-        virtual void BindImageTexture(uint32_t textureID, 
-                                      uint32_t slot = 0, 
-                                      bool readOnly = false)              = 0;
-        virtual void ReadPixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height, 
-                                uint32_t format, uint32_t type, void* pixels) = 0;
+        inline static auto get_api() -> API         { return s_api; }
+        inline static auto set_api(API api) -> void { s_api = api;  }
+        static auto create() -> Scope<RendererAPI>;
 
-        inline static API GetAPI()         { return s_API; }
-        inline static void SetAPI(API api) { s_API = api;  }
-        static Scope<RendererAPI> Create();
     private:
-        static API s_API;
+        static API s_api;
     };
 
-    class RenderCommand 
+    class RenderCommand
     {
     public:
-        inline static void Init() 
+        inline static auto init() -> void
         {
-            s_RendererAPI->Init();
+            s_renderer_api->init();
         }
 
-        inline static void SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
+        inline static auto set_viewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height) -> void
         {
-            s_RendererAPI->SetViewport(x, y, width, height);
+            s_renderer_api->set_viewport(x, y, width, height);
         }
 
-        inline static void SetClearColor(const glm::vec4& color)
+        inline static auto set_clear_color(const glm::vec4& color) -> void
         {
-            s_RendererAPI->SetClearColor(color);
+            s_renderer_api->set_clear_color(color);
         }
 
-        inline static void Clear()
+        inline static auto clear() -> void
         {
-            s_RendererAPI->Clear();
+            s_renderer_api->clear();
         }
 
-        inline static void EnableDepthTest()
+        inline static auto enable_depth_test() -> void
         {
-            s_RendererAPI->EnableDepthTest();
+            s_renderer_api->enable_depth_test();
         }
 
-        inline static void DisableDepthTest()
+        inline static auto disable_depth_test() -> void
         {
-            s_RendererAPI->DisableDepthTest();
+            s_renderer_api->disable_depth_test();
         }
 
-        inline static void SetFaceCulling(bool enabled)
+        inline static auto set_face_culling(bool enabled) -> void
         {
-            s_RendererAPI->SetFaceCulling(enabled);
+            s_renderer_api->set_face_culling(enabled);
         }
 
-        inline static void EnableBlending()
+        inline static auto enable_blending() -> void
         {
-            s_RendererAPI->EnableBlending();
+            s_renderer_api->enable_blending();
         }
 
-        inline static void DisableBlending()
+        inline static auto disable_blending() -> void
         {
-            s_RendererAPI->DisableBlending();
+            s_renderer_api->disable_blending();
         }
 
-        inline static void DrawIndexed(const Ref<VertexArray>& vertexArray, uint32_t indexCount = 0)
+        inline static auto draw_indexed(const Ref<VertexArray>& vertex_array, uint32_t index_count = 0) -> void
         {
-            s_RendererAPI->DrawIndexed(vertexArray, indexCount);
+            s_renderer_api->draw_indexed(vertex_array, index_count);
         }
 
-        inline static void DrawArrays(uint32_t vertexCount, uint32_t first = 0)
+        inline static auto draw_arrays(uint32_t vertex_count, uint32_t first = 0) -> void
         {
-            s_RendererAPI->DrawArrays(vertexCount, first);
+            s_renderer_api->draw_arrays(vertex_count, first);
         }
 
-        inline static void DrawLines(const Ref<VertexArray>& vertexArray, uint32_t indexCount = 0)
+        inline static auto draw_lines(const Ref<VertexArray>& vertex_array, uint32_t index_count = 0) -> void
         {
-            s_RendererAPI->DrawLines(vertexArray, indexCount);
+            s_renderer_api->draw_lines(vertex_array, index_count);
         }
 
-        inline static void BindTexture(uint32_t textureID, uint32_t slot = 0)
+        inline static auto bind_texture(uint32_t texture_id, uint32_t slot = 0) -> void
         {
-            s_RendererAPI->BindTexture(textureID, slot);
+            s_renderer_api->bind_texture(texture_id, slot);
         }
 
-        inline static void BindImageTexture(uint32_t textureID, uint32_t slot = 0, bool readOnly = false)
+        inline static auto bind_image_texture(uint32_t texture_id, uint32_t slot = 0, bool read_only = false) -> void
         {
-            s_RendererAPI->BindImageTexture(textureID, slot, readOnly);
+            s_renderer_api->bind_image_texture(texture_id, slot, read_only);
         }
 
-        inline static void ReadPixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height, 
-                                      uint32_t format, uint32_t type, void* pixels)
+        inline static auto read_pixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height,
+                                       uint32_t format, uint32_t type, void* pixels) -> void
         {
-            s_RendererAPI->ReadPixels(x, y, width, height, format, type, pixels);
+            s_renderer_api->read_pixels(x, y, width, height, format, type, pixels);
         }
 
     private:
-        static Scope<RendererAPI> s_RendererAPI;
+        static Scope<RendererAPI> s_renderer_api;
     };
 
-    class Renderer 
+    class Renderer
     {
     public:
-        static void Init();
-        static void Shutdown();
+        static auto init() -> void;
+        static auto shutdown() -> void;
 
-        static void OnWindowResize(uint32_t width, uint32_t height);
+        static auto on_window_resize(uint32_t width, uint32_t height) -> void;
 
-        static void Submit(const Ref<Shader>& shader, 
-                           const Ref<VertexArray>& vertexArray,
+        static auto submit(const Ref<Shader>& shader,
+                           const Ref<VertexArray>& vertex_array,
                            const glm::mat4& transform,
-                           const glm::mat4& viewProjection);
+                           const glm::mat4& view_projection) -> void;
 
-        static void SetClearColor(const glm::vec4& color);
-        static void Clear();
+        static auto set_clear_color(const glm::vec4& color) -> void;
+        static auto clear() -> void;
 
-        inline static RendererAPI::API GetAPI() { return RendererAPI::GetAPI(); }
+        inline static auto get_api() -> RendererAPI::API { return RendererAPI::get_api(); }
     };
 };