@@ -39,6 +39,8 @@ int main()

         std::array<float, 4> value1;

         std::array<float, 4> value2;

     } values = {};

+    auto texture0 = GLuint{};

+    glGenTextures(1, &texture0);

     // Global settings.

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

@@ -65,6 +67,7 @@ int main()

         .uniform("light_count", light_count)

         .uniform("color", color)

         .uniform("values", values)

+        .texture("texture0", texture0, GL_TEXTURE_2D)

         .validate();

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

 }

@@ -319,6 +322,26 @@ Bare arrays are not supported, wrap them in uniform blocks.

 [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

+#### Textures

+

+As a special case, uniform texture samplers can be set by calling

+`texture(std::string const & name, GLuint texture, GLenum target, bool required

+= true)`. Unless a texture unit is already correctly set up as a result of a

+previous call, one is automatically allocated and its `target` bound to

+`texture`. If a texture unit needs to be allocated but no unused one is

+available (the limit can be queried with

+[`glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, ...)`][glGet] the least

+recently used one is reused. [`uniform`](#uniforms) is then called with the

+given `name` (and `required`) and the allocated texture unit as the `value`.

+

+Subsequent calls with a given `texture` are very cheap provided that the number

+of other textures set since the previous call stay below the limit.

+

+If a subsequent call for a given `texture` uses a different `target` an error

+is thrown.

+

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

+

 ## Dependencies

 Public (interface):

new file mode 100644

@@ -0,0 +1,10 @@

+#version 110

+

+

+uniform sampler2D texture0;

+

+

+void main()

+{

+    gl_Position = texture2D(texture0, vec2(0)) * gl_Vertex;

+}

@@ -62,6 +62,13 @@ public:

         bool                required = true

     ) = delete;

+    Shader & texture(

+        std::string const & name,

+        GLuint              texture,

+        GLenum              target,

+        bool                required = true

+    );

+

 protected:

     struct Uniform

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

 #include <cstring>

 #include <fstream>

 #include <ios>

+#include <iterator>

 #include <list>

 #include <memory>

 #include <regex>

@@ -866,3 +867,104 @@ Shader::UniformBuffer * Shader::uniform_buffer_(

     // Return

     return &uniform_buffer;

 }

+

+

+Shader & Shader::texture(

+    std::string const & name,

+    GLuint              texture,

+    GLenum              target,

+    bool                required

+)

+{

+    // Get limits.

+    static auto const max_combined_texture_image_units = get_integer_<GLuint>(

+        GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS

+    );

+

+    // Define data.

+    struct Unit

+    {

+        GLuint unit;

+        GLenum target;

+        GLuint texture;

+    };

+    using Units = std::list<Unit>;

+    using Textures = std::unordered_map<GLuint, Units::iterator>;

+    static auto units = Units{};

+    static auto textures = Textures{};

+

+    // Define helpers.

+    static auto const unit_to_front = [&](Units::iterator const & unit_it)

+    {

+        if (unit_it != units.begin())

+            units.splice(units.begin(), units, unit_it, std::next(unit_it));

+    };

+    static auto const target_name = [](GLenum target)

+    {

+        return

+            STR_COND(target, GL_TEXTURE_1D)

+            STR_COND(target, GL_TEXTURE_2D)

+            STR_COND(target, GL_TEXTURE_3D)

+            STR_COND(target, GL_TEXTURE_1D_ARRAY)

+            STR_COND(target, GL_TEXTURE_2D_ARRAY)

+            STR_COND(target, GL_TEXTURE_RECTANGLE)

+            STR_COND(target, GL_TEXTURE_CUBE_MAP)

+            STR_COND(target, GL_TEXTURE_CUBE_MAP_ARRAY)

+            STR_COND(target, GL_TEXTURE_BUFFER)

+            STR_COND(target, GL_TEXTURE_2D_MULTISAMPLE)

+            STR_COND(target, GL_TEXTURE_2D_MULTISAMPLE_ARRAY)

+            STR(std::hex << std::showbase << target);

+    };

+

+    // Check textures.

+    auto texture_it = textures.find(texture);

+    if (texture_it != textures.end() && texture_it->second->texture == texture)

+    {

+        // Check for errors.

+        if (texture_it->second->target != target)

+            throw std::runtime_error{STR(

+                "Failed to set texture " << texture << "; " <<

+                "expected target " << target_name(texture_it->second->target)

+                << " but got " << target_name(target) << "."

+            )};

+

+        // Update units.

+        unit_to_front(texture_it->second);

+    }

+    else

+    {

+        // Update units.

+        if (units.size() < max_combined_texture_image_units)

+        {

+            units.emplace_front(Unit{(GLuint)units.size(), target, texture});

+        }

+        else

+        {

+            unit_to_front(std::prev(units.end()));

+            units.front().target = target;

+            units.front().texture = texture;

+        }

+

+        // Update textures.

+        if (texture_it == textures.end())

+            textures.emplace(texture, units.begin());

+        else

+            texture_it->second = units.begin();

+

+        // Bind.

+        auto const error = STR(

+            "Failed to bind texture " << texture << " to target " <<

+            target_name(target)

+        );

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

+        glActiveTexture(GL_TEXTURE0 + units.front().unit);

+        glBindTexture(target, texture);

+        error_(error, "wrong target?");

+    }

+

+    // Set uniform.

+    uniform(name, (GLint)units.front().unit, required);

+

+    // Return.

+    return *this;

+}

@@ -208,6 +208,24 @@ GLTEST(2, 0, 640, 480, glshader)

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

     )

+    // Texture.

+    auto texture0 = GLuint{};

+    glGenTextures(1, &texture0);

+    GLTEST_EXPECT_EXCEPTION(false,

+        Shader({"tests/texture.vert"}).use().texture("texture0", texture0, GL_TEXTURE_2D).texture("texture0", texture0, GL_TEXTURE_3D),

+        "Failed to set texture 1; "

+        "expected target GL_TEXTURE_2D but got GL_TEXTURE_3D."

+    )

+    auto texture1 = GLuint{};

+    glGenTextures(1, &texture1);

+    glActiveTexture(GL_TEXTURE0);

+    glBindTexture(GL_TEXTURE_3D, texture1);

+    GLTEST_EXPECT_EXCEPTION(false,

+        Shader({"tests/texture.vert"}).use().texture("texture0", texture1, GL_TEXTURE_2D),

+        "Failed to bind texture 2 to target GL_TEXTURE_2D; "

+        "got error GL_INVALID_OPERATION (wrong target?)."

+    )

+

     auto all = Shader({

         "tests/all.vert",

         "tests/all.frag",