feat: start of a basic rendering backend

1 files changed, 224 insertions, 0 deletions

diff --git a/src/platform/opengl/opengl_shader.cpp b/src/platform/opengl/opengl_shader.cpp
new file mode 100644
index 0000000..e2e6279
--- /dev/null
+++ b/src/platform/opengl/opengl_shader.cpp
@@ -0,0 +1,224 @@
+#include "opengl_shader.h"
+#include <glad/glad.h>
+#include <glm/gtc/type_ptr.hpp>
+#include <fstream>
+#include <iostream>
+
+namespace Donut
+{
+    static uint32_t ShaderTypeFromString(const std::string& type)
+    {
+        if (type == "vertex")
+            return GL_VERTEX_SHADER;
+        if (type == "fragment" || type == "pixel")
+            return GL_FRAGMENT_SHADER;
+        return 0;
+    }
+
+    OpenGLShader::OpenGLShader(const std::string& filepath)
+    {
+        std::string source = read_file(filepath);
+        auto shader_sources = pre_process(source);
+        compile(shader_sources);
+
+        auto last_slash = filepath.find_last_of("/\\");
+        last_slash = last_slash == std::string::npos ? 0 : last_slash + 1;
+        auto last_dot = filepath.rfind('.');
+        auto count = last_dot == std::string::npos ? filepath.size() - last_slash : last_dot - last_slash;
+        m_name = filepath.substr(last_slash, count);
+    }
+
+    OpenGLShader::OpenGLShader(const std::string& name, const std::string& vertex_src, const std::string& fragment_src)
+        : m_name(name) 
+    {
+        std::unordered_map<uint32_t, std::string> sources;
+        sources[GL_VERTEX_SHADER] = vertex_src;
+        sources[GL_FRAGMENT_SHADER] = fragment_src;
+        compile(sources);
+    }
+
+    OpenGLShader::~OpenGLShader()
+    {
+        glDeleteProgram(m_renderer_id);
+    }
+
+    std::string OpenGLShader::read_file(const std::string& filepath)
+    {
+        std::string result;
+        std::ifstream in(filepath, std::ios::in | std::ios::binary);
+        if (in) {
+            in.seekg(0, std::ios::end);
+            size_t size = in.tellg();
+            if (size != -1) {
+                result.resize(size);
+                in.seekg(0, std::ios::beg);
+                in.read(&result[0], size);
+            }
+        }
+        return result;
+    }
+
+    std::unordered_map<uint32_t, std::string> OpenGLShader::pre_process(const std::string& source)
+    {
+        std::unordered_map<uint32_t, std::string> shader_sources;
+
+        const char* type_token = "#type";
+        size_t type_token_length = strlen(type_token);
+        size_t pos = source.find(type_token, 0);
+        while (pos != std::string::npos) {
+            size_t eol = source.find_first_of("\r\n", pos);
+            size_t begin = pos + type_token_length + 1;
+            std::string type = source.substr(begin, eol - begin);
+
+            size_t next_line_pos = source.find_first_not_of("\r\n", eol);
+            pos = source.find(type_token, next_line_pos);
+            shader_sources[ShaderTypeFromString(type)] = (pos == std::string::npos) ? source.substr(next_line_pos) : 
+            source.substr(next_line_pos, pos - next_line_pos);
+        }
+
+        return shader_sources;
+    }
+
+    void OpenGLShader::compile(const std::unordered_map<uint32_t, std::string>& shader_sources)
+    {
+        uint32_t program = glCreateProgram();
+        std::vector<uint32_t> glShaderIDs(shader_sources.size());
+        for (auto& kv : shader_sources)
+        {
+            uint32_t type = kv.first;
+            const std::string& source = kv.second;
+
+            uint32_t shader = glCreateShader(type);
+            const char* source_c_str = source.c_str();
+            glShaderSource(shader, 1, &source_c_str, 0);
+            glCompileShader(shader);
+
+            int is_compiled = 0;
+            glGetShaderiv(shader, GL_COMPILE_STATUS, &is_compiled);
+            if (is_compiled == GL_FALSE)
+            {
+                int max_length = 0;
+                glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &max_length);
+                std::vector<char> info_log(max_length);
+                glGetShaderInfoLog(shader, max_length, &max_length, &info_log[0]);
+                glDeleteShader(shader);
+                std::cout << "Shader compilation failure!" << std::endl << info_log.data() << std::endl;
+                return;
+            }
+            glAttachShader(program, shader);
+            glShaderIDs.push_back(shader);
+        }
+
+        m_renderer_id = program;
+        glLinkProgram(m_renderer_id);
+
+        int is_linked = 0;
+        glGetProgramiv(m_renderer_id, GL_LINK_STATUS, (int*)&is_linked);
+        if (is_linked == GL_FALSE)
+        {
+            int max_length = 0;
+            glGetProgramiv(m_renderer_id, GL_INFO_LOG_LENGTH, &max_length);
+            std::vector<char> info_log(max_length);
+            glGetProgramInfoLog(m_renderer_id, max_length, &max_length, &info_log[0]);
+            glDeleteProgram(m_renderer_id);
+            for (auto id : glShaderIDs)
+                glDeleteShader(id);
+            std::cout << "Shader link failure!" << std::endl << info_log.data() << std::endl;
+            return;
+        }
+
+        for (auto id : glShaderIDs)
+        {
+            glDetachShader(m_renderer_id, id);
+            glDeleteShader(id);
+        }
+    }
+
+    void OpenGLShader::bind() const
+    {
+        glUseProgram(m_renderer_id);
+    }
+
+    void OpenGLShader::unbind() const
+    {
+        glUseProgram(0);
+    }
+
+    void OpenGLShader::set_int(const std::string& name, int value)
+    {
+        upload_uniform_int(name, value);
+    }
+
+    void OpenGLShader::set_int_array(const std::string& name, int* values, uint32_t count)
+    {
+        upload_uniform_int_array(name, values, count);
+    }
+
+    void OpenGLShader::set_float(const std::string& name, float value)
+    {
+        upload_uniform_float(name, value);
+    }
+
+    void OpenGLShader::set_float3(const std::string& name, const glm::vec3& value)
+    {
+        upload_uniform_float3(name, value);
+    }
+
+    void OpenGLShader::set_float4(const std::string& name, const glm::vec4& value)
+    {
+        upload_uniform_float4(name, value);
+    }
+
+    void OpenGLShader::set_mat4(const std::string& name, const glm::mat4& value)
+    {
+        upload_uniform_mat4(name, value);
+    }
+
+    void OpenGLShader::upload_uniform_int(const std::string& name, int value)
+    {
+        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)
+    {
+        int location = glGetUniformLocation(m_renderer_id, name.c_str());
+        glUniform1iv(location, count, values);
+    }
+
+    void OpenGLShader::upload_uniform_float(const std::string& name, float value)
+    {
+        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) 
+    {
+        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) 
+    {
+        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) 
+    {
+        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) 
+    {
+        int location = glGetUniformLocation(m_renderer_id, name.c_str());
+        glUniformMatrix3fv(location, 1, GL_FALSE, glm::value_ptr(matrix));
+    }
+
+    void OpenGLShader::upload_uniform_mat4(const std::string& name, const glm::mat4& matrix) 
+    {
+        int location = glGetUniformLocation(m_renderer_id, name.c_str());
+        glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(matrix));
+    }
+};