Triangle

14 files changed, 287 insertions, 1 deletions

diff --git a/src/Binder.cpp b/src/Binder.cpp
new file mode 100644
index 0000000..8f9b7df
--- /dev/null
+++ b/src/Binder.cpp
@@ -0,0 +1,50 @@
+#include <GL/glew.h>
+#include "Binder.hpp"
+#include "Mesh.hpp"
+
+namespace MC {
+
+BindableMesh Binder::load(Mesh& mesh) {
+    auto vao = create_vao();
+    store_in_attribute_list(0, 3, mesh.flat(), mesh.size() * 3);
+    unbind_vao();
+
+    return {vao, mesh.size()};
+}
+
+uint32_t Binder::create_vao() {
+    GLuint vao;
+    glGenVertexArrays(1, &vao);
+    glBindVertexArray(vao);
+
+    return static_cast<uint32_t>(vao);
+}
+
+uint32_t Binder::unbind_vao() {
+    glBindVertexArray(0);
+}
+
+void Binder::store_in_attribute_list(uint32_t attribute, size_t size, float* data, size_t data_size) {
+    GLuint vbo;
+    glGenBuffers(1, &vbo);
+
+    glBindBuffer(GL_ARRAY_BUFFER, vbo);
+    glBufferData(GL_ARRAY_BUFFER, data_size * sizeof(float), data, GL_STATIC_DRAW);
+    glVertexAttribPointer(attribute, size, GL_FLOAT, GL_FALSE, 3 * sizeof(float), nullptr);
+}
+
+void BindableMesh::bind() const {
+    glBindVertexArray(m_vao);
+    glEnableVertexAttribArray(0);
+}
+
+void BindableMesh::unbind() {
+    glBindVertexArray(0);
+    glDisableVertexAttribArray(0);
+}
+
+size_t BindableMesh::size() const {
+    return m_vertex_count;
+}
+
+}
\ No newline at end of file
diff --git a/src/Binder.hpp b/src/Binder.hpp
new file mode 100644
index 0000000..721ec77
--- /dev/null
+++ b/src/Binder.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <cstdint>
+#include "Mesh.hpp"
+
+namespace MC {
+
+class BindableMesh {
+public:
+    void bind() const;
+    void unbind();
+
+    size_t size() const;
+
+private:
+    BindableMesh(uint32_t vao, size_t vertex_count) : m_vao(vao), m_vertex_count(vertex_count) {};
+
+    uint32_t m_vao;
+    size_t m_vertex_count;
+
+    friend class Binder;
+};
+
+class Binder {
+public:
+    Binder() = default;;
+
+    static BindableMesh load(Mesh& mesh);
+
+private:
+    static uint32_t create_vao();
+    static uint32_t unbind_vao();
+
+    static void store_in_attribute_list(uint32_t attribute, size_t size, float* data, size_t data_size);
+};
+
+}
\ No newline at end of file
diff --git a/src/Math/Math.hpp b/src/Math/Math.hpp
new file mode 100644
index 0000000..66ffd36
--- /dev/null
+++ b/src/Math/Math.hpp
@@ -0,0 +1,3 @@
+#pragma once
+
+#include "Vector.hpp"
\ No newline at end of file
diff --git a/src/Math/Vector.hpp b/src/Math/Vector.hpp
new file mode 100644
index 0000000..9c76758
--- /dev/null
+++ b/src/Math/Vector.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+struct Vector3 {
+public:
+    Vector3(float x, float y, float z)
+        : x(x), y(y), z(z) {};
+
+    float x, y, z;
+};
diff --git a/src/Mesh.cpp b/src/Mesh.cpp
new file mode 100644
index 0000000..b8c3315
--- /dev/null
+++ b/src/Mesh.cpp
@@ -0,0 +1,9 @@
+#include "Mesh.hpp"
+
+float* MC::Mesh::flat() {
+    return (float*)m_positions.data();
+}
+
+std::size_t MC::Mesh::size() {
+    return m_positions.size();
+}
diff --git a/src/Mesh.hpp b/src/Mesh.hpp
new file mode 100644
index 0000000..acf4f3b
--- /dev/null
+++ b/src/Mesh.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <utility>
+#include <vector>
+#include <cstdint>
+#include "Math/Math.hpp"
+
+namespace MC {
+
+class Mesh {
+public:
+    Mesh(std::vector<Vector3> positions) : m_positions(std::move(positions)) {};
+
+    std::size_t size();
+    float* flat();
+private:
+    std::vector<Vector3> m_positions;
+};
+
+}
\ No newline at end of file
diff --git a/src/Shader/Shader.cpp b/src/Shader/Shader.cpp
new file mode 100644
index 0000000..0cd6ab3
--- /dev/null
+++ b/src/Shader/Shader.cpp
@@ -0,0 +1,24 @@
+#include <GL/glew.h>
+#include <stdexcept>
+#include "Shader.hpp"
+
+namespace MC {
+
+Shader::Shader(uint32_t type, const char* source) {
+    m_shader = glCreateShader(type);
+
+    glShaderSource(m_shader, 1, &source, nullptr);
+    glCompileShader(m_shader);
+
+    GLint success;
+    glGetShaderiv(m_shader, GL_COMPILE_STATUS, &success);
+    if(!success) {
+        char message[512] = {};
+        glGetShaderInfoLog(m_shader, 512, nullptr, message);
+
+        throw std::runtime_error(message);
+    }
+}
+
+
+}
\ No newline at end of file
diff --git a/src/Shader/Shader.hpp b/src/Shader/Shader.hpp
new file mode 100644
index 0000000..75c4f14
--- /dev/null
+++ b/src/Shader/Shader.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <cstdint>
+#include "ShaderSources.hpp"
+
+namespace MC {
+
+class Shader {
+
+public:
+    uint32_t get() const {
+        return m_shader;
+    }
+
+    static Shader create_vertex() {
+        return {GL_VERTEX_SHADER, ShaderSources::vertex_shader};
+    }
+
+    static Shader create_fragment() {
+        return {GL_FRAGMENT_SHADER, ShaderSources::fragment_shader};
+    }
+
+private:
+    Shader(uint32_t type, const char* source);
+
+    uint32_t m_shader;
+};
+
+}
\ No newline at end of file
diff --git a/src/Shader/ShaderProgram.cpp b/src/Shader/ShaderProgram.cpp
new file mode 100644
index 0000000..854b1bf
--- /dev/null
+++ b/src/Shader/ShaderProgram.cpp
@@ -0,0 +1,32 @@
+#include <GL/glew.h>
+#include <stdexcept>
+#include "ShaderProgram.hpp"
+
+namespace MC {
+
+ShaderProgram::ShaderProgram(Shader fragment, Shader vertex) {
+    m_program = glCreateProgram();
+
+    glAttachShader(m_program, fragment.get());
+    glAttachShader(m_program, vertex.get());
+
+    glLinkProgram(m_program);
+
+    glDeleteShader(fragment.get());
+    glDeleteShader(vertex.get());
+
+    GLint success;
+    glGetProgramiv(m_program, GL_LINK_STATUS, &success);
+    if(!success) {
+        char message[512] = {};
+        glGetProgramInfoLog(m_program, 512, nullptr, message);
+
+        throw std::runtime_error(message);
+    }
+}
+
+void ShaderProgram::bind() const {
+    glUseProgram(m_program);
+}
+
+}
diff --git a/src/Shader/ShaderProgram.hpp b/src/Shader/ShaderProgram.hpp
new file mode 100644
index 0000000..800e3ff
--- /dev/null
+++ b/src/Shader/ShaderProgram.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "Shader.hpp"
+
+namespace MC {
+
+class ShaderProgram {
+public:
+    ShaderProgram(Shader fragment, Shader vertex);
+
+    void bind() const;
+
+    uint32_t get();
+
+private:
+    uint32_t m_program;
+};
+
+}
\ No newline at end of file
diff --git a/src/Shader/ShaderSources.hpp b/src/Shader/ShaderSources.hpp
new file mode 100644
index 0000000..bd413b6
--- /dev/null
+++ b/src/Shader/ShaderSources.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace MC::ShaderSources {
+
+constexpr const char* vertex_shader =
+#include "Generated/vertex.glsl.includable"
+;
+
+constexpr const char* fragment_shader =
+#include "Generated/fragment.glsl.includable"
+;
+
+}
\ No newline at end of file
diff --git a/src/Shader/fragment.glsl b/src/Shader/fragment.glsl
new file mode 100644
index 0000000..017a2c8
--- /dev/null
+++ b/src/Shader/fragment.glsl
@@ -0,0 +1,8 @@
+#version 330 core
+
+out vec4 color;
+
+void main()
+{
+    color = vec4(1.0f, 0.5f, 0.2f, 1.0f);
+}
\ No newline at end of file
diff --git a/src/Shader/vertex.glsl b/src/Shader/vertex.glsl
new file mode 100644
index 0000000..8b1bbbd
--- /dev/null
+++ b/src/Shader/vertex.glsl
@@ -0,0 +1,7 @@
+#version 330 core
+
+in vec3 position;
+
+void main() {
+    gl_Position = vec4(position.x, position.y, position.z, 1.0);
+}
\ No newline at end of file
diff --git a/src/main.cpp b/src/main.cpp
index 91e1b23..d025c91 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -3,6 +3,9 @@
 #include <GLFW/glfw3.h>
 
 #include "Window.hpp"
