Port away from deprecated Shaders functionality.

What's especially nice is that the code snippets no longer need to
describe that there's "2 lights, 3 materials and 5 draws" because now
it's self-documenting.

doc/generated/primitives.cpp

@@ -278,7 +278,8 @@ int PrimitiveVisualizer::exec() {
         }
     }
 
-    Shaders::MeshVisualizerGL2D wireframe2D{Shaders::MeshVisualizerGL2D::Flag::Wireframe};
+    Shaders::MeshVisualizerGL2D wireframe2D{Shaders::MeshVisualizerGL2D::Configuration{}
+        .setFlags(Shaders::MeshVisualizerGL2D::Flag::Wireframe)};
     wireframe2D.setColor(0x00000000_srgbaf)
         .setWireframeColor(OutlineColor)
         .setWireframeWidth(2.0f)
@@ -309,7 +310,8 @@ int PrimitiveVisualizer::exec() {
         }
     }
 
-    Shaders::MeshVisualizerGL3D wireframe3D{Shaders::MeshVisualizerGL3D::Flag::Wireframe};
+    Shaders::MeshVisualizerGL3D wireframe3D{Shaders::MeshVisualizerGL3D::Configuration{}
+        .setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe)};
     wireframe3D.setColor(0x00000000_srgbaf)
         .setWireframeColor(OutlineColor)
         .setWireframeWidth(2.0f)

doc/generated/shaders.cpp

@@ -180,7 +180,9 @@ std::string ShaderVisualizer::meshVisualizer2D() {
         Matrix3::projection(Vector2{3.0f})*
         Matrix3::rotation(13.7_degf);
 
-    Shaders::MeshVisualizerGL2D{Shaders::MeshVisualizerGL2D::Flag::Wireframe}
+    Shaders::MeshVisualizerGL2D shader{Shaders::MeshVisualizerGL2D::Configuration{}
+        .setFlags(Shaders::MeshVisualizerGL2D::Flag::Wireframe)};
+    shader
         .setColor(BaseColor)
         .setWireframeColor(OutlineColor)
         .setWireframeWidth(2.0f)
@@ -206,7 +208,9 @@ std::string ShaderVisualizer::meshVisualizer2DPrimitiveId() {
         .setStorage(1, GL::TextureFormat::SRGB8Alpha8, size)
         .setSubImage(0, {}, ImageView2D{PixelFormat::RGB8Srgb, size, map});
 
-    Shaders::MeshVisualizerGL2D{Shaders::MeshVisualizerGL2D::Flag::PrimitiveId}
+    Shaders::MeshVisualizerGL2D shader{Shaders::MeshVisualizerGL2D::Configuration{}
+        .setFlags(Shaders::MeshVisualizerGL2D::Flag::PrimitiveId)};
+    shader
         .setTransformationProjectionMatrix(projection)
         .setColorMapTransformation(1.0f/255.0f, 1.0f/8.0f)
         .bindColorMapTexture(colorMapTexture)
@@ -220,10 +224,12 @@ std::string ShaderVisualizer::meshVisualizer3D() {
         Matrix4::rotationZ(13.7_degf)*
         Matrix4::rotationX(-12.6_degf);
 
-    Shaders::MeshVisualizerGL3D{Shaders::MeshVisualizerGL3D::Flag::Wireframe|
+    Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
+        .setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe|
                   Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
                   Shaders::MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|
-                              Shaders::MeshVisualizerGL3D::Flag::NormalDirection}
+                  Shaders::MeshVisualizerGL3D::Flag::NormalDirection)};
+    shader
         .setColor(BaseColor)
         .setWireframeColor(OutlineColor)
         .setWireframeWidth(2.0f)
@@ -253,7 +259,9 @@ std::string ShaderVisualizer::meshVisualizer3DPrimitiveId() {
         .setStorage(1, GL::TextureFormat::SRGB8Alpha8, size)
         .setSubImage(0, {}, ImageView2D{PixelFormat::RGB8Srgb, size, map});
 
-    Shaders::MeshVisualizerGL3D{Shaders::MeshVisualizerGL3D::Flag::PrimitiveId}
+    Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
+        .setFlags(Shaders::MeshVisualizerGL3D::Flag::PrimitiveId)};
+    shader
         .setTransformationMatrix(transformation)
         .setProjectionMatrix(Projection)
         .setColorMapTransformation(1.0f/255.0f, 1.0f/32.0f)

doc/snippets/MagnumShaders-gl.cpp

@@ -145,7 +145,8 @@ drawUniform.setData({
         .setNormalMatrix(transformationMatrix.normalMatrix())
 });
 
-Shaders::PhongGL shader{Shaders::PhongGL::Flag::UniformBuffers};
+Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
+    .setFlags(Shaders::PhongGL::Flag::UniformBuffers)};
 shader
     .bindProjectionBuffer(projectionUniform)
     .bindLightBuffer(lightUniform)
@@ -191,8 +192,11 @@ drawUniform.setData({
         .setMaterialId(0),
 });
 
-/* One light, two materials, three draws */
-Shaders::PhongGL shader{Shaders::PhongGL::Flag::UniformBuffers, 1, 2, 3};
+Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
+    .setFlags(Shaders::PhongGL::Flag::UniformBuffers)
+    .setLightCount(1)
+    .setMaterialCount(2)
+    .setDrawCount(3)};
 shader
     .bindProjectionBuffer(projectionUniform)
     .bindTransformationBuffer(transformationUniform)
@@ -214,8 +218,11 @@ GL::Mesh mesh;
 GL::MeshView redConeView{DOXYGEN_ELLIPSIS(mesh)}, yellowCubeView{DOXYGEN_ELLIPSIS(mesh)}, redSphereView{DOXYGEN_ELLIPSIS(mesh)};
 DOXYGEN_ELLIPSIS()
 
-/* One light, two materials, three draws; with multidraw enabled */
-Shaders::PhongGL shader{Shaders::PhongGL::Flag::MultiDraw, 1, 2, 3};
+Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
+    .setFlags(Shaders::PhongGL::Flag::MultiDraw)
+    .setLightCount(1)
+    .setMaterialCount(2)
+    .setDrawCount(3)};
 shader
     DOXYGEN_ELLIPSIS()
     .draw({redConeView, yellowCubeView, redSphereView});
@@ -253,8 +260,9 @@ sphereInstanced.addVertexBufferInstanced(GL::Buffer{instanceData}, 1, 0,
     Shaders::PhongGL::Color3{});
 sphereInstanced.setInstanceCount(3);
 
-Shaders::PhongGL shader{Shaders::PhongGL::Flag::InstancedTransformation|
-                        Shaders::PhongGL::Flag::VertexColor};
+Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
+    .setFlags(Shaders::PhongGL::Flag::InstancedTransformation|
+              Shaders::PhongGL::Flag::VertexColor)};
 shader
     .setProjectionMatrix(projectionMatrix)
     DOXYGEN_ELLIPSIS()
@@ -268,7 +276,8 @@ GL::Mesh mesh;
 GL::Texture2D diffuseTexture;
 DOXYGEN_ELLIPSIS()
 
-Shaders::PhongGL shader{Shaders::PhongGL::Flag::DiffuseTexture};
+Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
+    .setFlags(Shaders::PhongGL::Flag::DiffuseTexture)};
 shader.bindDiffuseTexture(diffuseTexture)
     DOXYGEN_ELLIPSIS()
     .draw(mesh);
@@ -302,11 +311,13 @@ textureTransformationUniform.setData({
         .setLayer(2),
 });
 
-Shaders::PhongGL shader{
-    Shaders::PhongGL::Flag::MultiDraw|
+Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
+    .setFlags(Shaders::PhongGL::Flag::MultiDraw|
               Shaders::PhongGL::Flag::DiffuseTexture|
-    Shaders::PhongGL::Flag::TextureArrays,
-    1, 2, 3};
+              Shaders::PhongGL::Flag::TextureArrays)
+    .setLightCount(1)
+    .setMaterialCount(2)
+    .setDrawCount(3)};
 shader
     DOXYGEN_ELLIPSIS()
     .bindDiffuseTexture(diffuseTexture)
@@ -331,7 +342,8 @@ mesh.addVertexBuffer(vertices, 0,
 GL::Mesh mesh;
 Matrix4 transformationMatrix, projectionMatrix;
 /* [shaders-meshvisualizer] */
-Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Flag::Wireframe};
+Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
+    .setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe)};
 shader
     .setColor(0x2f83cc_rgbf)
     .setWireframeColor(0xdcdcdc_rgbf)
@@ -347,9 +359,11 @@ shader
 Shaders::FlatGL3D::CompileState flatState =
     Shaders::FlatGL3D::compile();
 Shaders::FlatGL3D::CompileState flatTexturedState =
-    Shaders::FlatGL3D::compile(Shaders::FlatGL3D::Flag::Textured);
+    Shaders::FlatGL3D::compile(
+        Shaders::FlatGL3D::Configuration{}
+            .setFlags(Shaders::FlatGL3D::Flag::Textured));
 Shaders::MeshVisualizerGL3D::CompileState meshVisualizerState =
-    Shaders::MeshVisualizerGL3D::compile(DOXYGEN_ELLIPSIS(Shaders::MeshVisualizerGL3D::Flag::Wireframe));
+    Shaders::MeshVisualizerGL3D::compile(DOXYGEN_ELLIPSIS(Shaders::MeshVisualizerGL3D::Configuration{}));
 
 while(!flatState.isLinkFinished() ||
       !flatTexturedState.isLinkFinished() ||
@@ -428,8 +442,8 @@ drawUniform.setData({
 });
 
 Shaders::DistanceFieldVectorGL2D shader{
-    Shaders::DistanceFieldVectorGL2D::Flag::UniformBuffers
-};
+    Shaders::DistanceFieldVectorGL2D::Configuration{}
+        .setFlags(Shaders::DistanceFieldVectorGL2D::Flag::UniformBuffers)};
 shader
     .bindTransformationProjectionBuffer(projectionTransformationUniform)
     .bindMaterialBuffer(materialUniform)
@@ -498,7 +512,8 @@ mesh.addVertexBuffer(vertices, 0,
 Matrix4 transformationMatrix, projectionMatrix;
 GL::Texture2D texture;
 
-Shaders::FlatGL3D shader{Shaders::FlatGL3D::Flag::Textured};
+Shaders::FlatGL3D shader{Shaders::FlatGL3D::Configuration{}
+    .setFlags(Shaders::FlatGL3D::Flag::Textured)};
 shader.setTransformationProjectionMatrix(projectionMatrix*transformationMatrix)
     .bindTexture(texture)
     .draw(mesh);
@@ -519,7 +534,8 @@ objectId.setStorage(GL::RenderbufferFormat::R16UI, size); // large as needed
 framebuffer.attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, color)
     .attachRenderbuffer(GL::Framebuffer::ColorAttachment{1}, objectId);
 
-Shaders::FlatGL3D shader{Shaders::FlatGL3D::Flag::ObjectId};
+Shaders::FlatGL3D shader{Shaders::FlatGL3D::Configuration{}
+    .setFlags(Shaders::FlatGL3D::Flag::ObjectId)};
 
 // ...
 
@@ -581,7 +597,8 @@ drawUniform.setData({
         .setMaterialId(0)
 });
 
-Shaders::FlatGL3D shader{Shaders::FlatGL3D::Flag::UniformBuffers};
+Shaders::FlatGL3D shader{Shaders::FlatGL3D::Configuration{}
+    .setFlags(Shaders::FlatGL3D::Flag::UniformBuffers)};
 shader
     .bindTransformationProjectionBuffer(projectionTransformationUniform)
     .bindMaterialBuffer(materialUniform)
@@ -677,7 +694,8 @@ Matrix4 transformationMatrix = Matrix4::translation(Vector3::zAxis(-5.0f));
 Matrix4 projectionMatrix =
     Matrix4::perspectiveProjection(35.0_degf, 1.0f, 0.001f, 100.0f);
 
-Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Flag::Wireframe};
+Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
+    .setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe)};
 shader.setColor(0x2f83cc_rgbf)
     .setWireframeColor(0xdcdcdc_rgbf)
     .setViewportSize(Vector2{GL::defaultFramebuffer.viewport().size()})
