@@ -13,8 +13,8 @@ LDLIBS    += -lglfw -lGLEW -lGL

 CXXFLAGS += -g

 ## Files

-SRCS =

-HDRS =

+SRCS = shader.cpp

+HDRS = shader.hpp

 ## Standard targets

@@ -2,8 +2,26 @@

 A C++11 helper for [OpenGL][] >=2.0 [shaders][Shader].

+`glshader` can load an arbitrary number of [shaders][Shader] with the type

+autodetected by the file extension (using the same rules as the [OpenGL /

+OpenGL ES Reference Compiler][]). For example:

+

+```cpp

+Shader shader({

+    "test.vert",

+    "test.frag",

+});

+shader.use();

+```

+

+Errors are handled by throwing [`std::runtime_error`][] with a [`what()`][]

+that returns helpful context as well as the OpenGL info log where appropriate.

+See the [tests](#tests) source for an overview of (some of) the generated error

+messages.

+

 [OpenGL]: https://www.opengl.org

 [Shader]: https://www.khronos.org/opengl/wiki/Shader

+[OpenGL / OpenGL ES Reference Compiler]: https://www.khronos.org/opengles/sdk/tools/Reference-Compiler/

 [`std::runtime_error`]: https://en.cppreference.com/w/cpp/error/runtime_error

 [`what()`]: https://en.cppreference.com/w/cpp/error/exception/what

new file mode 100644

@@ -0,0 +1,261 @@

+#include "shader.hpp"

+

+#include <vector>

+#include <string>

+#include <fstream>

+#include <stdexcept>

+#include <iostream>

+

+#include <GL/glew.h>

+

+#include "str.hpp"

+

+

+static void checked_action(

+    void (glAction)(

+        GLuint object

+    ),

+    GLuint object,

+    GLenum status_enum,

+    void (glGetObjectiv)(

+        GLuint object, GLenum pname, GLint *params

+    ),

+    void (glGetObjectInfoLog)(

+        GLuint object, GLsizei maxLength, GLsizei *length, GLchar *infoLog

+    ),

+    std::string const & what

+)

+{

+    // Perform action.

+    glAction(object);

+

+    // Check status.

+    GLint status;

+    glGetObjectiv(object, status_enum, &status);

+    if (status)

+        return;

+

+    // Get info log length.

+    GLint info_log_length;

+    glGetObjectiv(object, GL_INFO_LOG_LENGTH, &info_log_length);

+

+    // Get info log content.

+    std::string info_log;

+    if (info_log_length) {

+        std::vector<char> info_log_buf(info_log_length);

+        glGetObjectInfoLog(object, info_log_length, nullptr, &info_log_buf[0]);

+        info_log = STR("\n" << &info_log[0]);

+    }

+

+    // Throw.

+    throw std::runtime_error{STR(what << info_log)};

+}

+

+

+static GLenum shader_type(std::string type_str)

+{

+    return

+        type_str == "vert" ? GL_VERTEX_SHADER :

+        type_str == "tesc" ? GL_TESS_CONTROL_SHADER :

+        type_str == "tese" ? GL_TESS_EVALUATION_SHADER :

+        type_str == "geom" ? GL_GEOMETRY_SHADER :

+        type_str == "frag" ? GL_FRAGMENT_SHADER :

+        type_str == "comp" ? GL_COMPUTE_SHADER :

+        0;

+}

+

+

+Shader::Shader(std::vector<std::string> paths, std::string name)

+:

+    program_{0},

+    paths_{std::move(paths)},

+    name_{!name.empty()

+        ? std::move(name)

+        : STR_JOIN(", ", "'" << it << "'", paths_)

+    }

+{

+    new_();

+}

+

+

+Shader::Shader(Shader const & other)

+:

+    program_{0},

+    paths_  {other.paths_},

+    name_   {other.name_}

+{

+    new_();

+}

+

+

+Shader & Shader::operator=(Shader const & other)

+{

+    delete_();

+    program_ = 0;

+    paths_   = other.paths_;

+    name_    = other.name_;

+    new_();

+    return *this;

+}

+

+

+Shader::Shader(Shader && other)

+:

+    program_{std::move(other.program_)},

+    paths_  {std::move(other.paths_)},

+    name_   {std::move(other.name_)}

+{

+    other.program_ = 0;

+}

+

+

+Shader & Shader::operator=(Shader && other)

+{

+    delete_();

+    program_ = std::move(other.program_);

+    paths_   = std::move(other.paths_);

+    name_    = std::move(other.name_);

+    other.program_ = 0;

+    return *this;

+}

+

+

+Shader::~Shader()

+{

+    delete_();

+}

+

+

+Shader & Shader::use()

+{

+    glUseProgram(program_);

+    return *this;

+}

+

+

+Shader & Shader::validate()

+{

+    // Validate shader and check for errors.

+    checked_action(

+        glValidateProgram, program_,

+        GL_VALIDATE_STATUS, glGetProgramiv, glGetProgramInfoLog,

+        STR("Failed to validate shader program " << name_ << ".")

+    );

+    return *this;

+}

+

+

+void Shader::new_()

+{

+    try

+    {

+        // Create program.

+        program_ = glCreateProgram();

+        if (!program_)

+            throw std::runtime_error{STR(

+                "Failed to create shader program for " << name_ << "."

+            )};

+

+        // Label program.

+        glObjectLabel(GL_PROGRAM, program_, -1, name_.c_str());

+

+        // Process shader paths.

+        std::vector<GLuint> shaders;

+        for (auto const & path : paths_)

+        {

+            // Infer shader type from path extension.

+            // https://www.khronos.org/opengles/sdk/tools/Reference-Compiler/

+            auto pos = path.rfind(".");

+            if (pos == path.npos)

+                throw std::runtime_error{STR(

+                    "Failed to infer shader type of '" << path <<

+                    "' of shader program " << name_ << "; no file extension."

+                )};

+            auto type_str = path.substr(pos + 1);

+            auto type = shader_type(type_str);

+            if (!type)

+                throw std::runtime_error{STR(

+                    "Failed to infer shader type of '" << path <<

+                    "' of shader program " << name_ <<

+                    "; unknown file extension '" << type_str << "'."

+                )};

+

+            // Create, attach, and flag shader for deletion when detached.

+            auto shader = glCreateShader(type);

+            if (!shader)

+                throw std::runtime_error{STR(

+                    "Failed to create " << type_str << " shader for " << path

+                    << " of shader program " << name_ << "."

+                )};

+            glAttachShader(program_, shader);

+            glDeleteShader(shader);

+            shaders.push_back(shader);

+

+            // Label shader.

+            glObjectLabel(GL_SHADER, shader, -1, path.c_str());

+

+            // Set shader source.

+            std::ifstream source_file(path);

+            if (!source_file)

+                throw std::runtime_error{STR(

+                    "Failed to open " << type_str << " shader '" << path <<

+                    "' of shader program " << name_ << "."

+                )};

+            auto source_str = STR(source_file.rdbuf());

+            std::vector<char const *> sources = { source_str.c_str() };

+            glShaderSource(shader, sources.size(), &sources[0], nullptr);

+

+            // Compile shader and check for errors.

+            checked_action(

+                glCompileShader, shader,

+                GL_COMPILE_STATUS, glGetShaderiv, glGetShaderInfoLog,

+                STR(

+                    "Failed to compile " << type_str << " shader '" << path <<

+                    "' of shader program " << name_ << "."

+                )

+            );

+        }

+

+        // Link program and check for errors.

+        checked_action(

+            glLinkProgram, program_,

+            GL_LINK_STATUS, glGetProgramiv, glGetProgramInfoLog,

+            STR("Failed to link shader program " << name_ << ".")

+        );

+

+        // Detach shaders.

+        for (auto shader : shaders)

+            glDetachShader(program_, shader);

+    }

+    catch (...)

+    {

+        delete_();

+        throw;

+    }

+}

+

+

+void Shader::delete_()

+{

+    // Delete program (and detach and delete shaders).

+    glDeleteProgram(program_);

+}

+

+

+void Shader::ensure_current_(

+    std::string const & operation,

+    std::string const & name

+)

+{

+    GLuint current_program;

+    glGetIntegerv(GL_CURRENT_PROGRAM, (GLint *)&current_program);

+    if (current_program != program_) {

+        auto action = name.empty()

+            ? operation

+            : STR(operation << " '" << name << "'");

+        throw std::runtime_error{STR(

+            "Failed to " << action << " of shader program " << name_ <<

+            "; program is not current."

+        )};

+    }

+}

new file mode 100644

@@ -0,0 +1,47 @@

+#ifndef GLSHADER_SHADER_HPP

+#define GLSHADER_SHADER_HPP

+

+

+#include <vector>

+#include <string>

+

+#include <GL/glew.h>

+

+

+class Shader {

+public:

+

+    Shader(std::vector<std::string> paths, std::string name = "");

+    Shader(Shader &&);

+    Shader(Shader const &);

+    Shader & operator=(Shader &&);

+    Shader & operator=(Shader const &);

+    ~Shader();

+

+    Shader & use();

+    Shader & validate();

+

+private:

+

+    void new_();

+    void delete_();

+    void ensure_current_(

+        std::string const & operation,

+        std::string const & name = ""

+    );

+

+    GLuint program_;

+    std::vector<std::string> paths_;

+    std::string name_;

+};

+

+

+#ifdef NDEBUG

+    #define GLSHADER_ENSURE_CURRENT(OPERATION, NAME)

+#else

+    #define GLSHADER_ENSURE_CURRENT(OPERATION, NAME) \

+        ensure_current_(OPERATION, NAME)

+#endif

+

+

+#endif // GLSHADER_SHADER_HPP

new file mode 100644

@@ -0,0 +1,5 @@

+#version 110

+

+

+int main() {

+}

new file mode 100644

@@ -0,0 +1,5 @@

+#version 110

+

+

+void main() {

+}

new file mode 100644

@@ -0,0 +1,6 @@

+#version 110

+

+

+void main() {

+    gl_FragColor = vec4(1, 0, 0, 1);

+}

new file mode 100644

@@ -0,0 +1,6 @@

+#version 110

+

+

+void main() {

+    gl_Position = gl_Vertex;

+}

@@ -9,6 +9,7 @@

 #include <GLFW/glfw3.h>

 #include "str.hpp"

+#include "shader.hpp"

 static auto debugMessageDisable = false;

@@ -40,6 +41,47 @@ static auto debugMessageDisable = false;

 void test() {

+    EXPECT_EXCEPTION(

+        Shader({ "bad_noextension" }),

+        "Failed to infer shader type of 'bad_noextension' of shader program 'bad_noextension'; no file extension."

+    )

+    EXPECT_EXCEPTION(

+        Shader({ "bad.unknownextension" }),

+        "Failed to infer shader type of 'bad.unknownextension' of shader program 'bad.unknownextension'; unknown file extension 'unknownextension'."

+    )

+    EXPECT_EXCEPTION(

+        Shader({ "bad_nonexistent.vert" }),

+        "Failed to open vert shader 'bad_nonexistent.vert' of shader program 'bad_nonexistent.vert'."

+    )

+    EXPECT_EXCEPTION(

+        Shader({ "bad_compile.vert" }),

+        "Failed to compile vert shader 'bad_compile.vert' of shader program 'bad_compile.vert'."

+        // "0:4(5): error: main() must return void"

+        // "0:4(1): error: function `main' has non-void return type int, but no return statement"

+    )

+    EXPECT_EXCEPTION(

+        Shader({ "bad_link.vert", "good.frag" }),

+        "Failed to link shader program 'bad_link.vert', 'good.frag'."

+        // "error: vertex shader does not write to `gl_Position'. "

+    )

+    {

+        Shader shader{std::move(Shader({

+            "good.vert",

+            "good.frag",

+        }))};

+        shader.use();

+        shader = Shader({

+            "good.vert",

+            "good.frag",

+        });

+        shader.use();

+    }

+    Shader shader({

+        "good.vert",

+        "good.frag",

+    });

+    shader.use();

+    shader.validate();

 }