@@ -13,6 +13,8 @@ A [C++11][] [OpenGL][] \>=[2.0][] [shader][] library.

 Overview of usage:

 ```cpp

+#include <array>

+

 #include <GL/glew.h>

 #include <glm/glm.hpp>

@@ -32,6 +34,11 @@ int main()

     // Local data.

     auto light_count = 3;

     auto color = glm::vec4{1, 0, 0, 1};

+    struct

+    {

+        std::array<float, 4> value1;

+        std::array<float, 4> value2;

+    } values = {};

     // Global settings.

     Shader::root("assets/shaders");

@@ -57,7 +64,9 @@ int main()

         .use()

         .uniform("light_count", light_count)

         .uniform("color", color)

+        .uniform("values", values)

         .validate();

+    Shader::uniform_buffer("values", values);

 }

 ```

@@ -294,6 +303,22 @@ 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.

+#### Uniform blocks / buffers

+

+If no specialization is provided, [uniform block][]s are assumed. This requires

+OpenGL \>=3.1 or the [`ARB_uniform_buffer_object`][] extension, an error is

+thrown if it is not available. Shared, by name, [Uniform Buffer Object

+(UBO)][]s are automatically allocated. Beware of alignment, it is recommended

+to use the `std140` [memory layout][] and to [avoid `vec3`/`mat3`][].

+

+Bare arrays are not supported, wrap them in uniform blocks.

+

+[Uniform block]: https://www.khronos.org/opengl/wiki/Interface_Block_(GLSL)#Uniform_blocks

+[`ARB_uniform_buffer_object`]: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_uniform_buffer_object.txt

+[Uniform Buffer Object (UBO)]: https://www.khronos.org/opengl/wiki/Uniform_Buffer_Object

+[memory layout]: https://www.khronos.org/opengl/wiki/Interface_Block_(GLSL)#Memory_layout

+[avoid `vec3`/`mat3`]: https://stackoverflow.com/questions/38172696/should-i-ever-use-a-vec3-inside-of-a-uniform-buffer-or-shader-storage-buffer-object

+

 ## Dependencies

 Public (interface):

@@ -2,6 +2,7 @@

 #extension GL_ARB_shading_language_include : require

+#extension GL_ARB_uniform_buffer_object : require

 #include "all_green.h"

@@ -9,6 +10,10 @@

 uniform float blue;

 uniform vec4 color;

+layout(std140) uniform small

+{

+    vec4 value1;

+};

 void main()

new file mode 100644

@@ -0,0 +1,17 @@

+#version 110

+

+

+#extension GL_ARB_uniform_buffer_object : require

+

+

+layout(std140) uniform small

+{

+    vec4 value1;

+    vec4 value2;

+};

+

+

+void main()

+{

+    gl_Position = gl_Vertex;

+}

new file mode 100644

@@ -0,0 +1,16 @@

+#version 110

+

+

+#extension GL_ARB_uniform_buffer_object : require

+

+

+layout(std140) uniform small

+{

+    vec4 value1;

+};

+

+

+void main()

+{

+    gl_Position = gl_Vertex;

+}

@@ -41,6 +41,25 @@ public:

         std::string const & name,

         Value       const & value,

         bool                required = true

+    );

+    template<typename Value>

+    Shader & uniform(

+        std::string const & name,

+        Value             * value,

+        bool                required = true

+    ) = delete;

+

+    template<typename Value>

+    static void uniform_buffer(

+        std::string const & name,

+        Value       const & value,

+        bool                required = true

+    );

+    template<typename Value>

+    static void uniform_buffer(

+        std::string const & name,

+        Value             * value,

+        bool                required = true

     ) = delete;

 protected:

@@ -51,6 +70,19 @@ protected:

         bool set;

     };

+    struct UniformBuffer

+    {

+        GLuint buffer;

+        GLsizeiptr size;

+        GLuint binding;

+        bool set;

+    };

+

+    struct UniformBlock

+    {

+        UniformBuffer & buffer;

+    };

+

     void validate_() const;

     void current_(

         std::string const & error

@@ -66,17 +98,31 @@ protected:

         std::string const & name,

         bool                required

     );

