@@ -5,9 +5,14 @@ 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][]). [Uniforms][Uniform] are set with a unified

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

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

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

-naming conventions). For example:

+naming conventions). For other types of data [uniform blocks][Uniform block]

+are used with (shared, per name) [Uniform Buffer Object (UBO)][] backing

+(beware of alignment). UBOs can also be accessed directly and bound to a

+uniform block by name. The expected usage pattern (as used by

+[`glBufferData`][]) can optionally be specified (defaults to

+`GL_DYNAMIC_DRAW`). For example:

 ```cpp

 Shader shader({

@@ -18,6 +23,16 @@ shader.use();

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

 shader.uniform("color", color);

+

+struct Matrices {

+    glm::mat4 view;

+    glm::mat4 projection;

+} matrices;

+// Either:

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

+// or:

+Shader::ubo("matrices", matrices);

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

 ```

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

@@ -28,6 +43,9 @@ messages.

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

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

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

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

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

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

 [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

@@ -11,6 +11,13 @@

 #include "str.hpp"

+Shader::StringCache<Shader::UniformBuffer>

+Shader::uniform_buffer_cache_{};

+

+GLuint

+Shader::uniform_buffer_binding_next_{0};

+

+

 static void checked_action(

     void (glAction)(

         GLuint object

@@ -65,6 +72,25 @@ static GLenum shader_type(std::string type_str)

 }

+static std::string uniform_buffer_usage_str(GLenum usage)

+{

+    switch(usage)

+    {

+        STR_CASE(GL_STREAM_DRAW)

+        STR_CASE(GL_STREAM_READ)

+        STR_CASE(GL_STREAM_COPY)

+        STR_CASE(GL_STATIC_DRAW)

+        STR_CASE(GL_STATIC_READ)

+        STR_CASE(GL_STATIC_COPY)

+        STR_CASE(GL_DYNAMIC_DRAW)

+        STR_CASE(GL_DYNAMIC_READ)

+        STR_CASE(GL_DYNAMIC_COPY)

+        default:

+            return STR(std::hex << std::showbase << usage);

+    }

+}

+

+

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

 :

     program_{0},

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

         ? std::move(name)

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

     },

-    uniform_location_cache_{}

+    uniform_location_cache_{},

+    uniform_block_index_cache_{}

 {

     new_();

 }

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

 Shader::Shader(Shader const & other)

 :

-    program_               {0},

-    paths_                 {other.paths_},

-    name_                  {other.name_},

-    uniform_location_cache_{other.uniform_location_cache_}

+    program_                  {0},

+    paths_                    {other.paths_},

+    name_                     {other.name_},

+    uniform_location_cache_   {other.uniform_location_cache_},

+    uniform_block_index_cache_{other.uniform_block_index_cache_}

 {

     new_();

 }

@@ -93,10 +121,11 @@ Shader::Shader(Shader const & other)

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

 {

     delete_();

-    program_                = 0;

-    paths_                  = other.paths_;

-    name_                   = other.name_;

-    uniform_location_cache_ = other.uniform_location_cache_;

+    program_                   = 0;

+    paths_                     = other.paths_;

+    name_                      = other.name_;

+    uniform_location_cache_    = other.uniform_location_cache_;

+    uniform_block_index_cache_ = other.uniform_block_index_cache_;

     new_();

     return *this;

 }

@@ -104,10 +133,11 @@ 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_)},

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

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

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

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

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

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

 {

     other.program_ = 0;

 }

@@ -116,10 +146,11 @@ 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_);

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

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

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

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

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

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

     other.program_ = 0;

     return *this;

 }

@@ -240,13 +271,51 @@ void Shader::new_()

 }

-void Shader::delete_()

