@@ -4,7 +4,10 @@ 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:

+OpenGL ES Reference Compiler][]). [Uniforms][Uniform] are set with a unified

+interface (using template specialization). Data is provided by [OpenGL

+Mathematics (GLM)][] objects (which uses [OpenGL Shading Language (GLSL)][]

+naming conventions). For example:

 ```cpp

 Shader shader({

@@ -12,6 +15,9 @@ Shader shader({

     "test.frag",

 });

 shader.use();

+

+glm::vec4 color(1, 0, 0, 1);

+shader.uniform("color", color);

 ```

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

@@ -21,7 +27,10 @@ messages.

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

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

+[Uniform]: https://www.khronos.org/opengl/wiki/Uniform

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

+[OpenGL Mathematics (GLM)]: https://glm.g-truc.net

+[OpenGL Shading Language (GLSL)]: https://www.khronos.org/opengl/wiki/OpenGL_Shading_Language

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

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

@@ -45,7 +54,8 @@ manager][] can be done with:

 // Library dependencies.

 sudo apt-get install \

     libgl1-mesa-dev \

-    libglew-dev

+    libglew-dev \

+    libglm-dev

 // Test dependencies.

 sudo apt-get install \

@@ -72,7 +72,8 @@ Shader::Shader(std::vector<std::string> paths, std::string name)

     name_{!name.empty()

         ? std::move(name)

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

-    }

+    },

+    uniform_location_cache_{}

 {

     new_();

 }

@@ -80,9 +81,10 @@ Shader::Shader(std::vector<std::string> paths, std::string name)

 Shader::Shader(Shader const & other)

 :

-    program_{0},

-    paths_  {other.paths_},

-    name_   {other.name_}

+    program_               {0},

+    paths_                 {other.paths_},

+    name_                  {other.name_},

+    uniform_location_cache_{other.uniform_location_cache_}

 {

     new_();

 }

@@ -91,9 +93,10 @@ Shader::Shader(Shader const & other)

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

 {

     delete_();

-    program_ = 0;

-    paths_   = other.paths_;

-    name_    = other.name_;

+    program_                = 0;

+    paths_                  = other.paths_;

+    name_                   = other.name_;

+    uniform_location_cache_ = other.uniform_location_cache_;

     new_();

     return *this;

 }

@@ -101,9 +104,10 @@ Shader & Shader::operator=(Shader const & other)

 Shader::Shader(Shader && other)

 :

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

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

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

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

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

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

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

 {

     other.program_ = 0;

 }

@@ -112,9 +116,10 @@ Shader::Shader(Shader && other)

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

 {

     delete_();

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

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

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

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

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

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

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

     other.program_ = 0;

     return *this;

 }

@@ -259,3 +264,24 @@ void Shader::ensure_current_(

         )};

     }

 }

+

+

+GLint Shader::uniform_location_(std::string const & name)

+{

+    // Try cache.

+    auto cache_entry = uniform_location_cache_.find(name);

+    if (cache_entry != uniform_location_cache_.end())

+        return cache_entry->second;

+

+    // Query OpenGL.

+    auto location = glGetUniformLocation(program_, name.c_str());

+    if (location == -1)

+        throw std::runtime_error{STR(

+            "Failed to get location of uniform '" << name <<

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

+        )};

+

+    // Save in cache and return.

+    uniform_location_cache_.emplace(name, location);

+    return location;

+}

@@ -4,8 +4,11 @@

 #include <vector>

 #include <string>

+#include <unordered_map>

 #include <GL/glew.h>

+#include <glm/glm.hpp>

+#include <glm/gtc/type_ptr.hpp>

 class Shader {

@@ -20,19 +23,26 @@ public:

     Shader & use();

     Shader & validate();

+    template<typename Value>

+    Shader & uniform(std::string const & name, Value const & value) = delete;

 private:

+    template<typename Value>

+    using StringCache = std::unordered_map<std::string, Value>;

+

     void new_();

     void delete_();

     void ensure_current_(

         std::string const & operation,

         std::string const & name = ""

     );

+    GLint uniform_location_(std::string const & name);

     GLuint program_;

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

     std::string name_;

+    StringCache<GLint> uniform_location_cache_;

 };

@@ -44,4 +54,88 @@ private:

 #endif

+#define GLSHADER_UNIFORM(VALUE_TYPE, CODE) \

+    template<> \

+    inline Shader & Shader::uniform( \

+        std::string const & name, VALUE_TYPE const & value \

+    ) { \

+        GLSHADER_ENSURE_CURRENT("set uniform", name); \

+        CODE; \

+        return *this; \

+    }