+    UniformBlock * uniform_block_(

+        std::string const & error,

+        std::string const & name,

+        bool                required,

+        GLsizeiptr          size

+    );

+    static UniformBuffer * uniform_buffer_(

+        std::string const & error,

+        std::string const & name,

+        bool                required,

+        GLsizeiptr          size

+    );

     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_;

+    GLuint                       program_;

+    std::string                  program_name_;

+    std::string           static root_;

+    Defines               static defines_;

+    Locations             static verts_;

+    Locations             static frags_;

+    ByName<Uniform>              uniforms_;

+    ByName<UniformBlock>         uniform_blocks_;

+    ByName<UniformBuffer> static uniform_buffers_;

 };

@@ -123,6 +169,49 @@ inline Shader & Shader::use()

 }

+// Uniform template definitions.

+

+#define GLSHADER_UNIFORM_BUFFER_(BLOCK_OR_BUFFER, BUFFER, SET) \

+    if (auto block_or_buffer = BLOCK_OR_BUFFER( \

+        error, name, required, sizeof(value) \

+    )) \

+    { \

+        glBindBuffer(GL_UNIFORM_BUFFER, block_or_buffer->BUFFER); \

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

+        glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(value), &value); \

+        GLSHADER_DEBUG_(error_(error);) \

+        GLSHADER_DEBUG_(block_or_buffer->SET = true;) \

+    }

+

+template<typename Value>

+inline void Shader::uniform_buffer(

+    std::string const & name,

+    Value       const & value,

+    bool                required

+)

+{

+    GLSHADER_DEBUG_ERROR_(

+        "Failed to set uniform buffer '" + name + "'"

+    )

+    GLSHADER_UNIFORM_BUFFER_(uniform_buffer_, buffer, set)

+}

+

+template<typename Value>

+inline Shader & Shader::uniform(

+    std::string const & name,

+    Value       const & value,

+    bool                required

+)

+{

+    GLSHADER_DEBUG_ERROR_(

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

+    )

+    GLSHADER_DEBUG_(current_(error);)

+    GLSHADER_UNIFORM_BUFFER_(uniform_block_, buffer.buffer, buffer.set)

+    return *this;

+}

+

+

 // Uniform template specializations.

 #define GLSHADER_UNIFORM_SIGNATURE_(TYPE) \

@@ -33,6 +33,7 @@ GLSHADER_INIT_(Shader::root_, {})

 GLSHADER_INIT_(Shader::defines_, {})

 GLSHADER_INIT_(Shader::verts_, {})

 GLSHADER_INIT_(Shader::frags_, {})

+GLSHADER_INIT_(Shader::uniform_buffers_, {})

 template<typename Type>

@@ -402,7 +403,8 @@ Shader::Shader(Paths const & paths)

     program_name_{STR(

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

     )},

-    uniforms_{}

+    uniforms_{},

+    uniform_blocks_{}

 {

     // Get label limits.

     static auto const max_label_length = get_integer_<GLsizei>(

@@ -560,6 +562,39 @@ Shader::Shader(Paths const & paths)

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

             }

         );

+

+        // Initialize uniform blocks.

+        for_variable_(

+            program_,

+            GL_ACTIVE_UNIFORM_BLOCKS, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH,

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

+            {

+                if (!(GLEW_VERSION_3_1 || GLEW_ARB_uniform_buffer_object))

+                    throw std::runtime_error{STR(

+                        "Failed to initialize uniform block; " <<

+                        "ARB_uniform_buffer_object not available."

+                    )};

+                glGetActiveUniformBlockName(

+                    program_, index, max_length,

+                    nullptr, name

+                );

+                auto error = STR(

+                    "Failed to initialize uniform block '" << name << "' of "

+                    << program_name_

+                );

+                auto size = GLsizei{};

+                glGetActiveUniformBlockiv(

+                    program_, index, GL_UNIFORM_BLOCK_DATA_SIZE, (GLint *)&size

+                );

+                auto & uniform_buffer = *uniform_buffer_(

+                    error, name, false, size

+                );

+                glUniformBlockBinding(program_, index, uniform_buffer.binding);

+                uniform_blocks_.emplace(

+                    name, UniformBlock{uniform_buffer}

+                );

+            }

+        );

     }

     catch (...)

     {

@@ -573,9 +608,10 @@ Shader::Shader(Paths const & paths)

 Shader::Shader(Shader && other) noexcept

 :

-    program_     {other.program_},

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

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

+    program_       {other.program_},

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

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

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

 {

     other.program_ = 0;

 }

@@ -635,6 +671,14 @@ void Shader::validate_() const

             return uniform.set;

         }

     );

