Shaders: renamed TextShader to VectorShader.

The code can be used for drawing any vector art, not only font glyphs.

src/Shaders/AbstractVectorShader.h

@@ -1,5 +1,5 @@
-#ifndef Magnum_Shaders_AbstractTextShader_h
-#define Magnum_Shaders_AbstractTextShader_h
+#ifndef Magnum_Shaders_AbstractVectorShader_h
+#define Magnum_Shaders_AbstractVectorShader_h
 /*
     Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
 
@@ -16,7 +16,7 @@
 */
 
 /** @file
- * @brief Class Magnum::Shaders::AbstractTextShader
+ * @brief Class Magnum::Shaders::AbstractVectorShader
  */
 
 #include "AbstractShaderProgram.h"
@@ -26,11 +26,11 @@
 namespace Magnum { namespace Shaders {
 
 /**
-@brief Base for text shaders
+@brief Base for vector shaders
 
-@see AbstractTextShader2D, AbstractTextShader3D
+@see AbstractVectorShader2D, AbstractVectorShader3D
 */
-template<UnsignedInt dimensions> class AbstractTextShader: public AbstractShaderProgram {
+template<UnsignedInt dimensions> class AbstractVectorShader: public AbstractShaderProgram {
     public:
         /** @brief Vertex position */
         typedef Attribute<0, typename DimensionTraits<dimensions>::VectorType> Position;
@@ -39,19 +39,19 @@ template<UnsignedInt dimensions> class AbstractTextShader: public AbstractShader
         typedef Attribute<1, Vector2> TextureCoordinates;
 
         enum: GLint {
-            FontTextureLayer = 16   /**< Layer for font texture */
+            VectorTextureLayer = 16 /**< Layer for vector texture */
         };
 
-        ~AbstractTextShader() = 0;
+        ~AbstractVectorShader() = 0;
 };
 
-template<UnsignedInt dimensions> inline AbstractTextShader<dimensions>::~AbstractTextShader() {}
+template<UnsignedInt dimensions> inline AbstractVectorShader<dimensions>::~AbstractVectorShader() {}
 
 /** @brief Base for two-dimensional text shaders */
-typedef AbstractTextShader<2> AbstractTextShader2D;
+typedef AbstractVectorShader<2> AbstractVectorShader2D;
 
 /** @brief Base for three-dimensional text shader */
-typedef AbstractTextShader<3> AbstractTextShader3D;
+typedef AbstractVectorShader<3> AbstractVectorShader3D;
 
 }}
 

src/Shaders/CMakeLists.txt

@@ -1,21 +1,21 @@
 corrade_add_resource(MagnumShaders_RCS MagnumShaders
     FlatShader2D.vert FlatShader3D.vert FlatShader.frag
     PhongShader.vert PhongShader.frag
-    TextShader2D.vert TextShader3D.vert TextShader.frag
+    VectorShader2D.vert VectorShader3D.vert VectorShader.frag
     VertexColorShader2D.vert VertexColorShader3D.vert VertexColorShader.frag
     compatibility.glsl)
 set(MagnumShaders_SRCS
     FlatShader.cpp
     PhongShader.cpp
-    TextShader.cpp
+    VectorShader.cpp
     VertexColorShader.cpp
     ${MagnumShaders_RCS})
 set(MagnumShaders_HEADERS
-    AbstractTextShader.h
+    AbstractVectorShader.h
     FlatShader.h
     PhongShader.h
     Shaders.h
-    TextShader.h
+    VectorShader.h
     VertexColorShader.h
 
     magnumShadersVisibility.h)

src/Shaders/Shaders.h

@@ -25,9 +25,9 @@ namespace Magnum { namespace Shaders {
 
 /** @todoc remove when doxygen is sane again */
 #ifndef DOXYGEN_GENERATING_OUTPUT
-template<UnsignedInt> class AbstractTextShader;
-typedef AbstractTextShader<2> AbstractTextShader2D;
-typedef AbstractTextShader<3> AbstractTextShader3D;
+template<UnsignedInt> class AbstractVectorShader;
+typedef AbstractVectorShader<2> AbstractVectorShader2D;
+typedef AbstractVectorShader<3> AbstractVectorShader3D;
 
 template<UnsignedInt> class FlatShader;
 typedef FlatShader<2> FlatShader2D;
@@ -35,9 +35,9 @@ typedef FlatShader<3> FlatShader3D;
 
 class PhongShader;
 
-template<UnsignedInt> class TextShader;
-typedef TextShader<2> TextShader2D;
-typedef TextShader<3> TextShader3D;
+template<UnsignedInt> class VectorShader;
+typedef VectorShader<2> VectorShader2D;
+typedef VectorShader<3> VectorShader3D;
 
 template<UnsignedInt> class VertexColorShader;
 typedef VertexColorShader<2> VertexColorShader2D;

src/Shaders/VectorShader.cpp

@@ -13,7 +13,7 @@
     GNU Lesser General Public License version 3 for more details.
 */
 
-#include "TextShader.h"
+#include "VectorShader.h"
 
 #include <Utility/Resource.h>
 
@@ -25,11 +25,11 @@ namespace Magnum { namespace Shaders {
 
 namespace {
     template<UnsignedInt> constexpr const char* vertexShaderName();
-    template<> constexpr const char* vertexShaderName<2>() { return "TextShader2D.vert"; }
-    template<> constexpr const char* vertexShaderName<3>() { return "TextShader3D.vert"; }
+    template<> constexpr const char* vertexShaderName<2>() { return "VectorShader2D.vert"; }
+    template<> constexpr const char* vertexShaderName<3>() { return "VectorShader3D.vert"; }
 }
 
-template<UnsignedInt dimensions> TextShader<dimensions>::TextShader(): transformationProjectionMatrixUniform(0), colorUniform(1) {
+template<UnsignedInt dimensions> VectorShader<dimensions>::VectorShader(): transformationProjectionMatrixUniform(0), colorUniform(1) {
     Corrade::Utility::Resource rs("MagnumShaders");
 
     #ifndef MAGNUM_TARGET_GLES
@@ -41,12 +41,12 @@ template<UnsignedInt dimensions> TextShader<dimensions>::TextShader(): transform
     Shader vertexShader(v, Shader::Type::Vertex);
     vertexShader.addSource(rs.get("compatibility.glsl"));
     vertexShader.addSource(rs.get(vertexShaderName<dimensions>()));
-    AbstractTextShader<dimensions>::attachShader(vertexShader);
+    AbstractVectorShader<dimensions>::attachShader(vertexShader);
 
     Shader fragmentShader(v, Shader::Type::Fragment);
     fragmentShader.addSource(rs.get("compatibility.glsl"));
-    fragmentShader.addSource(rs.get("TextShader.frag"));
-    AbstractTextShader<dimensions>::attachShader(fragmentShader);
+    fragmentShader.addSource(rs.get("VectorShader.frag"));
+    AbstractVectorShader<dimensions>::attachShader(fragmentShader);
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>() ||
@@ -54,28 +54,28 @@ template<UnsignedInt dimensions> TextShader<dimensions>::TextShader(): transform
     #else
     if(!Context::current()->isVersionSupported(Version::GLES300)) {
     #endif
-        AbstractTextShader<dimensions>::bindAttributeLocation(AbstractTextShader<dimensions>::Position::Location, "position");
-        AbstractTextShader<dimensions>::bindAttributeLocation(AbstractTextShader<dimensions>::TextureCoordinates::Location, "textureCoordinates");
+        AbstractVectorShader<dimensions>::bindAttributeLocation(AbstractVectorShader<dimensions>::Position::Location, "position");
+        AbstractVectorShader<dimensions>::bindAttributeLocation(AbstractVectorShader<dimensions>::TextureCoordinates::Location, "textureCoordinates");
     }
 
-    AbstractTextShader<dimensions>::link();
+    AbstractVectorShader<dimensions>::link();
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>()) {
     #else
     {
     #endif
-        transformationProjectionMatrixUniform = AbstractTextShader<dimensions>::uniformLocation("transformationProjectionMatrix");
-        colorUniform = AbstractTextShader<dimensions>::uniformLocation("color");
+        transformationProjectionMatrixUniform = AbstractVectorShader<dimensions>::uniformLocation("transformationProjectionMatrix");
+        colorUniform = AbstractVectorShader<dimensions>::uniformLocation("color");
     }
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::shading_language_420pack>())
-        AbstractTextShader<dimensions>::setUniform(AbstractTextShader<dimensions>::uniformLocation("fontTexture"), AbstractTextShader<dimensions>::FontTextureLayer);
+        AbstractVectorShader<dimensions>::setUniform(AbstractVectorShader<dimensions>::uniformLocation("vectorTexture"), AbstractVectorShader<dimensions>::VectorTextureLayer);
     #endif
 }
 
-template class TextShader<2>;
-template class TextShader<3>;
+template class VectorShader<2>;
+template class VectorShader<3>;
 
 }}

src/Shaders/VectorShader.frag

@@ -10,9 +10,9 @@ uniform lowp vec3 color;
 #endif
 
 #ifdef EXPLICIT_TEXTURE_LAYER
-layout(binding = 16) uniform sampler2D fontTexture;
+layout(binding = 16) uniform sampler2D vectorTexture;
 #else
-uniform lowp sampler2D fontTexture;
+uniform lowp sampler2D vectorTexture;
 #endif
 
 in vec2 fragmentTextureCoordinates;
@@ -22,6 +22,6 @@ out vec4 fragmentColor;
 #endif
 
 void main() {
-    lowp float intensity = texture(fontTexture, fragmentTextureCoordinates).r;
+    lowp float intensity = texture(vectorTexture, fragmentTextureCoordinates).r;
     fragmentColor = vec4(intensity*color, intensity);
 }

src/Shaders/VectorShader.h

@@ -1,5 +1,5 @@
-#ifndef Magnum_Shaders_TextShader_h
-#define Magnum_Shaders_TextShader_h
+#ifndef Magnum_Shaders_VectorShader_h
+#define Magnum_Shaders_VectorShader_h
 /*
     Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
 
@@ -16,35 +16,35 @@
 */
 
 /** @file
- * @brief Class Magnum::Shaders::TextShader
+ * @brief Class Magnum::Shaders::VectorShader
  */
 
 #include "Math/Matrix3.h"
 #include "Math/Matrix4.h"
-#include "AbstractTextShader.h"
+#include "AbstractVectorShader.h"
 
 #include "magnumShadersVisibility.h"
 
 namespace Magnum { namespace Shaders {
 
 /**
-@brief %Text shader
+@brief Vector shader
 
-@see TextShader2D, TextShader3D
+@see VectorShader2D, VectorShader3D
 */
-template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT TextShader: public AbstractTextShader<dimensions> {
+template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VectorShader: public AbstractVectorShader<dimensions> {
     public:
-        TextShader();
+        VectorShader();
 
         /** @brief Set transformation and projection matrix */
-        inline TextShader* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
-            AbstractTextShader<dimensions>::setUniform(transformationProjectionMatrixUniform, matrix);
+        inline VectorShader* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+            AbstractVectorShader<dimensions>::setUniform(transformationProjectionMatrixUniform, matrix);
             return this;
         }
 
-        /** @brief Set text color */
-        inline TextShader* setColor(const Color3<>& color) {
-            AbstractTextShader<dimensions>::setUniform(colorUniform, color);
+        /** @brief Set fill color */
+        inline VectorShader* setColor(const Color3<>& color) {
+            AbstractVectorShader<dimensions>::setUniform(colorUniform, color);
             return this;
         }
 
@@ -53,11 +53,11 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT TextShader: public
             colorUniform;
 };
 
-/** @brief Two-dimensional text shader */
-typedef TextShader<2> TextShader2D;
+/** @brief Two-dimensional vector shader */
+typedef VectorShader<2> VectorShader2D;
 
-/** @brief Three-dimensional text shader */
-typedef TextShader<3> TextShader3D;
+/** @brief Three-dimensional vector shader */
+typedef VectorShader<3> VectorShader3D;
 
 }}
 

src/Text/TextRenderer.cpp

@@ -27,7 +27,7 @@
 #include "Extensions.h"
 #include "Mesh.h"
 #include "Swizzle.h"
-#include "Shaders/AbstractTextShader.h"
+#include "Shaders/AbstractVectorShader.h"
 #include "Text/Font.h"
 
 namespace Magnum { namespace Text {
@@ -277,8 +277,8 @@ template<UnsignedInt dimensions> std::tuple<Mesh, Rectangle> TextRenderer<dimens
     mesh.setPrimitive(Mesh::Primitive::Triangles)
         ->setIndexCount(indexCount)
         ->addInterleavedVertexBuffer(vertexBuffer, 0,
-            typename Shaders::AbstractTextShader<dimensions>::Position(),
-            typename Shaders::AbstractTextShader<dimensions>::TextureCoordinates())
+            typename Shaders::AbstractVectorShader<dimensions>::Position(),
+            typename Shaders::AbstractVectorShader<dimensions>::TextureCoordinates())
         ->setIndexBuffer(indexBuffer, 0, indexType, 0, vertexCount);
 
     return std::make_tuple(std::move(mesh), rectangle);
@@ -295,8 +295,8 @@ template<UnsignedInt dimensions> TextRenderer<dimensions>::TextRenderer(Font& fo
 
     _mesh.setPrimitive(Mesh::Primitive::Triangles)
         ->addInterleavedVertexBuffer(&vertexBuffer, 0,
-            typename Shaders::AbstractTextShader<dimensions>::Position(),
-            typename Shaders::AbstractTextShader<dimensions>::TextureCoordinates());
+            typename Shaders::AbstractVectorShader<dimensions>::Position(),
+            typename Shaders::AbstractVectorShader<dimensions>::TextureCoordinates());
 }
 
 template<UnsignedInt dimensions> void TextRenderer<dimensions>::reserve(const uint32_t glyphCount, const Buffer::Usage vertexBufferUsage, const Buffer::Usage indexBufferUsage) {

src/Text/TextRenderer.h

@@ -48,7 +48,7 @@ The text can be then drawn by configuring text shader, binding font texture
 and drawing the mesh:
 @code
 Text::Font font;
-Shaders::TextShader2D shader;
+Shaders::VectorShader2D shader;
 Buffer vertexBuffer, indexBuffer;
 Mesh mesh;
 
@@ -61,7 +61,7 @@ std::tie(mesh, rectangle) = Text::TextRenderer2D::render(font, 0.15f,
 shader.setTransformationProjectionMatrix(projection*Matrix3::translation(-rectangle.width()/2.0f))
     ->setColor(Color3<>(1.0f));
     ->use();
-font.texture()->bind(Shaders::TextShader2D::FontTextureLayer);
+font.texture()->bind(Shaders::VectorShader2D::FontTextureLayer);
 mesh.draw();
 @endcode
 See render(Font&, Float, const std::string&) and
@@ -73,7 +73,7 @@ mutable texts (e.g. FPS counters, chat messages) there is another approach
 that doesn't recreate everything on each text change:
 @code
 Text::Font font;
-Shaders::TextShader2D shader;
+Shaders::VectorShader2D shader;
 
 // Initialize renderer and reserve memory for enough glyphs
 Text::TextRenderer2D renderer(font, 0.15f);
@@ -86,7 +86,7 @@ renderer.render("Hello World Countdown: 10");
 shader.setTransformationProjectionMatrix(projection*Matrix3::translation(-renderer.rectangle().width()/2.0f))
     ->setColor(Color3<>(1.0f));
     ->use();
-font.texture()->bind(Shaders::TextShader2D::FontTextureLayer);
+font.texture()->bind(Shaders::VectorShader2D::FontTextureLayer);
 renderer.mesh().draw();
 @endcode
 
@@ -96,7 +96,7 @@ Mutable text rendering requires @extension{ARB,map_buffer_range} (also part of
 OpenGL ES 3.0 or available as @es_extension{EXT,map_buffer_range} in ES 2.0)
 for asynchronous buffer updates.
 
-@see TextRenderer2D, TextRenderer3D, Font, Shaders::AbstractTextShader
+@see TextRenderer2D, TextRenderer3D, Font, Shaders::AbstractVectorShader
 */
 template<UnsignedInt dimensions> class MAGNUM_TEXT_EXPORT TextRenderer {
     public:
@@ -120,7 +120,7 @@ template<UnsignedInt dimensions> class MAGNUM_TEXT_EXPORT TextRenderer {
          * @param indexBuffer   %Buffer where to store indices
          * @param usage         Usage of vertex and index buffer
          *
-         * Returns mesh prepared for use with Shaders::AbstractTextShader
+         * Returns mesh prepared for use with Shaders::AbstractVectorShader
          * subclasses and rectangle spanning the rendered text.
          */
         static std::tuple<Mesh, Rectangle> render(Font& font, Float size, const std::string& text, Buffer* vertexBuffer, Buffer* indexBuffer, Buffer::Usage usage);