+#include "Mesh.hpp"
+#include "Binder.hpp"
+#include "Shader/ShaderProgram.hpp"
 
 #define APP_NAME "Meowcraft"
 
@@ -10,6 +13,7 @@
 #define WINDOW_HEIGHT 800
 
 void run();
+void render(MC::BindableMesh&);
 void setup_gl();
 
 int main() {
@@ -33,19 +37,41 @@ void run() {
 
     glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
 
+    MC::Mesh triangle({
+        {-0.5, -0.5, 0.0},
+        {0.5, -0.5, 0.0},
+        {0.0, 0.5, 0.0},
+    });
+
+    auto mesh = MC::Binder::load(triangle);
+
+    MC::ShaderProgram program(MC::Shader::create_fragment(), MC::Shader::create_vertex());
+    program.bind();
+
     while (!window.should_close()) {
         window.start_frame();
 
         if (window.key(GLFW_KEY_ESCAPE, GLFW_PRESS)) {
             window.close();
         }
+
+        render(mesh);
     }
 }
 
+void render(MC::BindableMesh& mesh) {
+    glClearColor(0.65f, 0.8f, 0.8f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    mesh.bind();
+    glDrawArrays(GL_TRIANGLES, 0, mesh.size());
+    mesh.unbind();
+}
+
 void setup_gl() {
     GLenum error;
     if ((error = glewInit()) != GLEW_OK) {
-        std::string error_string = std::string(reinterpret_cast<const char*>(glewGetErrorString(error)));
+        std::string error_string(reinterpret_cast<const char*>(glewGetErrorString(error)));
         throw std::runtime_error("Failed to load GL functions: " + error_string);
     }
 }