+

+    // Validate uniform blocks.

+    uniforms_validate_(validate_error, "uniform block", uniform_blocks_,

+        [](UniformBlock const & uniform_block)

+        {

+            return uniform_block.buffer.set;

+        }

+    );

 }

@@ -665,11 +709,160 @@ Shader::Uniform * Shader::uniform_(

     // Error if required.

     if (required)

+    {

+        auto error_hint = std::string{};

+        if (uniform_blocks_.find(name) != uniform_blocks_.end())

+            error_hint = " (did you mean the uniform block?)";

+        throw std::runtime_error{STR(

+            error << "; " <<

+            "uniform required but not found" << error_hint << "."

+        )};

+    }

+

+    // Return.

+    return nullptr;

+}

+

+

+Shader::UniformBlock * Shader::uniform_block_(

+    std::string const & error,

+    std::string const & name,

+    bool required,

+    GLsizeiptr size

+)

+{

+    // Return if found.

+    auto it = uniform_blocks_.find(name);

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

+    {

+        auto & uniform_block = it->second;

+        if (size != uniform_block.buffer.size)

+            throw std::runtime_error{STR(

+                error << "; " <<

+                "expected size " << uniform_block.buffer.size << " but got " <<

+                size << "."

+            )};

+        return &uniform_block;

+    }

+

+    // Error if required.

+    if (required)

+    {

+        auto error_hint = std::string{};

+        if (uniforms_.find(name) != uniforms_.end())

+            error_hint = " (did you mean the uniform?)";

         throw std::runtime_error{STR(

             error << "; " <<

-            "uniform required but not found."

+            "uniform block required but not found" << error_hint << "."

         )};

+    }

     // Return.

     return nullptr;

 }

+

+

+Shader::UniformBuffer * Shader::uniform_buffer_(

+    std::string const & error,

+    std::string const & name,

+    bool required,

+    GLsizeiptr size

+)

+{

+    // Get uniform block / buffer limits.

+    static auto const max_uniform_block_size = get_integer_<GLuint>(

+        GL_MAX_UNIFORM_BLOCK_SIZE

+    );

+    static auto const max_uniform_buffer_bindings = get_integer_<GLuint>(

+        GL_MAX_UNIFORM_BUFFER_BINDINGS

+    );

+

+    // Define next binding.

+    static auto next_uniform_buffer_binding_ = GLuint{0};

+

+    // Return if found.

+    auto it = uniform_buffers_.find(name);

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

+    {

+        auto & uniform_buffer = it->second;

+        if (size != uniform_buffer.size)

+            throw std::runtime_error{STR(

+                error << "; " <<

+                "expected size " << uniform_buffer.size << " but got " << size

+                << "."

+            )};

+        return &uniform_buffer;

+    }

+

+    // Error if required.

+    if (required)

+        throw std::runtime_error{STR(

+            error << "; " <<

+            "uniform buffer required but not found."

+        )};

+

+    // Set create error.

+    auto create_error = STR(

+        error << ":\n" <<

+        "Failed to create uniform buffer '" << name << "'"

+    );

+

+    // Check availability.

+    if (!(GLEW_VERSION_3_1 || GLEW_ARB_uniform_buffer_object))

+        throw std::runtime_error{STR(

+            create_error << "; " <<

+            "ARB_uniform_buffer_object not available."

+        )};

+

+    // Create storage.

+    auto emplace = uniform_buffers_.emplace(name, UniformBuffer{});

+    if (!emplace.second)

+        throw std::runtime_error{STR(

+            create_error << "; " <<

+            "already exists."

+        )};

+    auto & uniform_buffer = emplace.first->second;

+

+    // Check for errors.

+    if (size > max_uniform_block_size)

+        throw std::runtime_error{STR(

+            create_error << "; " <<

+            "buffer has size " << size << " but max size is " <<

+            max_uniform_block_size << "."

+        )};

+    if (next_uniform_buffer_binding_ >= max_uniform_buffer_bindings)

+        throw std::runtime_error{STR(

+            create_error << "; " <<

+            "buffer would have binding " << next_uniform_buffer_binding_ <<

+            " but max bindings is " << max_uniform_buffer_bindings << "."

+        )};

+

+    // Generate and bind.

+    glGenBuffers(1, &uniform_buffer.buffer);

+    glBindBuffer(GL_UNIFORM_BUFFER, uniform_buffer.buffer),

+

+    // Allocate size.

+    uniform_buffer.size = size;

+    error_(create_error, "unprocessed previous error");

+    glBufferData(

+        GL_UNIFORM_BUFFER,

+        uniform_buffer.size,

+        nullptr,

+        GL_DYNAMIC_DRAW

+    );

+    error_(create_error);

+

+    // Allocate binding and bind.

+    uniform_buffer.binding = next_uniform_buffer_binding_++;

+    glBindBufferBase(

+        GL_UNIFORM_BUFFER,

+        uniform_buffer.binding,

+        uniform_buffer.buffer

+    );

+

+    // Mark as unset.

+    uniform_buffer.set = false;

+

+    // Return

+    return &uniform_buffer;

+}