@@ -726,10 +744,10 @@ mesh.addVertexBuffer(vertices, 0,
 /* [MeshVisualizerGL3D-usage-tbn2] */
 Matrix4 transformationMatrix, projectionMatrix;
 
-Shaders::MeshVisualizerGL3D shader{
-    Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
+Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
+    .setFlags(Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
               Shaders::MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|
-    Shaders::MeshVisualizerGL3D::Flag::NormalDirection};
+              Shaders::MeshVisualizerGL3D::Flag::NormalDirection)};
 shader.setViewportSize(Vector2{GL::defaultFramebuffer.viewport().size()})
     .setTransformationMatrix(transformationMatrix)
     .setProjectionMatrix(projectionMatrix)
@@ -759,9 +777,9 @@ GL::Mesh mesh;
 /* [MeshVisualizerGL3D-usage-no-geom2] */
 Matrix4 transformationMatrix, projectionMatrix;
 
-Shaders::MeshVisualizerGL3D shader{
-    Shaders::MeshVisualizerGL3D::Flag::Wireframe|
-    Shaders::MeshVisualizerGL3D::Flag::NoGeometryShader};
+Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
+    .setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe|
+              Shaders::MeshVisualizerGL3D::Flag::NoGeometryShader)};
 shader.setColor(0x2f83cc_rgbf)
     .setWireframeColor(0xdcdcdc_rgbf)
     .setTransformationMatrix(transformationMatrix)
@@ -787,8 +805,8 @@ colorMapTexture
     .setStorage(1, GL::TextureFormat::RGBA8, size)
     .setSubImage(0, {}, ImageView2D{PixelFormat::RGB8Srgb, size, map});
 
-Shaders::MeshVisualizerGL3D shader{
-    Shaders::MeshVisualizerGL3D::Flag::InstancedObjectId};
+Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
+    .setFlags(Shaders::MeshVisualizerGL3D::Flag::InstancedObjectId)};
 shader.setColorMapTransformation(0.0f, 1.0f/Math::max(objectIds))
     .setTransformationMatrix(transformationMatrix)
     .setProjectionMatrix(projectionMatrix)
@@ -824,9 +842,9 @@ drawUniform.setData({
         .setMaterialId(0)
 });
 
-Shaders::MeshVisualizerGL3D shader{
-    Shaders::MeshVisualizerGL3D::Flag::Wireframe|
-    Shaders::MeshVisualizerGL3D::Flag::UniformBuffers
+Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
+    .setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe|
+              Shaders::MeshVisualizerGL3D::Flag::UniformBuffers)
 };
 shader
     .setViewportSize(Vector2{GL::defaultFramebuffer.viewport().size()})
@@ -923,8 +941,9 @@ mesh.addVertexBuffer(vertices, 0,
 Matrix4 transformationMatrix, projectionMatrix;
 GL::Texture2D diffuseTexture, specularTexture;
 
-Shaders::PhongGL shader{Shaders::PhongGL::Flag::DiffuseTexture|
-                      Shaders::PhongGL::Flag::SpecularTexture};
+Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
+    .setFlags(Shaders::PhongGL::Flag::DiffuseTexture|
+              Shaders::PhongGL::Flag::SpecularTexture)};
 shader.bindTextures(nullptr, &diffuseTexture, &specularTexture, nullptr)
     .setTransformationMatrix(transformationMatrix)
     .setNormalMatrix(transformationMatrix.normalMatrix())
@@ -938,7 +957,8 @@ shader.bindTextures(nullptr, &diffuseTexture, &specularTexture, nullptr)
 /* [PhongGL-usage-lights] */
 Matrix4 directionalLight, pointLight1, pointLight2; // camera-relative
 
-Shaders::PhongGL shader{{}, 3}; // 3 lights
+Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
+    .setLightCount(3)};
 shader
     .setLightPositions({Vector4{directionalLight.up(), 0.0f},
                         Vector4{pointLight1.translation(), 1.0f},
@@ -959,7 +979,8 @@ GL::Texture2D diffuseTexture;
 /* [PhongGL-usage-lights-ambient] */
 Trade::LightData ambientLight = DOXYGEN_ELLIPSIS(Trade::LightData{{}, {}, {}});
 
-Shaders::PhongGL shader{Shaders::PhongGL::Flag::AmbientTexture|DOXYGEN_ELLIPSIS(Shaders::PhongGL::Flag::DiffuseTexture), DOXYGEN_ELLIPSIS(3)};
+Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
+    .setFlags(Shaders::PhongGL::Flag::AmbientTexture|DOXYGEN_ELLIPSIS(Shaders::PhongGL::Flag::DiffuseTexture))};
 shader
     .setAmbientColor(ambientColor + ambientLight.color()*ambientLight.intensity())
     .bindAmbientTexture(diffuseTexture)
@@ -971,8 +992,9 @@ shader
 GL::Texture2D diffuseAlphaTexture;
 Color3 diffuseRgb, specularRgb;
 /* [PhongGL-usage-alpha] */
-Shaders::PhongGL shader{Shaders::PhongGL::Flag::AmbientTexture|
-                      Shaders::PhongGL::Flag::DiffuseTexture};
+Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
+    .setFlags(Shaders::PhongGL::Flag::AmbientTexture|
+              Shaders::PhongGL::Flag::DiffuseTexture)};
 shader.bindTextures(&diffuseAlphaTexture, &diffuseAlphaTexture, nullptr, nullptr)
     .setAmbientColor(0x000000ff_rgbaf)
     .setDiffuseColor(Color4{diffuseRgb, 0.0f})
@@ -1010,7 +1032,8 @@ drawUniform.setData({
         .setMaterialId(0)
 });
 
-Shaders::PhongGL shader{Shaders::PhongGL::Flag::UniformBuffers};
+Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
+    .setFlags(Shaders::PhongGL::Flag::UniformBuffers)};
 shader
     .bindProjectionBuffer(projectionUniform)
     .bindLightBuffer(lightUniform)
@@ -1075,7 +1098,8 @@ drawUniform.setData({
         .setMaterialId(0)
 });
 
-Shaders::VectorGL2D shader{Shaders::VectorGL2D::Flag::UniformBuffers};
+Shaders::VectorGL2D shader{Shaders::VectorGL2D::Configuration{}
+    .setFlags(Shaders::VectorGL2D::Flag::UniformBuffers)};
 shader
     .bindTransformationProjectionBuffer(projectionTransformationUniform)
     .bindMaterialBuffer(materialUniform)
@@ -1129,7 +1153,8 @@ projectionTransformationUniform.setData({
         .setTransformationProjectionMatrix(projectionMatrix*transformationMatrix)
 });
 
-Shaders::VertexColorGL3D shader{Shaders::VertexColorGL3D::Flag::UniformBuffers};
+Shaders::VertexColorGL3D shader{Shaders::VertexColorGL3D::Configuration{}
+    .setFlags(Shaders::VertexColorGL3D::Flag::UniformBuffers)};
 shader
     .bindTransformationProjectionBuffer(projectionTransformationUniform)
     .draw(mesh);

src/Magnum/MeshTools/Test/CompileGLTest.cpp

