refactor: trailing return types in the OpenGL and Metal backends

1 files changed, 23 insertions, 23 deletions

diff --git a/src/platform/opengl/opengl_shader.cpp b/src/platform/opengl/opengl_shader.cpp
index e7c3d6a..c233bd6 100644
--- a/src/platform/opengl/opengl_shader.cpp
+++ b/src/platform/opengl/opengl_shader.cpp
@@ -71,7 +71,7 @@ namespace Donut
         glDeleteProgram(m_renderer_id);
     }
 
-    std::string OpenGLShader::read_file(const std::string& filepath)
+    auto OpenGLShader::read_file(const std::string& filepath) -> std::string
     {
         std::string result;
         std::ifstream in(filepath, std::ios::in |
@@ -91,7 +91,7 @@ namespace Donut
         return result;
     }
 
-    std::unordered_map<uint32_t, std::string> OpenGLShader::pre_process(const std::string& source)
+    auto OpenGLShader::pre_process(const std::string& source) -> std::unordered_map<uint32_t, std::string>
     {
         std::unordered_map<uint32_t, std::string> shader_sources;
 
@@ -114,7 +114,7 @@ namespace Donut
         return shader_sources;
     }
 
-    void OpenGLShader::compile(const std::unordered_map<uint32_t, std::string>& shader_sources)
+    auto OpenGLShader::compile(const std::unordered_map<uint32_t, std::string>& shader_sources) -> void
     {
         uint32_t program = glCreateProgram();
         std::vector<uint32_t> glShaderIDs(shader_sources.size());
@@ -176,114 +176,114 @@ namespace Donut
         }
     }
 
-    void OpenGLShader::bind() const
+    auto OpenGLShader::bind() const -> void
     {
         glUseProgram(m_renderer_id);
     }
 
-    void OpenGLShader::unbind() const
+    auto OpenGLShader::unbind() const -> void
     {
         glUseProgram(0);
     }
 
-    void OpenGLShader::set_int(const std::string& name, int value)
+    auto OpenGLShader::set_int(const std::string& name, int value) -> void
     {
         upload_uniform_int(name, value);
     }
 
-    void OpenGLShader::set_int_array(const std::string& name, int* values, uint32_t count)
+    auto OpenGLShader::set_int_array(const std::string& name, int* values, uint32_t count) -> void
     {
         upload_uniform_int_array(name, values, count);
     }
 
-    void OpenGLShader::set_float(const std::string& name, float value)
+    auto OpenGLShader::set_float(const std::string& name, float value) -> void
     {
         upload_uniform_float(name, value);
     }
 
-    void OpenGLShader::set_float2(const std::string& name, const glm::vec2& value)
+    auto OpenGLShader::set_float2(const std::string& name, const glm::vec2& value) -> void
     {
         upload_uniform_float2(name, value);
     }
 
-    void OpenGLShader::set_float3(const std::string& name, const glm::vec3& value)
+    auto OpenGLShader::set_float3(const std::string& name, const glm::vec3& value) -> void
     {
         upload_uniform_float3(name, value);
     }
 
-    void OpenGLShader::set_float4(const std::string& name, const glm::vec4& value)
+    auto OpenGLShader::set_float4(const std::string& name, const glm::vec4& value) -> void
     {
         upload_uniform_float4(name, value);
     }
 
-    void OpenGLShader::set_mat4(const std::string& name, const glm::mat4& value)
+    auto OpenGLShader::set_mat4(const std::string& name, const glm::mat4& value) -> void
     {
         upload_uniform_mat4(name, value);
     }
 
-    void OpenGLShader::upload_uniform_int(const std::string& name, int value)
+    auto OpenGLShader::upload_uniform_int(const std::string& name, int value) -> void
     {
         int location = glGetUniformLocation(m_renderer_id, name.c_str());
         glUniform1i(location, value);
     }
 
-    void OpenGLShader::upload_uniform_int_array(const std::string& name, int* values, uint32_t count)
+    auto OpenGLShader::upload_uniform_int_array(const std::string& name, int* values, uint32_t count) -> void
     {
         int location = glGetUniformLocation(m_renderer_id, name.c_str());
         glUniform1iv(location, count, values);
     }
 
-    void OpenGLShader::upload_uniform_float(const std::string& name, float value)
+    auto OpenGLShader::upload_uniform_float(const std::string& name, float value) -> void
     {
         int location = glGetUniformLocation(m_renderer_id, name.c_str());
         glUniform1f(location, value);
     }
 
-    void OpenGLShader::upload_uniform_float2(const std::string& name, const glm::vec2& value)
+    auto OpenGLShader::upload_uniform_float2(const std::string& name, const glm::vec2& value) -> void
     {
         int location = glGetUniformLocation(m_renderer_id, name.c_str());
         glUniform2f(location, value.x, value.y);
     }
 
-    void OpenGLShader::upload_uniform_float3(const std::string& name, const glm::vec3& value)
+    auto OpenGLShader::upload_uniform_float3(const std::string& name, const glm::vec3& value) -> void
     {
         int location = glGetUniformLocation(m_renderer_id, name.c_str());
         glUniform3f(location, value.x, value.y, value.z);
     }
 
-    void OpenGLShader::upload_uniform_float4(const std::string& name, const glm::vec4& value)
+    auto OpenGLShader::upload_uniform_float4(const std::string& name, const glm::vec4& value) -> void
     {
         int location = glGetUniformLocation(m_renderer_id, name.c_str());
         glUniform4f(location, value.x, value.y, value.z, value.w);
     }
 
-    void OpenGLShader::upload_uniform_mat3(const std::string& name, const glm::mat3& matrix)
+    auto OpenGLShader::upload_uniform_mat3(const std::string& name, const glm::mat3& matrix) -> void
     {
         int location = glGetUniformLocation(m_renderer_id, name.c_str());
         glUniformMatrix3fv(location, 1, m_is_slang ? GL_TRUE : GL_FALSE, glm::value_ptr(matrix));
     }
 
-    void OpenGLShader::upload_uniform_mat4(const std::string& name, const glm::mat4& matrix)
+    auto OpenGLShader::upload_uniform_mat4(const std::string& name, const glm::mat4& matrix) -> void
     {
         int location = glGetUniformLocation(m_renderer_id, name.c_str());
         glUniformMatrix4fv(location, 1, m_is_slang ? GL_TRUE : GL_FALSE, glm::value_ptr(matrix));
     }
 
-    void OpenGLShader::dispatch(uint32_t x, uint32_t y, uint32_t z)
+    auto OpenGLShader::dispatch(uint32_t x, uint32_t y, uint32_t z) -> void
     {
         if (m_renderer_id == 0 || glDispatchCompute == nullptr)
             return;
         glDispatchCompute(x, y, z);
     }
 
-    void OpenGLShader::dispatch_indirect(uint32_t offset)
+    auto OpenGLShader::dispatch_indirect(uint32_t offset) -> void
     {
         if (m_renderer_id == 0 || glDispatchComputeIndirect == nullptr)
             return;
         glDispatchComputeIndirect(offset);
     }
 
-    void OpenGLShader::memory_barrier(uint32_t barriers)
+    auto OpenGLShader::memory_barrier(uint32_t barriers) -> void
     {
         if (glMemoryBarrier == nullptr)
             return;