Explicitly passing shader to Mesh*::draw().

Previously the API didn't encourage the user to set up and activate
shader before drawing the meshes, leading to unintuitive behavior:

    // Can I just call draw() or do I have to fully understand the
    // meaning of the universe before?
    mesh.draw();

Now the draw() needs the shader passed explicitly as parameter, which
should hint that the shader must be set up somehow:

    // Right, so this needs just a shader and that's all. Expecting this
    // I fortunately *did* configure all the uniforms before this call.
    mesh.draw(shader);

It is also possible to pass the shader as rvalue, in case the drawing is
just a one-off thing and is already fully configured.

    mesh.draw(MyShader{});

As usual, the original API is kept, is marked as deprecated and will be
removed in some future release.

doc/opengl-mapping.dox

@@ -248,7 +248,7 @@ OpenGL function                        | Matching API
 @fn_gl{Uniform}, \n @fn_gl{ProgramUniform}, \n @fn_gl_extension{ProgramUniform,EXT,direct_state_access} | @ref AbstractShaderProgram::setUniform()
 @fn_gl{UniformBlockBinding}            | |
 @fn_gl{UniformSubroutines}             | |
-@fn_gl{UseProgram}                     | @ref AbstractShaderProgram::use()
+@fn_gl{UseProgram}                     | @ref Mesh::draw(), @ref MeshView::draw()
 @fn_gl{UseProgramStages}               | |
 @fn_gl{ValidateProgram}                | @ref AbstractShaderProgram::validate()
 @fn_gl{ValidateProgramPipeline}        | |

src/Magnum/AbstractShaderProgram.h

@@ -248,19 +248,17 @@ Basic workflow with %AbstractShaderProgram subclasses is: instance shader
 class, configure attribute binding in meshes (see @ref Mesh-configuration "Mesh documentation"
 for more information) and map shader outputs to framebuffer attachments if
 needed (see @ref Framebuffer-usage "Framebuffer documentation" for more
-information). In each draw event set uniforms, mark the shader for use, bind
-specific framebuffer (if needed) and bind required textures to their
-respective layers using @ref AbstractTexture::bind(Int). Then call
-@ref Mesh::draw(). Example:
+information). In each draw event set uniforms, bind specific framebuffer (if
+needed) and bind required textures to their respective layers using
+@ref AbstractTexture::bind(Int). Then call @ref Mesh::draw(). Example:
 @code
 shader.setTransformation(transformation)
-    .setProjection(projection)
-    .use();
+    .setProjection(projection);
 
 diffuseTexture.bind(MyShader::DiffuseTextureLayer);
 specularTexture.bind(MyShader::SpecularTextureLayer);
 
-mesh.draw();
+mesh.draw(shader);
 @endcode
 
 @section AbstractShaderProgram-types Mapping between GLSL and Magnum types
@@ -303,9 +301,8 @@ also @ref Attribute::DataType enum for additional type options.
 
 @section AbstractShaderProgram-performance-optimization Performance optimizations
 
-The engine tracks currently used shader program to avoid unnecessary calls to
-@fn_gl{UseProgram}. %Shader limits (such as @ref maxVertexAttributes())
-are cached, so repeated queries don't result in repeated @fn_gl{Get} calls.
+%Shader limits (such as @ref maxVertexAttributes()) are cached, so repeated
+queries don't result in repeated @fn_gl{Get} calls.
 
 If extension @extension{ARB,separate_shader_objects} (part of OpenGL 4.1) or
 @extension{EXT,direct_state_access} is available, uniform setting functions