@@ -123,12 +123,14 @@ struct CompileGLTest: GL::OpenGLTester {
         PluginManager::Manager<Trade::AbstractImporter> _manager{"nonexistent"};
 
         Shaders::FlatGL2D _flat2D;
-        Shaders::FlatGL2D _flatTextured2D{Shaders::FlatGL2D::Flag::Textured};
+        Shaders::FlatGL2D _flatTextured2D{Shaders::FlatGL2D::Configuration{}
+            .setFlags(Shaders::FlatGL2D::Flag::Textured)};
         #ifndef MAGNUM_TARGET_GLES2
         Shaders::FlatGL2D _flatObjectId2D{NoCreate};
         #endif
         Shaders::FlatGL3D _flat3D;
-        Shaders::FlatGL3D _flatTextured3D{Shaders::FlatGL3D::Flag::Textured};
+        Shaders::FlatGL3D _flatTextured3D{Shaders::FlatGL3D::Configuration{}
+            .setFlags(Shaders::FlatGL3D::Flag::Textured)};
         #ifndef MAGNUM_TARGET_GLES2
         Shaders::FlatGL3D _flatObjectId3D{NoCreate};
         #endif
@@ -331,8 +333,10 @@ CompileGLTest::CompileGLTest() {
     if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
     #endif
     {
-        _flatObjectId2D = Shaders::FlatGL2D{Shaders::FlatGL2D::Flag::InstancedObjectId};
-        _flatObjectId3D = Shaders::FlatGL3D{Shaders::FlatGL3D::Flag::InstancedObjectId};
+        _flatObjectId2D = Shaders::FlatGL2D{Shaders::FlatGL2D::Configuration{}
+            .setFlags(Shaders::FlatGL2D::Flag::InstancedObjectId)};
+        _flatObjectId3D = Shaders::FlatGL3D{Shaders::FlatGL3D::Configuration{}
+            .setFlags(Shaders::FlatGL3D::Flag::InstancedObjectId)};
         _objectId.setStorage(GL::RenderbufferFormat::R32UI, {32, 32});
         _framebuffer
             .attachRenderbuffer(GL::Framebuffer::ColorAttachment{1}, _objectId)
@@ -351,14 +355,14 @@ CompileGLTest::CompileGLTest() {
     if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
     #endif
     {
-        _meshVisualizer3D = Shaders::MeshVisualizerGL3D{
-            Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
+        _meshVisualizer3D = Shaders::MeshVisualizerGL3D{Shaders::MeshVisualizerGL3D::Configuration{}
+            .setFlags(Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
                       Shaders::MeshVisualizerGL3D::Flag::BitangentDirection|
-            Shaders::MeshVisualizerGL3D::Flag::NormalDirection};
-        _meshVisualizerBitangentsFromTangents3D = Shaders::MeshVisualizerGL3D{
-            Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
+                      Shaders::MeshVisualizerGL3D::Flag::NormalDirection)};
+        _meshVisualizerBitangentsFromTangents3D = Shaders::MeshVisualizerGL3D{Shaders::MeshVisualizerGL3D::Configuration{}
+            .setFlags(Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
                       Shaders::MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|
-            Shaders::MeshVisualizerGL3D::Flag::NormalDirection};
+                      Shaders::MeshVisualizerGL3D::Flag::NormalDirection)};
     }
     #endif
 }

src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp

@@ -374,7 +374,8 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::construct() {
     auto&& data = ConstructData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    DistanceFieldVectorGL<dimensions> shader{data.flags};
+    DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
+        .setFlags(data.flags)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_VERIFY(shader.id());
     {
@@ -390,7 +391,8 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::construct() {
 template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructAsync() {
     setTestCaseTemplateName(Utility::format("{}", dimensions));
 
-    typename DistanceFieldVectorGL<dimensions>::CompileState state = DistanceFieldVectorGL<dimensions>::compile(DistanceFieldVectorGL2D::Flag::TextureTransformation);
+    typename DistanceFieldVectorGL<dimensions>::CompileState state = DistanceFieldVectorGL<dimensions>::compile(typename DistanceFieldVectorGL<dimensions>::Configuration{}
+        .setFlags(DistanceFieldVectorGL2D::Flag::TextureTransformation));
     CORRADE_COMPARE(state.flags(), DistanceFieldVectorGL2D::Flag::TextureTransformation);
 
     while(!state.isLinkFinished())
@@ -435,7 +437,10 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructUnifor
         #endif
     }
 
-    DistanceFieldVectorGL<dimensions> shader{data.flags, data.materialCount, data.drawCount};
+    DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
+        .setFlags(data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_COMPARE(shader.materialCount(), data.materialCount);
     CORRADE_COMPARE(shader.drawCount(), data.drawCount);
@@ -458,7 +463,10 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructUnifor
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    typename DistanceFieldVectorGL<dimensions>::CompileState state = DistanceFieldVectorGL<dimensions>::compile(DistanceFieldVectorGL2D::Flag::UniformBuffers, 16, 48);
+    typename DistanceFieldVectorGL<dimensions>::CompileState state = DistanceFieldVectorGL<dimensions>::compile(typename DistanceFieldVectorGL<dimensions>::Configuration{}
+        .setFlags(DistanceFieldVectorGL2D::Flag::UniformBuffers)
+        .setMaterialCount(16)
+        .setDrawCount(48));
     CORRADE_COMPARE(state.flags(), DistanceFieldVectorGL2D::Flag::UniformBuffers);
     CORRADE_COMPARE(state.materialCount(), 16);
     CORRADE_COMPARE(state.drawCount(), 48);
@@ -486,7 +494,8 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructUnifor
 template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructMove() {
     setTestCaseTemplateName(Utility::format("{}", dimensions));
 
-    DistanceFieldVectorGL<dimensions> a{DistanceFieldVectorGL<dimensions>::Flag::TextureTransformation};
+    DistanceFieldVectorGL<dimensions> a{typename DistanceFieldVectorGL<dimensions>::Configuration{}
+        .setFlags(DistanceFieldVectorGL<dimensions>::Flag::TextureTransformation)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -513,7 +522,10 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructMoveUn
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    DistanceFieldVectorGL<dimensions> a{DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers, 2, 5};
+    DistanceFieldVectorGL<dimensions> a{typename DistanceFieldVectorGL<dimensions>::Configuration{}
+        .setFlags(DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers)
+        .setMaterialCount(2)
+        .setDrawCount(5)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -552,7 +564,10 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructUnifor
 
     std::ostringstream out;
     Error redirectError{&out};
-    DistanceFieldVectorGL<dimensions>{data.flags, data.materialCount, data.drawCount};
+    DistanceFieldVectorGL<dimensions>{typename DistanceFieldVectorGL<dimensions>::Configuration{}
+        .setFlags(data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(out.str(), Utility::formatString(
         "Shaders::DistanceFieldVectorGL: {}\n", data.message));
 }
@@ -572,7 +587,8 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::setUniformUnifo
     std::ostringstream out;
     Error redirectError{&out};
 
-    DistanceFieldVectorGL<dimensions> shader{DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers};
+    DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
+        .setFlags(DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers)};
     shader.setTransformationProjectionMatrix({})
         .setTextureMatrix({})
         .setColor({})
@@ -650,7 +666,8 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::bindTextureTran
     Error redirectError{&out};
 
     GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
-    DistanceFieldVectorGL<dimensions> shader{DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers};
+    DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
+        .setFlags(DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers)};
     shader.bindTextureTransformationBuffer(buffer)
           .bindTextureTransformationBuffer(buffer, 0, 16);
     CORRADE_COMPARE(out.str(),
@@ -672,8 +689,11 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::setWrongDrawOff
 
     std::ostringstream out;
     Error redirectError{&out};
-    DistanceFieldVectorGL<dimensions>{DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers, 2, 5}
-        .setDrawOffset(5);
+    DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
+        .setFlags(DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers)
+        .setMaterialCount(2)
+        .setDrawCount(5)};
+    shader.setDrawOffset(5);
     CORRADE_COMPARE(out.str(),
         "Shaders::DistanceFieldVectorGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
 }
@@ -751,7 +771,8 @@ template<DistanceFieldVectorGL2D::Flag flag> void DistanceFieldVectorGLTest::ren
         .setSubImage(0, {}, *image);
     #endif
 
-    DistanceFieldVectorGL2D shader{flag};
+    DistanceFieldVectorGL2D shader{DistanceFieldVectorGL2D::Configuration{}
+        .setFlags(flag)};
     shader.bindVectorTexture(texture);
 
     if(flag == DistanceFieldVectorGL2D::Flag{}) {
@@ -839,7 +860,8 @@ template<DistanceFieldVectorGL3D::Flag flag> void DistanceFieldVectorGLTest::ren
         .setSubImage(0, {}, *image);
     #endif
 
-    DistanceFieldVectorGL3D shader{flag};
+    DistanceFieldVectorGL3D shader{DistanceFieldVectorGL3D::Configuration{}
+        .setFlags(flag)};
     shader.bindVectorTexture(texture);
 
     if(flag == DistanceFieldVectorGL3D::Flag{}) {
@@ -930,7 +952,8 @@ template<DistanceFieldVectorGL2D::Flag flag> void DistanceFieldVectorGLTest::ren
         .setSubImage(0, {}, *image);
     #endif
 
-    DistanceFieldVectorGL2D shader{data.flags|flag};
+    DistanceFieldVectorGL2D shader{DistanceFieldVectorGL2D::Configuration{}
+        .setFlags(data.flags|flag)};
     shader.bindVectorTexture(texture);
 
     if(flag == DistanceFieldVectorGL2D::Flag{}) {
@@ -1038,7 +1061,8 @@ template<DistanceFieldVectorGL3D::Flag flag> void DistanceFieldVectorGLTest::ren
         .setSubImage(0, {}, *image);
     #endif
 
-    DistanceFieldVectorGL3D shader{data.flags|flag};
+    DistanceFieldVectorGL3D shader{DistanceFieldVectorGL3D::Configuration{}
+        .setFlags(data.flags|flag)};
     shader.bindVectorTexture(texture);
 
     if(flag == DistanceFieldVectorGL3D::Flag{}) {
@@ -1235,7 +1259,10 @@ void DistanceFieldVectorGLTest::renderMulti2D() {
         .setMaterialId(data.drawCount == 1 ? 0 : 0);
     GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, drawData};
 
-    DistanceFieldVectorGL2D shader{DistanceFieldVectorGL2D::Flag::UniformBuffers|DistanceFieldVectorGL2D::Flag::TextureTransformation|data.flags, data.materialCount, data.drawCount};
+    DistanceFieldVectorGL2D shader{DistanceFieldVectorGL2D::Configuration{}
+        .setFlags(DistanceFieldVectorGL2D::Flag::UniformBuffers|DistanceFieldVectorGL2D::Flag::TextureTransformation|data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     shader.bindVectorTexture(vector);
 
     /* Just one draw, rebinding UBOs each time */
@@ -1441,7 +1468,10 @@ void DistanceFieldVectorGLTest::renderMulti3D() {
         .setMaterialId(data.drawCount == 1 ? 0 : 0);
     GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, drawData};
 
-    DistanceFieldVectorGL3D shader{DistanceFieldVectorGL3D::Flag::UniformBuffers|DistanceFieldVectorGL3D::Flag::TextureTransformation|data.flags, data.materialCount, data.drawCount};
+    DistanceFieldVectorGL3D shader{DistanceFieldVectorGL3D::Configuration{}
+        .setFlags(DistanceFieldVectorGL3D::Flag::UniformBuffers|DistanceFieldVectorGL3D::Flag::TextureTransformation|data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     shader.bindVectorTexture(vector);
 
     /* Just one draw, rebinding UBOs each time */

src/Magnum/Shaders/Test/FlatGLTest.cpp

@@ -853,7 +853,8 @@ template<UnsignedInt dimensions> void FlatGLTest::construct() {
         CORRADE_SKIP(GL::Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
-    FlatGL<dimensions> shader{data.flags};
+    FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(data.flags)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_VERIFY(shader.id());
     {
@@ -869,7 +870,8 @@ template<UnsignedInt dimensions> void FlatGLTest::construct() {
 template<UnsignedInt dimensions> void FlatGLTest::constructAsync() {
     setTestCaseTemplateName(Utility::format("{}", dimensions));
 
-    typename FlatGL<dimensions>::CompileState state = FlatGL<dimensions>::compile(FlatGL2D::Flag::Textured|FlatGL2D::Flag::TextureTransformation);
+    typename FlatGL<dimensions>::CompileState state = FlatGL<dimensions>::compile(typename FlatGL<dimensions>::Configuration{}
+        .setFlags(FlatGL2D::Flag::Textured|FlatGL2D::Flag::TextureTransformation));
     CORRADE_COMPARE(state.flags(),  FlatGL2D::Flag::Textured|FlatGL2D::Flag::TextureTransformation);
 
     while(!state.isLinkFinished())
@@ -918,7 +920,10 @@ template<UnsignedInt dimensions> void FlatGLTest::constructUniformBuffers() {
         #endif
     }
 
-    FlatGL<dimensions> shader{data.flags, data.materialCount, data.drawCount};
+    FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_COMPARE(shader.materialCount(), data.materialCount);
     CORRADE_COMPARE(shader.drawCount(), data.drawCount);
@@ -941,7 +946,10 @@ template<UnsignedInt dimensions> void FlatGLTest::constructUniformBuffersAsync()
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    typename FlatGL<dimensions>::CompileState state = FlatGL<dimensions>::compile(FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::AlphaMask, 8, 48);
+    typename FlatGL<dimensions>::CompileState state = FlatGL<dimensions>::compile(typename FlatGL<dimensions>::Configuration{}
+        .setFlags(FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::AlphaMask)
+        .setMaterialCount(8)
+        .setDrawCount(48));
     CORRADE_COMPARE(state.flags(), FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::AlphaMask);
     CORRADE_COMPARE(state.materialCount(), 8);
     CORRADE_COMPARE(state.drawCount(), 48);
@@ -969,7 +977,8 @@ template<UnsignedInt dimensions> void FlatGLTest::constructUniformBuffersAsync()
 template<UnsignedInt dimensions> void FlatGLTest::constructMove() {
     setTestCaseTemplateName(Utility::format("{}", dimensions));
 
-    FlatGL<dimensions> a{FlatGL<dimensions>::Flag::Textured};
+    FlatGL<dimensions> a{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(FlatGL<dimensions>::Flag::Textured)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -996,7 +1005,10 @@ template<UnsignedInt dimensions> void FlatGLTest::constructMoveUniformBuffers()
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    FlatGL<dimensions> a{FlatGL<dimensions>::Flag::UniformBuffers, 2, 5};
+    FlatGL<dimensions> a{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(FlatGL<dimensions>::Flag::UniformBuffers)
+        .setMaterialCount(2)
+        .setDrawCount(5)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -1028,7 +1040,8 @@ template<UnsignedInt dimensions> void FlatGLTest::constructInvalid() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    FlatGL<dimensions>{data.flags};
+    FlatGL<dimensions>{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(data.flags)};
     CORRADE_COMPARE(out.str(), Utility::formatString(
         "Shaders::FlatGL: {}\n", data.message));
 }
@@ -1048,7 +1061,10 @@ template<UnsignedInt dimensions> void FlatGLTest::constructUniformBuffersInvalid
 
     std::ostringstream out;
     Error redirectError{&out};
-    FlatGL<dimensions>{data.flags, data.materialCount, data.drawCount};
+    FlatGL<dimensions>{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(out.str(), Utility::formatString(
         "Shaders::FlatGL: {}\n", data.message));
 }
@@ -1068,7 +1084,8 @@ template<UnsignedInt dimensions> void FlatGLTest::setUniformUniformBuffersEnable
     std::ostringstream out;
     Error redirectError{&out};
 
-    FlatGL<dimensions> shader{FlatGL<dimensions>::Flag::UniformBuffers};
+    FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(FlatGL<dimensions>::Flag::UniformBuffers)};
     shader.setTransformationProjectionMatrix({})
         .setTextureMatrix({})
         .setTextureLayer({})
@@ -1131,7 +1148,8 @@ template<UnsignedInt dimensions> void FlatGLTest::bindTexturesInvalid() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    FlatGL<dimensions> shader{data.flags};
+    FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(data.flags)};
     GL::Texture2D texture;
     shader.bindTexture(texture);
     #ifndef MAGNUM_TARGET_GLES2
@@ -1156,7 +1174,8 @@ template<UnsignedInt dimensions> void FlatGLTest::bindTextureArraysInvalid() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    FlatGL<dimensions> shader{data.flags};
+    FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(data.flags)};
     GL::Texture2DArray textureArray;
     shader.bindTexture(textureArray);
     shader.bindObjectIdTexture(textureArray);
@@ -1226,7 +1245,8 @@ template<UnsignedInt dimensions> void FlatGLTest::bindTextureTransformBufferNotE
     Error redirectError{&out};
 
     GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
-    FlatGL<dimensions> shader{FlatGL<dimensions>::Flag::UniformBuffers};
+    FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(FlatGL<dimensions>::Flag::UniformBuffers)};
     shader.bindTextureTransformationBuffer(buffer)
           .bindTextureTransformationBuffer(buffer, 0, 16);
     CORRADE_COMPARE(out.str(),
@@ -1265,8 +1285,11 @@ template<UnsignedInt dimensions> void FlatGLTest::setWrongDrawOffset() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    FlatGL<dimensions>{FlatGL<dimensions>::Flag::UniformBuffers, 2, 5}
-        .setDrawOffset(5);
+    FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(FlatGL<dimensions>::Flag::UniformBuffers)
+        .setMaterialCount(2)
+        .setDrawCount(5)};
+    shader.setDrawOffset(5);
     CORRADE_COMPARE(out.str(),
         "Shaders::FlatGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
 }
@@ -1313,7 +1336,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderDefaults2D() {
 
     GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32));
 
-    FlatGL2D shader{flag};
+    FlatGL2D shader{FlatGL2D::Configuration{}
+        .setFlags(flag)};
 
     if(flag == FlatGL2D::Flag{}) {
         shader.draw(circle);
@@ -1366,7 +1390,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderDefaults3D() {
 
     GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
 
-    FlatGL3D shader{flag};
+    FlatGL3D shader{FlatGL3D::Configuration{}
+        .setFlags(flag)};
 
     if(flag == FlatGL3D::Flag{}) {
         shader.draw(sphere);
@@ -1419,7 +1444,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderColored2D() {
 
     GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32));
 
-    FlatGL2D shader{flag};
+    FlatGL2D shader{FlatGL2D::Configuration{}
+        .setFlags(flag)};
 
     if(flag == FlatGL2D::Flag{}) {
         shader
@@ -1482,7 +1508,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderColored3D() {
 
     GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
 
-    FlatGL3D shader{flag};
+    FlatGL3D shader{FlatGL3D::Configuration{}
+        .setFlags(flag)};
 
     if(flag == FlatGL3D::Flag{}) {
         shader
@@ -1586,7 +1613,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderSinglePixelTextured2D() {
         flags |= FlatGL2D::Flag::TextureTransformation;
     }
     #endif
-    FlatGL2D shader{flags};
+    FlatGL2D shader{FlatGL2D::Configuration{}
+        .setFlags(flags)};
 
     const Color4ub imageData[]{ 0x9999ff_rgb };
     ImageView2D image{PixelFormat::RGBA8Unorm, Vector2i{1}, imageData};
@@ -1698,7 +1726,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderSinglePixelTextured3D() {
         flags |= FlatGL3D::Flag::TextureTransformation;
     }
     #endif
-    FlatGL3D shader{flags};
+    FlatGL3D shader{FlatGL3D::Configuration{}
+        .setFlags(flags)};
 
     const Color4ub imageData[]{ 0x9999ff_rgb };
     ImageView2D image{PixelFormat::RGBA8Unorm, Vector2i{1}, imageData};
@@ -1830,7 +1859,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderTextured2D() {
         flags |= FlatGL2D::Flag::TextureTransformation;
     }
     #endif
-    FlatGL2D shader{flags};
+    FlatGL2D shader{FlatGL2D::Configuration{}
+        .setFlags(flags)};
 
     GL::Texture2D texture{NoCreate};
     #ifndef MAGNUM_TARGET_GLES2
@@ -1956,7 +1986,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderTextured3D() {
         flags |= FlatGL3D::Flag::TextureTransformation;
     }
     #endif
-    FlatGL3D shader{flags};
+    FlatGL3D shader{FlatGL3D::Configuration{}
+        .setFlags(flags)};
 
     GL::Texture2D texture{NoCreate};
     #ifndef MAGNUM_TARGET_GLES2
@@ -2096,7 +2127,8 @@ template<class T, FlatGL2D::Flag flag> void FlatGLTest::renderVertexColor2D() {
         .setStorage(1, TextureFormatRGB, image->size())
         .setSubImage(0, {}, *image);
 
-    FlatGL2D shader{FlatGL2D::Flag::Textured|FlatGL2D::Flag::VertexColor|flag};
+    FlatGL2D shader{FlatGL2D::Configuration{}
+        .setFlags(FlatGL2D::Flag::Textured|FlatGL2D::Flag::VertexColor|flag)};
     shader.bindTexture(texture);
 
     if(flag == FlatGL2D::Flag{}) {
@@ -2185,7 +2217,8 @@ template<class T, FlatGL2D::Flag flag> void FlatGLTest::renderVertexColor3D() {
         .setStorage(1, TextureFormatRGB, image->size())
         .setSubImage(0, {}, *image);
 
-    FlatGL3D shader{FlatGL3D::Flag::Textured|FlatGL3D::Flag::VertexColor|flag};
+    FlatGL3D shader{FlatGL3D::Configuration{}
+        .setFlags(FlatGL3D::Flag::Textured|FlatGL3D::Flag::VertexColor|flag)};
     shader.bindTexture(texture);
 
     if(flag == FlatGL2D::Flag{}) {
@@ -2289,7 +2322,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderAlpha2D() {
     GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32,
         Primitives::Circle2DFlag::TextureCoordinates));
 
-    FlatGL2D shader{data.flags|flag};
+    FlatGL2D shader{FlatGL2D::Configuration{}
+        .setFlags(data.flags|flag)};
     shader.bindTexture(texture);
 
     if(flag == FlatGL2D::Flag{}) {
@@ -2375,7 +2409,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderAlpha3D() {
     GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32,
         Primitives::UVSphereFlag::TextureCoordinates));
 
-    FlatGL3D shader{data.flags|flag};
+    FlatGL3D shader{FlatGL3D::Configuration{}
+        .setFlags(data.flags|flag)};
     shader.bindTexture(texture);
 
     if(flag == FlatGL2D::Flag{}) {
@@ -2519,7 +2554,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderObjectId2D() {
         CORRADE_INFO("Texture arrays currently require texture transformation if UBOs are used, enabling implicitly.");
         flags |= FlatGL2D::Flag::TextureTransformation;
     }
-    FlatGL2D shader{FlatGL2D::Flag::ObjectId|flags};
+    FlatGL2D shader{FlatGL2D::Configuration{}
+        .setFlags(FlatGL2D::Flag::ObjectId|flags)};
 
     GL::Texture2D texture{NoCreate};
     GL::Texture2DArray textureArray{NoCreate};
@@ -2651,7 +2687,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderObjectId3D() {
         CORRADE_INFO("Texture arrays currently require texture transformation if UBOs are used, enabling implicitly.");
         flags |= FlatGL3D::Flag::TextureTransformation;
     }
-    FlatGL3D shader{FlatGL3D::Flag::ObjectId|flags};
+    FlatGL3D shader{FlatGL3D::Configuration{}
+        .setFlags(FlatGL3D::Flag::ObjectId|flags)};
 
     GL::Texture2D texture{NoCreate};
     GL::Texture2DArray textureArray{NoCreate};
@@ -2850,8 +2887,9 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderInstanced2D() {
         )
         .setInstanceCount(3);
 
-    FlatGL2D shader{FlatGL2D::Flag::VertexColor|
-        FlatGL2D::Flag::InstancedTransformation|data.flags|flag};
+    FlatGL2D shader{FlatGL2D::Configuration{}
+        .setFlags(FlatGL2D::Flag::VertexColor|
+        FlatGL2D::Flag::InstancedTransformation|data.flags|flag)};
 
     GL::Texture2D texture{NoCreate};
     #ifndef MAGNUM_TARGET_GLES2
@@ -3163,8 +3201,9 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderInstanced3D() {
         )
         .setInstanceCount(3);
 
-    FlatGL3D shader{FlatGL3D::Flag::VertexColor|
-        FlatGL3D::Flag::InstancedTransformation|data.flags|flag};
+    FlatGL3D shader{FlatGL3D::Configuration{}
+        .setFlags(FlatGL3D::Flag::VertexColor|
+        FlatGL3D::Flag::InstancedTransformation|data.flags|flag)};
 
     GL::Texture2D texture{NoCreate};
     #ifndef MAGNUM_TARGET_GLES2
@@ -3426,7 +3465,10 @@ void FlatGLTest::renderMulti2D() {
         CORRADE_SKIP("UBOs with dynamically indexed arrays are a crashy dumpster fire on SwiftShader, can't test.");
     #endif
 
-    FlatGL2D shader{FlatGL2D::Flag::UniformBuffers|data.flags, data.materialCount, data.drawCount};
+    FlatGL2D shader{FlatGL2D::Configuration{}
+        .setFlags(FlatGL2D::Flag::UniformBuffers|data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
 
     GL::Texture2D texture{NoCreate};
     GL::Texture2DArray textureArray{NoCreate};
@@ -3762,7 +3804,10 @@ void FlatGLTest::renderMulti3D() {
         CORRADE_SKIP("UBOs with dynamically indexed arrays are a crashy dumpster fire on SwiftShader, can't test.");
     #endif
 
-    FlatGL3D shader{FlatGL3D::Flag::UniformBuffers|data.flags, data.materialCount, data.drawCount};
+    FlatGL3D shader{FlatGL3D::Configuration{}
+        .setFlags(FlatGL3D::Flag::UniformBuffers|data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
 
     GL::Texture2D texture{NoCreate};
     GL::Texture2DArray textureArray{NoCreate};

src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp

@@ -1403,7 +1403,8 @@ void MeshVisualizerGLTest::construct2D() {
     }
     #endif
 
-    MeshVisualizerGL2D shader{data.flags};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(data.flags)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_VERIFY(shader.id());
     {
@@ -1418,7 +1419,8 @@ void MeshVisualizerGLTest::construct2D() {
 
 
 void MeshVisualizerGLTest::construct2DAsync() {
-    MeshVisualizerGL2D::CompileState state = MeshVisualizerGL2D::compile(MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader);
+    MeshVisualizerGL2D::CompileState state = MeshVisualizerGL2D::compile(MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader));
     CORRADE_COMPARE(state.flags(), MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader);
 
     while(!state.isLinkFinished())
@@ -1503,7 +1505,10 @@ void MeshVisualizerGLTest::constructUniformBuffers2D() {
         #endif
     }
 
-    MeshVisualizerGL2D shader{data.flags, data.materialCount, data.drawCount};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_VERIFY(shader.id());
     {
@@ -1523,7 +1528,10 @@ void MeshVisualizerGLTest::constructUniformBuffers2DAsync() {
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    MeshVisualizerGL2D::CompileState state = MeshVisualizerGL2D::compile( MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader, 8, 55);
+    MeshVisualizerGL2D::CompileState state = MeshVisualizerGL2D::compile(MeshVisualizerGL2D::Configuration{}
+        .setFlags( MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)
+        .setMaterialCount(8)
+        .setDrawCount(55));
     CORRADE_COMPARE(state.flags(),  MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader);
     CORRADE_COMPARE(state.materialCount(), 8);
     CORRADE_COMPARE(state.drawCount(), 55);
@@ -1595,7 +1603,8 @@ void MeshVisualizerGLTest::construct3D() {
     }
     #endif
 
-    MeshVisualizerGL3D shader{data.flags};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(data.flags)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_VERIFY(shader.id());
     {
@@ -1609,7 +1618,8 @@ void MeshVisualizerGLTest::construct3D() {
 }
 
 void MeshVisualizerGLTest::construct3DAsync() {
-    MeshVisualizerGL3D::CompileState state = MeshVisualizerGL3D::compile(MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader);
+    MeshVisualizerGL3D::CompileState state = MeshVisualizerGL3D::compile(MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader));
     CORRADE_COMPARE(state.flags(), MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader);
 
     while(!state.isLinkFinished())
@@ -1694,7 +1704,10 @@ void MeshVisualizerGLTest::constructUniformBuffers3D() {
         #endif
     }
 
-    MeshVisualizerGL3D shader{data.flags, data.materialCount, data.drawCount};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_VERIFY(shader.id());
     {
@@ -1713,7 +1726,10 @@ void MeshVisualizerGLTest::constructUniformBuffers3DAsync() {
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    MeshVisualizerGL3D::CompileState state = MeshVisualizerGL3D::compile(MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader, 6, 28);
+    MeshVisualizerGL3D::CompileState state = MeshVisualizerGL3D::compile(MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)
+        .setMaterialCount(6)
+        .setDrawCount(28));
     CORRADE_COMPARE(state.flags(), MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader);
     CORRADE_COMPARE(state.materialCount(), 6);
     CORRADE_COMPARE(state.drawCount(), 28);
@@ -1746,7 +1762,8 @@ void MeshVisualizerGLTest::construct2DInvalid() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    MeshVisualizerGL2D{data.flags};
+    MeshVisualizerGL2D{MeshVisualizerGL2D::Configuration{}
+        .setFlags(data.flags)};
     CORRADE_COMPARE(out.str(), Utility::formatString("Shaders::MeshVisualizerGL{}\n", data.message));
 }
 
@@ -1764,7 +1781,10 @@ void MeshVisualizerGLTest::constructUniformBuffers2DInvalid() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    MeshVisualizerGL2D{data.flags, data.materialCount, data.drawCount};
+    MeshVisualizerGL2D{MeshVisualizerGL2D::Configuration{}
+        .setFlags(data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(out.str(), Utility::formatString("Shaders::MeshVisualizerGL2D: {}\n", data.message));
 }
 #endif
@@ -1777,7 +1797,8 @@ void MeshVisualizerGLTest::construct3DInvalid() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    MeshVisualizerGL3D{data.flags};
+    MeshVisualizerGL3D{MeshVisualizerGL3D::Configuration{}
+        .setFlags(data.flags)};
     CORRADE_COMPARE(out.str(), Utility::formatString("Shaders::MeshVisualizerGL{}\n", data.message));
 }
 
@@ -1795,13 +1816,17 @@ void MeshVisualizerGLTest::constructUniformBuffers3DInvalid() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    MeshVisualizerGL3D{data.flags, data.materialCount, data.drawCount};
+    MeshVisualizerGL3D{MeshVisualizerGL3D::Configuration{}
+        .setFlags(data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(out.str(), Utility::formatString("Shaders::MeshVisualizerGL3D: {}\n", data.message));
 }
 #endif
 
 void MeshVisualizerGLTest::constructMove2D() {
-    MeshVisualizerGL2D a{MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader};
+    MeshVisualizerGL2D a{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -1826,7 +1851,10 @@ void MeshVisualizerGLTest::constructMoveUniformBuffers2D() {
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    MeshVisualizerGL2D a{MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader, 2, 5};
+    MeshVisualizerGL2D a{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)
+        .setMaterialCount(2)
+        .setDrawCount(5)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -1850,7 +1878,8 @@ void MeshVisualizerGLTest::constructMoveUniformBuffers2D() {
 #endif
 
 void MeshVisualizerGLTest::constructMove3D() {
-    MeshVisualizerGL3D a{MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader};
+    MeshVisualizerGL3D a{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -1875,7 +1904,10 @@ void MeshVisualizerGLTest::constructMoveUniformBuffers3D() {
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    MeshVisualizerGL3D a{MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader, 2, 5};
+    MeshVisualizerGL3D a{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)
+        .setMaterialCount(2)
+        .setDrawCount(5)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -1910,7 +1942,8 @@ void MeshVisualizerGLTest::setUniformUniformBuffersEnabled2D() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)};
     shader.setTransformationProjectionMatrix({})
         .setTextureMatrix({})
         .setTextureLayer({})
@@ -1944,7 +1977,8 @@ void MeshVisualizerGLTest::setUniformUniformBuffersEnabled3D() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)};
     shader.setProjectionMatrix({})
         .setTransformationMatrix({})
         .setTextureMatrix({})
@@ -1989,7 +2023,8 @@ void MeshVisualizerGLTest::bindBufferUniformBuffersNotEnabled2D() {
     Error redirectError{&out};
 
     GL::Buffer buffer;
-    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)};
     shader.bindTransformationProjectionBuffer(buffer)
           .bindTransformationProjectionBuffer(buffer, 0, 16)
           .bindDrawBuffer(buffer)
@@ -2018,7 +2053,8 @@ void MeshVisualizerGLTest::bindBufferUniformBuffersNotEnabled3D() {
     Error redirectError{&out};
 
     GL::Buffer buffer;
-    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)};
     shader.bindProjectionBuffer(buffer)
           .bindProjectionBuffer(buffer, 0, 16)
           .bindTransformationBuffer(buffer)
@@ -2058,7 +2094,8 @@ void MeshVisualizerGLTest::bindObjectIdTextureInvalid2D() {
     #endif
 
     GL::Texture2D texture;
-    MeshVisualizerGL2D shader{data.flags2D};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(data.flags2D)};
 
     std::ostringstream out;
     Error redirectError{&out};
@@ -2078,7 +2115,8 @@ void MeshVisualizerGLTest::bindObjectIdTextureInvalid3D() {
     #endif
 
     GL::Texture2D texture;
-    MeshVisualizerGL3D shader{data.flags3D};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(data.flags3D)};
 
     std::ostringstream out;
     Error redirectError{&out};
@@ -2101,7 +2139,8 @@ void MeshVisualizerGLTest::bindObjectIdTextureArrayInvalid2D() {
     Error redirectError{&out};
 
     GL::Texture2DArray textureArray;
-    MeshVisualizerGL2D shader{data.flags2D};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(data.flags2D)};
     shader.bindObjectIdTexture(textureArray);
 
     CORRADE_COMPARE(out.str(), data.message);
@@ -2122,7 +2161,8 @@ void MeshVisualizerGLTest::bindObjectIdTextureArrayInvalid3D() {
     Error redirectError{&out};
 
     GL::Texture2DArray textureArray;
-    MeshVisualizerGL3D shader{data.flags3D};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(data.flags3D)};
     shader.bindObjectIdTexture(textureArray);
 
     CORRADE_COMPARE(out.str(), data.message);
@@ -2198,7 +2238,8 @@ void MeshVisualizerGLTest::setWireframeNotEnabled3D() {
 void MeshVisualizerGLTest::setTextureMatrixNotEnabled2D() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
-    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::ObjectIdTexture};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::ObjectIdTexture)};
 
     std::ostringstream out;
     Error redirectError{&out};
@@ -2210,7 +2251,8 @@ void MeshVisualizerGLTest::setTextureMatrixNotEnabled2D() {
 void MeshVisualizerGLTest::setTextureMatrixNotEnabled3D() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
-    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::ObjectIdTexture};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::ObjectIdTexture)};
 
     std::ostringstream out;
     Error redirectError{&out};
@@ -2222,7 +2264,8 @@ void MeshVisualizerGLTest::setTextureMatrixNotEnabled3D() {
 void MeshVisualizerGLTest::setTextureLayerNotArray2D() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
-    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::ObjectIdTexture};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::ObjectIdTexture)};
 
     std::ostringstream out;
     Error redirectError{&out};
@@ -2234,7 +2277,8 @@ void MeshVisualizerGLTest::setTextureLayerNotArray2D() {
 void MeshVisualizerGLTest::setTextureLayerNotArray3D() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
-    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::ObjectIdTexture};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::ObjectIdTexture)};
 
     std::ostringstream out;
     Error redirectError{&out};
@@ -2252,7 +2296,8 @@ void MeshVisualizerGLTest::bindTextureTransformBufferNotEnabled2D() {
     #endif
 
     GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
-    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::ObjectIdTexture};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::ObjectIdTexture)};
 
     std::ostringstream out;
     Error redirectError{&out};
@@ -2272,7 +2317,8 @@ void MeshVisualizerGLTest::bindTextureTransformBufferNotEnabled3D() {
     #endif
 
     GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
-    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::ObjectIdTexture};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::ObjectIdTexture)};
 
     std::ostringstream out;
     Error redirectError{&out};
@@ -2355,7 +2401,8 @@ void MeshVisualizerGLTest::setTangentBitangentNormalNotEnabled3D() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::Wireframe};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::Wireframe)};
     shader.setNormalMatrix({})
         .setLineWidth({})
         .setLineLength({});
@@ -2378,8 +2425,11 @@ void MeshVisualizerGLTest::setWrongDrawOffset2D() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    MeshVisualizerGL2D{MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader, 2, 5}
-        .setDrawOffset(5);
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)
+        .setMaterialCount(2)
+        .setDrawCount(5)};
+    shader.setDrawOffset(5);
     CORRADE_COMPARE(out.str(),
         "Shaders::MeshVisualizerGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
 }
@@ -2394,7 +2444,11 @@ void MeshVisualizerGLTest::setWrongDrawOffset3D() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    MeshVisualizerGL3D{MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader, 2, 5}
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)
+        .setMaterialCount(2)
+        .setDrawCount(5)};
+    shader
         .setDrawOffset(5);
     CORRADE_COMPARE(out.str(),
         "Shaders::MeshVisualizerGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
@@ -2463,7 +2517,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderDefault
 
     GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(16));
 
-    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::Wireframe|flag};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::Wireframe|flag)};
 
     if(flag == MeshVisualizerGL2D::Flag{}) {
         shader.draw(circle);
@@ -2556,7 +2611,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
 
     GL::Mesh sphere = MeshTools::compile(Primitives::icosphereSolid(1));
 
-    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::Wireframe|flag};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::Wireframe|flag)};
 
     if(flag == MeshVisualizerGL3D::Flag{}) {
         shader.draw(sphere);
@@ -2651,7 +2707,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderDefault
 
     GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(16));
 
-    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::ObjectId|flag};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::ObjectId|flag)};
     shader.bindColorMapTexture(_colorMapTexture);
 
     if(flag == MeshVisualizerGL2D::Flag{}) {
@@ -2704,7 +2761,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
 
     GL::Mesh icosphere = MeshTools::compile(Primitives::icosphereSolid(0));
 
-    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::InstancedObjectId|flag};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::InstancedObjectId|flag)};
     shader.bindColorMapTexture(_colorMapTexture);
 
     if(flag == MeshVisualizerGL3D::Flag{}) {
@@ -2785,7 +2843,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderDefault
                 Containers::arrayView(ids)}
         }));
 
-    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::InstancedObjectId|flag};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::InstancedObjectId|flag)};
     shader.bindColorMapTexture(colorMapTexture);
 
     if(flag == MeshVisualizerGL2D::Flag{}) {
@@ -2861,7 +2920,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
                 Containers::arrayView(ids)}
         }));
 
-    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::InstancedObjectId|flag};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::InstancedObjectId|flag)};
     shader.bindColorMapTexture(colorMapTexture);
 
     if(flag == MeshVisualizerGL3D::Flag{}) {
@@ -2921,7 +2981,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderDefault
 
     GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(16));
 
