shader builders

framework/include/resource.h

@@ -0,0 +1,28 @@
+#ifndef GL_TEMPLATE_RESOURCE_H
+#define GL_TEMPLATE_RESOURCE_H
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+std::string readFile(const std::string &path) {
+    std::ifstream file(path);
+    if (!file) return std::string();
+
+    file.ignore(std::numeric_limits<std::streamsize>::max());
+    auto size = file.gcount();
+
+    if (size > 0x10000) return std::string();
+
+    file.clear();
+    file.seekg(0, std::ios_base::beg);
+
+    std::stringstream sstr;
+    sstr << file.rdbuf();
+    file.close();
+
+    return sstr.str();
+}
+
+#endif //GL_TEMPLATE_RESOURCE_H

framework/include/util.h

@@ -0,0 +1,84 @@
+#ifndef GL_TEMPLATE_UTIL_H
+#define GL_TEMPLATE_UTIL_H
+
+#include "resource.h"
+
+#include <glad/glad.h>
+
+#include <initializer_list>
+#include <string>
+
+namespace util {
+    void shaderFile(GLuint shader, const std::string &path) {
+        const std::string str = readFile(path);
+        const char *c_str = str.c_str();
+        glShaderSource(shader, 1, &c_str, nullptr);
+    }
+
+    const std::string shaderInfoLog(GLuint shader) {
+        GLint log_len;
+        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_len);
+        char log[log_len];
+        glGetShaderInfoLog(shader, log_len, nullptr, log);
+        return std::string(log);
+    }
+
+    const std::string programInfoLog(GLuint program) {
+        GLint log_len;
+        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_len);
+        char log[log_len];
+        glGetProgramInfoLog(program, log_len, nullptr, log);
+        return std::string(log);
+    }
+
+    GLuint buildShader(const std::string &path) {
+        std::string ext = path.substr(path.rfind("."));
+
+        GLenum kind;
+        if (ext == ".vert") {
+            kind = GL_VERTEX_SHADER;
+        } else if (ext == ".frag") {
+            kind = GL_FRAGMENT_SHADER;
+        } else {
+            fprintf(stderr, "Cannot parse path %s\n", path.c_str());
+            return 0;
+        }
+
+        GLuint shader = glCreateShader(kind);
+        util::shaderFile(shader, path);
+        glCompileShader(shader);
+
+        GLint comp;
+        glGetShaderiv(shader, GL_COMPILE_STATUS, &comp);
+        if (!comp) {
+            const std::string log = shaderInfoLog(shader);
+            fprintf(stderr, "SHADER ERROR: %s\n%s", path.c_str(), log.c_str());
+            glDeleteShader(shader);
+            return 0;
+        }
+
+        return shader;
+    }
+
+    GLuint buildProgram(std::initializer_list<GLuint> shaders) {
+        GLuint program = glCreateProgram();
+
+        for (GLuint shader : shaders)
+            glAttachShader(program, shader);
+
+        glLinkProgram(program);
+
+        GLint link;
+        glGetProgramiv(program, GL_LINK_STATUS, &link);
+        if (!link) {
+            const std::string log = programInfoLog(program);
+            fprintf(stderr, "PROGRAM ERROR:\n%s", log.c_str());
+            glDeleteProgram(program);
+            return 0;
+        }
+
+        return program;
+    }
+}
+
+#endif //GL_TEMPLATE_UTIL_H

framework/src/framework.cpp

