From 703ce0bd89fbf02ec42c46a1de9bd8cdb3cf6c15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Tue, 4 Feb 2014 12:18:56 +0100 Subject: [PATCH] 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 | 2 +- src/Magnum/AbstractShaderProgram.h | 28 +++++++------ src/Magnum/DebugTools/ForceRenderer.cpp | 5 +-- .../Implementation/AxisAlignedBoxRenderer.cpp | 5 +-- .../DebugTools/Implementation/BoxRenderer.cpp | 5 +-- .../Implementation/CapsuleRenderer.cpp | 9 ++--- .../Implementation/CylinderRenderer.cpp | 5 +-- .../Implementation/LineSegmentRenderer.cpp | 5 +-- .../Implementation/PointRenderer.cpp | 5 +-- .../Implementation/SphereRenderer.cpp | 5 +-- src/Magnum/DebugTools/ObjectRenderer.cpp | 6 +-- src/Magnum/Mesh.h | 40 ++++++++++++++----- src/Magnum/MeshView.cpp | 12 ++++++ src/Magnum/MeshView.h | 11 ++++- src/Magnum/ResourceManager.h | 3 +- src/Magnum/Shaders/Generic.h | 3 +- .../Test/AbstractShaderProgramGLTest.cpp | 12 ------ src/Magnum/Test/MeshGLTest.cpp | 7 +--- src/Magnum/Test/PrimitiveQueryGLTest.cpp | 3 +- src/Magnum/Test/SampleQueryGLTest.cpp | 10 ++--- src/Magnum/Text/Renderer.h | 6 +-- src/Magnum/TextureTools/DistanceField.cpp | 5 +-- 22 files changed, 103 insertions(+), 89 deletions(-) diff --git a/doc/opengl-mapping.dox b/doc/opengl-mapping.dox index 98d1c6a4a..c855e4bb8 100644 --- a/doc/opengl-mapping.dox +++ b/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} | | diff --git a/src/Magnum/AbstractShaderProgram.h b/src/Magnum/AbstractShaderProgram.h index 09bc42fd9..7cdd763ae 100644 --- a/src/Magnum/AbstractShaderProgram.h +++ b/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 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); diff --git a/src/Magnum/DebugTools/ForceRenderer.cpp b/src/Magnum/DebugTools/ForceRenderer.cpp index 825c2406c..e763955a7 100644 --- a/src/Magnum/DebugTools/ForceRenderer.cpp +++ b/src/Magnum/DebugTools/ForceRenderer.cpp @@ -97,9 +97,8 @@ template ForceRenderer::ForceRenderer(SceneG template void ForceRenderer::draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractCamera& camera) { shader->setTransformationProjectionMatrix(camera.projectionMatrix()*Implementation::forceRendererTransformation(transformationMatrix.transformPoint(forcePosition), force)*DimensionTraits::MatrixType::scaling(typename DimensionTraits::VectorType(options->scale()))) - .setColor(options->color()) - .use(); - mesh->draw(); + .setColor(options->color()); + mesh->draw(*shader); } template class ForceRenderer<2>; diff --git a/src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp b/src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp index c84f1c810..33e014ca5 100644 --- a/src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp +++ b/src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp @@ -38,9 +38,8 @@ template void AxisAlignedBoxRenderer::draw(R AbstractBoxRenderer::wireframeShader->setTransformationProjectionMatrix(projectionMatrix* DimensionTraits::MatrixType::translation((axisAlignedBox.min()+axisAlignedBox.max())/2)* DimensionTraits::MatrixType::scaling(axisAlignedBox.max()-axisAlignedBox.min())) - .setColor(options->color()) - .use(); - AbstractBoxRenderer::wireframeMesh->draw(); + .setColor(options->color()); + AbstractBoxRenderer::wireframeMesh->draw(*AbstractBoxRenderer::wireframeShader); } template class AxisAlignedBoxRenderer<2>; diff --git a/src/Magnum/DebugTools/Implementation/BoxRenderer.cpp b/src/Magnum/DebugTools/Implementation/BoxRenderer.cpp index b47ef553d..e070188c9 100644 --- a/src/Magnum/DebugTools/Implementation/BoxRenderer.cpp +++ b/src/Magnum/DebugTools/Implementation/BoxRenderer.cpp @@ -36,9 +36,8 @@ template BoxRenderer::BoxRenderer(const Shap template void BoxRenderer::draw(Resource& options, const typename DimensionTraits::MatrixType& projectionMatrix) { AbstractBoxRenderer::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*box.transformation()) - .setColor(options->color()) - .use(); - AbstractBoxRenderer::wireframeMesh->draw(); + .setColor(options->color()); + AbstractBoxRenderer::wireframeMesh->draw(*AbstractBoxRenderer::wireframeShader); } template class BoxRenderer<2>; diff --git a/src/Magnum/DebugTools/Implementation/CapsuleRenderer.cpp b/src/Magnum/DebugTools/Implementation/CapsuleRenderer.cpp index 5007e1e81..2c46cd430 100644 --- a/src/Magnum/DebugTools/Implementation/CapsuleRenderer.cpp +++ b/src/Magnum/DebugTools/Implementation/CapsuleRenderer.cpp @@ -100,20 +100,19 @@ template CapsuleRenderer::CapsuleRenderer(co template void CapsuleRenderer::draw(Resource& options, const typename DimensionTraits::MatrixType& projectionMatrix) { std::array::MatrixType, 3> transformations = Implementation::capsuleRendererTransformation(capsule.a(), capsule.b(), capsule.radius()); - AbstractShapeRenderer::wireframeShader->setColor(options->color()) - .use(); + AbstractShapeRenderer::wireframeShader->setColor(options->color()); /* Bottom */ AbstractShapeRenderer::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*transformations[0]); - AbstractCapsuleRenderer::bottom->draw(); + AbstractCapsuleRenderer::bottom->draw(*AbstractShapeRenderer::wireframeShader); /* Cylinder */ AbstractShapeRenderer::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*transformations[1]); - AbstractCapsuleRenderer::cylinder->draw(); + AbstractCapsuleRenderer::cylinder->draw(*AbstractShapeRenderer::wireframeShader); /* Top */ AbstractShapeRenderer::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*transformations[2]); - AbstractCapsuleRenderer::top->draw(); + AbstractCapsuleRenderer::top->draw(*AbstractShapeRenderer::wireframeShader); } template class CapsuleRenderer<2>; diff --git a/src/Magnum/DebugTools/Implementation/CylinderRenderer.cpp b/src/Magnum/DebugTools/Implementation/CylinderRenderer.cpp index 7e6e14e6d..20f3e1798 100644 --- a/src/Magnum/DebugTools/Implementation/CylinderRenderer.cpp +++ b/src/Magnum/DebugTools/Implementation/CylinderRenderer.cpp @@ -51,9 +51,8 @@ template CylinderRenderer::CylinderRenderer( template void CylinderRenderer::draw(Resource& options, const typename DimensionTraits::MatrixType& projectionMatrix) { AbstractShapeRenderer::wireframeShader->setTransformationProjectionMatrix(projectionMatrix* Implementation::cylinderRendererTransformation(cylinder.a(), cylinder.b(), cylinder.radius())) - .setColor(options->color()) - .use(); - AbstractShapeRenderer::wireframeMesh->draw(); + .setColor(options->color()); + AbstractShapeRenderer::wireframeMesh->draw(*AbstractShapeRenderer::wireframeShader); } template class CylinderRenderer<2>; diff --git a/src/Magnum/DebugTools/Implementation/LineSegmentRenderer.cpp b/src/Magnum/DebugTools/Implementation/LineSegmentRenderer.cpp index be8ef4a46..956bbae84 100644 --- a/src/Magnum/DebugTools/Implementation/LineSegmentRenderer.cpp +++ b/src/Magnum/DebugTools/Implementation/LineSegmentRenderer.cpp @@ -58,9 +58,8 @@ template LineSegmentRenderer::LineSegmentRen template void LineSegmentRenderer::draw(Resource& options, const typename DimensionTraits::MatrixType& projectionMatrix) { AbstractShapeRenderer::wireframeShader->setTransformationProjectionMatrix(projectionMatrix* Implementation::lineSegmentRendererTransformation(line.a(), line.b())) - .setColor(options->color()) - .use(); - AbstractShapeRenderer::wireframeMesh->draw(); + .setColor(options->color()); + AbstractShapeRenderer::wireframeMesh->draw(*AbstractShapeRenderer::wireframeShader); } template class LineSegmentRenderer<2>; diff --git a/src/Magnum/DebugTools/Implementation/PointRenderer.cpp b/src/Magnum/DebugTools/Implementation/PointRenderer.cpp index f5434c2ef..29614f3da 100644 --- a/src/Magnum/DebugTools/Implementation/PointRenderer.cpp +++ b/src/Magnum/DebugTools/Implementation/PointRenderer.cpp @@ -58,9 +58,8 @@ template void PointRenderer::draw(Resource::wireframeShader->setTransformationProjectionMatrix(projectionMatrix* DimensionTraits::MatrixType::translation(point.position())* DimensionTraits::MatrixType::scaling(typename DimensionTraits::VectorType(options->pointSize()/2))) - .setColor(options->color()) - .use(); - AbstractShapeRenderer::wireframeMesh->draw(); + .setColor(options->color()); + AbstractShapeRenderer::wireframeMesh->draw(*AbstractShapeRenderer::wireframeShader); } template class PointRenderer<2>; diff --git a/src/Magnum/DebugTools/Implementation/SphereRenderer.cpp b/src/Magnum/DebugTools/Implementation/SphereRenderer.cpp index 58b454712..dbdf66ab4 100644 --- a/src/Magnum/DebugTools/Implementation/SphereRenderer.cpp +++ b/src/Magnum/DebugTools/Implementation/SphereRenderer.cpp @@ -50,9 +50,8 @@ template void SphereRenderer::draw(Resource< AbstractShapeRenderer::wireframeShader->setTransformationProjectionMatrix(projectionMatrix* DimensionTraits::MatrixType::translation(sphere.position())* DimensionTraits::MatrixType::scaling(typename DimensionTraits::VectorType(sphere.radius()))) - .setColor(options->color()) - .use(); - AbstractShapeRenderer::wireframeMesh->draw(); + .setColor(options->color()); + AbstractShapeRenderer::wireframeMesh->draw(*AbstractShapeRenderer::wireframeShader); } template class SphereRenderer<2>; diff --git a/src/Magnum/DebugTools/ObjectRenderer.cpp b/src/Magnum/DebugTools/ObjectRenderer.cpp index 618a2064c..669f8806a 100644 --- a/src/Magnum/DebugTools/ObjectRenderer.cpp +++ b/src/Magnum/DebugTools/ObjectRenderer.cpp @@ -175,10 +175,8 @@ template ObjectRenderer::ObjectRenderer(Scen } template void ObjectRenderer::draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractCamera& camera) { - shader->setTransformationProjectionMatrix(camera.projectionMatrix()*transformationMatrix*DimensionTraits::MatrixType::scaling(typename DimensionTraits::VectorType(options->size()))) - .use(); - - mesh->draw(); + shader->setTransformationProjectionMatrix(camera.projectionMatrix()*transformationMatrix*DimensionTraits::MatrixType::scaling(typename DimensionTraits::VectorType(options->size()))); + mesh->draw(*shader); } template class ObjectRenderer<2>; diff --git a/src/Magnum/Mesh.h b/src/Magnum/Mesh.h index 243efe699..87b6e25c6 100644 --- a/src/Magnum/Mesh.h +++ b/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 diff --git a/src/Magnum/MeshView.cpp b/src/Magnum/MeshView.cpp index ac8ea04a4..893b50c02 100644 --- a/src/Magnum/MeshView.cpp +++ b/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 } diff --git a/src/Magnum/MeshView.h b/src/Magnum/MeshView.h index cde4452fc..4b137ea17 100644 --- a/src/Magnum/MeshView.h +++ b/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; diff --git a/src/Magnum/ResourceManager.h b/src/Magnum/ResourceManager.h index 6fa15a672..56e7479f4 100644 --- a/src/Magnum/ResourceManager.h +++ b/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. diff --git a/src/Magnum/Shaders/Generic.h b/src/Magnum/Shaders/Generic.h index f3090256e..315a0e851 100644 --- a/src/Magnum/Shaders/Generic.h +++ b/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 diff --git a/src/Magnum/Test/AbstractShaderProgramGLTest.cpp b/src/Magnum/Test/AbstractShaderProgramGLTest.cpp index 6e64fa06a..153dd8ba6 100644 --- a/src/Magnum/Test/AbstractShaderProgramGLTest.cpp +++ b/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 diff --git a/src/Magnum/Test/MeshGLTest.cpp b/src/Magnum/Test/MeshGLTest.cpp index 8ec197adf..f9a608780 100644 --- a/src/Magnum/Test/MeshGLTest.cpp +++ b/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 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() { diff --git a/src/Magnum/Test/PrimitiveQueryGLTest.cpp b/src/Magnum/Test/PrimitiveQueryGLTest.cpp index cd017599b..d2509454e 100644 --- a/src/Magnum/Test/PrimitiveQueryGLTest.cpp +++ b/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(); diff --git a/src/Magnum/Test/SampleQueryGLTest.cpp b/src/Magnum/Test/SampleQueryGLTest.cpp index cb62b80b5..39b6ffdd6 100644 --- a/src/Magnum/Test/SampleQueryGLTest.cpp +++ b/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(); diff --git a/src/Magnum/Text/Renderer.h b/src/Magnum/Text/Renderer.h index 0ca6f2a8c..58dad37ab 100644 --- a/src/Magnum/Text/Renderer.h +++ b/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 diff --git a/src/Magnum/TextureTools/DistanceField.cpp b/src/Magnum/TextureTools/DistanceField.cpp index b5ba59b17..21d9d247b 100644 --- a/src/Magnum/TextureTools/DistanceField.cpp +++ b/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); } }}