-    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::VertexId|flag};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::VertexId|flag)};
     shader.bindColorMapTexture(_colorMapTexture);
 
     if(flag == MeshVisualizerGL2D::Flag{}) {
@@ -2972,7 +3033,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
 
     GL::Mesh icosphere = MeshTools::compile(Primitives::icosphereSolid(0));
 
-    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::VertexId|flag};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::VertexId|flag)};
     shader.bindColorMapTexture(_colorMapTexture);
 
     if(flag == MeshVisualizerGL3D::Flag{}) {
@@ -3056,7 +3118,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderDefault
 
     GL::Mesh circle = MeshTools::compile(circleData);
 
-    MeshVisualizerGL2D shader{flags|flag};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(flags|flag)};
     shader.bindColorMapTexture(_colorMapTexture);
 
     if(flag == MeshVisualizerGL2D::Flag{}) {
@@ -3137,7 +3200,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
 
     GL::Mesh icosphere = MeshTools::compile(icosphereData);
 
-    MeshVisualizerGL3D shader{flags|flag};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(flags|flag)};
     shader.bindColorMapTexture(_colorMapTexture);
 
     if(flag == MeshVisualizerGL3D::Flag{}) {
@@ -3196,9 +3260,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
     GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(4, 8,
         Primitives::UVSphereFlag::Tangents));
 