@@ -1,3 +1,4 @@

+#include <array>

 #include <string>

 #include <GL/glew.h>

@@ -166,6 +167,47 @@ GLTEST(2, 0, 640, 480, glshader)

     // Uniform OpenGL Mathematics (GLM).

     glm::vec4 color{1.0F};

+    // Uniform buffer.

+    struct

+    {

+        std::array<float, 4> value1;

+    } small = {};

+    struct

+    {

+        std::array<float, 4> value1;

+        std::array<float, 4> value2;

+    } big = {};

+    GLTEST_EXPECT_EXCEPTION(false,

+        Shader({"tests/uniform_buffer_small.vert"}).use().validate(),

+        "Failed to validate shader program 'tests/uniform_buffer_small.vert'; "

+        "uniform block 'small' not set."

+    )

+    GLTEST_EXPECT_EXCEPTION(false,

+        Shader::uniform_buffer("small", big),

+        "Failed to set uniform buffer 'small'; "

+        "expected size 16 but got 32."

+    )

+    GLTEST_EXPECT_EXCEPTION(false,

+        Shader({"tests/uniform_buffer_small.vert"}).use().uniform("small", big),

+        "Failed to set uniform block 'small' of shader program 'tests/uniform_buffer_small.vert'; "

+        "expected size 16 but got 32."

+    )

+    GLTEST_EXPECT_EXCEPTION(false,

+        Shader({"tests/uniform_buffer_bad_size.vert"}),

+        "Failed to initialize uniform block 'small' of shader program 'tests/uniform_buffer_bad_size.vert'; "

+        "expected size 16 but got 32."

+    )

+    GLTEST_EXPECT_EXCEPTION(false,

+        Shader({"tests/uniform_buffer_small.vert"}).use().uniform("small", 1.0F),

+        "Failed to set uniform 'small' of shader program 'tests/uniform_buffer_small.vert'; "

+        "uniform required but not found (did you mean the uniform block?)."

+    )

+    GLTEST_EXPECT_EXCEPTION(false,

+        Shader({"tests/uniform_blue.frag"}).use().uniform("blue", small),

+        "Failed to set uniform block 'blue' of shader program 'tests/uniform_blue.frag'; "

+        "uniform block required but not found (did you mean the uniform?)."

+    )

+

     auto all = Shader({

         "tests/all.vert",

         "tests/all.frag",

@@ -175,7 +217,9 @@ GLTEST(2, 0, 640, 480, glshader)

         .use()

         .uniform("blue", blue)

         .uniform("color", color)

+        .uniform("small", small)

         .validate();

+    Shader::uniform_buffer("small", small);

     constexpr auto size = 0.5F;

     glBegin(GL_TRIANGLE_STRIP);