@@ -137,6 +137,9 @@ Additional issues that are not typically detected by [`glValidateProgram`][]

 are checked for:

 -   Shader program not [current](#use).

+-   Uniforms not set with a call to [`uniform`](#uniforms), uniform blocks not

+    set with a call to `uniform` or `uniform_buffer`. (OpenGL defaults them to

+    zero unless initialized in the shader.)

 If the macro [`NDEBUG`][] is defined, the check is optimised out. Therefore, it

 is recommended to always call `validate()` before issuing draw calls.

@@ -148,7 +151,7 @@ is recommended to always call `validate()` before issuing draw calls.

 ### Use

 The shader needs to be [use][]d by calling `use()` before performing certain

-other actions on it.

+other actions on it, such as calling [`uniform`](#uniforms).

 If the macro [`NDEBUG`][] is not defined, an error is thrown if this is not the

 case.

@@ -243,6 +246,29 @@ up once at application startup.

 [`glDrawBuffers`]: https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glDrawBuffers.xhtml

 [program interface query]: https://www.khronos.org/opengl/wiki/Program_Introspection#Interface_query

+### Uniforms

+

+[Uniform][]s are set with the template specialized `uniform(std::string const &

+name, T const & value, bool required = true)`. If `required` is `true` an error

+is thrown if the shader does not contain an active uniform with the given

+`name`. If the macro [`NDEBUG`][] is not defined an error is thrown if the

+value is of the wrong type. [`use`](#use) must be called before calling

+`uniform`.

+

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

+

+#### User-defined uniforms

+

+Support for e.g. third party mathematics libraries can be added by providing

+the relevant template specializations of `uniform`. The macro

+`GLSHADER_UNIFORM(TYPE, CODE)` may be used to ease this task. `TYPE` is the

+type for which to provide the specialization and `CODE` is code that may use

+the supplied variables `TYPE const & value` and `GLint const & location`,

+probably as parameters to `glUniform*`. `GLSHADER_UNIFORM_DELETE(TYPE)` can be

+used to [`delete`][] the specialization for a given type.

+

+[`delete`]: https://en.cppreference.com/w/cpp/language/function#Deleted_functions

+

 ## Dependencies

 Public (interface):

@@ -5,6 +5,7 @@

 #include <map>

 #include <set>

 #include <string>

+#include <unordered_map>

 #include <GL/glew.h>

@@ -35,19 +36,47 @@ public:

     Shader & validate();

     Shader & use();

+    template<typename Value>

+    Shader & uniform(

+        std::string const & name,

+        Value       const & value,

+        bool                required = true

+    ) = delete;

+

 protected:

+    struct Uniform

+    {

+        GLint location;

+        bool set;

+    };

+

     void validate_() const;

     void current_(

         std::string const & error

     ) const;

-    GLuint             program_;

-    std::string        program_name_;

-    std::string static root_;

-    Defines     static defines_;

-    Locations   static verts_;

-    Locations   static frags_;

+    static void error_(

+        std::string const & error,

+        std::string const & error_hint = {}

+    );

+

+    Uniform * uniform_(

+        std::string const & error,

+        std::string const & name,

+        bool                required

+    );

+

+    template<typename Value>

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

+

+    GLuint                 program_;

+    std::string            program_name_;

+    std::string     static root_;

+    Defines         static defines_;

+    Locations       static verts_;

+    Locations       static frags_;

+    ByName<Uniform>        uniforms_;

 };

@@ -55,8 +84,12 @@ protected:

 #ifndef NDEBUG

     #define GLSHADER_DEBUG_(...) __VA_ARGS__

+    #define GLSHADER_DEBUG_ERROR_(...) \

+        auto error = std::string{} + __VA_ARGS__;

 #else

     #define GLSHADER_DEBUG_(...)

+    #define GLSHADER_DEBUG_ERROR_(...) \

+        auto error = std::string{};

 #endif // NDEBUG

@@ -90,4 +123,36 @@ inline Shader & Shader::use()

 }

+// Uniform template specializations.

+

+#define GLSHADER_UNIFORM_SIGNATURE_(TYPE) \

+    template<> \

+    inline Shader & Shader::uniform( \

+        std::string const & name, \

+        TYPE        const & value, \

+        bool                required \

+    )

+

+#define GLSHADER_UNIFORM_DELETE(TYPE) \

+    GLSHADER_UNIFORM_SIGNATURE_(TYPE) = delete;

+

+#define GLSHADER_UNIFORM(TYPE, CODE) \

+    GLSHADER_UNIFORM_SIGNATURE_(TYPE) \

+    { \

+        GLSHADER_DEBUG_ERROR_( \

+            "Failed to set uniform '" + name + "' of " + program_name_ \

+        ) \

+        GLSHADER_DEBUG_(current_(error);) \

+        if (auto * uniform = uniform_(error, name, required)) \

+        { \

+            GLint const & location = uniform->location; \

+            GLSHADER_DEBUG_(error_(error, "unprocessed previous error");) \

+            CODE \

+            GLSHADER_DEBUG_(error_(error, "wrong type?");) \

+            GLSHADER_DEBUG_(uniform->set = true;) \

+        } \

+        return *this; \

+    }

+

+

 #endif // GLSHADER_SHADER_HPP_

@@ -5,6 +5,7 @@

 #include <cerrno>

 #include <cstring>

 #include <fstream>

+#include <ios>

 #include <list>

 #include <memory>

 #include <regex>

@@ -44,6 +45,28 @@ static Type get_integer_(GLenum name, bool supported = true)

 }

+void Shader::error_(

+    std::string const & error,

+    std::string const & error_hint

+)

+{

+    auto gl_error = glGetError();

+    if (gl_error != GL_NO_ERROR)

+        throw std::runtime_error{STR(

+            error << "; " <<

+            "got error " << (

+                STR_COND(gl_error, GL_INVALID_ENUM)

+                STR_COND(gl_error, GL_INVALID_VALUE)

+                STR_COND(gl_error, GL_INVALID_OPERATION)

+                STR_COND(gl_error, GL_OUT_OF_MEMORY)

+                STR(std::hex << std::showbase << gl_error)

+            ) <<

+            (error_hint.empty() ? "" : STR(" (" << error_hint << ")")) <<

+            "."

+        )};

+}

+

+

 static void info_log_action_(

     std::string const & error,

     void (action)(GLuint object),

@@ -378,7 +401,8 @@ Shader::Shader(Paths const & paths)

     program_{0},

     program_name_{STR(

         "shader program " << STR_JOIN(", ", it, "'" << it << "'", paths)

-    )}

+    )},