-    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::TangentDirection|
-            MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|
-            MeshVisualizerGL3D::Flag::NormalDirection|flag};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::TangentDirection|MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|MeshVisualizerGL3D::Flag::NormalDirection|flag)};
     /** @todo make this unnecessary */
     shader.setViewportSize({80, 80});
 
@@ -3296,7 +3359,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderWirefra
         }
     } else circle = MeshTools::compile(circleData);
 
-    MeshVisualizerGL2D shader{data.flags|MeshVisualizerGL2D::Flag::Wireframe|flag};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(data.flags|MeshVisualizerGL2D::Flag::Wireframe|flag)};
     shader.setViewportSize({80, 80});
 
     if(flag == MeshVisualizerGL2D::Flag{}) {
@@ -3425,7 +3489,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderWirefra
         }
     } else sphere = MeshTools::compile(sphereData);
 
-    MeshVisualizerGL3D shader{data.flags|MeshVisualizerGL3D::Flag::Wireframe|flag};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(data.flags|MeshVisualizerGL3D::Flag::Wireframe|flag)};
     shader.setViewportSize({80, 80});
 
     if(flag == MeshVisualizerGL3D::Flag{}) {
@@ -3605,7 +3670,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderObjectV
         CORRADE_INFO("Texture arrays currently require texture transformation if UBOs are used, enabling implicitly.");
         flags |= MeshVisualizerGL2D::Flag::TextureTransformation;
     }