+

+#define GLSHADER_UNIFORM_SCALAR(VALUE_TYPE, GL_TYPE) \

+    GLSHADER_UNIFORM( \

+        VALUE_TYPE, \

+        glUniform1##GL_TYPE( \

+            uniform_location_(name), value \

+        ) \

+    )

+

+#define GLSHADER_UNIFORM_N(N, GLM_VALUE_TYPE, GL_TYPE) \

+    GLSHADER_UNIFORM( \

+        glm::GLM_VALUE_TYPE##N, \

+        glUniform##N##GL_TYPE##v( \

+            uniform_location_(name), 1, glm::value_ptr(value) \

+        ) \

+    )

+

+#define GLSHADER_UNIFORM_N_BOOL(N) \

+    GLSHADER_UNIFORM( \

+        glm::bvec##N, \

+        GLint int_value[N]; \

+        for (auto i = 0; i < N; ++i) \

+            int_value[i] = value[i]; \

+        glUniform##N##iv( \

+            uniform_location_(name), 1, &int_value[0] \

+        ) \

+    )

+

+#define GLSHADER_UNIFORM_MATRIX_N(N) \

+    GLSHADER_UNIFORM( \

+        glm::mat##N, \

+        glUniformMatrix##N##fv( \

+            uniform_location_(name), 1, GL_FALSE, glm::value_ptr(value) \

+        ) \

+    )

+

+#define GLSHADER_UNIFORM_MATRIX_N_M(N, M) \

+    GLSHADER_UNIFORM( \

+        glm::mat##N##x##M, \

+        glUniformMatrix##N##x##M##fv( \

+            uniform_location_(name), 1, GL_FALSE, glm::value_ptr(value) \

+        ) \

+    )

+

+GLSHADER_UNIFORM_SCALAR(bool, i)

+GLSHADER_UNIFORM_SCALAR(int, i)

+GLSHADER_UNIFORM_SCALAR(glm::uint, ui)

+GLSHADER_UNIFORM_SCALAR(float, f)

+GLSHADER_UNIFORM_SCALAR(double, f)

+

+GLSHADER_UNIFORM_N_BOOL(2)

+GLSHADER_UNIFORM_N_BOOL(3)

+GLSHADER_UNIFORM_N_BOOL(4)

+GLSHADER_UNIFORM_N(2, ivec, i)

+GLSHADER_UNIFORM_N(3, ivec, i)

+GLSHADER_UNIFORM_N(4, ivec, i)

+GLSHADER_UNIFORM_N(2, uvec, ui)

+GLSHADER_UNIFORM_N(3, uvec, ui)

+GLSHADER_UNIFORM_N(4, uvec, ui)

+GLSHADER_UNIFORM_N(2, vec, f)

+GLSHADER_UNIFORM_N(3, vec, f)

+GLSHADER_UNIFORM_N(4, vec, f)

+

+GLSHADER_UNIFORM_MATRIX_N(2)

+GLSHADER_UNIFORM_MATRIX_N(3)

+GLSHADER_UNIFORM_MATRIX_N(4)

+

+GLSHADER_UNIFORM_MATRIX_N_M(2, 3)

+GLSHADER_UNIFORM_MATRIX_N_M(2, 4)

+GLSHADER_UNIFORM_MATRIX_N_M(3, 2)

+GLSHADER_UNIFORM_MATRIX_N_M(3, 4)

+GLSHADER_UNIFORM_MATRIX_N_M(4, 2)

+GLSHADER_UNIFORM_MATRIX_N_M(4, 3)

+

+

 #endif // GLSHADER_SHADER_HPP

@@ -1,6 +1,9 @@

 #version 110

+uniform vec4 color;

+

+

 void main() {

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

+    gl_FragColor = color;

 }

@@ -82,6 +82,17 @@ void test() {

     });

     shader.use();

     shader.validate();

+

+    glm::vec4 color(1, 0, 0, 1);

+    EXPECT_EXCEPTION(

+        Shader({ "good.vert", "good.frag" }).uniform("noncurrent", color),

+        "Failed to set uniform 'noncurrent' of shader program 'good.vert', 'good.frag'; program is not current."

+    )

+    EXPECT_EXCEPTION(

+        shader.uniform("nonexistent", color),

+        "Failed to get location of uniform 'nonexistent' of shader program 'good.vert', 'good.frag'."

+    )

+    shader.uniform("color", color);

 }