-{

+void Shader::delete_() {

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

     glDeleteProgram(program_);

 }

+Shader & Shader::uniform(

+    std::string const & name, std::string const & buffer_name

+) {

+    // Find uniform buffer in cache.

+    auto cache_entry = uniform_buffer_cache_.find(buffer_name);

+    if (cache_entry == uniform_buffer_cache_.end())

+        throw std::runtime_error{STR(

+            "Failed to set uniform block '" << name << "' of shader program "

+            << name << "; no uniform buffer '" << buffer_name << "'."

+        )};

+    auto const & uniform_buffer = cache_entry->second;

+

+    // Bind.

+    glUniformBlockBinding(

+        program_, uniform_block_index_(name), uniform_buffer.binding

+    );

+

+    // Return.

+    return *this;

+}

+

+

+void Shader::uniform_buffer_delete(std::string const & name) {

+    // Find uniform buffer in cache.

+    auto cache_entry = uniform_buffer_cache_.find(name);

+    if (cache_entry == uniform_buffer_cache_.end())

+        throw std::runtime_error{STR(

+            "Failed to delete uniform buffer '" << name << "'; does not exist."

+        )};

+    auto const & uniform_buffer = cache_entry->second;

+

+    // Delete buffer.

+    glDeleteBuffers(1, &uniform_buffer.buffer);

+

+    // Erase cache entries.

+    uniform_buffer_cache_.erase(cache_entry);

+}

+

+

 void Shader::ensure_current_(

     std::string const & operation,

     std::string const & name

@@ -285,3 +354,104 @@ GLint Shader::uniform_location_(std::string const & name)

     uniform_location_cache_.emplace(name, location);

     return location;

 }

+

+

+GLuint Shader::uniform_block_index_(std::string const & name) {

+    // Try cache.

+    auto & cache = uniform_block_index_cache_;

+    auto cache_entry = cache.find(name);

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

+        return cache_entry->second;

+

+    // Query OpenGL.

+    auto index = glGetUniformBlockIndex(program_, name.c_str());

+    if (index == GL_INVALID_INDEX)

+        throw std::runtime_error{STR(

+            "Failed to get index of uniform block '" << name <<

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

+        )};

+

+    // Save in cache and return.

+    cache.emplace(name, index);

+    return index;

+}

+

+

+GLuint Shader::uniform_buffer_(

+    std::string const & name, GLsizeiptr size, GLenum usage

+) {

+    // Get usage string.

+    auto const & usage_str = uniform_buffer_usage_str(usage);

+

+    // Try cache.

+    auto cache_entry = uniform_buffer_cache_.find(name);

+    if (cache_entry != uniform_buffer_cache_.end()) {

+        // Get uniform buffer.

+        auto const & uniform_buffer = cache_entry->second;

+

+        // Check size and usage.

+        if (size != uniform_buffer.size)

+            throw std::runtime_error{STR(

+                "Failed to set data of uniform buffer '" << name <<

+                "'; data has size " << size << " but buffer has size " <<

+                uniform_buffer.size << "."

+            )};

+        if (usage != uniform_buffer.usage)

+            throw std::runtime_error{STR(

+                "Failed to set data of uniform buffer '" << name <<

+                "'; data has usage " << usage_str << " but buffer has usage "

+                << uniform_buffer_usage_str(uniform_buffer.usage) << "."

+            )};

+

+        // Return.

+        return uniform_buffer.buffer;

+    }

+

+    // Validate size and usage.

+    if (size <= 0)

+        throw std::runtime_error{STR(

+            "Failed to create uniform buffer '" << name << "', invalid size "

+            << size << "."

+        )};

+    if (usage_str.rfind("GL_", 0) != 0)

+        throw std::runtime_error{STR(

+            "Failed to create uniform buffer '" << name << "', invalid usage "

+            << usage_str << "."

+        )};

+

+    // Check max uniform buffer bindings.

+    GLuint max_uniform_buffer_bindings;

+    glGetIntegerv(

+        GL_MAX_UNIFORM_BUFFER_BINDINGS,

+        (GLint *)&max_uniform_buffer_bindings

+    );

+    if (uniform_buffer_binding_next_ >= max_uniform_buffer_bindings)

+        throw std::runtime_error{STR(

+            "Failed to bind uniform buffer '" << name << "'; max bindings of "

+            << max_uniform_buffer_bindings << " exceeded."

+        )};

+

+    // Create uniform buffer.

+    UniformBuffer uniform_buffer;

+

+    // Generate and bind.

+    glGenBuffers(1, &uniform_buffer.buffer);

+    glBindBuffer(GL_UNIFORM_BUFFER, uniform_buffer.buffer),

+

+    // Set size and usage.

+    uniform_buffer.size = size;

+    uniform_buffer.usage = usage;

+    glBufferData(

+        GL_UNIFORM_BUFFER, uniform_buffer.size, nullptr, uniform_buffer.usage

+    );

+

+    // Allocate binding and bind.

+    uniform_buffer.binding = uniform_buffer_binding_next_++;

+    glBindBufferBase(

+        GL_UNIFORM_BUFFER, uniform_buffer.binding, uniform_buffer.buffer

+    );

+

+    // Save in cache and return.

+    uniform_buffer_cache_.emplace(name, uniform_buffer);

+    return uniform_buffer.buffer;

+}

@@ -24,13 +24,28 @@ public:

     Shader & use();

     Shader & validate();

     template<typename Value>

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

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

+    Shader & uniform(std::string const & name, std::string const & buffer_name);

+    template<typename Value>

+    static void uniform_buffer(

+        std::string const & name,

+        Value const & value,

+        GLenum usage = GL_DYNAMIC_DRAW

+    );

+    static void uniform_buffer_delete(std::string const & name);

 private:

     template<typename Value>

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

+    struct UniformBuffer {

+        GLuint buffer;

+        GLsizeiptr size;

+        GLenum usage;

+        GLuint binding;

+    };

+

     void new_();

     void delete_();

     void ensure_current_(

@@ -38,11 +53,18 @@ private:

         std::string const & name = ""

     );

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

+    GLuint uniform_block_index_(std::string const & name);

+    static GLuint uniform_buffer_(

+        std::string const & name, GLsizeiptr size, GLenum usage

+    );

     GLuint program_;

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

     std::string name_;

     StringCache<GLint> uniform_location_cache_;

+    StringCache<GLuint> uniform_block_index_cache_;

+    static StringCache<UniformBuffer> uniform_buffer_cache_;

+    static GLuint uniform_buffer_binding_next_;

 };