-    MeshVisualizerGL2D shader{flags};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(flags)};
     shader
         /* Shouldn't assert (nor warn) when wireframe is not enabled */
         .setViewportSize({80, 80})
@@ -3792,7 +3858,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderObjectV
         CORRADE_INFO("Texture arrays currently require texture transformation if UBOs are used, enabling implicitly.");
         flags |= MeshVisualizerGL3D::Flag::TextureTransformation;
     }
-    MeshVisualizerGL3D shader{flags};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(flags)};
     shader
         /* Shouldn't assert (nor warn) when wireframe is not enabled */
         .setViewportSize({80, 80})
@@ -3937,8 +4004,9 @@ void MeshVisualizerGLTest::renderWireframe3DPerspective() {
 
     GL::Mesh plane = MeshTools::compile(Primitives::planeSolid());
 
-    MeshVisualizerGL3D{MeshVisualizerGL3D::Flag::Wireframe}
-        .setWireframeWidth(8.0f)
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::Wireframe)};
+    shader.setWireframeWidth(8.0f)
         .setWireframeColor(0xff0000_rgbf)
         .setViewportSize({80, 80})
         .setTransformationMatrix(
@@ -4067,7 +4135,9 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderTangent
         Matrix4::scaling(Vector3::yScale(1.5f));
 
     if(data.secondPassFlags) {
-        MeshVisualizerGL3D{data.secondPassFlags}
+        MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+            .setFlags(data.secondPassFlags)};
+        shader
             /** @todo make this unnecessary */
             .setViewportSize({80, 80})
             .setTransformationMatrix(transformation)
@@ -4077,7 +4147,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderTangent
             .draw(mesh);
     }
 
-    MeshVisualizerGL3D shader{data.flags|flag};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(data.flags|flag)};
     /** @todo make this unnecessary */
     shader.setViewportSize({80, 80});
     if(data.flags & (MeshVisualizerGL3D::Flag::PrimitiveId|MeshVisualizerGL3D::Flag::ObjectId|MeshVisualizerGL3D::Flag::VertexId))
@@ -4258,8 +4329,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderInstanc
         )
         .setInstanceCount(3);
 
-    MeshVisualizerGL2D shader{
-        MeshVisualizerGL2D::Flag::InstancedTransformation|data.flags|flag};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::InstancedTransformation|data.flags|flag)};
     shader.setViewportSize(Vector2{RenderSize});
     #ifndef MAGNUM_TARGET_GLES2
     if(data.flags & (MeshVisualizerGL2D::Flag::VertexId|MeshVisualizerGL2D::Flag::ObjectId))
@@ -4528,8 +4599,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderInstanc
         )
         .setInstanceCount(3);
 
-    MeshVisualizerGL3D shader{
-        MeshVisualizerGL3D::Flag::InstancedTransformation|data.flags|flag};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::InstancedTransformation|data.flags|flag)};
     shader.setViewportSize(Vector2{RenderSize});
     #ifndef MAGNUM_TARGET_GLES2
     if(data.flags & (MeshVisualizerGL3D::Flag::VertexId|MeshVisualizerGL3D::Flag::ObjectId))
@@ -4749,7 +4820,10 @@ void MeshVisualizerGLTest::renderMulti2D() {
         CORRADE_SKIP("UBOs with dynamically indexed arrays are a crashy dumpster fire on SwiftShader, can't test.");
     #endif
 
-    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::UniformBuffers|data.flags, data.materialCount, data.drawCount};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     shader.setViewportSize(Vector2{RenderSize});
     if(data.flags & (MeshVisualizerGL2D::Flag::VertexId|MeshVisualizerGL2D::Flag::ObjectId))
         shader.bindColorMapTexture(_colorMapTexture);
@@ -5069,7 +5143,10 @@ void MeshVisualizerGLTest::renderMulti3D() {
         CORRADE_SKIP("UBOs with dynamically indexed arrays are a crashy dumpster fire on SwiftShader, can't test.");
     #endif
 
-    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::UniformBuffers|data.flags, data.materialCount, data.drawCount};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(MeshVisualizerGL3D::Flag::UniformBuffers|data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     shader.setViewportSize(Vector2{RenderSize});
     if(data.flags & (MeshVisualizerGL3D::Flag::VertexId|MeshVisualizerGL3D::Flag::ObjectId))
         shader.bindColorMapTexture(_colorMapTexture);

src/Magnum/Shaders/Test/PhongGLTest.cpp

@@ -1186,7 +1186,9 @@ void PhongGLTest::construct() {
         CORRADE_SKIP(GL::Extensions::EXT::texture_array::string() << "is not supported.");
     #endif
 
-    PhongGL shader{data.flags, data.lightCount};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(data.flags)
+        .setLightCount(data.lightCount)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_COMPARE(shader.lightCount(), data.lightCount);
     CORRADE_VERIFY(shader.id());
@@ -1201,7 +1203,9 @@ void PhongGLTest::construct() {
 }
 
 void PhongGLTest::constructAsync() {
-    PhongGL::CompileState state = PhongGL::compile(PhongGL::Flag::SpecularTexture|PhongGL::Flag::InstancedTextureOffset, 3);
+    PhongGL::CompileState state = PhongGL::compile(PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::SpecularTexture|PhongGL::Flag::InstancedTextureOffset)
+        .setLightCount(3));
     CORRADE_COMPARE(state.flags(), PhongGL::Flag::SpecularTexture|PhongGL::Flag::InstancedTextureOffset);
     CORRADE_COMPARE(state.lightCount(), 3);
 
@@ -1250,7 +1254,11 @@ void PhongGLTest::constructUniformBuffers() {
         #endif
     }
 
-    PhongGL shader{data.flags, data.lightCount, data.materialCount, data.drawCount};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(data.flags)
+        .setLightCount(data.lightCount)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_COMPARE(shader.lightCount(), data.lightCount);
     CORRADE_COMPARE(shader.materialCount(), data.materialCount);
@@ -1272,7 +1280,11 @@ void PhongGLTest::constructUniformBuffersAsync() {
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    PhongGL::CompileState state = PhongGL::compile(PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling, 8, 8, 24);
+    PhongGL::CompileState state = PhongGL::compile(PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling)
+        .setLightCount(8)
+        .setMaterialCount(8)
+        .setDrawCount(24));
     CORRADE_COMPARE(state.flags(), PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling);
     CORRADE_COMPARE(state.lightCount(), 8);
     CORRADE_COMPARE(state.materialCount(), 8);
@@ -1300,7 +1312,9 @@ void PhongGLTest::constructUniformBuffersAsync() {
 #endif
 
 void PhongGLTest::constructMove() {
-    PhongGL a{PhongGL::Flag::AlphaMask, 3};
+    PhongGL a{PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::AlphaMask)
+        .setLightCount(3)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -1327,7 +1341,11 @@ void PhongGLTest::constructMoveUniformBuffers() {
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    PhongGL a{PhongGL::Flag::UniformBuffers, 3, 2, 5};
+    PhongGL a{PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::UniformBuffers)
+        .setLightCount(3)
+        .setMaterialCount(2)
+        .setDrawCount(5)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -1360,7 +1378,8 @@ void PhongGLTest::constructInvalid() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    PhongGL{data.flags};
+    PhongGL{PhongGL::Configuration{}
+        .setFlags(data.flags)};
     CORRADE_COMPARE(out.str(), Utility::formatString(
         "Shaders::PhongGL: {}\n", data.message));
 }
@@ -1379,7 +1398,11 @@ void PhongGLTest::constructUniformBuffersInvalid() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    PhongGL{data.flags, data.lightCount, data.materialCount, data.drawCount};
+    PhongGL{PhongGL::Configuration{}
+        .setFlags(data.flags)
+        .setLightCount(data.lightCount)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(out.str(), Utility::formatString(
         "Shaders::PhongGL: {}\n", data.message));
 }
@@ -1397,7 +1420,8 @@ void PhongGLTest::setUniformUniformBuffersEnabled() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    PhongGL shader{PhongGL::Flag::UniformBuffers};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::UniformBuffers)};
     shader.setAmbientColor({})
           .setDiffuseColor({})
           .setNormalTextureScale({})
@@ -1494,7 +1518,8 @@ void PhongGLTest::bindTexturesInvalid() {
     Error redirectError{&out};
 
     GL::Texture2D texture;
-    PhongGL shader{data.flags};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(data.flags)};
     shader.bindAmbientTexture(texture)
           .bindDiffuseTexture(texture)
           .bindSpecularTexture(texture)
@@ -1523,7 +1548,8 @@ void PhongGLTest::bindTextureArraysInvalid() {
     Error redirectError{&out};
 
     GL::Texture2DArray textureArray;
-    PhongGL shader{data.flags};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(data.flags)};
     shader.bindAmbientTexture(textureArray)
           .bindDiffuseTexture(textureArray)
           .bindSpecularTexture(textureArray)
@@ -1554,7 +1580,8 @@ void PhongGLTest::setSpecularDisabled() {
     Error redirectError{&out};
 
     GL::Texture2D texture;
-    PhongGL shader{PhongGL::Flag::NoSpecular};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::NoSpecular)};
     shader.setSpecularColor({})
         .setShininess({})
         /* {{}} makes GCC 4.8 warn about zero as null pointer constant */
@@ -1621,7 +1648,8 @@ void PhongGLTest::bindTextureTransformBufferNotEnabled() {
     Error redirectError{&out};
 
     GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
-    PhongGL shader{PhongGL::Flag::UniformBuffers};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::UniformBuffers)};
     shader.bindTextureTransformationBuffer(buffer)
           .bindTextureTransformationBuffer(buffer, 0, 16);
     CORRADE_COMPARE(out.str(),
@@ -1650,7 +1678,9 @@ void PhongGLTest::setWrongLightCount() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    PhongGL{{}, 5}
+    PhongGL shader{PhongGL::Configuration{}
+        .setLightCount(5)};
+    shader
         .setLightColors({Color3{}})
         .setLightPositions({Vector4{}})
         .setLightRanges({0.0f});
@@ -1665,7 +1695,9 @@ void PhongGLTest::setWrongLightId() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    PhongGL{{}, 3}
+    PhongGL shader{PhongGL::Configuration{}
+        .setLightCount(3)};
+    shader
         .setLightColor(3, Color3{})
         .setLightPosition(3, Vector4{})
         .setLightRange(3, 0.0f);
@@ -1686,8 +1718,12 @@ void PhongGLTest::setWrongDrawOffset() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    PhongGL{PhongGL::Flag::UniformBuffers, 1, 2, 5}
-        .setDrawOffset(5);
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::UniformBuffers)
+        .setLightCount(1)
+        .setMaterialCount(2)
+        .setDrawCount(5)};
+    shader.setDrawOffset(5);
     CORRADE_COMPARE(out.str(),
         "Shaders::PhongGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
 }