@@ -93,7 +93,7 @@ void App::center(GLFWmonitor *monitor) {
     getSize(&w, &h);
 
     setPos(x + (mode->width - w) / 2,
-           y + (mode->height - h) / 2);
+        y + (mode->height - h) / 2);
 }
 
 void App::close() {

glapp/CMakeLists.txt

@@ -1,10 +1,29 @@
 project(sample)
 
-add_executable(sample
+add_executable(${PROJECT_NAME}
         src/main.cpp)
 
-target_link_libraries(sample
+target_link_libraries(${PROJECT_NAME}
         glad
         glm
         glfw
         framework)
+
+
+set(SHADERS
+        shaders/main.frag
+        shaders/main.vert)
+add_custom_target(shaders DEPENDS ${SHADERS})
+
+add_custom_command(
+        TARGET shaders PRE_BUILD
+        COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_CURRENT_BINARY_DIR}/shaders/
+        COMMENT "clearing shaders"
+)
+add_custom_command(
+        TARGET shaders POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/shaders/ ${CMAKE_CURRENT_BINARY_DIR}/shaders/
+        COMMENT "copying shaders"
+)
+
+add_dependencies(${PROJECT_NAME} shaders)

glapp/shaders/main.frag

@@ -0,0 +1,9 @@
+#version 330
+
+in vec3 color;
+
+out vec4 fcolor;
+
+void main() {
+    fcolor = vec4(color, 1);
+}

glapp/shaders/main.vert

@@ -0,0 +1,13 @@
+#version 330
+
+uniform mat4 pvm;
+
+in vec3 vCol;
+in vec2 vPos;
+
+out vec3 color;
+
+void main() {
+    gl_Position = pvm * vec4(vPos, 0, 1);
+    color = vCol;
+}

glapp/src/main.cpp

@@ -1,4 +1,5 @@
 #include <framework.h>
+#include <util.h>
 
 #include <glm/vec3.hpp>
 #include <glm/vec4.hpp>
@@ -16,33 +17,13 @@ struct Vertex {
     glm::vec3 col;
 };
 
-static const char *vertex_shader_text =
-        "uniform mat4 pvm;\n"
-        "attribute vec3 vCol;\n"
-        "attribute vec2 vPos;\n"
-        "varying vec3 color;\n"
-        "void main()\n"
-        "{\n"
-        "    gl_Position = pvm * vec4(vPos, 0.0, 1.0);\n"
-        "    color = vCol;\n"
-        "}\n";
-
-
-static const char *fragment_shader_text =
-        "varying vec3 color;\n"
-        "void main()\n"
-        "{\n"
-        "    gl_FragColor = vec4(color, 1.0);\n"
-        "}\n";
-
-
 class GLApp : public App {
 private:
     std::vector<Vertex> vertices = {
-            {glm::vec2(+0.5f, +0.5f), glm::vec3(1, 0, 0)},
-            {glm::vec2(+0.5f, -0.5f), glm::vec3(0, 1, 0)},
-            {glm::vec2(-0.5f, -0.5f), glm::vec3(0, 0, 1)},
-            {glm::vec2(-0.5f, +0.5f), glm::vec3(1, 1, 1)},
+        {glm::vec2(+0.5f, +0.5f), glm::vec3(1, 0, 0)},
+        {glm::vec2(+0.5f, -0.5f), glm::vec3(0, 1, 0)},
+        {glm::vec2(-0.5f, -0.5f), glm::vec3(0, 0, 1)},
+        {glm::vec2(-0.5f, +0.5f), glm::vec3(1, 1, 1)},
     };
 
     GLuint vertex_buffer = 0;
@@ -62,18 +43,10 @@ protected:
         glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
         glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices.front(), GL_STATIC_DRAW);
 
-        vertex_shader = glCreateShader(GL_VERTEX_SHADER);
-        glShaderSource(vertex_shader, 1, &vertex_shader_text, nullptr);
-        glCompileShader(vertex_shader);
-
-        fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
-        glShaderSource(fragment_shader, 1, &fragment_shader_text, nullptr);
-        glCompileShader(fragment_shader);
-
-        program = glCreateProgram();
-        glAttachShader(program, vertex_shader);
-        glAttachShader(program, fragment_shader);
-        glLinkProgram(program);
+        program = util::buildProgram({
+            vertex_shader = util::buildShader("shaders/main.vert"),
+            fragment_shader = util::buildShader("shaders/main.frag"),
+        });
 
         pvm_location = (GLuint) glGetUniformLocation(program, "pvm");
         vpos_location = (GLuint) glGetAttribLocation(program, "vPos");