@@ -20,6 +20,9 @@ Overview of usage:

 // Global data.

 constexpr auto light_count_max = 32;

+constexpr auto vert_position  = 0;

+constexpr auto vert_tex_coord = 1;

+constexpr auto frag_color = 0;

 int main()

@@ -29,6 +32,13 @@ int main()

     Shader::defines({

         {"light_count_max", std::to_string(light_count_max)},

     });

+    Shader::verts({

+        {"vert_position",  vert_position},

+        {"vert_tex_coord", vert_tex_coord},

+    });

+    Shader::frags({

+        {"frag_color", frag_color},

+    });

     // Create.

     auto player = Shader({

@@ -202,6 +212,37 @@ been seen before.

 [`glNamedStringARB`]: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_shading_language_include.txt

 [`glCompileShaderIncludeARB`]: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_shading_language_include.txt

+### User-defined vertex inputs (attributes) and fragment outputs (data)

+

+Locations for user-defined [vertex inputs][] (attributes) and [fragment

+outputs][] (data, requires OpenGL >= 3.0) can be specified by calling

+`Shader::verts(Shader::Locations const & verts)` and

+`Shader::frags(Shader::Locations const & frags)` respectively before

+instantiating a `Shader` that uses them. `Shader::Locations` is an alias for

+`std::map<std::string, GLuint>`. Any `location` [layout qualifier][] overrides

+the values specified this way. Note that a `Shader` object retains the input

+and output locations that were in effect when it was instantiated. See

+[`glBindAttribLocation`][] and [`glBindFragDataLocation`][]. Note that fragment

+outputs are subject to [`glDrawBuffer`][] / [`glDrawBuffers`][].

+

+An error is thrown if a shader uses a non-specified input. No error is thrown

+for non-specified outputs (this is mostly a result of the inability to

+enumerate shader outputs before the introduction of the [program interface

+query][]). Shaders need not use all of the specified inputs/outputs.

+

+The intent is for the application to define global unchanging input/output

+locations that are used by all shaders, geometry and framebuffers and set them

+up once at application startup.

+

+[vertex inputs]: https://www.khronos.org/opengl/wiki/Vertex_Shader#Inputs

+[fragment outputs]: https://www.khronos.org/opengl/wiki/Fragment_Shader#Outputs

+[layout qualifier]: https://www.khronos.org/opengl/wiki/Layout_Qualifier_(GLSL)

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

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

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

+[`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

+

 ## Dependencies

 Public (interface):

@@ -18,7 +18,10 @@

 #include <tests/all_subdir/all_recursive.h>

+attribute vec4 vert_position;

+

+

 void main()

 {

-    gl_Position = gl_Vertex;

+    gl_Position = gl_Vertex + vert_position;

 }

new file mode 100644

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

+# version 110

+

+

+attribute vec4 vert_unset;

+

+

+void main()

+{

+    gl_Position = gl_Vertex + vert_unset;

+}

@@ -23,9 +23,12 @@ public:

     Shader & operator=(Shader const &) = delete;

     using Defines = std::map<std::string, std::string>;

+    using Locations = std::map<std::string, GLuint>;

     static void root(std::string const & root);

     static void defines(Defines const & defines);

+    static void verts(Locations const & verts);

+    static void frags(Locations const & frags);

     GLuint program() const;

@@ -43,6 +46,8 @@ protected:

     std::string        program_name_;

     std::string static root_;

     Defines     static defines_;

+    Locations   static verts_;

+    Locations   static frags_;

 };

@@ -64,6 +69,8 @@ protected:

     }

 GLSHADER_SET_(std::string, root)

 GLSHADER_SET_(Defines, defines)

+GLSHADER_SET_(Locations, verts)

+GLSHADER_SET_(Locations, frags)

 inline GLuint Shader::program() const

 {

@@ -23,10 +23,15 @@

 using Here = std::tuple<std::string, int, std::string>;

+constexpr auto max_length_workaround = 4096;

+

+

 // NOLINTNEXTLINE

 #define GLSHADER_INIT_(NAME, INIT) decltype(NAME) NAME INIT;

 GLSHADER_INIT_(Shader::root_, {})

 GLSHADER_INIT_(Shader::defines_, {})

+GLSHADER_INIT_(Shader::verts_, {})

+GLSHADER_INIT_(Shader::frags_, {})

 template<typename Type>

@@ -340,6 +345,34 @@ static std::string source_(

 }

+template<typename Function>

+static void for_variable_(

+    GLuint program,

+    GLenum count_enum,

+    GLenum max_length_enum,

+    Function function

+)

+{

+    // Get count.

+    auto count = GLuint{};

+    glGetProgramiv(program, count_enum, (GLint *)&count);

+

+    // Get max length.

+    auto max_length = GLsizei{};

+    glGetProgramiv(program, max_length_enum, &max_length);

+

+    // Work around driver bugs.

+    if (max_length == 0 && count != 0)

+        max_length = max_length_workaround;

+

+    // Allocate and call function.

+    // NOLINTNEXTLINE

+    auto name = std::unique_ptr<GLchar[]>(new GLchar[max_length]);

+    for (auto index = GLuint{0}; index < count; ++index)

+        function(index, max_length, &name[0]);

+}

+

+

 Shader::Shader(Paths const & paths)

 :

     program_{0},

@@ -441,6 +474,19 @@ Shader::Shader(Paths const & paths)

             );

         }

+        // Set vertex input locations.

+        for (auto const & vert : verts_)

+            glBindAttribLocation(

+                program_, vert.second, vert.first.c_str()

+            );

+

+        // Set fragment output locations.

+        if (GLEW_VERSION_3_0)

+            for (auto const & frag : frags_)

+                glBindFragDataLocation(

+                    program_, frag.second, frag.first.c_str()

+                );

+

         // Link program.

         info_log_action_(

             STR("Failed to link " << program_name_),

@@ -451,6 +497,27 @@ Shader::Shader(Paths const & paths)

         // Detach shaders.

         for (auto const & shader : shaders)

             glDetachShader(program_, shader);

+

+        // Initialize vertex inputs.

+        for_variable_(

+            program_,

+            GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,

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

+            {

+                GLint  size{};

+                GLenum type{};

+                glGetActiveAttrib(

+                    program_, index, max_length,

+                    nullptr, &size, &type, name

+                );

+                auto location = glGetAttribLocation(program_, name);

+                if (location != -1 && verts_.find(name) == verts_.end())

+                    throw std::runtime_error{STR(

+                        "Failed to initialize vertex input '" << name <<

+                        "' of " << program_name_ << "."

+                    )};

+            }

+        );

     }

     catch (...)

     {

@@ -125,6 +125,18 @@ GLTEST(2, 0, 640, 480, glshader)

         "assets/shaders/tests/include_nested_extension.vert:7: #include \"include_nested_extension.h\""

     )

+    // Vertex inputs.

+    constexpr auto vert_position  = 0;

+    constexpr auto vert_tex_coord = 1;

+    Shader::verts({

+        {"vert_position",  vert_position},

+        {"vert_tex_coord", vert_tex_coord},

+    });

+    GLTEST_EXPECT_EXCEPTION(false,

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

+        "Failed to initialize vertex input 'vert_unset' of shader program 'tests/vert_unset.vert'."

+    );

+

     auto all = Shader({

         "tests/all.vert",

         "tests/all.frag",