@@ -1740,7 +1776,8 @@ template<PhongGL::Flag flag> void PhongGLTest::renderDefaults() {
 
     GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
 
-    PhongGL shader{flag};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(flag)};
 
     if(flag == PhongGL::Flag{}) {
         shader.draw(sphere);
@@ -1816,7 +1853,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderColored() {
 
     GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
 
-    PhongGL shader{flag, 2};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(flag)
+        .setLightCount(2)};
 
     if(flag == PhongGL::Flag{}) {
         shader
@@ -1944,7 +1983,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderSinglePixelTextured() {
         flags |= PhongGL::Flag::TextureTransformation;
     }
     #endif
-    PhongGL shader{flags, 2};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(flags)
+        .setLightCount(2)};
 
     const Color4ub ambientData[]{ 0x330033_rgb };
     ImageView2D ambientImage{PixelFormat::RGBA8Unorm, Vector2i{1}, ambientData};
@@ -2130,7 +2171,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderTextured() {
         flags |= PhongGL::Flag::TextureTransformation;
     }
     #endif
-    PhongGL shader{flags, 2};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(flags)
+        .setLightCount(2)};
 
     Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
     CORRADE_VERIFY(importer);
@@ -2375,7 +2418,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderTexturedNormal() {
         flags |= PhongGL::Flag::TextureTransformation;
     }
     #endif
-    PhongGL shader{flags, 2};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(flags)
+        .setLightCount(2)};
 
     GL::Texture2D normal{NoCreate};
     #ifndef MAGNUM_TARGET_GLES2
@@ -2576,7 +2621,9 @@ template<class T, PhongGL::Flag flag> void PhongGLTest::renderVertexColor() {
         .setStorage(1, TextureFormatRGB, image->size())
         .setSubImage(0, {}, *image);
 
-    PhongGL shader{PhongGL::Flag::DiffuseTexture|PhongGL::Flag::VertexColor|flag, 2};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::DiffuseTexture|PhongGL::Flag::VertexColor|flag)
+        .setLightCount(2)};
     shader.bindDiffuseTexture(diffuse);
 
     if(flag == PhongGL::Flag{}) {
@@ -2672,7 +2719,8 @@ template<PhongGL::Flag flag> void PhongGLTest::renderShininess() {
 
     GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
 
-    PhongGL shader{flag|data.flags};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(flag|data.flags)};
     if(flag == PhongGL::Flag{}) {
         if(!(data.flags & PhongGL::Flag::NoSpecular)) shader
             .setSpecularColor(data.specular)
@@ -2860,7 +2908,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderAlpha() {
     GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32,
         Primitives::UVSphereFlag::TextureCoordinates));
 
-    PhongGL shader{data.flags|flag, 2};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(data.flags|flag)
+        .setLightCount(2)};
     shader.bindTextures(&ambient, &diffuse, nullptr, nullptr);
 
     if(flag == PhongGL::Flag{}) {
@@ -3026,7 +3076,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderObjectId() {
         CORRADE_INFO("Texture arrays currently require texture transformation if UBOs are used, enabling implicitly.");
         flags |= PhongGL::Flag::TextureTransformation;
     }
-    PhongGL shader{PhongGL::Flag::ObjectId|flags, 2};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::ObjectId|flags)
+        .setLightCount(2)};
 
     GL::Texture2D texture{NoCreate};
     GL::Texture2DArray textureArray{NoCreate};
@@ -3178,7 +3230,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderLights() {
     Matrix4 transformation =
         Matrix4::translation({0.0f, 0.0f, -1.5f});
 
-    PhongGL shader{flag, 1};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(flag)
+        .setLightCount(1)};
     if(flag == PhongGL::Flag{}) {
         shader
             /* Set non-black ambient to catch accidental NaNs -- the render
@@ -3268,7 +3322,9 @@ void PhongGLTest::renderLightsSetOneByOne() {
     Matrix4 transformation =
         Matrix4::translation({0.0f, 0.0f, -1.5f});
 
-    PhongGL{{}, 2}
+    PhongGL shader{PhongGL::Configuration{}
+        .setLightCount(2)};
+    shader
         /* Set non-black ambient to catch accidental NaNs -- the render should
            never be fully black */
         .setAmbientColor(0x222222_rgbf)
@@ -3334,7 +3390,9 @@ void PhongGLTest::renderLowLightAngle() {
        in the vertex shader, where the incorrect normalization caused the
        fragment-interpolated light direction being incorrect, most visible with
        long polygons and low light angles. */
-    PhongGL{{}, 1}
+    PhongGL shader{PhongGL::Configuration{}
+        .setLightCount(1)};
+    shader
         .setLightPositions({{0.0f, 0.1f, 0.0f, 1.0f}})
         .setShininess(200)
         .setTransformationMatrix(transformation)
@@ -3404,7 +3462,9 @@ void PhongGLTest::renderLightCulling() {
         .setColor(0x669933_rgbf);
     GL::Buffer lightUniform{lights};
 
-    PhongGL shader{PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling, 64};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling)
+        .setLightCount(64)};
     shader
         .bindProjectionBuffer(projectionUniform)
         .bindTransformationBuffer(transformationUniform)
@@ -3464,7 +3524,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderZeroLights() {
         flags |= PhongGL::Flag::ObjectId;
     }
     #endif
-    PhongGL shader{flags|flag, 0};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(flags|flag)
+        .setLightCount(0)};
 
     Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
     CORRADE_VERIFY(importer);
@@ -3700,8 +3762,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderInstanced() {
         )
         .setInstanceCount(3);
 
-    PhongGL shader{PhongGL::Flag::VertexColor|
-          PhongGL::Flag::InstancedTransformation|data.flags|flag, 2};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::VertexColor|PhongGL::Flag::InstancedTransformation|data.flags|flag)
+        .setLightCount(2)};
 
     GL::Texture2D diffuse{NoCreate};
     GL::Texture2D normal{NoCreate};
@@ -4046,7 +4109,11 @@ void PhongGLTest::renderMulti() {
         CORRADE_SKIP("UBOs with dynamically indexed arrays are a crashy dumpster fire on SwiftShader, can't test.");
     #endif
 
-    PhongGL shader{PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling|data.flags, data.lightCount, data.materialCount, data.drawCount};
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling|data.flags)
+        .setLightCount(data.lightCount)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
 
     GL::Texture2D diffuse{NoCreate};
     GL::Texture2DArray diffuseArray{NoCreate};

src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp

@@ -594,9 +594,11 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::flat() {
     }
     #endif
 
-    FlatGL<dimensions> shader{data.flags
+    FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
+        .setFlags(data.flags)
         #ifndef MAGNUM_TARGET_GLES2
-        , data.materialCount, data.drawCount
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)
         #endif
     };
 
@@ -705,9 +707,12 @@ void ShadersGLBenchmark::phong() {
     }
     #endif
 
-    PhongGL shader{data.flags, data.lightCount
+    PhongGL shader{PhongGL::Configuration{}
+        .setFlags(data.flags)
+        .setLightCount(data.lightCount)
         #ifndef MAGNUM_TARGET_GLES2
-        , data.materialCount, data.drawCount
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)
         #endif
     };
 
@@ -873,9 +878,10 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::vertexColor() {
     }
     #endif
 
-    VertexColorGL<dimensions> shader{data.flags
+    VertexColorGL<dimensions> shader{typename VertexColorGL<dimensions>::Configuration{}
+        .setFlags(data.flags)
         #ifndef MAGNUM_TARGET_GLES2
-        , data.drawCount
+        .setDrawCount(data.drawCount)
         #endif
     };
 
@@ -932,9 +938,11 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::vector() {
     }
     #endif
 
-    VectorGL<dimensions> shader{data.flags
+    VectorGL<dimensions> shader{typename VectorGL<dimensions>::Configuration{}
+        .setFlags(data.flags)
         #ifndef MAGNUM_TARGET_GLES2
-        , data.materialCount, data.drawCount
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)
         #endif
     };
     shader.bindVectorTexture(_textureWhite);
@@ -1004,9 +1012,11 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::distanceFieldVector()
     }
     #endif
 
-    DistanceFieldVectorGL<dimensions> shader{data.flags
+    DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
+        .setFlags(data.flags)
         #ifndef MAGNUM_TARGET_GLES2
-        , data.materialCount, data.drawCount
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)
         #endif
     };
     shader.bindVectorTexture(_textureWhite);
@@ -1116,7 +1126,8 @@ void ShadersGLBenchmark::meshVisualizer2D() {
     }
     #endif
 
