refactor: trailing return types in the Vulkan backend

18 files changed, 185 insertions, 185 deletions

diff --git a/src/platform/vulkan/vulkan_context.cpp b/src/platform/vulkan/vulkan_context.cpp
index d98cc67..c8e2757 100644
--- a/src/platform/vulkan/vulkan_context.cpp
+++ b/src/platform/vulkan/vulkan_context.cpp
@@ -32,7 +32,7 @@ namespace Donut
         uint32_t         graphics_family = 0;
         VkPhysicalDeviceMemoryProperties mem_props{};
 
-        uint32_t find_memory_type(uint32_t type_filter, VkMemoryPropertyFlags flags) const
+        auto find_memory_type(uint32_t type_filter, VkMemoryPropertyFlags flags) const -> uint32_t
         {
             for (uint32_t i = 0; i < mem_props.memoryTypeCount; ++i)
                 if ((type_filter & (1u << i)) &&
@@ -60,7 +60,7 @@ namespace Donut
     VulkanContext::VulkanContext()  { m_impl = new Impl(); }
     VulkanContext::~VulkanContext() { shutdown(); delete m_impl; m_impl = nullptr; }
 
-    bool VulkanContext::init()
+    auto VulkanContext::init() -> bool
     {
         Impl& v = *m_impl;
 
@@ -150,7 +150,7 @@ namespace Donut
         return true;
     }
 
-    bool VulkanContext::self_test_clear()
+    auto VulkanContext::self_test_clear() -> bool
     {
         Impl& v = *m_impl;
         if (v.device == VK_NULL_HANDLE) return false;
@@ -310,7 +310,7 @@ namespace Donut
         return data;
     }
 
-    bool VulkanContext::self_test_triangle()
+    auto VulkanContext::self_test_triangle() -> bool
     {
         Impl& v = *m_impl;
         if (v.device == VK_NULL_HANDLE) return false;
@@ -478,7 +478,7 @@ namespace Donut
         return ok;
     }
 
-    bool VulkanContext::render_geodesic(const char* png_path)
+    auto VulkanContext::render_geodesic(const char* png_path) -> bool
     {
         Impl& v = *m_impl;
         if (v.device == VK_NULL_HANDLE) return false;
@@ -732,14 +732,14 @@ namespace Donut
         return true;
     }
 
-    void VulkanContext::shutdown()
+    auto VulkanContext::shutdown() -> void
     {
         Impl& v = *m_impl;
         if (v.device)   { vkDestroyDevice(v.device, nullptr);   v.device = VK_NULL_HANDLE; }
         if (v.instance) { vkDestroyInstance(v.instance, nullptr); v.instance = VK_NULL_HANDLE; }
     }
 
-    bool vulkan_self_test()
+    auto vulkan_self_test() -> bool
     {
         VulkanContext ctx;
         if (!ctx.init())
diff --git a/src/platform/vulkan/vulkan_context.h b/src/platform/vulkan/vulkan_context.h
index f84e52b..82c28c5 100644
--- a/src/platform/vulkan/vulkan_context.h
+++ b/src/platform/vulkan/vulkan_context.h
@@ -8,19 +8,19 @@ namespace Donut
         VulkanContext();
         ~VulkanContext();
 
-        bool init();
-        void shutdown();
+        auto init() -> bool;
+        auto shutdown() -> void;
 
-        bool self_test_clear();
+        auto self_test_clear() -> bool;
 
-        bool self_test_triangle();
+        auto self_test_triangle() -> bool;
 
-        bool render_geodesic(const char* png_path);
+        auto render_geodesic(const char* pngPath) -> bool;
 
     private:
         struct Impl;
         Impl* m_impl = nullptr;
     };
 
-    bool vulkan_self_test();
+    auto vulkan_self_test() -> bool;
 }
diff --git a/src/platform/vulkan/vulkan_index_buffer.cpp b/src/platform/vulkan/vulkan_index_buffer.cpp
index 2757668..ec535c4 100644
--- a/src/platform/vulkan/vulkan_index_buffer.cpp
+++ b/src/platform/vulkan/vulkan_index_buffer.cpp
@@ -11,11 +11,11 @@ namespace Donut
 	{
 	}
 
-	void VulkanIndexBuffer::bind() const
+	auto VulkanIndexBuffer::bind() const -> void
 	{
 	}
 
-	void VulkanIndexBuffer::unbind() const
+	auto VulkanIndexBuffer::unbind() const -> void
 	{
 	}
 };
diff --git a/src/platform/vulkan/vulkan_index_buffer.h b/src/platform/vulkan/vulkan_index_buffer.h
index 9a192b7..a0734a8 100644
--- a/src/platform/vulkan/vulkan_index_buffer.h
+++ b/src/platform/vulkan/vulkan_index_buffer.h
@@ -11,10 +11,10 @@ namespace Donut
 		VulkanIndexBuffer(uint32_t* indices, uint32_t count);
 		virtual ~VulkanIndexBuffer();
 
-		virtual void bind()   const override;
-		virtual void unbind() const override;
+		virtual auto bind() const -> void override;
+		virtual auto unbind() const -> void override;
 
-		virtual uint32_t get_count() const override { return m_count; }
+		virtual auto get_count() const -> uint32_t override{ return m_count; }
 	private:
 		uint32_t m_renderer_id;
 		uint32_t m_count;
diff --git a/src/platform/vulkan/vulkan_renderer.cpp b/src/platform/vulkan/vulkan_renderer.cpp
index 65fdcc7..30eed3b 100644
--- a/src/platform/vulkan/vulkan_renderer.cpp
+++ b/src/platform/vulkan/vulkan_renderer.cpp
@@ -32,7 +32,7 @@ namespace Donut
 
     static constexpr int MAX_FRAMES_IN_FLIGHT = 2;
 