@@ -323,6 +320,8 @@ comes in handy.
 @todo `GL_NUM_{PROGRAM,SHADER}_BINARY_FORMATS` + `GL_{PROGRAM,SHADER}_BINARY_FORMATS` (vector), (@extension{ARB,ES2_compatibility})
  */
 class MAGNUM_EXPORT AbstractShaderProgram: public AbstractObject {
+    friend class Mesh;
+    friend class MeshView;
     friend struct Implementation::ShaderProgramState;
 
     public:
@@ -549,12 +548,13 @@ class MAGNUM_EXPORT AbstractShaderProgram: public AbstractObject {
          */
         std::pair<bool, std::string> validate();
 
+        #ifdef MAGNUM_BUILD_DEPRECATED
         /**
          * @brief Use shader for rendering
-         *
-         * @see @fn_gl{UseProgram}
+         * @deprecated Use @ref Magnum::Mesh::draw(AbstractShaderProgram&) "Mesh::draw(AbstractShaderProgram&)" instead.
          */
         void use();
+        #endif
 
     protected:
         #ifndef MAGNUM_TARGET_GLES2
@@ -790,6 +790,10 @@ class MAGNUM_EXPORT AbstractShaderProgram: public AbstractObject {
         #endif
 
     private:
+        #ifndef MAGNUM_BUILD_DEPRECATED
+        void use();
+        #endif
+
         void MAGNUM_LOCAL uniformImplementationDefault(GLint location, GLsizei count, const GLfloat* values);
         void MAGNUM_LOCAL uniformImplementationDefault(GLint location, GLsizei count, const Math::Vector<2, GLfloat>* values);
         void MAGNUM_LOCAL uniformImplementationDefault(GLint location, GLsizei count, const Math::Vector<3, GLfloat>* values);

src/Magnum/DebugTools/ForceRenderer.cpp

@@ -97,9 +97,8 @@ template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneG
 
 template<UnsignedInt dimensions> void ForceRenderer<dimensions>::draw(const typename DimensionTraits<dimensions, Float>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) {
     shader->setTransformationProjectionMatrix(camera.projectionMatrix()*Implementation::forceRendererTransformation<dimensions>(transformationMatrix.transformPoint(forcePosition), force)*DimensionTraits<dimensions, Float>::MatrixType::scaling(typename DimensionTraits<dimensions, Float>::VectorType(options->scale())))
-        .setColor(options->color())
-        .use();
-    mesh->draw();
+        .setColor(options->color());
+    mesh->draw(*shader);
 }
 
 template class ForceRenderer<2>;

src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp

@@ -38,9 +38,8 @@ template<UnsignedInt dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(R
     AbstractBoxRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
         DimensionTraits<dimensions, Float>::MatrixType::translation((axisAlignedBox.min()+axisAlignedBox.max())/2)*
         DimensionTraits<dimensions, Float>::MatrixType::scaling(axisAlignedBox.max()-axisAlignedBox.min()))
-        .setColor(options->color())
-        .use();
-    AbstractBoxRenderer<dimensions>::wireframeMesh->draw();
+        .setColor(options->color());
+    AbstractBoxRenderer<dimensions>::wireframeMesh->draw(*AbstractBoxRenderer<dimensions>::wireframeShader);
 }
 
 template class AxisAlignedBoxRenderer<2>;

src/Magnum/DebugTools/Implementation/BoxRenderer.cpp

@@ -36,9 +36,8 @@ template<UnsignedInt dimensions> BoxRenderer<dimensions>::BoxRenderer(const Shap
 
 template<UnsignedInt dimensions> void BoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
     AbstractBoxRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*box.transformation())
-        .setColor(options->color())
-        .use();
-    AbstractBoxRenderer<dimensions>::wireframeMesh->draw();
+        .setColor(options->color());
+    AbstractBoxRenderer<dimensions>::wireframeMesh->draw(*AbstractBoxRenderer<dimensions>::wireframeShader);
 }
 
 template class BoxRenderer<2>;

src/Magnum/DebugTools/Implementation/CapsuleRenderer.cpp

@@ -100,20 +100,19 @@ template<UnsignedInt dimensions> CapsuleRenderer<dimensions>::CapsuleRenderer(co
 
 template<UnsignedInt dimensions> void CapsuleRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
     std::array<typename DimensionTraits<dimensions, Float>::MatrixType, 3> transformations = Implementation::capsuleRendererTransformation<dimensions>(capsule.a(), capsule.b(), capsule.radius());
-    AbstractShapeRenderer<dimensions>::wireframeShader->setColor(options->color())
-        .use();
+    AbstractShapeRenderer<dimensions>::wireframeShader->setColor(options->color());
 
     /* Bottom */
     AbstractShapeRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*transformations[0]);
-    AbstractCapsuleRenderer<dimensions>::bottom->draw();
+    AbstractCapsuleRenderer<dimensions>::bottom->draw(*AbstractShapeRenderer<dimensions>::wireframeShader);
 
     /* Cylinder */
     AbstractShapeRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*transformations[1]);
-    AbstractCapsuleRenderer<dimensions>::cylinder->draw();
+    AbstractCapsuleRenderer<dimensions>::cylinder->draw(*AbstractShapeRenderer<dimensions>::wireframeShader);
 
     /* Top */
     AbstractShapeRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*transformations[2]);
