Shaders: removed superfluous `*Shader` suffix from class names.

src/DebugTools/ForceRenderer.cpp

@@ -28,7 +28,7 @@
 #include "Mesh.h"
 #include "DebugTools/ResourceManager.h"
 #include "SceneGraph/AbstractCamera.h"
-#include "Shaders/FlatShader.h"
+#include "Shaders/Flat.h"
 
 #include "DebugTools/Implementation/ForceRendererTransformation.h"
 
@@ -66,8 +66,8 @@ const std::array<UnsignedByte, 6> indices{{
 
 template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneGraph::AbstractObject<dimensions>* object, const typename DimensionTraits<dimensions, Float>::VectorType& forcePosition, const typename DimensionTraits<dimensions, Float>::VectorType* force, ResourceKey options, SceneGraph::DrawableGroup<dimensions>* drawables): SceneGraph::Drawable<dimensions>(object, drawables), forcePosition(forcePosition), force(force), options(ResourceManager::instance()->get<ForceRendererOptions>(options)) {
     /* Shader */
-    shader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::FlatShader<dimensions>>(shaderKey<dimensions>());
-    if(!shader) ResourceManager::instance()->set<AbstractShaderProgram>(shader.key(), new Shaders::FlatShader<dimensions>);
+    shader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::Flat<dimensions>>(shaderKey<dimensions>());
+    if(!shader) ResourceManager::instance()->set<AbstractShaderProgram>(shader.key(), new Shaders::Flat<dimensions>);
 
     /* Mesh and vertex buffer */
     mesh = ResourceManager::instance()->get<Mesh>("force");
@@ -89,7 +89,7 @@ template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneG
     mesh->setPrimitive(Mesh::Primitive::Lines)
         ->setIndexCount(indices.size())
         ->addVertexBuffer(vertexBuffer, 0,
-            typename Shaders::FlatShader<dimensions>::Position(Shaders::FlatShader<dimensions>::Position::Components::Two))
+            typename Shaders::Flat<dimensions>::Position(Shaders::Flat<dimensions>::Position::Components::Two))
         ->setIndexBuffer(indexBuffer, 0, Mesh::IndexType::UnsignedByte, 0, positions.size());
     ResourceManager::instance()->set<Mesh>(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
 }

src/DebugTools/ForceRenderer.h

@@ -128,7 +128,7 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ForceRenderer: p
         const typename DimensionTraits<dimensions, Float>::VectorType* const force;
 
         Resource<ForceRendererOptions> options;
-        Resource<AbstractShaderProgram, Shaders::FlatShader<dimensions>> shader;
+        Resource<AbstractShaderProgram, Shaders::Flat<dimensions>> shader;
         Resource<Mesh> mesh;
         Resource<Buffer> vertexBuffer, indexBuffer;
 };

src/DebugTools/Implementation/AbstractShapeRenderer.cpp

@@ -29,7 +29,7 @@
 #include "Mesh.h"
 #include "DebugTools/ResourceManager.h"
 #include "MeshTools/CompressIndices.h"
-#include "Shaders/FlatShader.h"
+#include "Shaders/Flat.h"
 #include "Trade/MeshData2D.h"
 #include "Trade/MeshData3D.h"
 