-    MeshVisualizerGL2D shader{data.flags};
+    MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
+        .setFlags(data.flags)};
     shader.setViewportSize(Vector2{RenderSize});
     #ifndef MAGNUM_TARGET_GLES2
     if(data.flags & (MeshVisualizerGL2D::Flag::InstancedObjectId|MeshVisualizerGL2D::Flag::VertexId|MeshVisualizerGL2D::Flag::PrimitiveIdFromVertexId
@@ -1250,7 +1261,8 @@ void ShadersGLBenchmark::meshVisualizer3D() {
     }
     #endif
 
-    MeshVisualizerGL3D shader{data.flags};
+    MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
+        .setFlags(data.flags)};
     shader.setViewportSize(Vector2{RenderSize});
 
     #ifndef MAGNUM_TARGET_GLES2

src/Magnum/Shaders/Test/VectorGLTest.cpp

@@ -370,7 +370,8 @@ template<UnsignedInt dimensions> void VectorGLTest::construct() {
     auto&& data = ConstructData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    VectorGL<dimensions> shader{data.flags};
+    VectorGL<dimensions> shader{typename VectorGL<dimensions>::Configuration{}
+        .setFlags(data.flags)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_VERIFY(shader.id());
     {
@@ -386,7 +387,8 @@ template<UnsignedInt dimensions> void VectorGLTest::construct() {
 template<UnsignedInt dimensions> void VectorGLTest::constructAsync() {
     setTestCaseTemplateName(Utility::format("{}", dimensions));
 
-    typename VectorGL<dimensions>::CompileState state = VectorGL<dimensions>::compile(VectorGL2D::Flag::TextureTransformation);
+    typename VectorGL<dimensions>::CompileState state = VectorGL<dimensions>::compile(typename VectorGL<dimensions>::Configuration{}
+        .setFlags(VectorGL2D::Flag::TextureTransformation));
     CORRADE_COMPARE(state.flags(), VectorGL2D::Flag::TextureTransformation);
 
     while(!state.isLinkFinished())
@@ -432,7 +434,10 @@ template<UnsignedInt dimensions> void VectorGLTest::constructUniformBuffers() {
         #endif
     }
 
-    VectorGL<dimensions> shader{data.flags, data.materialCount, data.drawCount};
+    VectorGL<dimensions> shader{typename VectorGL<dimensions>::Configuration{}
+        .setFlags(data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_COMPARE(shader.drawCount(), data.drawCount);
     CORRADE_VERIFY(shader.id());
@@ -454,7 +459,10 @@ template<UnsignedInt dimensions> void VectorGLTest::constructUniformBuffersAsync
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    typename VectorGL<dimensions>::CompileState state = VectorGL<dimensions>::compile(VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation, 15, 42);
+    typename VectorGL<dimensions>::CompileState state = VectorGL<dimensions>::compile(typename VectorGL<dimensions>::Configuration{}
+        .setFlags(VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation)
+        .setMaterialCount(15)
+        .setDrawCount(42));
     CORRADE_COMPARE(state.flags(), VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation);
     CORRADE_COMPARE(state.materialCount(), 15);
     CORRADE_COMPARE(state.drawCount(), 42);
@@ -482,7 +490,8 @@ template<UnsignedInt dimensions> void VectorGLTest::constructUniformBuffersAsync
 template<UnsignedInt dimensions> void VectorGLTest::constructMove() {
     setTestCaseTemplateName(Utility::format("{}", dimensions));
 
-    VectorGL<dimensions> a{VectorGL<dimensions>::Flag::TextureTransformation};
+    VectorGL<dimensions> a{typename VectorGL<dimensions>::Configuration{}
+        .setFlags(VectorGL<dimensions>::Flag::TextureTransformation)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -509,7 +518,10 @@ template<UnsignedInt dimensions> void VectorGLTest::constructMoveUniformBuffers(
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    VectorGL<dimensions> a{VectorGL<dimensions>::Flag::UniformBuffers, 2, 5};
+    VectorGL<dimensions> a{typename VectorGL<dimensions>::Configuration{}
+        .setFlags(VectorGL<dimensions>::Flag::UniformBuffers)
+        .setMaterialCount(2)
+        .setDrawCount(5)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -547,7 +559,10 @@ template<UnsignedInt dimensions> void VectorGLTest::constructUniformBuffersInval
 
     std::ostringstream out;
     Error redirectError{&out};
-    VectorGL<dimensions>{data.flags, data.materialCount, data.drawCount};
+    VectorGL<dimensions>{typename VectorGL<dimensions>::Configuration{}
+        .setFlags(data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(out.str(), Utility::formatString(
         "Shaders::VectorGL: {}\n", data.message));
 }
@@ -567,7 +582,8 @@ template<UnsignedInt dimensions> void VectorGLTest::setUniformUniformBuffersEnab
     std::ostringstream out;
     Error redirectError{&out};
 
-    VectorGL<dimensions> shader{VectorGL<dimensions>::Flag::UniformBuffers};
+    VectorGL<dimensions> shader{typename VectorGL<dimensions>::Configuration{}
+        .setFlags(VectorGL<dimensions>::Flag::UniformBuffers)};
     shader.setTransformationProjectionMatrix({})
         .setTextureMatrix({})
         .setBackgroundColor({})
@@ -641,7 +657,8 @@ template<UnsignedInt dimensions> void VectorGLTest::bindTextureTransformBufferNo
     Error redirectError{&out};
 
     GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
-    VectorGL<dimensions> shader{VectorGL<dimensions>::Flag::UniformBuffers};
+    VectorGL<dimensions> shader{typename VectorGL<dimensions>::Configuration{}
+        .setFlags(VectorGL<dimensions>::Flag::UniformBuffers)};
     shader.bindTextureTransformationBuffer(buffer)
           .bindTextureTransformationBuffer(buffer, 0, 16);
     CORRADE_COMPARE(out.str(),
@@ -663,7 +680,10 @@ template<UnsignedInt dimensions> void VectorGLTest::setWrongDrawOffset() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    VectorGL<dimensions>{VectorGL<dimensions>::Flag::UniformBuffers, 2, 5}
+    VectorGL<dimensions>{typename VectorGL<dimensions>::Configuration{}
+        .setFlags(VectorGL<dimensions>::Flag::UniformBuffers)
+        .setMaterialCount(2)
+        .setDrawCount(5)}
         .setDrawOffset(5);
     CORRADE_COMPARE(out.str(),
         "Shaders::VectorGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
@@ -742,7 +762,8 @@ template<VectorGL2D::Flag flag> void VectorGLTest::renderDefaults2D() {
         .setSubImage(0, {}, *image);
     #endif
 
-    VectorGL2D shader{flag};
+    VectorGL2D shader{VectorGL2D::Configuration{}
+        .setFlags(flag)};
     shader.bindVectorTexture(texture);
 
     if(flag == VectorGL2D::Flag{}) {
@@ -821,7 +842,8 @@ template<VectorGL3D::Flag flag> void VectorGLTest::renderDefaults3D() {
         .setSubImage(0, {}, *image);
     #endif
 
-    VectorGL3D shader{flag};
+    VectorGL3D shader{VectorGL3D::Configuration{}
+        .setFlags(flag)};
     shader.bindVectorTexture(texture);
 
     if(flag == VectorGL3D::Flag{}) {
@@ -903,7 +925,8 @@ template<VectorGL2D::Flag flag> void VectorGLTest::render2D() {
         .setSubImage(0, {}, *image);
     #endif
 
-    VectorGL2D shader{data.flags|flag};
+    VectorGL2D shader{VectorGL2D::Configuration{}
+        .setFlags(data.flags|flag)};
     shader.bindVectorTexture(texture);
 
     if(flag == VectorGL2D::Flag{}) {
@@ -1008,7 +1031,8 @@ template<VectorGL3D::Flag flag> void VectorGLTest::render3D() {
         .setSubImage(0, {}, *image);
     #endif
 
-    VectorGL3D shader{data.flags|flag};
+    VectorGL3D shader{VectorGL3D::Configuration{}
+        .setFlags(data.flags|flag)};
     shader.bindVectorTexture(texture);
 
     if(flag == VectorGL3D::Flag{}) {
@@ -1200,7 +1224,10 @@ void VectorGLTest::renderMulti2D() {
         .setMaterialId(data.drawCount == 1 ? 0 : 1);
     GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, drawData};
 
-    VectorGL2D shader{VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation|data.flags, data.materialCount, data.drawCount};
+    VectorGL2D shader{VectorGL2D::Configuration{}
+        .setFlags(VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation|data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     shader.bindVectorTexture(vector);
 
     /* Just one draw, rebinding UBOs each time */
@@ -1406,7 +1433,10 @@ void VectorGLTest::renderMulti3D() {
         .setMaterialId(data.drawCount == 1 ? 0 : 1);
     GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, drawData};
 
-    VectorGL3D shader{VectorGL3D::Flag::UniformBuffers|VectorGL3D::Flag::TextureTransformation|data.flags, data.materialCount, data.drawCount};
+    VectorGL3D shader{VectorGL3D::Configuration{}
+        .setFlags(VectorGL3D::Flag::UniformBuffers|VectorGL3D::Flag::TextureTransformation|data.flags)
+        .setMaterialCount(data.materialCount)
+        .setDrawCount(data.drawCount)};
     shader.bindVectorTexture(vector);
 
     /* Just one draw, rebinding UBOs each time */

src/Magnum/Shaders/Test/VertexColorGLTest.cpp

@@ -367,7 +367,9 @@ template<UnsignedInt dimensions> void VertexColorGLTest::constructUniformBuffers
         #endif
     }
 
-    VertexColorGL<dimensions> shader{data.flags, data.drawCount};
+    VertexColorGL<dimensions> shader{typename VertexColorGL<dimensions>::Configuration{}
+        .setFlags(data.flags)
+        .setDrawCount(data.drawCount)};
     CORRADE_COMPARE(shader.flags(), data.flags);
     CORRADE_COMPARE(shader.drawCount(), data.drawCount);
     CORRADE_VERIFY(shader.id());
@@ -389,7 +391,9 @@ template<UnsignedInt dimensions> void VertexColorGLTest::constructUniformBuffers
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    typename VertexColorGL<dimensions>::CompileState state = VertexColorGL<dimensions>::compile(VertexColorGL2D::Flag::UniformBuffers, 63);
+    typename VertexColorGL<dimensions>::CompileState state = VertexColorGL<dimensions>::compile(typename VertexColorGL<dimensions>::Configuration{}
+        .setFlags(VertexColorGL2D::Flag::UniformBuffers)
+        .setDrawCount(63));
     CORRADE_COMPARE(state.flags(), VertexColorGL2D::Flag::UniformBuffers);
     CORRADE_COMPARE(state.drawCount(), 63);
 
@@ -440,7 +444,9 @@ template<UnsignedInt dimensions> void VertexColorGLTest::constructMoveUniformBuf
         CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
     #endif
 
-    VertexColorGL<dimensions> a{VertexColorGL<dimensions>::Flag::UniformBuffers, 5};
+    VertexColorGL<dimensions> a{typename VertexColorGL<dimensions>::Configuration{}
+        .setFlags(VertexColorGL<dimensions>::Flag::UniformBuffers)
+        .setDrawCount(5)};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -474,7 +480,9 @@ template<UnsignedInt dimensions> void VertexColorGLTest::constructUniformBuffers
 
     std::ostringstream out;
     Error redirectError{&out};
-    VertexColorGL<dimensions>{VertexColorGL<dimensions>::Flag::UniformBuffers, 0};
+    VertexColorGL<dimensions>{typename VertexColorGL<dimensions>::Configuration{}
+        .setFlags(VertexColorGL<dimensions>::Flag::UniformBuffers)
+        .setDrawCount(0)};
     CORRADE_COMPARE(out.str(),
         "Shaders::VertexColorGL: draw count can't be zero\n");
 }
@@ -494,7 +502,8 @@ template<UnsignedInt dimensions> void VertexColorGLTest::setUniformUniformBuffer
     std::ostringstream out;
     Error redirectError{&out};
 
-    VertexColorGL<dimensions> shader{VertexColorGL<dimensions>::Flag::UniformBuffers};
+    VertexColorGL<dimensions> shader{typename VertexColorGL<dimensions>::Configuration{}
+        .setFlags(VertexColorGL<dimensions>::Flag::UniformBuffers)};
     shader.setTransformationProjectionMatrix({});
     CORRADE_COMPARE(out.str(),
         "Shaders::VertexColorGL::setTransformationProjectionMatrix(): the shader was created with uniform buffers enabled\n");
@@ -531,7 +540,9 @@ template<UnsignedInt dimensions> void VertexColorGLTest::setWrongDrawOffset() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    VertexColorGL<dimensions>{VertexColorGL<dimensions>::Flag::UniformBuffers, 5}
+    VertexColorGL<dimensions>{typename VertexColorGL<dimensions>::Configuration{}
+        .setFlags(VertexColorGL<dimensions>::Flag::UniformBuffers)
+        .setDrawCount(5)}
         .setDrawOffset(5);
     CORRADE_COMPARE(out.str(),
         "Shaders::VertexColorGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
@@ -591,7 +602,8 @@ template<class T, VertexColorGL2D::Flag flag> void VertexColorGLTest::renderDefa
     GL::Mesh circle = MeshTools::compile(circleData);
     circle.addVertexBuffer(colors, 0, GL::Attribute<VertexColorGL2D::Color3::Location, T>{});
 
-    VertexColorGL2D shader{flag};
+    VertexColorGL2D shader{VertexColorGL2D::Configuration{}
+        .setFlags(flag)};
 
     if(flag == VertexColorGL2D::Flag{}) {
         shader.draw(circle);
@@ -657,7 +669,8 @@ template<class T, VertexColorGL2D::Flag flag> void VertexColorGLTest::renderDefa
     GL::Mesh sphere = MeshTools::compile(sphereData);
     sphere.addVertexBuffer(colors, 0, GL::Attribute<VertexColorGL3D::Color4::Location, T>{});
 
-    VertexColorGL3D shader{flag};
+    VertexColorGL3D shader{VertexColorGL3D::Configuration{}
+        .setFlags(flag)};
 
     if(flag == VertexColorGL3D::Flag{}) {
         shader.draw(sphere);
@@ -717,7 +730,8 @@ template<class T, VertexColorGL2D::Flag flag> void VertexColorGLTest::render2D()
     GL::Mesh circle = MeshTools::compile(circleData);
     circle.addVertexBuffer(colors, 0, GL::Attribute<VertexColorGL2D::Color3::Location, T>{});
 
-    VertexColorGL2D shader{flag};
+    VertexColorGL2D shader{VertexColorGL2D::Configuration{}
+        .setFlags(flag)};
 
     if(flag == VertexColorGL2D::Flag{}) {
         shader.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
@@ -784,7 +798,8 @@ template<class T, VertexColorGL3D::Flag flag> void VertexColorGLTest::render3D()
     GL::Mesh sphere = MeshTools::compile(sphereData);
     sphere.addVertexBuffer(colors, 0, GL::Attribute<VertexColorGL3D::Color4::Location, T>{});
 
-    VertexColorGL3D shader{flag};
+    VertexColorGL3D shader{VertexColorGL3D::Configuration{}
+        .setFlags(flag)};
 
     if(flag == VertexColorGL3D::Flag{}) {
         shader.setTransformationProjectionMatrix(
@@ -908,7 +923,9 @@ void VertexColorGLTest::renderMulti2D() {
         );
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    VertexColorGL2D shader{VertexColorGL2D::Flag::UniformBuffers|data.flags, data.drawCount};
+    VertexColorGL2D shader{VertexColorGL2D::Configuration{}
+        .setFlags(VertexColorGL2D::Flag::UniformBuffers|data.flags)
+        .setDrawCount(data.drawCount)};
 
     /* Just one draw, rebinding UBOs each time */
     if(data.drawCount == 1) {
@@ -1039,7 +1056,9 @@ void VertexColorGLTest::renderMulti3D() {
         );
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    VertexColorGL3D shader{VertexColorGL3D::Flag::UniformBuffers|data.flags, data.drawCount};
+    VertexColorGL3D shader{VertexColorGL3D::Configuration{}
+        .setFlags(VertexColorGL3D::Flag::UniformBuffers|data.flags)
+        .setDrawCount(data.drawCount)};
 
     /* Just one draw, rebinding UBOs each time */
     if(data.drawCount == 1) {