+    uniforms_{}

 {

     // Get label limits.

     static auto const max_label_length = get_integer_<GLsizei>(

@@ -518,6 +542,24 @@ Shader::Shader(Paths const & paths)

                     )};

             }

         );

+

+        // Initialize uniforms.

+        for_variable_(

+            program_,

+            GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH,

+            [&](GLuint index, GLsizei max_length, GLchar * name)

+            {

+                GLint  size{};

+                GLenum type{};

+                glGetActiveUniform(

+                    program_, index, max_length,

+                    nullptr, &size, &type, name

+                );

+                auto location = glGetUniformLocation(program_, name);

+                if (location != -1)

+                    uniforms_.emplace(name, Uniform{location, false});

+            }

+        );

     }

     catch (...)

     {

@@ -532,7 +574,8 @@ Shader::Shader(Paths const & paths)

 Shader::Shader(Shader && other) noexcept

 :

     program_     {other.program_},

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

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

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

 {

     other.program_ = 0;

 }

@@ -545,6 +588,31 @@ Shader::~Shader()

 }

+template<typename Uniforms, typename Set>

+static void uniforms_validate_(

+    std::string const & error,

+    std::string const & uniform_type,

+    Uniforms uniforms,

+    Set set

+)

+{

+    // Find.

+    auto it = std::find_if(uniforms.begin(), uniforms.end(),

+        [&](typename Uniforms::value_type const & it)

+        {

+            return !set(it.second);

+        }

+    );

+

+    // Error if not found.

+    if (it != uniforms.end())

+        throw std::runtime_error{STR(

+            error << "; " <<

+            uniform_type << " '" << it->first << "' not set."

+        )};

+}

+

+

 void Shader::validate_() const

 {

     // Set error.

@@ -559,6 +627,14 @@ void Shader::validate_() const

     // Assert current.

     current_(validate_error);

+

+    // Validate uniforms.

+    uniforms_validate_(validate_error, "uniform", uniforms_,

+        [](Uniform const & uniform)

+        {

+            return uniform.set;

+        }

+    );

 }

@@ -571,3 +647,29 @@ void Shader::current_(std::string const & error) const

             "shader program not current."

         )};

 }

+

+

+Shader::Uniform * Shader::uniform_(

+    std::string const & error,

+    std::string const & name,

+    bool required

+)

+{

+    // Return if found.

+    auto it = uniforms_.find(name);

+    if (it != uniforms_.end())

+    {

+        auto & uniform = it->second;

+        return &uniform;

+    }

+

+    // Error if required.

+    if (required)

+        throw std::runtime_error{STR(

+            error << "; " <<

+            "uniform required but not found."

+        )};

+

+    // Return.

+    return nullptr;

+}