@@ -54,6 +76,29 @@ private:

 #endif

+template<typename Value>

+inline Shader & Shader::uniform(

+    std::string const & name, Value const & value

+) {

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

+    uniform_block_index_(name);

+    uniform_buffer(name, value);

+    uniform(name, name);

+    return *this;

+}

+

+

+template<typename Value>

+inline void Shader::uniform_buffer(

+    std::string const & name, Value const & value, GLenum usage

+) {

+    glBindBuffer(

+        GL_UNIFORM_BUFFER, uniform_buffer_(name, sizeof(value), usage)

+    );

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

+}

+

+

 #define GLSHADER_UNIFORM(VALUE_TYPE, CODE) \

     template<> \

     inline Shader & Shader::uniform( \

@@ -1,6 +1,12 @@

 #version 110

+// layout(std140) uniform matrices {

+//     mat4 view;

+//     mat4 projection;

+// };

+

+

 void main() {

     gl_Position = gl_Vertex;

 }

@@ -93,6 +93,38 @@ void test() {

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

     )

     shader.uniform("color", color);

+

+    struct Matrices {

+        glm::mat4 view;

+        glm::mat4 projection;

+    } matrices;

+    EXPECT_EXCEPTION(

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

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

+    )

+    EXPECT_EXCEPTION(

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

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

+    )

+    // (Allocate), set data and bind UBO implicitly.

+    // shader.uniform("matrices", matrices);

+    // (Allocate), set data and bind UBO explicitly.

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

+    // shader.uniform("matrices", "matrices");

+    EXPECT_EXCEPTION(

+        Shader::uniform_buffer("matrices", matrices, GL_STATIC_DRAW),

+        "Failed to set data of uniform buffer 'matrices'; data has usage GL_STATIC_DRAW but buffer has usage GL_DYNAMIC_DRAW."

+    )

+    EXPECT_EXCEPTION(

+        Shader::uniform_buffer("matrices", color),

+        "Failed to set data of uniform buffer 'matrices'; data has size 16 but buffer has size 128."

+    )

+    EXPECT_EXCEPTION(

+        Shader::uniform_buffer_delete("nonexistent"),

+        "Failed to delete uniform buffer 'nonexistent'; does not exist."

+    )

+    // Delete UBO.

+    // Shader::uniform_buffer_delete("matrices");

 }