-    void vulkan_prepare_glfw()
+    auto vulkan_prepare_glfw() -> void
     {
 #ifdef __APPLE__
         if (!getenv("VK_ICD_FILENAMES"))
@@ -110,31 +110,31 @@ namespace Donut
         VkPipelineLayout present_pipeline_layout = VK_NULL_HANDLE;
         VkPipeline present_pipeline = VK_NULL_HANDLE;
 
-        uint32_t find_memory_type(uint32_t type_filter, VkMemoryPropertyFlags flags) const;
-        bool create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props, VkBuffer& buf, VkDeviceMemory& mem) const;
-        static std::vector<uint32_t> load_spirv(const std::string& path);
-        bool create_shader_module(const std::string& path, VkShaderModule& out) const;
+        auto find_memory_type(uint32_t type_filter, VkMemoryPropertyFlags flags) const -> uint32_t;
+        auto create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props, VkBuffer& buf, VkDeviceMemory& mem) const -> bool;
+        static auto load_spirv(const std::string& path) -> std::vector<uint32_t>;
+        auto create_shader_module(const std::string& path, VkShaderModule& out) const -> bool;
 
-        bool create_instance();
-        bool pick_physical_and_device();
-        bool create_swapchain();
-        bool create_image_views();
-        bool create_render_pass();
-        bool create_framebuffers();
-        bool create_command_buffers();
-        bool create_sync_objects();
-        bool create_geodesic_resources();
-        bool create_hdri_cubemap(const char* path);
-        bool create_present_resources();
-        void process_input();
-        void update_geodesic_uniforms();
-        void destroy_geodesic_resources();
-        bool recreate_swapchain();
-        void cleanup_swapchain();
-        bool record_command_buffer(VkCommandBuffer cmd, uint32_t image_index, const glm::vec4& clear, ImDrawData* draw_data);
+        auto create_instance() -> bool;
+        auto pick_physical_and_device() -> bool;
+        auto create_swapchain() -> bool;
+        auto create_image_views() -> bool;
+        auto create_render_pass() -> bool;
+        auto create_framebuffers() -> bool;
+        auto create_command_buffers() -> bool;
+        auto create_sync_objects() -> bool;
+        auto create_geodesic_resources() -> bool;
+        auto create_hdri_cubemap(const char* path) -> bool;
+        auto create_present_resources() -> bool;
+        auto process_input() -> void;
+        auto update_geodesic_uniforms() -> void;
+        auto destroy_geodesic_resources() -> void;
+        auto recreate_swapchain() -> bool;
+        auto cleanup_swapchain() -> void;
+        auto record_command_buffer(VkCommandBuffer cmd, uint32_t image_index, const glm::vec4& clear, ImDrawData* draw_data) -> bool;
     };
 
-    bool VulkanRenderer::Impl::create_instance()
+    auto VulkanRenderer::Impl::create_instance() -> bool
     {
 #ifdef __APPLE__
         if (!getenv("VK_ICD_FILENAMES"))
@@ -189,7 +189,7 @@ namespace Donut
         return true;
     }
 
-    bool VulkanRenderer::Impl::pick_physical_and_device()
+    auto VulkanRenderer::Impl::pick_physical_and_device() -> bool
     {
         uint32_t count = 0;
         vkEnumeratePhysicalDevices(instance, &count, nullptr);
@@ -248,7 +248,7 @@ namespace Donut
         return true;
     }
 
-    bool VulkanRenderer::Impl::create_swapchain()
+    auto VulkanRenderer::Impl::create_swapchain() -> bool
     {
         VkSurfaceCapabilitiesKHR caps{};
         vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical, surface, &caps);
@@ -306,7 +306,7 @@ namespace Donut
         return true;
     }
 
-    bool VulkanRenderer::Impl::create_image_views()
+    auto VulkanRenderer::Impl::create_image_views() -> bool
     {
         image_views.resize(images.size());
         for (size_t i = 0; i < images.size(); ++i)
@@ -321,7 +321,7 @@ namespace Donut
         return true;
     }
 
-    bool VulkanRenderer::Impl::create_render_pass()
+    auto VulkanRenderer::Impl::create_render_pass() -> bool
     {
         VkAttachmentDescription color{};
         color.format = swapchain_format;
@@ -354,7 +354,7 @@ namespace Donut
         return true;
     }
 
-    bool VulkanRenderer::Impl::create_framebuffers()
+    auto VulkanRenderer::Impl::create_framebuffers() -> bool
     {
         framebuffers.resize(image_views.size());
         for (size_t i = 0; i < image_views.size(); ++i)
@@ -368,7 +368,7 @@ namespace Donut
         return true;
     }
 