@@ -53,7 +53,7 @@ template<> void create<2>(Trade::MeshData2D& data, Resource<Mesh>& meshResource,
     Mesh* mesh = new Mesh;
     mesh->setPrimitive(data.primitive())
         ->setVertexCount(data.positions(0)->size())
-        ->addVertexBuffer(buffer, 0, Shaders::FlatShader2D::Position());
+        ->addVertexBuffer(buffer, 0, Shaders::Flat2D::Position());
     ResourceManager::instance()->set(meshResource.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
 
     /* Index buffer, if needed, if not, resource key doesn't have to be set */
@@ -75,7 +75,7 @@ template<> void create<3>(Trade::MeshData3D& data, Resource<Mesh>& meshResource,
     Mesh* mesh = new Mesh;
     mesh->setPrimitive(data.primitive())
         ->setVertexCount(data.positions(0)->size())
-        ->addVertexBuffer(vertexBuffer, 0, Shaders::FlatShader3D::Position());
+        ->addVertexBuffer(vertexBuffer, 0, Shaders::Flat3D::Position());
     ResourceManager::instance()->set(meshResource.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
 
     /* Index buffer, if needed, if not, resource key doesn't have to be set */
@@ -90,13 +90,13 @@ template<> void create<3>(Trade::MeshData3D& data, Resource<Mesh>& meshResource,
 }
 
 template<UnsignedInt dimensions> AbstractShapeRenderer<dimensions>::AbstractShapeRenderer(ResourceKey meshKey, ResourceKey vertexBufferKey, ResourceKey indexBufferKey) {
-    wireframeShader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::FlatShader<dimensions>>(shaderKey<dimensions>());
+    wireframeShader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::Flat<dimensions>>(shaderKey<dimensions>());
     wireframeMesh = ResourceManager::instance()->get<Mesh>(meshKey);
     vertexBuffer = ResourceManager::instance()->get<Buffer>(vertexBufferKey);
     indexBuffer = ResourceManager::instance()->get<Buffer>(indexBufferKey);
 
     if(!wireframeShader) ResourceManager::instance()->set<AbstractShaderProgram>(shaderKey<dimensions>(),
-        new Shaders::FlatShader<dimensions>, ResourceDataState::Final, ResourcePolicy::Resident);
+        new Shaders::Flat<dimensions>, ResourceDataState::Final, ResourcePolicy::Resident);
 }
 
 template<UnsignedInt dimensions> AbstractShapeRenderer<dimensions>::~AbstractShapeRenderer() {}

src/DebugTools/Implementation/AbstractShapeRenderer.h

@@ -49,7 +49,7 @@ template<UnsignedInt dimensions> class AbstractShapeRenderer {
         /* Call only if the mesh resource isn't already present */
         void createResources(typename MeshData<dimensions>::Type data);
 
-        Resource<AbstractShaderProgram, Shaders::FlatShader<dimensions>> wireframeShader;
+        Resource<AbstractShaderProgram, Shaders::Flat<dimensions>> wireframeShader;
         Resource<Mesh> wireframeMesh;
 
     private:

src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp

@@ -27,7 +27,7 @@
 #include "Mesh.h"
 #include "DebugTools/ShapeRenderer.h"
 #include "Physics/AxisAlignedBox.h"
-#include "Shaders/FlatShader.h"
+#include "Shaders/Flat.h"
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 

src/DebugTools/Implementation/BoxRenderer.cpp

@@ -27,7 +27,7 @@
 #include "Mesh.h"
 #include "DebugTools/ShapeRenderer.h"
 #include "Physics/Box.h"
-#include "Shaders/FlatShader.h"
+#include "Shaders/Flat.h"
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 

src/DebugTools/Implementation/LineSegmentRenderer.cpp

@@ -28,7 +28,7 @@
 #include "DebugTools/ShapeRenderer.h"
 #include "Physics/Line.h"
 #include "Primitives/Line.h"
-#include "Shaders/FlatShader.h"
+#include "Shaders/Flat.h"
 #include "Trade/MeshData2D.h"
 #include "Trade/MeshData3D.h"
 

src/DebugTools/Implementation/PointRenderer.cpp

@@ -28,7 +28,7 @@
 #include "DebugTools/ShapeRenderer.h"
 #include "Physics/Point.h"
 #include "Primitives/Crosshair.h"
-#include "Shaders/FlatShader.h"
+#include "Shaders/Flat.h"
 #include "Trade/MeshData2D.h"
 #include "Trade/MeshData3D.h"
 

src/DebugTools/Implementation/SphereRenderer.cpp

@@ -28,7 +28,7 @@
 #include "DebugTools/ShapeRenderer.h"
 #include "Physics/Sphere.h"
 #include "Primitives/Circle.h"
-#include "Shaders/FlatShader.h"
+#include "Shaders/Flat.h"
 #include "Trade/MeshData2D.h"
 
 namespace Magnum { namespace DebugTools { namespace Implementation {

src/DebugTools/ObjectRenderer.cpp

@@ -28,7 +28,7 @@
 #include "DebugTools/ResourceManager.h"
 #include "MeshTools/Interleave.h"
 #include "SceneGraph/AbstractCamera.h"
-#include "Shaders/VertexColorShader.h"
+#include "Shaders/VertexColor.h"
 
 namespace Magnum { namespace DebugTools {
 
@@ -144,8 +144,8 @@ const std::array<UnsignedByte, 18> Renderer<3>::indices{{
 
 template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(SceneGraph::AbstractObject<dimensions>* object, ResourceKey options, SceneGraph::DrawableGroup<dimensions>* drawables): SceneGraph::Drawable<dimensions>(object, drawables), options(ResourceManager::instance()->get<ObjectRendererOptions>(options)) {
     /* Shader */
-    shader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::VertexColorShader<dimensions>>(Renderer<dimensions>::shader());
-    if(!shader) ResourceManager::instance()->set<AbstractShaderProgram>(shader.key(), new Shaders::VertexColorShader<dimensions>);
+    shader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::VertexColor<dimensions>>(Renderer<dimensions>::shader());
+    if(!shader) ResourceManager::instance()->set<AbstractShaderProgram>(shader.key(), new Shaders::VertexColor<dimensions>);
 
     /* Mesh and vertex buffer */
     mesh = ResourceManager::instance()->get<Mesh>(Renderer<dimensions>::mesh());
@@ -167,8 +167,8 @@ template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(Scen
     mesh->setPrimitive(Mesh::Primitive::Lines)
         ->setIndexCount(Renderer<dimensions>::indices.size())
         ->addInterleavedVertexBuffer(vertexBuffer, 0,
-            typename Shaders::VertexColorShader<dimensions>::Position(),
-            typename Shaders::VertexColorShader<dimensions>::Color())
+            typename Shaders::VertexColor<dimensions>::Position(),
+            typename Shaders::VertexColor<dimensions>::Color())
         ->setIndexBuffer(indexBuffer, 0, Mesh::IndexType::UnsignedByte, 0, Renderer<dimensions>::positions.size());
     ResourceManager::instance()->set<Mesh>(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
 }

src/DebugTools/ObjectRenderer.h

@@ -104,7 +104,7 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer:
 
     private:
         Resource<ObjectRendererOptions> options;
-        Resource<AbstractShaderProgram, Shaders::VertexColorShader<dimensions>> shader;
+        Resource<AbstractShaderProgram, Shaders::VertexColor<dimensions>> shader;
         Resource<Mesh> mesh;
         Resource<Buffer> vertexBuffer, indexBuffer;
 };

src/Shaders/AbstractVector.h

@@ -1,5 +1,5 @@
-#ifndef Magnum_Shaders_AbstractVectorShader_h
-#define Magnum_Shaders_AbstractVectorShader_h
+#ifndef Magnum_Shaders_AbstractVector_h
+#define Magnum_Shaders_AbstractVector_h
 /*
     This file is part of Magnum.
 
@@ -25,7 +25,7 @@
 */
 
 /** @file
- * @brief Class Magnum::Shaders::AbstractVectorShader, typedef Magnum::Shaders::AbstractVectorShader2D, Magnum::Shaders::AbstractVectorShader3D
+ * @brief Class Magnum::Shaders::AbstractVector, typedef Magnum::Shaders::AbstractVector2D, Magnum::Shaders::AbstractVector3D
  */
 
 #include "AbstractShaderProgram.h"
@@ -37,9 +37,9 @@ namespace Magnum { namespace Shaders {
 /**
 @brief Base for vector shaders
 
-@see AbstractVectorShader2D, AbstractVectorShader3D
+@see AbstractVector2D, AbstractVector3D
 */
-template<UnsignedInt dimensions> class AbstractVectorShader: public AbstractShaderProgram {
+template<UnsignedInt dimensions> class AbstractVector: public AbstractShaderProgram {
     public:
         /** @brief Vertex position */
         typedef Attribute<0, typename DimensionTraits<dimensions>::VectorType> Position;
@@ -51,16 +51,16 @@ template<UnsignedInt dimensions> class AbstractVectorShader: public AbstractShad
             VectorTextureLayer = 16 /**< Layer for vector texture */
         };
 
-        virtual ~AbstractVectorShader() = 0;
+        virtual ~AbstractVector() = 0;
 };
 
-template<UnsignedInt dimensions> inline AbstractVectorShader<dimensions>::~AbstractVectorShader() {}
+template<UnsignedInt dimensions> inline AbstractVector<dimensions>::~AbstractVector() {}
 
 /** @brief Base for two-dimensional text shaders */
-typedef AbstractVectorShader<2> AbstractVectorShader2D;
+typedef AbstractVector<2> AbstractVector2D;
 
 /** @brief Base for three-dimensional text shader */
-typedef AbstractVectorShader<3> AbstractVectorShader3D;
+typedef AbstractVector<3> AbstractVector3D;
 
 }}
 

src/Shaders/CMakeLists.txt

@@ -23,29 +23,29 @@
 #
 
 corrade_add_resource(MagnumShaders_RCS MagnumShaders
-    AbstractVectorShader2D.vert AbstractVectorShader3D.vert
-    FlatShader2D.vert FlatShader3D.vert FlatShader.frag
-    PhongShader.vert PhongShader.frag
-    VectorShader.frag DistanceFieldVectorShader.frag
-    VertexColorShader2D.vert VertexColorShader3D.vert VertexColorShader.frag
+    AbstractVector2D.vert AbstractVector3D.vert
+    Flat2D.vert Flat3D.vert Flat.frag
+    Phong.vert Phong.frag
+    Vector.frag DistanceFieldVector.frag
+    VertexColor2D.vert VertexColor3D.vert VertexColor.frag
     compatibility.glsl)
 
 set(MagnumShaders_SRCS
-    DistanceFieldVectorShader.cpp
-    FlatShader.cpp
-    PhongShader.cpp
-    VectorShader.cpp
-    VertexColorShader.cpp
+    DistanceFieldVector.cpp
+    Flat.cpp
+    Phong.cpp
+    Vector.cpp
+    VertexColor.cpp
     ${MagnumShaders_RCS})
 
 set(MagnumShaders_HEADERS
-    DistanceFieldVectorShader.h
-    AbstractVectorShader.h
-    FlatShader.h
-    PhongShader.h
+    DistanceFieldVector.h
+    AbstractVector.h
+    Flat.h
+    Phong.h
     Shaders.h
-    VectorShader.h
-    VertexColorShader.h
+    Vector.h
+    VertexColor.h
 
     magnumShadersVisibility.h)
 

src/Shaders/DistanceFieldVector.cpp

@@ -22,7 +22,7 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#include "DistanceFieldVectorShader.h"
+#include "DistanceFieldVector.h"
 
 #include <Utility/Resource.h>
 
@@ -34,11 +34,11 @@ namespace Magnum { namespace Shaders {
 
 namespace {
     template<UnsignedInt> constexpr const char* vertexShaderName();
-    template<> constexpr const char* vertexShaderName<2>() { return "AbstractVectorShader2D.vert"; }
-    template<> constexpr const char* vertexShaderName<3>() { return "AbstractVectorShader3D.vert"; }
+    template<> constexpr const char* vertexShaderName<2>() { return "AbstractVector2D.vert"; }
+    template<> constexpr const char* vertexShaderName<3>() { return "AbstractVector3D.vert"; }
 }
 
-template<UnsignedInt dimensions> DistanceFieldVectorShader<dimensions>::DistanceFieldVectorShader(): transformationProjectionMatrixUniform(0), colorUniform(1), outlineColorUniform(2), outlineRangeUniform(3), smoothnessUniform(4) {
+template<UnsignedInt dimensions> DistanceFieldVector<dimensions>::DistanceFieldVector(): transformationProjectionMatrixUniform(0), colorUniform(1), outlineColorUniform(2), outlineRangeUniform(3), smoothnessUniform(4) {
     Corrade::Utility::Resource rs("MagnumShaders");
 
     #ifndef MAGNUM_TARGET_GLES
@@ -54,7 +54,7 @@ template<UnsignedInt dimensions> DistanceFieldVectorShader<dimensions>::Distance
 
     Shader fragmentShader(v, Shader::Type::Fragment);
     fragmentShader.addSource(rs.get("compatibility.glsl"));
-    fragmentShader.addSource(rs.get("DistanceFieldVectorShader.frag"));
+    fragmentShader.addSource(rs.get("DistanceFieldVector.frag"));
     AbstractShaderProgram::attachShader(fragmentShader);
 
     #ifndef MAGNUM_TARGET_GLES
@@ -64,8 +64,8 @@ template<UnsignedInt dimensions> DistanceFieldVectorShader<dimensions>::Distance
     if(!Context::current()->isVersionSupported(Version::GLES300))
     #endif
     {
-        AbstractShaderProgram::bindAttributeLocation(AbstractVectorShader<dimensions>::Position::Location, "position");
-        AbstractShaderProgram::bindAttributeLocation(AbstractVectorShader<dimensions>::TextureCoordinates::Location, "textureCoordinates");
+        AbstractShaderProgram::bindAttributeLocation(AbstractVector<dimensions>::Position::Location, "position");
+        AbstractShaderProgram::bindAttributeLocation(AbstractVector<dimensions>::TextureCoordinates::Location, "textureCoordinates");
     }
 
     AbstractShaderProgram::link();
@@ -84,11 +84,11 @@ template<UnsignedInt dimensions> DistanceFieldVectorShader<dimensions>::Distance
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::shading_language_420pack>())
         AbstractShaderProgram::setUniform(AbstractShaderProgram::uniformLocation("vectorTexture"),
-                                          AbstractVectorShader<dimensions>::VectorTextureLayer);
+                                          AbstractVector<dimensions>::VectorTextureLayer);
     #endif
 }
 
-template class DistanceFieldVectorShader<2>;
-template class DistanceFieldVectorShader<3>;
+template class DistanceFieldVector<2>;
+template class DistanceFieldVector<3>;
 
 }}

src/Shaders/DistanceFieldVector.h

@@ -1,5 +1,5 @@
-#ifndef Magnum_Shaders_DistanceFieldVectorShader_h
-#define Magnum_Shaders_DistanceFieldVectorShader_h
+#ifndef Magnum_Shaders_DistanceFieldVector_h
+#define Magnum_Shaders_DistanceFieldVector_h
 /*
     This file is part of Magnum.
 
@@ -25,12 +25,12 @@
 */
 
 /** @file
- * @brief Class Magnum::Shaders::DistanceFieldVectorShader, typedef Magnum::Shaders::DistanceFieldVectorShader2D, Magnum::Shaders::DistanceFieldVectorShader3D
+ * @brief Class Magnum::Shaders::DistanceFieldVector, typedef Magnum::Shaders::DistanceFieldVector2D, Magnum::Shaders::DistanceFieldVector3D
  */
 
 #include "Math/Matrix3.h"
 #include "Math/Matrix4.h"
-#include "AbstractVectorShader.h"
+#include "AbstractVector.h"
 
 #include "magnumShadersVisibility.h"
 
@@ -42,14 +42,14 @@ namespace Magnum { namespace Shaders {
 Renders vector art in form of signed distance field. See TextureTools::distanceField()
 for more information. Note that the final rendered outlook will greatly depend
 on radius of input distance field and value passed to setSmoothness().
-@see DistanceFieldVectorShader2D, DistanceFieldVectorShader3D
+@see DistanceFieldVector2D, DistanceFieldVector3D
 */
-template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVectorShader: public AbstractVectorShader<dimensions> {
+template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector: public AbstractVector<dimensions> {
     public:
-        DistanceFieldVectorShader();
+        DistanceFieldVector();
 
         /** @brief Set transformation and projection matrix */
-        inline DistanceFieldVectorShader* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+        inline DistanceFieldVector* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
             AbstractShaderProgram::setUniform(transformationProjectionMatrixUniform, matrix);
             return this;
         }
@@ -60,7 +60,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
          *
          * @see setOutlineColor()
          */
-        inline DistanceFieldVectorShader* setColor(const Color4<>& color) {
+        inline DistanceFieldVector* setColor(const Color4<>& color) {
             AbstractShaderProgram::setUniform(colorUniform, color);
             return this;
         }
@@ -71,7 +71,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
          *
          * @see setOutlineRange(), setColor()
          */
-        inline DistanceFieldVectorShader* setOutlineColor(const Color4<>& color) {
+        inline DistanceFieldVector* setOutlineColor(const Color4<>& color) {
             AbstractShaderProgram::setUniform(outlineColorUniform, color);
             return this;
         }
@@ -90,7 +90,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
          *
          * @see setOutlineColor()
          */
-        inline DistanceFieldVectorShader* setOutlineRange(Float start, Float end) {
+        inline DistanceFieldVector* setOutlineRange(Float start, Float end) {
             AbstractShaderProgram::setUniform(outlineRangeUniform, Vector2(start, end));
             return this;
         }
@@ -103,7 +103,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
          * values will make them look more crisp (but possibly aliased). Initial
          * value is `0.04f`.
          */
-        inline DistanceFieldVectorShader* setSmoothness(Float value) {
+        inline DistanceFieldVector* setSmoothness(Float value) {
             AbstractShaderProgram::setUniform(smoothnessUniform, value);
             return this;
         }
@@ -117,10 +117,10 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
 };
 
 /** @brief Two-dimensional distance field vector shader */
-typedef DistanceFieldVectorShader<2> DistanceFieldVectorShader2D;
+typedef DistanceFieldVector<2> DistanceFieldVector2D;
 
 /** @brief Three-dimensional distance field vector shader */
-typedef DistanceFieldVectorShader<3> DistanceFieldVectorShader3D;
+typedef DistanceFieldVector<3> DistanceFieldVector3D;
 
 }}
 

src/Shaders/Flat.cpp

@@ -22,7 +22,7 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#include "FlatShader.h"
+#include "Flat.h"
 
 #include <Utility/Resource.h>
 
@@ -33,11 +33,11 @@ namespace Magnum { namespace Shaders {
 
 namespace {
     template<UnsignedInt> constexpr const char* vertexShaderName();
-    template<> constexpr const char* vertexShaderName<2>() { return "FlatShader2D.vert"; }
-    template<> constexpr const char* vertexShaderName<3>() { return "FlatShader3D.vert"; }
+    template<> constexpr const char* vertexShaderName<2>() { return "Flat2D.vert"; }
+    template<> constexpr const char* vertexShaderName<3>() { return "Flat3D.vert"; }
 }
 
-template<UnsignedInt dimensions> FlatShader<dimensions>::FlatShader(): transformationProjectionMatrixUniform(0), colorUniform(1) {
+template<UnsignedInt dimensions> Flat<dimensions>::Flat(): transformationProjectionMatrixUniform(0), colorUniform(1) {
     Corrade::Utility::Resource rs("MagnumShaders");
 
     #ifndef MAGNUM_TARGET_GLES
@@ -53,7 +53,7 @@ template<UnsignedInt dimensions> FlatShader<dimensions>::FlatShader(): transform
 
     Shader fragmentShader(v, Shader::Type::Fragment);
     fragmentShader.addSource(rs.get("compatibility.glsl"));
-    fragmentShader.addSource(rs.get("FlatShader.frag"));
+    fragmentShader.addSource(rs.get("Flat.frag"));
     attachShader(fragmentShader);
 
     #ifndef MAGNUM_TARGET_GLES
@@ -77,7 +77,7 @@ template<UnsignedInt dimensions> FlatShader<dimensions>::FlatShader(): transform
     }
 }
 
-template class FlatShader<2>;
-template class FlatShader<3>;
+template class Flat<2>;
+template class Flat<3>;
 
 }}

src/Shaders/Flat.h

@@ -1,5 +1,5 @@
-#ifndef Magnum_Shaders_FlatShader_h
-#define Magnum_Shaders_FlatShader_h
+#ifndef Magnum_Shaders_Flat_h
+#define Magnum_Shaders_Flat_h
 /*
     This file is part of Magnum.
 
@@ -25,7 +25,7 @@
 */
 
 /** @file
- * @brief Class Magnum::Shaders::FlatShader
+ * @brief Class Magnum::Shaders::Flat
  */
 
 #include "Math/Matrix3.h"
@@ -42,20 +42,20 @@ namespace Magnum { namespace Shaders {
 @brief Flat shader
 
 Draws whole mesh with one color.
-@see FlatShader2D, FlatShader3D
+@see Flat2D, Flat3D
 */
-template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT FlatShader: public AbstractShaderProgram {
+template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Flat: public AbstractShaderProgram {
     public:
         /** @brief Vertex position */
         typedef Attribute<0, typename DimensionTraits<dimensions>::VectorType> Position;
 
-        explicit FlatShader();
+        explicit Flat();
 
         /**
          * @brief Set transformation and projection matrix
          * @return Pointer to self (for method chaining)
          */
-        FlatShader<dimensions>* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+        Flat<dimensions>* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
             setUniform(transformationProjectionMatrixUniform, matrix);
             return this;
         }
@@ -64,7 +64,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT FlatShader: public
          * @brief Set color
          * @return Pointer to self (for method chaining)
          */
-        FlatShader<dimensions>* setColor(const Color4<>& color) {
+        Flat<dimensions>* setColor(const Color4<>& color) {
             setUniform(colorUniform, color);
             return this;
         }
@@ -75,10 +75,10 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT FlatShader: public
 };
 
 /** @brief 2D flat shader */
-typedef FlatShader<2> FlatShader2D;
+typedef Flat<2> Flat2D;
 
 /** @brief 3D flat shader */
-typedef FlatShader<3> FlatShader3D;
+typedef Flat<3> Flat3D;
 
 }}
 

src/Shaders/Phong.cpp

@@ -22,7 +22,7 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#include "PhongShader.h"
+#include "Phong.h"
 
 #include <Utility/Resource.h>
 
@@ -31,7 +31,7 @@
 
 namespace Magnum { namespace Shaders {
 
-PhongShader::PhongShader(): transformationMatrixUniform(0), projectionMatrixUniform(1), normalMatrixUniform(2), lightUniform(3), diffuseColorUniform(4), ambientColorUniform(5), specularColorUniform(6), lightColorUniform(7), shininessUniform(8) {
+Phong::Phong(): transformationMatrixUniform(0), projectionMatrixUniform(1), normalMatrixUniform(2), lightUniform(3), diffuseColorUniform(4), ambientColorUniform(5), specularColorUniform(6), lightColorUniform(7), shininessUniform(8) {
     Corrade::Utility::Resource rs("MagnumShaders");
 
     #ifndef MAGNUM_TARGET_GLES
@@ -42,12 +42,12 @@ PhongShader::PhongShader(): transformationMatrixUniform(0), projectionMatrixUnif
 
     Shader vertexShader(v, Shader::Type::Vertex);
     vertexShader.addSource(rs.get("compatibility.glsl"));
-    vertexShader.addSource(rs.get("PhongShader.vert"));
+    vertexShader.addSource(rs.get("Phong.vert"));
     attachShader(vertexShader);
 
     Shader fragmentShader(v, Shader::Type::Fragment);
     fragmentShader.addSource(rs.get("compatibility.glsl"));
-    fragmentShader.addSource(rs.get("PhongShader.frag"));
+    fragmentShader.addSource(rs.get("Phong.frag"));
     attachShader(fragmentShader);
 
     #ifndef MAGNUM_TARGET_GLES

src/Shaders/Phong.h

@@ -1,5 +1,5 @@
-#ifndef Magnum_Shaders_PhongShader_h
-#define Magnum_Shaders_PhongShader_h
+#ifndef Magnum_Shaders_Phong_h
+#define Magnum_Shaders_Phong_h
 /*
     This file is part of Magnum.
 
@@ -25,7 +25,7 @@
 */
 
 /** @file
- * @brief Class Magnum::Shaders::PhongShader
+ * @brief Class Magnum::Shaders::Phong
  */
 
 #include "Math/Matrix4.h"
@@ -42,12 +42,12 @@ namespace Magnum { namespace Shaders {
 If supported, uses GLSL 3.20 and @extension{ARB,explicit_attrib_location},
 otherwise falls back to GLSL 1.20.
 */
-class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
+class MAGNUM_SHADERS_EXPORT Phong: public AbstractShaderProgram {
     public:
         typedef Attribute<0, Vector3> Position; /**< @brief Vertex position */
         typedef Attribute<1, Vector3> Normal;   /**< @brief Normal direction */
 
-        explicit PhongShader();
+        explicit Phong();
 
         /**
          * @brief Set ambient color
@@ -55,7 +55,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          *
          * If not set, default value is `(0.0f, 0.0f, 0.0f)`.
          */
-        inline PhongShader* setAmbientColor(const Color3<>& color) {
+        inline Phong* setAmbientColor(const Color3<>& color) {
             setUniform(ambientColorUniform, color);
             return this;
         }
@@ -64,7 +64,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          * @brief Set diffuse color
          * @return Pointer to self (for method chaining)
          */
-        inline PhongShader* setDiffuseColor(const Color3<>& color) {
+        inline Phong* setDiffuseColor(const Color3<>& color) {
             setUniform(diffuseColorUniform, color);
             return this;
         }
@@ -75,7 +75,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          *
          * If not set, default value is `(1.0f, 1.0f, 1.0f)`.
          */
-        inline PhongShader* setSpecularColor(const Color3<>& color) {
+        inline Phong* setSpecularColor(const Color3<>& color) {
             setUniform(specularColorUniform, color);
             return this;
         }
@@ -87,7 +87,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          * The larger value, the harder surface (smaller specular highlight).
          * If not set, default value is `80.0f`.
          */
-        inline PhongShader* setShininess(Float shininess) {
+        inline Phong* setShininess(Float shininess) {
             setUniform(shininessUniform, shininess);
             return this;
         }
@@ -96,7 +96,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          * @brief Set transformation and normal matrix
          * @return Pointer to self (for method chaining)
          */
-        inline PhongShader* setTransformationMatrix(const Matrix4& matrix) {
+        inline Phong* setTransformationMatrix(const Matrix4& matrix) {
             setUniform(transformationMatrixUniform, matrix);
             setUniform(normalMatrixUniform, matrix.rotation());
             return this;
@@ -106,7 +106,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          * @brief Set projection matrix
          * @return Pointer to self (for method chaining)
          */
-        inline PhongShader* setProjectionMatrix(const Matrix4& matrix) {
+        inline Phong* setProjectionMatrix(const Matrix4& matrix) {
             setUniform(projectionMatrixUniform, matrix);
             return this;
         }
@@ -115,7 +115,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          * @brief Set light position
          * @return Pointer to self (for method chaining)
          */
-        inline PhongShader* setLightPosition(const Vector3& light) {
+        inline Phong* setLightPosition(const Vector3& light) {
             setUniform(lightUniform, light);
             return this;
         }
@@ -126,7 +126,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          *
          * If not set, default value is `(1.0f, 1.0f, 1.0f)`.
          */
-        inline PhongShader* setLightColor(const Color3<>& color) {
+        inline Phong* setLightColor(const Color3<>& color) {
             setUniform(lightColorUniform, color);
             return this;
         }

src/Shaders/Shaders.h

@@ -35,27 +35,27 @@ namespace Magnum { namespace Shaders {
 /** @todoc remove when doxygen is sane again */
 #ifndef DOXYGEN_GENERATING_OUTPUT
 
-template<UnsignedInt> class DistanceFieldVectorShader;
-typedef DistanceFieldVectorShader<2> DistanceFieldVectorShader2D;
-typedef DistanceFieldVectorShader<3> DistanceFieldVectorShader3D;
+template<UnsignedInt> class DistanceFieldVector;
+typedef DistanceFieldVector<2> DistanceFieldVector2D;
+typedef DistanceFieldVector<3> DistanceFieldVector3D;
 
-template<UnsignedInt> class AbstractVectorShader;
-typedef AbstractVectorShader<2> AbstractVectorShader2D;
-typedef AbstractVectorShader<3> AbstractVectorShader3D;
+template<UnsignedInt> class AbstractVector;
+typedef AbstractVector<2> AbstractVector2D;
+typedef AbstractVector<3> AbstractVector3D;
 
-template<UnsignedInt> class FlatShader;
-typedef FlatShader<2> FlatShader2D;
-typedef FlatShader<3> FlatShader3D;
+template<UnsignedInt> class Flat;
+typedef Flat<2> Flat2D;
+typedef Flat<3> Flat3D;
 
-class PhongShader;
+class Phong;
 
-template<UnsignedInt> class VectorShader;
-typedef VectorShader<2> VectorShader2D;
-typedef VectorShader<3> VectorShader3D;
+template<UnsignedInt> class Vector;
+typedef Vector<2> Vector2D;
+typedef Vector<3> Vector3D;
 
-template<UnsignedInt> class VertexColorShader;
-typedef VertexColorShader<2> VertexColorShader2D;
-typedef VertexColorShader<3> VertexColorShader3D;
+template<UnsignedInt> class VertexColor;
+typedef VertexColor<2> VertexColor2D;
+typedef VertexColor<3> VertexColor3D;
 #endif
 
 }}

src/Shaders/Vector.cpp

@@ -22,7 +22,7 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#include "VectorShader.h"
+#include "Vector.h"
 
 #include <Utility/Resource.h>
 
@@ -34,11 +34,11 @@ namespace Magnum { namespace Shaders {
 
 namespace {
     template<UnsignedInt> constexpr const char* vertexShaderName();
-    template<> constexpr const char* vertexShaderName<2>() { return "AbstractVectorShader2D.vert"; }
-    template<> constexpr const char* vertexShaderName<3>() { return "AbstractVectorShader3D.vert"; }
+    template<> constexpr const char* vertexShaderName<2>() { return "AbstractVector2D.vert"; }
+    template<> constexpr const char* vertexShaderName<3>() { return "AbstractVector3D.vert"; }
 }
 
-template<UnsignedInt dimensions> VectorShader<dimensions>::VectorShader(): transformationProjectionMatrixUniform(0), colorUniform(1) {
+template<UnsignedInt dimensions> Vector<dimensions>::Vector(): transformationProjectionMatrixUniform(0), colorUniform(1) {
     Corrade::Utility::Resource rs("MagnumShaders");
 
     #ifndef MAGNUM_TARGET_GLES
@@ -54,7 +54,7 @@ template<UnsignedInt dimensions> VectorShader<dimensions>::VectorShader(): trans
 
     Shader fragmentShader(v, Shader::Type::Fragment);
     fragmentShader.addSource(rs.get("compatibility.glsl"));
-    fragmentShader.addSource(rs.get("VectorShader.frag"));
+    fragmentShader.addSource(rs.get("Vector.frag"));
     AbstractShaderProgram::attachShader(fragmentShader);
 
     #ifndef MAGNUM_TARGET_GLES
@@ -64,8 +64,8 @@ template<UnsignedInt dimensions> VectorShader<dimensions>::VectorShader(): trans
     if(!Context::current()->isVersionSupported(Version::GLES300))
     #endif
     {
-        AbstractShaderProgram::bindAttributeLocation(AbstractVectorShader<dimensions>::Position::Location, "position");
-        AbstractShaderProgram::bindAttributeLocation(AbstractVectorShader<dimensions>::TextureCoordinates::Location, "textureCoordinates");
+        AbstractShaderProgram::bindAttributeLocation(AbstractVector<dimensions>::Position::Location, "position");
+        AbstractShaderProgram::bindAttributeLocation(AbstractVector<dimensions>::TextureCoordinates::Location, "textureCoordinates");
     }
 
     AbstractShaderProgram::link();
@@ -80,11 +80,11 @@ template<UnsignedInt dimensions> VectorShader<dimensions>::VectorShader(): trans
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::shading_language_420pack>())
-        AbstractShaderProgram::setUniform(AbstractShaderProgram::uniformLocation("vectorTexture"), AbstractVectorShader<dimensions>::VectorTextureLayer);
+        AbstractShaderProgram::setUniform(AbstractShaderProgram::uniformLocation("vectorTexture"), AbstractVector<dimensions>::VectorTextureLayer);
     #endif
 }
 
-template class VectorShader<2>;
-template class VectorShader<3>;
+template class Vector<2>;
+template class Vector<3>;
 
 }}

src/Shaders/Vector.h

@@ -1,5 +1,5 @@
-#ifndef Magnum_Shaders_VectorShader_h
-#define Magnum_Shaders_VectorShader_h
+#ifndef Magnum_Shaders_Vector_h
+#define Magnum_Shaders_Vector_h
 /*
     This file is part of Magnum.
 
@@ -25,12 +25,12 @@
 */
 
 /** @file
- * @brief Class Magnum::Shaders::VectorShader, typedef Magnum::Shaders::VectorShader2D, Magnum::Shaders::VectorShader3D
+ * @brief Class Magnum::Shaders::Vector, typedef Magnum::Shaders::Vector2D, Magnum::Shaders::Vector3D
  */
 
 #include "Math/Matrix3.h"
 #include "Math/Matrix4.h"
-#include "AbstractVectorShader.h"
+#include "AbstractVector.h"
 
 #include "magnumShadersVisibility.h"
 
@@ -39,19 +39,19 @@ namespace Magnum { namespace Shaders {
 /**
 @brief Vector shader
 
-Renders vector art in plain grayscale form. See also DistanceFieldVectorShader
+Renders vector art in plain grayscale form. See also DistanceFieldVector
 for more advanced effects.
-@see VectorShader2D, VectorShader3D
+@see Vector2D, Vector3D
 */
-template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VectorShader: public AbstractVectorShader<dimensions> {
+template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Vector: public AbstractVector<dimensions> {
     public:
-        VectorShader();
+        Vector();
 
         /**
          * @brief Set transformation and projection matrix
          * @return Pointer to self (for method chaining)
          */
-        inline VectorShader* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+        inline Vector* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
             AbstractShaderProgram::setUniform(transformationProjectionMatrixUniform, matrix);
             return this;
         }
@@ -60,7 +60,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VectorShader: publi
          * @brief Set fill color
          * @return Pointer to self (for method chaining)
          */
-        inline VectorShader* setColor(const Color4<>& color) {
+        inline Vector* setColor(const Color4<>& color) {
             AbstractShaderProgram::setUniform(colorUniform, color);
             return this;
         }
@@ -71,10 +71,10 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VectorShader: publi
 };
 
 /** @brief Two-dimensional vector shader */
-typedef VectorShader<2> VectorShader2D;
+typedef Vector<2> Vector2D;
 
 /** @brief Three-dimensional vector shader */
-typedef VectorShader<3> VectorShader3D;
+typedef Vector<3> Vector3D;
 
 }}
 

src/Shaders/VertexColor.cpp

@@ -22,7 +22,7 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#include "VertexColorShader.h"
+#include "VertexColor.h"
 
 #include <Utility/Resource.h>
 
@@ -33,11 +33,11 @@ namespace Magnum { namespace Shaders {
 
 namespace {
     template<UnsignedInt> constexpr const char* vertexShaderName();
-    template<> constexpr const char* vertexShaderName<2>() { return "VertexColorShader2D.vert"; }
-    template<> constexpr const char* vertexShaderName<3>() { return "VertexColorShader3D.vert"; }
+    template<> constexpr const char* vertexShaderName<2>() { return "VertexColor2D.vert"; }
+    template<> constexpr const char* vertexShaderName<3>() { return "VertexColor3D.vert"; }
 }
 
-template<UnsignedInt dimensions> VertexColorShader<dimensions>::VertexColorShader(): transformationProjectionMatrixUniform(0) {
+template<UnsignedInt dimensions> VertexColor<dimensions>::VertexColor(): transformationProjectionMatrixUniform(0) {
     Corrade::Utility::Resource rs("MagnumShaders");
 
     #ifndef MAGNUM_TARGET_GLES
@@ -53,7 +53,7 @@ template<UnsignedInt dimensions> VertexColorShader<dimensions>::VertexColorShade
 
     Shader fragmentShader(v, Shader::Type::Fragment);
     fragmentShader.addSource(rs.get("compatibility.glsl"));
-    fragmentShader.addSource(rs.get("VertexColorShader.frag"));
+    fragmentShader.addSource(rs.get("VertexColor.frag"));
     attachShader(fragmentShader);
 
     #ifndef MAGNUM_TARGET_GLES
@@ -82,7 +82,7 @@ template<UnsignedInt dimensions> VertexColorShader<dimensions>::VertexColorShade
     #endif
 }
 
-template class VertexColorShader<2>;
-template class VertexColorShader<3>;
+template class VertexColor<2>;
+template class VertexColor<3>;
 
 }}

src/Shaders/VertexColor.h

@@ -1,5 +1,5 @@
-#ifndef Magnum_Shaders_VertexColorShader_h
-#define Magnum_Shaders_VertexColorShader_h
+#ifndef Magnum_Shaders_VertexColor_h
+#define Magnum_Shaders_VertexColor_h
 /*
     This file is part of Magnum.
 
@@ -25,7 +25,7 @@
 */
 
 /** @file
- * @brief Class Magnum::Shaders::VertexColorShader
+ * @brief Class Magnum::Shaders::VertexColor
  */
 
 #include "Math/Matrix3.h"
@@ -42,9 +42,9 @@ namespace Magnum { namespace Shaders {
 @brief Vertex color shader
 
 Draws vertex-colored mesh.
-@see VertexColorShader2D, VertexColorShader3D
+@see VertexColor2D, VertexColor3D
 */
-template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColorShader: public AbstractShaderProgram {
+template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColor: public AbstractShaderProgram {
     public:
         /** @brief Vertex position */
         typedef Attribute<0, typename DimensionTraits<dimensions>::VectorType> Position;
@@ -52,7 +52,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColorShader:
         /** @brief Vertex color */
         typedef Attribute<1, Color3<>> Color;
 
-        explicit VertexColorShader();
+        explicit VertexColor();
 
         /**
          * @brief Set transformation and projection matrix
@@ -60,7 +60,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColorShader:
          *
          * Default is identity matrix.
          */
-        inline VertexColorShader<dimensions>* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+        inline VertexColor<dimensions>* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
             setUniform(transformationProjectionMatrixUniform, matrix);
             return this;
         }
@@ -70,10 +70,10 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColorShader:
 };
 
 /** @brief 2D vertex color shader */
-typedef VertexColorShader<2> VertexColorShader2D;
+typedef VertexColor<2> VertexColor2D;
 
 /** @brief 3D vertex color shader */
-typedef VertexColorShader<3> VertexColorShader3D;
+typedef VertexColor<3> VertexColor3D;
 
 }}
 

src/Text/TextRenderer.cpp

@@ -27,7 +27,7 @@
 #include "Context.h"
 #include "Extensions.h"
 #include "Mesh.h"
-#include "Shaders/AbstractVectorShader.h"
+#include "Shaders/AbstractVector.h"
 #include "Text/AbstractFont.h"
 
 namespace Magnum { namespace Text {
@@ -179,9 +179,9 @@ template<UnsignedInt dimensions> std::tuple<Mesh, Rectangle> TextRenderer<dimens
     auto r = AbstractTextRenderer::render(font, cache, size, text, vertexBuffer, indexBuffer, usage);
     Mesh& mesh = std::get<0>(r);
     mesh.addInterleavedVertexBuffer(vertexBuffer, 0,
-            typename Shaders::AbstractVectorShader<dimensions>::Position(
-                Shaders::AbstractVectorShader<dimensions>::Position::Components::Two),
-            typename Shaders::AbstractVectorShader<dimensions>::TextureCoordinates());
+            typename Shaders::AbstractVector<dimensions>::Position(
+                Shaders::AbstractVector<dimensions>::Position::Components::Two),
+            typename Shaders::AbstractVector<dimensions>::TextureCoordinates());
     return std::move(r);
 }
 
@@ -203,8 +203,8 @@ AbstractTextRenderer::~AbstractTextRenderer() {}
 template<UnsignedInt dimensions> TextRenderer<dimensions>::TextRenderer(AbstractFont* const font, const GlyphCache* const cache, const Float size): AbstractTextRenderer(font, cache, size) {
     /* Finalize mesh configuration */
     _mesh.addInterleavedVertexBuffer(&vertexBuffer, 0,
-            typename Shaders::AbstractVectorShader<dimensions>::Position(Shaders::AbstractVectorShader<dimensions>::Position::Components::Two),
-            typename Shaders::AbstractVectorShader<dimensions>::TextureCoordinates());
+            typename Shaders::AbstractVector<dimensions>::Position(Shaders::AbstractVector<dimensions>::Position::Components::Two),
+            typename Shaders::AbstractVector<dimensions>::TextureCoordinates());
 }
 
 void AbstractTextRenderer::reserve(const uint32_t glyphCount, const Buffer::Usage vertexBufferUsage, const Buffer::Usage indexBufferUsage) {

src/TextureTools/DistanceField.cpp

@@ -69,12 +69,13 @@ DistanceFieldShader::DistanceFieldShader() {
     /** @todo compatibility! */
 
     Corrade::Utility::Resource rs("MagnumTextureTools");
-    attachShader(Shader::fromData(Version::GL330, Shader::Type::Vertex, rs.get("DistanceFieldShader.vert")));
 
-    Shader fragmentShader(Version::GL330, Shader::Type::Fragment);
-    fragmentShader.addSource(rs.get("compatibility.glsl"));
-    fragmentShader.addSource(rs.get("DistanceFieldShader.frag"));
-    attachShader(fragmentShader);
+    attachShader(Shader(Version::GL330, Shader::Type::Vertex)
+        .addSource(rs.get("DistanceFieldShader.vert")));
+
+    attachShader(Shader(Version::GL330, Shader::Type::Fragment)
+        .addSource(rs.get("compatibility.glsl"))
+        .addSource(rs.get("DistanceFieldShader.frag")));
 
     link();
 }