-    AbstractCapsuleRenderer<dimensions>::top->draw();
+    AbstractCapsuleRenderer<dimensions>::top->draw(*AbstractShapeRenderer<dimensions>::wireframeShader);
 }
 
 template class CapsuleRenderer<2>;

src/Magnum/DebugTools/Implementation/CylinderRenderer.cpp

@@ -51,9 +51,8 @@ template<UnsignedInt dimensions> CylinderRenderer<dimensions>::CylinderRenderer(
 template<UnsignedInt dimensions> void CylinderRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
     AbstractShapeRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
         Implementation::cylinderRendererTransformation<dimensions>(cylinder.a(), cylinder.b(), cylinder.radius()))
-        .setColor(options->color())
-        .use();
-    AbstractShapeRenderer<dimensions>::wireframeMesh->draw();
+        .setColor(options->color());
+    AbstractShapeRenderer<dimensions>::wireframeMesh->draw(*AbstractShapeRenderer<dimensions>::wireframeShader);
 }
 
 template class CylinderRenderer<2>;

src/Magnum/DebugTools/Implementation/LineSegmentRenderer.cpp

@@ -58,9 +58,8 @@ template<UnsignedInt dimensions> LineSegmentRenderer<dimensions>::LineSegmentRen
 template<UnsignedInt dimensions> void LineSegmentRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
     AbstractShapeRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
         Implementation::lineSegmentRendererTransformation<dimensions>(line.a(), line.b()))
-        .setColor(options->color())
-        .use();
-    AbstractShapeRenderer<dimensions>::wireframeMesh->draw();
+        .setColor(options->color());
+    AbstractShapeRenderer<dimensions>::wireframeMesh->draw(*AbstractShapeRenderer<dimensions>::wireframeShader);
 }
 
 template class LineSegmentRenderer<2>;

src/Magnum/DebugTools/Implementation/PointRenderer.cpp

@@ -58,9 +58,8 @@ template<UnsignedInt dimensions> void PointRenderer<dimensions>::draw(Resource<S
     AbstractShapeRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
         DimensionTraits<dimensions, Float>::MatrixType::translation(point.position())*
         DimensionTraits<dimensions, Float>::MatrixType::scaling(typename DimensionTraits<dimensions, Float>::VectorType(options->pointSize()/2)))
-        .setColor(options->color())
-        .use();
-    AbstractShapeRenderer<dimensions>::wireframeMesh->draw();
+        .setColor(options->color());
+    AbstractShapeRenderer<dimensions>::wireframeMesh->draw(*AbstractShapeRenderer<dimensions>::wireframeShader);
 }
 
 template class PointRenderer<2>;

src/Magnum/DebugTools/Implementation/SphereRenderer.cpp

@@ -50,9 +50,8 @@ template<UnsignedInt dimensions> void SphereRenderer<dimensions>::draw(Resource<
     AbstractShapeRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
         DimensionTraits<dimensions, Float>::MatrixType::translation(sphere.position())*
         DimensionTraits<dimensions, Float>::MatrixType::scaling(typename DimensionTraits<dimensions, Float>::VectorType(sphere.radius())))
-        .setColor(options->color())
-        .use();
-    AbstractShapeRenderer<dimensions>::wireframeMesh->draw();
+        .setColor(options->color());
+    AbstractShapeRenderer<dimensions>::wireframeMesh->draw(*AbstractShapeRenderer<dimensions>::wireframeShader);
 }
 
 template class SphereRenderer<2>;

src/Magnum/DebugTools/ObjectRenderer.cpp

@@ -175,10 +175,8 @@ template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(Scen
 }
 
 template<UnsignedInt dimensions> void ObjectRenderer<dimensions>::draw(const typename DimensionTraits<dimensions, Float>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) {
-    shader->setTransformationProjectionMatrix(camera.projectionMatrix()*transformationMatrix*DimensionTraits<dimensions, Float>::MatrixType::scaling(typename DimensionTraits<dimensions, Float>::VectorType(options->size())))
-        .use();
-
-    mesh->draw();
+    shader->setTransformationProjectionMatrix(camera.projectionMatrix()*transformationMatrix*DimensionTraits<dimensions, Float>::MatrixType::scaling(typename DimensionTraits<dimensions, Float>::VectorType(options->size())));
+    mesh->draw(*shader);
 }
 
 template class ObjectRenderer<2>;

src/Magnum/Mesh.h