-    bool VulkanRenderer::Impl::create_command_buffers()
+    auto VulkanRenderer::Impl::create_command_buffers() -> bool
     {
         VkCommandPoolCreateInfo pci{ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
         pci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
@@ -384,7 +384,7 @@ namespace Donut
         return true;
     }
 
-    bool VulkanRenderer::Impl::create_sync_objects()
+    auto VulkanRenderer::Impl::create_sync_objects() -> bool
     {
         image_available.resize(MAX_FRAMES_IN_FLIGHT);
         in_flight.resize(MAX_FRAMES_IN_FLIGHT);
@@ -404,7 +404,7 @@ namespace Donut
         return true;
     }
 
-    uint32_t VulkanRenderer::Impl::find_memory_type(uint32_t type_filter, VkMemoryPropertyFlags flags) const
+    auto VulkanRenderer::Impl::find_memory_type(uint32_t type_filter, VkMemoryPropertyFlags flags) const -> uint32_t
     {
         for (uint32_t i = 0; i < mem_props.memoryTypeCount; ++i)
             if ((type_filter & (1u << i)) && (mem_props.memoryTypes[i].propertyFlags & flags) == flags)
@@ -412,8 +412,8 @@ namespace Donut
         return UINT32_MAX;
     }
 
-    bool VulkanRenderer::Impl::create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props,
-                                            VkBuffer& buf, VkDeviceMemory& mem) const
+    auto VulkanRenderer::Impl::create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props,
+                                            VkBuffer& buf, VkDeviceMemory& mem) const -> bool
     {
         VkBufferCreateInfo bci{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
         bci.size = size; bci.usage = usage; bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
@@ -427,7 +427,7 @@ namespace Donut
         return true;
     }
 
-    std::vector<uint32_t> VulkanRenderer::Impl::load_spirv(const std::string& path)
+    auto VulkanRenderer::Impl::load_spirv(const std::string& path) -> std::vector<uint32_t>
     {
         std::ifstream file(path, std::ios::ate | std::ios::binary);
         if (!file.is_open()) return {};
@@ -438,7 +438,7 @@ namespace Donut
         return data;
     }
 
-    bool VulkanRenderer::Impl::create_shader_module(const std::string& path, VkShaderModule& out) const
+    auto VulkanRenderer::Impl::create_shader_module(const std::string& path, VkShaderModule& out) const -> bool
     {
         auto spv = load_spirv(path);
         if (spv.empty()) { DONUT_ERROR("Vulkan: failed to load SPIR-V {}", path); return false; }
@@ -447,7 +447,7 @@ namespace Donut
         return vkCreateShaderModule(device, &ci, nullptr, &out) == VK_SUCCESS;
     }
 
-    bool VulkanRenderer::Impl::create_geodesic_resources()
+    auto VulkanRenderer::Impl::create_geodesic_resources() -> bool
     {
         const VkFormat fmt = VK_FORMAT_R8G8B8A8_UNORM;
         const VkMemoryPropertyFlags host_vis = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
@@ -588,7 +588,7 @@ namespace Donut
         return true;
     }
 
-    bool VulkanRenderer::Impl::create_hdri_cubemap(const char* path)
+    auto VulkanRenderer::Impl::create_hdri_cubemap(const char* path) -> bool
     {
         const VkMemoryPropertyFlags host_vis = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
         const uint32_t FACE = 1024;
@@ -832,7 +832,7 @@ namespace Donut
         return true;
     }
 
-    bool VulkanRenderer::Impl::create_present_resources()
+    auto VulkanRenderer::Impl::create_present_resources() -> bool
     {
         VkSamplerCreateInfo smci{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
         smci.magFilter = VK_FILTER_LINEAR; smci.minFilter = VK_FILTER_LINEAR;
@@ -890,7 +890,7 @@ namespace Donut
         return true;
     }
 
-    void VulkanRenderer::Impl::update_geodesic_uniforms()
+    auto VulkanRenderer::Impl::update_geodesic_uniforms() -> void
     {
         struct CamUBO {
             glm::vec3 pos; float p0; glm::vec3 right; float p1;
@@ -920,7 +920,7 @@ namespace Donut
         g_ScrollAccum += y;
     }
 
-    void VulkanRenderer::Impl::process_input()
+    auto VulkanRenderer::Impl::process_input() -> void
     {
         bool over_ui = imgui_init && ImGui::GetIO().WantCaptureMouse;
 
@@ -940,7 +940,7 @@ namespace Donut
             camera.process_orbital_scroll(0.0, scroll);
     }
 
-    void VulkanRenderer::Impl::destroy_geodesic_resources()
+    auto VulkanRenderer::Impl::destroy_geodesic_resources() -> void
     {
         if (present_pipeline) vkDestroyPipeline(device, present_pipeline, nullptr);
         if (present_pipeline_layout) vkDestroyPipelineLayout(device, present_pipeline_layout, nullptr);
@@ -970,7 +970,7 @@ namespace Donut
         if (geo_image_mem) vkFreeMemory(device, geo_image_mem, nullptr);
     }
 
-    bool VulkanRenderer::Impl::record_command_buffer(VkCommandBuffer cmd, uint32_t image_index, const glm::vec4& clear, ImDrawData* draw_data)
+    auto VulkanRenderer::Impl::record_command_buffer(VkCommandBuffer cmd, uint32_t image_index, const glm::vec4& clear, ImDrawData* draw_data) -> bool
     {
         VkCommandBufferBeginInfo begin{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
         VK_CHECK(vkBeginCommandBuffer(cmd, &begin));
@@ -1010,7 +1010,7 @@ namespace Donut
         return true;
     }
 
-    void VulkanRenderer::Impl::cleanup_swapchain()
+    auto VulkanRenderer::Impl::cleanup_swapchain() -> void
     {
         for (auto fb : framebuffers) vkDestroyFramebuffer(device, fb, nullptr);
         framebuffers.clear();
@@ -1020,7 +1020,7 @@ namespace Donut
         if (swapchain)  { vkDestroySwapchainKHR(device, swapchain, nullptr); swapchain = VK_NULL_HANDLE; }
     }
 
-    bool VulkanRenderer::Impl::recreate_swapchain()
+    auto VulkanRenderer::Impl::recreate_swapchain() -> bool
     {
         int w = 0, h = 0;
         glfwGetFramebufferSize(window, &w, &h);
@@ -1044,7 +1044,7 @@ namespace Donut
     VulkanRenderer::VulkanRenderer()  { m_impl = new Impl(); }
     VulkanRenderer::~VulkanRenderer() { shutdown(); delete m_impl; m_impl = nullptr; }
 
-    bool VulkanRenderer::init(void* glfwWindow, int width, int height)
+    auto VulkanRenderer::init(void* glfwWindow, int width, int height) -> bool
     {
         Impl& v = *m_impl;
         v.window = (GLFWwindow*)glfwWindow;
@@ -1066,7 +1066,7 @@ namespace Donut
         return true;
     }
 
-    bool VulkanRenderer::init_im_gui()
+    auto VulkanRenderer::init_im_gui() -> bool
     {
         Impl& v = *m_impl;
         if (v.device == VK_NULL_HANDLE) return false;
@@ -1110,13 +1110,13 @@ namespace Donut
         return true;
     }
 
-    void VulkanRenderer::on_resize(int width, int height)
+    auto VulkanRenderer::on_resize(int width, int height) -> void
     {
         m_impl->framebuffer_resized = true;
         m_impl->width = width; m_impl->height = height;
     }
 
-    void VulkanRenderer::draw_frame(const glm::vec4& clear_color, const std::function<void()>& build_ui)
+    auto VulkanRenderer::draw_frame(const glm::vec4& clear_color, const std::function<void()>& build_ui) -> void
     {
         Impl& v = *m_impl;
         if (v.device == VK_NULL_HANDLE) return;
@@ -1183,7 +1183,7 @@ namespace Donut
         v.current_frame = (v.current_frame + 1) % MAX_FRAMES_IN_FLIGHT;
     }
 
-    void VulkanRenderer::shutdown()
+    auto VulkanRenderer::shutdown() -> void
     {
         Impl& v = *m_impl;
         if (v.device == VK_NULL_HANDLE) { if (v.instance && v.surface) { vkDestroySurfaceKHR(v.instance, v.surface, nullptr); v.surface = VK_NULL_HANDLE; } if (v.instance) { vkDestroyInstance(v.instance, nullptr); v.instance = VK_NULL_HANDLE; } return; }
diff --git a/src/platform/vulkan/vulkan_renderer.h b/src/platform/vulkan/vulkan_renderer.h
index 0bf2395..3ea330d 100644
--- a/src/platform/vulkan/vulkan_renderer.h
+++ b/src/platform/vulkan/vulkan_renderer.h
@@ -5,7 +5,7 @@
 
 namespace Donut
 {
-    void vulkan_prepare_glfw();
+    auto vulkan_prepare_glfw() -> void;
 
     class VulkanRenderer
     {
@@ -13,14 +13,14 @@ namespace Donut
         VulkanRenderer();
         ~VulkanRenderer();
 
-        bool init(void* glfwWindow, int width, int height);
-        void shutdown();
+        auto init(void* glfwWindow, int width, int height) -> bool;
+        auto shutdown() -> void;
 
-        bool init_im_gui();
+        auto init_im_gui() -> bool;
 
-        void draw_frame(const glm::vec4& clear_color, const std::function<void()>& build_ui = {});
+        auto draw_frame(const glm::vec4& clearColor, const std::function<void()>& buildUI = {}) -> void;
 
-        void on_resize(int width, int height);
+        auto on_resize(int width, int height) -> void;
 
     private:
         struct Impl;
diff --git a/src/platform/vulkan/vulkan_renderer_api.cpp b/src/platform/vulkan/vulkan_renderer_api.cpp
index 00344fb..006d662 100644
--- a/src/platform/vulkan/vulkan_renderer_api.cpp
+++ b/src/platform/vulkan/vulkan_renderer_api.cpp
@@ -2,64 +2,64 @@
 
 namespace Donut
 {
-    void VulkanRendererAPI::init()
+    auto VulkanRendererAPI::init() -> void
     {
     }
 
-    void VulkanRendererAPI::set_viewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
+    auto VulkanRendererAPI::set_viewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height) -> void
     {
     }
 
-    void VulkanRendererAPI::set_clear_color(const glm::vec4& color)
+    auto VulkanRendererAPI::set_clear_color(const glm::vec4& color) -> void
     {
     }
 
-    void VulkanRendererAPI::clear()
+    auto VulkanRendererAPI::clear() -> void
     {
     }
 
-    void VulkanRendererAPI::enable_depth_test()
+    auto VulkanRendererAPI::enable_depth_test() -> void
     {
     }
 
-    void VulkanRendererAPI::disable_depth_test()
+    auto VulkanRendererAPI::disable_depth_test() -> void
     {
     }
 
-    void VulkanRendererAPI::set_face_culling(bool enabled)
+    auto VulkanRendererAPI::set_face_culling(bool enabled) -> void
     {
     }
 
-    void VulkanRendererAPI::enable_blending()
+    auto VulkanRendererAPI::enable_blending() -> void
     {
     }
 
-    void VulkanRendererAPI::disable_blending()
+    auto VulkanRendererAPI::disable_blending() -> void
     {
     }
 
-    void VulkanRendererAPI::draw_indexed(const Ref<VertexArray>& vertex_array, uint32_t index_count)
+    auto VulkanRendererAPI::draw_indexed(const Ref<VertexArray>& vertex_array, uint32_t index_count) -> void
     {
     }
 
-    void VulkanRendererAPI::draw_arrays(uint32_t vertex_count, uint32_t first)
+    auto VulkanRendererAPI::draw_arrays(uint32_t vertex_count, uint32_t first) -> void
     {
     }
 
-    void VulkanRendererAPI::draw_lines(const Ref<VertexArray>& vertex_array, uint32_t index_count)
+    auto VulkanRendererAPI::draw_lines(const Ref<VertexArray>& vertex_array, uint32_t index_count) -> void
     {
     }
 
-    void VulkanRendererAPI::bind_texture(uint32_t texture_id, uint32_t slot)
+    auto VulkanRendererAPI::bind_texture(uint32_t texture_id, uint32_t slot) -> void
     {
     }
 
-    void VulkanRendererAPI::bind_image_texture(uint32_t texture_id, uint32_t slot, bool read_only)
+    auto VulkanRendererAPI::bind_image_texture(uint32_t texture_id, uint32_t slot, bool read_only) -> void
     {
     }
 
-    void VulkanRendererAPI::read_pixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height, 
-                                       uint32_t format, uint32_t type, void* pixels)
+    auto VulkanRendererAPI::read_pixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height, 
+                                       uint32_t format, uint32_t type, void* pixels) -> void
     {
     }
 };
diff --git a/src/platform/vulkan/vulkan_renderer_api.h b/src/platform/vulkan/vulkan_renderer_api.h
index 72ea60a..15bf76d 100644
--- a/src/platform/vulkan/vulkan_renderer_api.h
+++ b/src/platform/vulkan/vulkan_renderer_api.h
@@ -9,16 +9,16 @@ namespace Donut
         : public RendererAPI
     {
     public:
-        virtual void init()                                       override;
+        virtual auto init() -> void override;
         virtual void set_viewport(uint32_t x,     uint32_t y, 
                                  uint32_t width, uint32_t height) override;
-        virtual void set_clear_color(const glm::vec4& color)        override;
-        virtual void clear()                                      override;
-        virtual void enable_depth_test()                            override;
-        virtual void disable_depth_test()                           override;
-        virtual void set_face_culling(bool enabled)                 override;
-        virtual void enable_blending()                             override;
-        virtual void disable_blending()                            override;
+        virtual auto set_clear_color(const glm::vec4& color) -> void override;
+        virtual auto clear() -> void override;
+        virtual auto enable_depth_test() -> void override;
+        virtual auto disable_depth_test() -> void override;
+        virtual auto set_face_culling(bool enabled) -> void override;
+        virtual auto enable_blending() -> void override;
+        virtual auto disable_blending() -> void override;
 
         virtual void draw_indexed(const Ref<VertexArray>& vertex_array, 
                                  uint32_t index_count = 0)         override;
diff --git a/src/platform/vulkan/vulkan_shader.cpp b/src/platform/vulkan/vulkan_shader.cpp
index 6572dae..30968cf 100644
--- a/src/platform/vulkan/vulkan_shader.cpp
+++ b/src/platform/vulkan/vulkan_shader.cpp
@@ -23,97 +23,97 @@ namespace Donut
 	{
 	}
 
-	void VulkanShader::bind() const
+	auto VulkanShader::bind() const -> void
 	{
 	}
 
-	void VulkanShader::unbind() const
+	auto VulkanShader::unbind() const -> void
 	{
 	}
 
-	void VulkanShader::set_int(const std::string& name, int value)
+	auto VulkanShader::set_int(const std::string& name, int value) -> void
 	{
 	}
 
-	void VulkanShader::set_int_array(const std::string& name, int* values, uint32_t count)
+	auto VulkanShader::set_int_array(const std::string& name, int* values, uint32_t count) -> void
 	{
 	}
 
-	void VulkanShader::set_float(const std::string& name, float value)
+	auto VulkanShader::set_float(const std::string& name, float value) -> void
 	{
 	}
 
-	void VulkanShader::set_float2(const std::string& name, const glm::vec2& value)
+	auto VulkanShader::set_float2(const std::string& name, const glm::vec2& value) -> void
 	{
 	}
 
-	void VulkanShader::set_float3(const std::string& name, const glm::vec3& value)
+	auto VulkanShader::set_float3(const std::string& name, const glm::vec3& value) -> void
 	{
 	}
 
-	void VulkanShader::set_float4(const std::string& name, const glm::vec4& value)
+	auto VulkanShader::set_float4(const std::string& name, const glm::vec4& value) -> void
 	{
 	}
 
-	void VulkanShader::set_mat4(const std::string& name, const glm::mat4& value)
+	auto VulkanShader::set_mat4(const std::string& name, const glm::mat4& value) -> void
 	{
 	}
 
-	void VulkanShader::dispatch(uint32_t x, uint32_t y, uint32_t z)
+	auto VulkanShader::dispatch(uint32_t x, uint32_t y, uint32_t z) -> void
 	{
 	}
 
-	void VulkanShader::dispatch_indirect(uint32_t offset)
+	auto VulkanShader::dispatch_indirect(uint32_t offset) -> void
 	{
 	}
 
-	void VulkanShader::memory_barrier(uint32_t barriers)
+	auto VulkanShader::memory_barrier(uint32_t barriers) -> void
 	{
 	}
 
-	void VulkanShader::upload_uniform_int(const std::string& name, int value)
+	auto VulkanShader::upload_uniform_int(const std::string& name, int value) -> void
 	{
 	}
 
-	void VulkanShader::upload_uniform_int_array(const std::string& name, int* values, uint32_t count)
+	auto VulkanShader::upload_uniform_int_array(const std::string& name, int* values, uint32_t count) -> void
 	{
 	}
 
-	void VulkanShader::upload_uniform_float(const std::string& name, float value)
+	auto VulkanShader::upload_uniform_float(const std::string& name, float value) -> void
 	{
 	}
 
-	void VulkanShader::upload_uniform_float2(const std::string& name, const glm::vec2& value)
+	auto VulkanShader::upload_uniform_float2(const std::string& name, const glm::vec2& value) -> void
 	{
 	}
 
-	void VulkanShader::upload_uniform_float3(const std::string& name, const glm::vec3& value)
+	auto VulkanShader::upload_uniform_float3(const std::string& name, const glm::vec3& value) -> void
 	{
 	}
 
-	void VulkanShader::upload_uniform_float4(const std::string& name, const glm::vec4& value)
+	auto VulkanShader::upload_uniform_float4(const std::string& name, const glm::vec4& value) -> void
 	{
 	}
 
-	void VulkanShader::upload_uniform_mat3(const std::string& name, const glm::mat3& matrix)
+	auto VulkanShader::upload_uniform_mat3(const std::string& name, const glm::mat3& matrix) -> void
 	{
 	}
 
-	void VulkanShader::upload_uniform_mat4(const std::string& name, const glm::mat4& matrix)
+	auto VulkanShader::upload_uniform_mat4(const std::string& name, const glm::mat4& matrix) -> void
 	{
 	}
 
-	std::string VulkanShader::read_file(const std::string& filepath)
+	auto VulkanShader::read_file(const std::string& filepath) -> std::string
 	{
 		return "";
 	}
 
-	std::unordered_map<uint32_t, std::string> VulkanShader::pre_process(const std::string& source)
+	auto VulkanShader::pre_process(const std::string& source) -> std::unordered_map<uint32_t, std::string>
 	{
 		return {};
 	}
 
-	void VulkanShader::compile(const std::unordered_map<uint32_t, std::string>& shader_sources)
+	auto VulkanShader::compile(const std::unordered_map<uint32_t, std::string>& shader_sources) -> void
 	{
 	}
 };
diff --git a/src/platform/vulkan/vulkan_shader.h b/src/platform/vulkan/vulkan_shader.h
index 1619522..9453130 100644
--- a/src/platform/vulkan/vulkan_shader.h
+++ b/src/platform/vulkan/vulkan_shader.h
@@ -16,36 +16,36 @@ namespace Donut
 		VulkanShader(const std::string& name, const std::string& compute_src);
 		virtual ~VulkanShader();
 
-		virtual void bind()   const override;
-		virtual void unbind() const override;
+		virtual auto bind() const -> void override;
+		virtual auto unbind() const -> void override;
 
-		virtual void set_int(const std::string& name, int value)                        override;
-		virtual void set_int_array(const std::string& name, int* values, uint32_t count) override;
-		virtual void set_float(const std::string& name, float value)                    override;
-		virtual void set_float2(const std::string& name, const glm::vec2& value)        override;
-		virtual void set_float3(const std::string& name, const glm::vec3& value)        override;
-		virtual void set_float4(const std::string& name, const glm::vec4& value)        override;
-		virtual void set_mat4(const std::string& name, const glm::mat4& value)          override;
+		virtual auto set_int(const std::string& name, int value) -> void override;
+		virtual auto set_int_array(const std::string& name, int* values, uint32_t count) -> void override;
+		virtual auto set_float(const std::string& name, float value) -> void override;
+		virtual auto set_float2(const std::string& name, const glm::vec2& value) -> void override;
+		virtual auto set_float3(const std::string& name, const glm::vec3& value) -> void override;
+		virtual auto set_float4(const std::string& name, const glm::vec4& value) -> void override;
+		virtual auto set_mat4(const std::string& name, const glm::mat4& value) -> void override;
 
-		virtual void dispatch(uint32_t x, uint32_t y = 1, uint32_t z = 1) override;
-		virtual void dispatch_indirect(uint32_t offset = 0)                override;
-		virtual void memory_barrier(uint32_t barriers)                     override;
+		virtual auto dispatch(uint32_t x, uint32_t y = 1, uint32_t z = 1) -> void override;
+		virtual auto dispatch_indirect(uint32_t offset = 0) -> void override;
+		virtual auto memory_barrier(uint32_t barriers) -> void override;
 
-		virtual const std::string& get_name() const override { return m_name; }
-	virtual uint32_t get_renderer_id() const override { return m_renderer_id; }
+		virtual auto get_name() const -> const std::string& override{ return m_name; }
+	virtual auto get_renderer_id() const -> uint32_t override{ return m_renderer_id; }
 
-		void upload_uniform_int(const std::string& name, int value);
-		void upload_uniform_int_array(const std::string& name, int* values, uint32_t count);
-		void upload_uniform_float(const std::string& name, float value);
-		void upload_uniform_float2(const std::string& name, const glm::vec2& value);
-		void upload_uniform_float3(const std::string& name, const glm::vec3& value);
-		void upload_uniform_float4(const std::string& name, const glm::vec4& value);
-		void upload_uniform_mat3(const std::string& name, const glm::mat3& matrix);
-		void upload_uniform_mat4(const std::string& name, const glm::mat4& matrix);
+		auto upload_uniform_int(const std::string& name, int value) -> void;
+		auto upload_uniform_int_array(const std::string& name, int* values, uint32_t count) -> void;
+		auto upload_uniform_float(const std::string& name, float value) -> void;
+		auto upload_uniform_float2(const std::string& name, const glm::vec2& value) -> void;
+		auto upload_uniform_float3(const std::string& name, const glm::vec3& value) -> void;
+		auto upload_uniform_float4(const std::string& name, const glm::vec4& value) -> void;
+		auto upload_uniform_mat3(const std::string& name, const glm::mat3& matrix) -> void;
+		auto upload_uniform_mat4(const std::string& name, const glm::mat4& matrix) -> void;
 	private:
-		std::string read_file(const std::string& filepath);
-		std::unordered_map<uint32_t, std::string> pre_process(const std::string& source);
-		void compile(const std::unordered_map<uint32_t, std::string>& shader_sources);
+		auto read_file(const std::string& filepath) -> std::string;
+		auto pre_process(const std::string& source) -> std::unordered_map<uint32_t, std::string>;
+		auto compile(const std::unordered_map<uint32_t, std::string>& shader_sources) -> void;
 		uint32_t    m_renderer_id;
 		std::string m_name;
 	};
diff --git a/src/platform/vulkan/vulkan_texture.cpp b/src/platform/vulkan/vulkan_texture.cpp
index d2b1e20..adbdb68 100644
--- a/src/platform/vulkan/vulkan_texture.cpp
+++ b/src/platform/vulkan/vulkan_texture.cpp
@@ -24,15 +24,15 @@ namespace Donut
 	{
 	}
 
-	void VulkanTexture2D::set_data(void* data, uint32_t size)
+	auto VulkanTexture2D::set_data(void* data, uint32_t size) -> void
 	{
 	}
 
-	void VulkanTexture2D::bind(uint32_t slot) const
+	auto VulkanTexture2D::bind(uint32_t slot) const -> void
 	{
 	}
 
-	void VulkanTexture2D::bind_as_image(uint32_t slot, bool read_only) const
+	auto VulkanTexture2D::bind_as_image(uint32_t slot, bool read_only) const -> void
 	{
 	}
 
@@ -58,15 +58,15 @@ namespace Donut
 	{
 	}
 
-	void VulkanCubemapTexture::set_data(void* data, uint32_t size)
+	auto VulkanCubemapTexture::set_data(void* data, uint32_t size) -> void
 	{
 	}
 
-	void VulkanCubemapTexture::bind(uint32_t slot) const
+	auto VulkanCubemapTexture::bind(uint32_t slot) const -> void
 	{
 	}
 
-	void VulkanCubemapTexture::bind_as_image(uint32_t slot, bool read_only) const
+	auto VulkanCubemapTexture::bind_as_image(uint32_t slot, bool read_only) const -> void
 	{
 	}
 };
diff --git a/src/platform/vulkan/vulkan_texture.h b/src/platform/vulkan/vulkan_texture.h
index d1b5dc3..ea8471b 100644
--- a/src/platform/vulkan/vulkan_texture.h
+++ b/src/platform/vulkan/vulkan_texture.h
@@ -12,13 +12,13 @@ namespace Donut
 		VulkanTexture2D(const std::string& path);
 		virtual ~VulkanTexture2D();
 
-		virtual uint32_t get_width()      const override { return m_width; }
-		virtual uint32_t get_height()     const override { return m_height; }
-		virtual uint32_t get_renderer_id() const override { return m_renderer_id; }
+		virtual auto get_width() const -> uint32_t override{ return m_width; }
+		virtual auto get_height() const -> uint32_t override{ return m_height; }
+		virtual auto get_renderer_id() const -> uint32_t override{ return m_renderer_id; }
 
-		virtual void set_data(void* data, uint32_t size) override;
-		virtual void bind(uint32_t slot = 0) const override;
-		virtual void bind_as_image(uint32_t slot = 0, bool read_only = false) const override;
+		virtual auto set_data(void* data, uint32_t size) -> void override;
+		virtual auto bind(uint32_t slot = 0) const -> void override;
+		virtual auto bind_as_image(uint32_t slot = 0, bool read_only = false) const -> void override;
 
 		virtual bool operator==(const Texture& other) const override
 		{
@@ -39,13 +39,13 @@ namespace Donut
 		VulkanCubemapTexture(const std::string& path);
 		virtual ~VulkanCubemapTexture();
 
-		virtual uint32_t get_width()      const override { return m_width;      }
-		virtual uint32_t get_height()     const override { return m_height;     }
-		virtual uint32_t get_renderer_id() const override { return m_renderer_id; }
+		virtual auto get_width() const -> uint32_t override{ return m_width;      }
+		virtual auto get_height() const -> uint32_t override{ return m_height;     }
+		virtual auto get_renderer_id() const -> uint32_t override{ return m_renderer_id; }
 
-		virtual void set_data(void* data, uint32_t size)                          override;
-		virtual void bind(uint32_t slot = 0)                               const override;
-		virtual void bind_as_image(uint32_t slot = 0, bool read_only = false) const override;
+		virtual auto set_data(void* data, uint32_t size) -> void override;
+		virtual auto bind(uint32_t slot = 0) const -> void override;
+		virtual auto bind_as_image(uint32_t slot = 0, bool read_only = false) const -> void override;
 
 		virtual bool operator==(const Texture& other) const override
 		{
diff --git a/src/platform/vulkan/vulkan_uniform_buffer.cpp b/src/platform/vulkan/vulkan_uniform_buffer.cpp
index 6fafeee..bcbc991 100644
--- a/src/platform/vulkan/vulkan_uniform_buffer.cpp
+++ b/src/platform/vulkan/vulkan_uniform_buffer.cpp
@@ -11,11 +11,11 @@ namespace Donut
     {
     }
 
-    void VulkanUniformBuffer::set_data(const void* data, uint32_t size, uint32_t offset)
+    auto VulkanUniformBuffer::set_data(const void* data, uint32_t size, uint32_t offset) -> void
     {
     }
 
-    void VulkanUniformBuffer::bind(uint32_t binding)
+    auto VulkanUniformBuffer::bind(uint32_t binding) -> void
     {
     }
 };
diff --git a/src/platform/vulkan/vulkan_uniform_buffer.h b/src/platform/vulkan/vulkan_uniform_buffer.h
index 8dd7686..7d9ad0a 100644
--- a/src/platform/vulkan/vulkan_uniform_buffer.h
+++ b/src/platform/vulkan/vulkan_uniform_buffer.h
@@ -10,8 +10,8 @@ namespace Donut
         VulkanUniformBuffer(uint32_t size, uint32_t binding);
         virtual ~VulkanUniformBuffer();
 
-        virtual void set_data(const void* data, uint32_t size, uint32_t offset = 0) override;
-        virtual void bind(uint32_t binding)                                        override;
+        virtual auto set_data(const void* data, uint32_t size, uint32_t offset = 0) -> void override;
+        virtual auto bind(uint32_t binding) -> void override;
     private:
         uint32_t m_size;
         uint32_t m_binding;
diff --git a/src/platform/vulkan/vulkan_vertex_array.cpp b/src/platform/vulkan/vulkan_vertex_array.cpp
index 8258696..69f4679 100644
--- a/src/platform/vulkan/vulkan_vertex_array.cpp
+++ b/src/platform/vulkan/vulkan_vertex_array.cpp
@@ -10,20 +10,20 @@ namespace Donut
 	{
 	}
 
-	void VulkanVertexArray::bind() const
+	auto VulkanVertexArray::bind() const -> void
 	{
 	}
 
-	void VulkanVertexArray::unbind() const
+	auto VulkanVertexArray::unbind() const -> void
 	{
 	}
 
-	void VulkanVertexArray::add_vertex_buffer(const Ref<VertexBuffer>& vertex_buffer)
+	auto VulkanVertexArray::add_vertex_buffer(const Ref<VertexBuffer>& vertex_buffer) -> void
 	{
 		m_vertex_buffers.push_back(vertex_buffer);
 	}
 
-	void VulkanVertexArray::set_index_buffer(const Ref<IndexBuffer>& index_buffer)
+	auto VulkanVertexArray::set_index_buffer(const Ref<IndexBuffer>& index_buffer) -> void
 	{
 		m_index_buffer = index_buffer;
 	}
diff --git a/src/platform/vulkan/vulkan_vertex_array.h b/src/platform/vulkan/vulkan_vertex_array.h
index f4356d9..0d282a2 100644
--- a/src/platform/vulkan/vulkan_vertex_array.h
+++ b/src/platform/vulkan/vulkan_vertex_array.h
@@ -12,14 +12,14 @@ namespace Donut
 		VulkanVertexArray();
 		virtual ~VulkanVertexArray();
 
-		virtual void bind()   const override;
-		virtual void unbind() const override;
+		virtual auto bind() const -> void override;
+		virtual auto unbind() const -> void override;
 
-		virtual void add_vertex_buffer(const Ref<VertexBuffer>& vertex_buffer) override;
-		virtual void set_index_buffer(const Ref<IndexBuffer>& index_buffer)   override;
+		virtual auto add_vertex_buffer(const Ref<VertexBuffer>& vertex_buffer) -> void override;
+		virtual auto set_index_buffer(const Ref<IndexBuffer>& index_buffer) -> void override;
 
-		virtual const std::vector<Ref<VertexBuffer>>& get_vertex_buffers() const { return m_vertex_buffers; }
-		virtual const Ref<IndexBuffer>& get_index_buffer()                 const { return m_index_buffer;   }
+		virtual auto get_vertex_buffers() const -> const std::vector<Ref<VertexBuffer>>& { return m_vertex_buffers; }
+		virtual auto get_index_buffer() const -> const Ref<IndexBuffer>& { return m_index_buffer;   }
 	private:
 		uint32_t                                   m_renderer_id;
 		std::vector<Ref<VertexBuffer>> m_vertex_buffers;
diff --git a/src/platform/vulkan/vulkan_vertex_buffer.cpp b/src/platform/vulkan/vulkan_vertex_buffer.cpp
index a5906f8..608e044 100644
--- a/src/platform/vulkan/vulkan_vertex_buffer.cpp
+++ b/src/platform/vulkan/vulkan_vertex_buffer.cpp
@@ -14,15 +14,15 @@ namespace Donut
 	{
 	}
 
-	void VulkanVertexBuffer::bind() const
+	auto VulkanVertexBuffer::bind() const -> void
 	{
 	}
 
-	void VulkanVertexBuffer::unbind() const
+	auto VulkanVertexBuffer::unbind() const -> void
 	{
 	}
 
-	void VulkanVertexBuffer::set_data(const void* data, uint32_t size)
+	auto VulkanVertexBuffer::set_data(const void* data, uint32_t size) -> void
 	{
 	}
 };
diff --git a/src/platform/vulkan/vulkan_vertex_buffer.h b/src/platform/vulkan/vulkan_vertex_buffer.h
index 4c6f124..3218021 100644
--- a/src/platform/vulkan/vulkan_vertex_buffer.h
+++ b/src/platform/vulkan/vulkan_vertex_buffer.h
@@ -12,13 +12,13 @@ namespace Donut
 		VulkanVertexBuffer(float* vertices, uint32_t size);
 		virtual ~VulkanVertexBuffer();
 
-		virtual void bind()   const override;
-		virtual void unbind() const override;
+		virtual auto bind() const -> void override;
+		virtual auto unbind() const -> void override;
 
-		virtual void set_data(const void* data, uint32_t size) override;
+		virtual auto set_data(const void* data, uint32_t size) -> void override;
 
-		virtual const VertexBufferLayout& get_layout()      const override { return m_layout;  }
-		virtual void set_layout(const VertexBufferLayout& layout) override { m_layout = layout; }
+		virtual auto get_layout() const -> const VertexBufferLayout& override{ return m_layout;  }
+		virtual auto set_layout(const VertexBufferLayout& layout) -> void override{ m_layout = layout; }
 	private:
 		uint32_t           m_renderer_id;
 		VertexBufferLayout m_layout;