@@ -296,10 +296,11 @@ for more infromation) and call @ref Mesh::draw().
 If @extension{APPLE,vertex_array_object} (part of OpenGL 3.0), OpenGL ES 3.0 or
 @es_extension{OES,vertex_array_object} on OpenGL ES 2.0 is supported, VAOs are
 used instead of binding the buffers and specifying vertex attribute pointers
-in each @ref draw() call. The engine tracks currently bound VAO to avoid
-unnecessary calls to @fn_gl{BindVertexArray}. %Mesh limits and
-implementation-defined values (such as @ref maxVertexAttributes()) are cached,
-so repeated queries don't result in repeated @fn_gl{Get} calls.
+in each @ref draw() call. The engine tracks currently bound VAO and currently
+active shader program to avoid unnecessary calls to @fn_gl{BindVertexArray} and
+@fn_gl{UseProgram}. %Mesh limits and implementation-defined values (such as
+@ref maxVertexAttributes()) are cached, so repeated queries don't result in
+repeated @fn_gl{Get} calls.
 
 If extension @extension{EXT,direct_state_access} and VAOs are available,
 DSA functions are used for specifying attribute locations to avoid unnecessary
@@ -607,14 +608,34 @@ class MAGNUM_EXPORT Mesh: public AbstractObject {
 
         /**
          * @brief Draw the mesh
+         * @param shader    Shader to use for drawing
          *
-         * Expects an active shader with all uniforms set. See
+         * Expects that the shader is compatible with this mesh and is fully
+         * set up. See also
          * @ref AbstractShaderProgram-rendering-workflow "AbstractShaderProgram documentation"
          * for more information.
-         * @see @fn_gl{EnableVertexAttribArray}, @fn_gl{BindBuffer},
-         *      @fn_gl{VertexAttribPointer}, @fn_gl{DisableVertexAttribArray}
-         *      or @fn_gl{BindVertexArray} (if @extension{APPLE,vertex_array_object}
-         *      is available), @fn_gl{DrawArrays} or @fn_gl{DrawElements}/@fn_gl{DrawRangeElements}.
+         * @see @fn_gl{UseProgram}, @fn_gl{EnableVertexAttribArray},
+         *      @fn_gl{BindBuffer}, @fn_gl{VertexAttribPointer},
+         *      @fn_gl{DisableVertexAttribArray} or @fn_gl{BindVertexArray} (if
+         *      @extension{APPLE,vertex_array_object} is available), @fn_gl{DrawArrays}
+         *      or @fn_gl{DrawElements}/@fn_gl{DrawRangeElements}.
+         */
+        void draw(AbstractShaderProgram& shader) {
+            shader.use();
+
+            #ifndef MAGNUM_TARGET_GLES2
+            drawInternal(0, _vertexCount, _indexOffset, _indexCount, _indexStart, _indexEnd);
+            #else
+            drawInternal(0, _vertexCount, _indexOffset, _indexCount);
+            #endif
+        }
+
+        void draw(AbstractShaderProgram&& shader) { draw(shader); } /**< @overload */
+
+        #ifdef MAGNUM_BUILD_DEPRECATED
+        /**
+         * @copybrief draw(AbstractShaderProgram&)
+         * @deprecated Use @ref Magnum::Mesh::draw(AbstractShaderProgram&) instead.
          */
         void draw() {
             #ifndef MAGNUM_TARGET_GLES2
@@ -623,6 +644,7 @@ class MAGNUM_EXPORT Mesh: public AbstractObject {
             drawInternal(0, _vertexCount, _indexOffset, _indexCount);
             #endif
         }
+        #endif
 
     private:
         #ifndef DOXYGEN_GENERATING_OUTPUT

src/Magnum/MeshView.cpp

@@ -44,6 +44,17 @@ MeshView& MeshView::setIndexRange(Int first, Int count, UnsignedInt, UnsignedInt
     return *this;
 }
 
+void MeshView::draw(AbstractShaderProgram& shader) {
+    shader.use();
+
+    #ifndef MAGNUM_TARGET_GLES2
+    _original->drawInternal(_firstVertex, _vertexCount,  _indexOffset, _indexCount, _indexStart, _indexEnd);
+    #else
+    _original->drawInternal(_firstVertex, _vertexCount, _indexOffset, _indexCount);
+    #endif
+}
+
+#ifdef MAGNUM_BUILD_DEPRECATED
 void MeshView::draw() {
     #ifndef MAGNUM_TARGET_GLES2
     _original->drawInternal(_firstVertex, _vertexCount,  _indexOffset, _indexCount, _indexStart, _indexEnd);
@@ -51,5 +62,6 @@ void MeshView::draw() {
     _original->drawInternal(_firstVertex, _vertexCount, _indexOffset, _indexCount);
     #endif
 }
+#endif
 
 }

src/Magnum/MeshView.h

@@ -120,7 +120,16 @@ class MAGNUM_EXPORT MeshView {
          *
          * See @ref Mesh::draw() for more information.
          */
-        void draw();
+        void draw(AbstractShaderProgram& shader);
+        void draw(AbstractShaderProgram&& shader) { draw(shader); } /**< @overload */
+
+        #ifdef MAGNUM_BUILD_DEPRECATED
+        /**
+         * @copybrief draw(AbstractShaderProgram&)
+         * @deprecated Use
+         */
+        CORRADE_DEPRECATED("use draw(AbstractShaderProgram&) instead") void draw();
+        #endif
 
     private:
         Mesh* _original;

src/Magnum/ResourceManager.h

@@ -212,9 +212,8 @@ if(!cube) {
 @endcode
 - Using the resource data.
 @code
-shader->use();
 texture->bind(layer);
-cube->draw();
+cube->draw(*shader);
 @endcode
 - Destroying resource references and deleting manager instance when nothing
   references the resources anymore.

src/Magnum/Shaders/Generic.h

@@ -54,8 +54,7 @@ mesh.addVertexBuffer(vertexBuffer, 0,
 
 Shaders::Phong phong;
 // ...
-phong.use();
-mesh.draw();
+mesh.draw(phong);
 @endcode
 
 @see @ref Generic2D, @ref Generic3D

src/Magnum/Test/AbstractShaderProgramGLTest.cpp

@@ -199,10 +199,6 @@ void AbstractShaderProgramGLTest::create() {
     CORRADE_VERIFY(multiplierUniform >= 0);
     CORRADE_VERIFY(colorUniform >= 0);
     CORRADE_VERIFY(additionsUniform >= 0);
-
-    program.use();
-
-    MAGNUM_VERIFY_NO_ERROR();
 }
 
 void AbstractShaderProgramGLTest::createMultipleOutputs() {
@@ -236,10 +232,6 @@ void AbstractShaderProgramGLTest::createMultipleOutputs() {
     MAGNUM_VERIFY_NO_ERROR();
     CORRADE_VERIFY(linked);
     CORRADE_VERIFY(valid);
-
-    program.use();
-
-    MAGNUM_VERIFY_NO_ERROR();
     #elif !defined(MAGNUM_TARGET_GLES2)
     CORRADE_SKIP("Only explicit location specification supported in ES 3.0.");
     #else
@@ -278,10 +270,6 @@ void AbstractShaderProgramGLTest::createMultipleOutputsIndexed() {
     MAGNUM_VERIFY_NO_ERROR();
     CORRADE_VERIFY(linked);
     CORRADE_VERIFY(valid);
-
-    program.use();
-
-    MAGNUM_VERIFY_NO_ERROR();
 }
 #endif
 

src/Magnum/Test/MeshGLTest.cpp

@@ -393,12 +393,11 @@ Checker::Checker(AbstractShaderProgram&& shader, RenderbufferFormat format, Mesh
     framebuffer.attachRenderbuffer(Framebuffer::ColorAttachment(0), renderbuffer);
 
     framebuffer.bind(FramebufferTarget::ReadDraw);
-    shader.use();
     mesh.setVertexCount(2)
         .setPrimitive(MeshPrimitive::Points);
 
     /* Skip first vertex so we test also offsets */
-    MeshView(mesh).setVertexRange(1, 1).draw();
+    MeshView(mesh).setVertexRange(1, 1).draw(shader);
 }
 
 template<class T> T Checker::get(ColorFormat format, ColorType type) {
@@ -1148,13 +1147,11 @@ IndexChecker::IndexChecker(Mesh& mesh): framebuffer({{}, Vector2i(1)}) {
     framebuffer.attachRenderbuffer(Framebuffer::ColorAttachment(0), renderbuffer);
 
     framebuffer.bind(FramebufferTarget::ReadDraw);
-    MultipleShader shader;
-    shader.use();
     mesh.setIndexCount(2)
         .setPrimitive(MeshPrimitive::Points);
 
     /* Skip first vertex so we test also offsets */
-    MeshView(mesh).setIndexRange(1, 1).draw();
+    MeshView(mesh).setIndexRange(1, 1).draw(MultipleShader{});
 }
 
 Color4ub IndexChecker::get() {

src/Magnum/Test/PrimitiveQueryGLTest.cpp

@@ -97,8 +97,7 @@ void PrimitiveQueryGLTest::query() {
     q.begin(PrimitiveQuery::Target::PrimitivesGenerated);
 
     framebuffer.bind(FramebufferTarget::ReadDraw);
-    shader.use();
-    mesh.draw();
+    mesh.draw(shader);
 
     q.end();
     const bool availableBefore = q.resultAvailable();

src/Magnum/Test/SampleQueryGLTest.cpp

@@ -127,8 +127,7 @@ void SampleQueryGLTest::querySamplesPassed() {
     #endif
 
     framebuffer.bind(FramebufferTarget::ReadDraw);
-    shader.use();
-    mesh.draw();
+    mesh.draw(shader);
 
     q.end();
     const bool availableBefore = q.resultAvailable();
@@ -167,7 +166,6 @@ void SampleQueryGLTest::conditionalRender() {
 
     MyShader shader;
     framebuffer.bind(FramebufferTarget::ReadDraw);
-    shader.use();
 
     MAGNUM_VERIFY_NO_ERROR();
 
@@ -175,13 +173,13 @@ void SampleQueryGLTest::conditionalRender() {
 
     /* This should generate some samples */
     qYes.begin(SampleQuery::Target::SamplesPassed);
-    mesh.draw();
+    mesh.draw(shader);
     qYes.end();
 
     /* Thus this should be rendered */
     qYes.beginConditionalRender(SampleQuery::ConditionalRenderMode::Wait);
     q.begin(SampleQuery::Target::SamplesPassed);
-    mesh.draw();
+    mesh.draw(shader);
     q.end();
     qYes.endConditionalRender();
 
@@ -196,7 +194,7 @@ void SampleQueryGLTest::conditionalRender() {
     /* Thus this should not be rendered */
     qNo.beginConditionalRender(SampleQuery::ConditionalRenderMode::Wait);
     q.begin(SampleQuery::Target::SamplesPassed);
-    mesh.draw();
+    mesh.draw(shader);
     q.end();
     qNo.endConditionalRender();
 

src/Magnum/Text/Renderer.h

@@ -191,9 +191,8 @@ std::tie(mesh, rectangle) = Text::Renderer2D::render(*font, cache, 0.15f,
 // Draw white text centered on the screen
 shader.setTransformationProjectionMatrix(projection*Matrix3::translation(-rectangle.width()/2.0f))
     .setColor(Color3(1.0f));
-    .use();
 glyphCache->texture()->bind(Shaders::VectorShader2D::FontTextureLayer);
-mesh.draw();
+mesh.draw(shader);
 @endcode
 See @ref render(AbstractFont&, const GlyphCache&, Float, const std::string&, Alignment) and
 @ref render(AbstractFont&, const GlyphCache&, Float, const std::string&, Buffer&, Buffer&, BufferUsage, Alignment)
@@ -217,9 +216,8 @@ renderer.render("Hello World Countdown: 10");
 // Draw the text centered on the screen
 shader.setTransformationProjectionMatrix(projection*Matrix3::translation(-renderer.rectangle().width()/2.0f))
     .setColor(Color3(1.0f));
-    .use();
 glyphCache->texture()->bind(Shaders::VectorShader2D::FontTextureLayer);
-renderer.mesh().draw();
+renderer.mesh().draw(shader);
 @endcode
 
 @section Renderer-extensions Required OpenGL functionality

src/Magnum/TextureTools/DistanceField.cpp

@@ -162,8 +162,7 @@ void distanceField(Texture2D& input, Texture2D& output, const Range2Di& rectangl
 
     DistanceFieldShader shader;
     shader.setRadius(radius)
-        .setScaling(Vector2(imageSize)/Vector2(rectangle.size()))
-        .use();
+        .setScaling(Vector2(imageSize)/Vector2(rectangle.size()));
 
     input.bind(DistanceFieldShader::TextureLayer);
 
@@ -198,7 +197,7 @@ void distanceField(Texture2D& input, Texture2D& output, const Range2Di& rectangl
     }
 
     /* Draw the mesh */
-    mesh.draw();
+    mesh.draw(shader);
 }
 
 }}