Shaders: de-inline uniform setters.

Reduces includes in the header quite a lot, yay.

doc/generated/primitives.cpp

@@ -50,6 +50,9 @@
 #include <Magnum/GL/Renderer.h>
 #include <Magnum/GL/Texture.h>
 #include <Magnum/GL/TextureFormat.h>
+#include <Magnum/Math/Color.h>
+#include <Magnum/Math/Matrix3.h>
+#include <Magnum/Math/Matrix4.h>
 #include <Magnum/MeshTools/Compile.h>
 #include <Magnum/MeshTools/Interleave.h>
 #include <Magnum/MeshTools/Transform.h>

doc/generated/shaders.cpp

@@ -49,6 +49,9 @@
 #include <Magnum/GL/Renderer.h>
 #include <Magnum/GL/Texture.h>
 #include <Magnum/GL/TextureFormat.h>
+#include <Magnum/Math/Color.h>
+#include <Magnum/Math/Matrix3.h>
+#include <Magnum/Math/Matrix4.h>
 #include <Magnum/MeshTools/Compile.h>
 #include <Magnum/MeshTools/Interleave.h>
 #include <Magnum/Primitives/Square.h>

doc/snippets/MagnumShaders.cpp

@@ -35,6 +35,8 @@
 #include "Magnum/GL/RenderbufferFormat.h"
 #include "Magnum/GL/Texture.h"
 #include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix3.h"
+#include "Magnum/Math/Matrix4.h"
 #include "Magnum/MeshTools/Duplicate.h"
 #include "Magnum/Shaders/DistanceFieldVector.h"
 #include "Magnum/Shaders/Flat.h"

doc/snippets/MagnumText.cpp

@@ -30,6 +30,8 @@
 #include <Corrade/Utility/Resource.h>
 
 #include "Magnum/FileCallback.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix3.h"
 #include "Magnum/Shaders/Vector.h"
 #include "Magnum/Text/AbstractFont.h"
 #include "Magnum/Text/DistanceFieldGlyphCache.h"

src/Magnum/MeshTools/Test/CompileGLTest.cpp

@@ -39,6 +39,7 @@
 #include "Magnum/GL/RenderbufferFormat.h"
 #include "Magnum/GL/Texture.h"
 #include "Magnum/GL/TextureFormat.h"
+#include "Magnum/Math/Color.h"
 #include "Magnum/Math/Matrix4.h"
 #include "Magnum/MeshTools/Compile.h"
 #include "Magnum/MeshTools/Duplicate.h"

src/Magnum/Shaders/DistanceFieldVector.cpp

@@ -31,6 +31,9 @@
 #include "Magnum/GL/Context.h"
 #include "Magnum/GL/Extensions.h"
 #include "Magnum/GL/Shader.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix3.h"
+#include "Magnum/Math/Matrix4.h"
 
 #include "Magnum/Shaders/Implementation/CreateCompatibilityShader.h"
 
@@ -109,6 +112,31 @@ template<UnsignedInt dimensions> DistanceFieldVector<dimensions>::DistanceFieldV
     #endif
 }
 
+template<UnsignedInt dimensions> DistanceFieldVector<dimensions>& DistanceFieldVector<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
+    GL::AbstractShaderProgram::setUniform(_transformationProjectionMatrixUniform, matrix);
+    return *this;
+}
+
+template<UnsignedInt dimensions> DistanceFieldVector<dimensions>& DistanceFieldVector<dimensions>::setColor(const Color4& color) {
+    GL::AbstractShaderProgram::setUniform(_colorUniform, color);
+    return *this;
+}
+
+template<UnsignedInt dimensions> DistanceFieldVector<dimensions>& DistanceFieldVector<dimensions>::setOutlineColor(const Color4& color) {
+    GL::AbstractShaderProgram::setUniform(_outlineColorUniform, color);
+    return *this;
+}
+
+template<UnsignedInt dimensions> DistanceFieldVector<dimensions>& DistanceFieldVector<dimensions>::setOutlineRange(Float start, Float end) {
+    GL::AbstractShaderProgram::setUniform(_outlineRangeUniform, Vector2(start, end));
+    return *this;
+}
+
+template<UnsignedInt dimensions> DistanceFieldVector<dimensions>& DistanceFieldVector<dimensions>::setSmoothness(Float value) {
+    GL::AbstractShaderProgram::setUniform(_smoothnessUniform, value);
+    return *this;
+}
+
 template class DistanceFieldVector<2>;
 template class DistanceFieldVector<3>;
 

src/Magnum/Shaders/DistanceFieldVector.h

@@ -30,9 +30,6 @@
  */
 
 #include "Magnum/DimensionTraits.h"
-#include "Magnum/Math/Color.h"
-#include "Magnum/Math/Matrix3.h"
-#include "Magnum/Math/Matrix4.h"
 #include "Magnum/Shaders/AbstractVector.h"
 #include "Magnum/Shaders/visibility.h"
 
@@ -107,10 +104,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
          *
          * Initial value is an identity matrix.
          */
-        DistanceFieldVector& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
-            GL::AbstractShaderProgram::setUniform(_transformationProjectionMatrixUniform, matrix);
-            return *this;
-        }
+        DistanceFieldVector& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix);
 
         /**
          * @brief Set fill color
@@ -119,10 +113,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
          * Initial value is @cpp 0xffffffff_rgbaf @ce.
          * @see @ref setOutlineColor()
          */
-        DistanceFieldVector& setColor(const Color4& color) {
-            GL::AbstractShaderProgram::setUniform(_colorUniform, color);
-            return *this;
-        }
+        DistanceFieldVector& setColor(const Color4& color);
 
         /**
          * @brief Set outline color
@@ -132,10 +123,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
          * drawn --- see @ref setOutlineRange() for more information.
          * @see @ref setOutlineRange(), @ref setColor()
          */
-        DistanceFieldVector& setOutlineColor(const Color4& color) {
-            GL::AbstractShaderProgram::setUniform(_outlineColorUniform, color);
-            return *this;
-        }
+        DistanceFieldVector& setOutlineColor(const Color4& color);
 
         /**
          * @brief Set outline range
@@ -151,10 +139,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
          *
          * @see @ref setOutlineColor()
          */
-        DistanceFieldVector& setOutlineRange(Float start, Float end) {
-            GL::AbstractShaderProgram::setUniform(_outlineRangeUniform, Vector2(start, end));
-            return *this;
-        }
+        DistanceFieldVector& setOutlineRange(Float start, Float end);
 
         /**
          * @brief Set smoothness radius
@@ -164,10 +149,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
          * smaller values will make them look more crisp (but possibly
          * aliased). Initial value is @cpp 0.04f @ce.
          */
-        DistanceFieldVector& setSmoothness(Float value) {
-            GL::AbstractShaderProgram::setUniform(_smoothnessUniform, value);
-            return *this;
-        }
+        DistanceFieldVector& setSmoothness(Float value);
 
         #ifndef DOXYGEN_GENERATING_OUTPUT
         /* Overloads to remove WTF-factor from method chaining order */

src/Magnum/Shaders/Flat.cpp

@@ -33,6 +33,9 @@
 #include "Magnum/GL/Extensions.h"
 #include "Magnum/GL/Shader.h"
 #include "Magnum/GL/Texture.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix3.h"
+#include "Magnum/Math/Matrix4.h"
 
 #include "Magnum/Shaders/Implementation/CreateCompatibilityShader.h"
 
@@ -131,6 +134,16 @@ template<UnsignedInt dimensions> Flat<dimensions>::Flat(const Flags flags): _fla
     #endif
 }
 
+template<UnsignedInt dimensions> Flat<dimensions>& Flat<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
+    setUniform(_transformationProjectionMatrixUniform, matrix);
+    return *this;
+}
+
+template<UnsignedInt dimensions> Flat<dimensions>& Flat<dimensions>::setColor(const Magnum::Color4& color) {
+    setUniform(_colorUniform, color);
+    return *this;
+}
+
 template<UnsignedInt dimensions> Flat<dimensions>& Flat<dimensions>::bindTexture(GL::Texture2D& texture) {
     CORRADE_ASSERT(_flags & Flag::Textured,
         "Shaders::Flat::bindTexture(): the shader was not created with texturing enabled", *this);

src/Magnum/Shaders/Flat.h

@@ -31,9 +31,6 @@
 
 #include "Magnum/DimensionTraits.h"
 #include "Magnum/GL/AbstractShaderProgram.h"
-#include "Magnum/Math/Color.h"
-#include "Magnum/Math/Matrix3.h"
-#include "Magnum/Math/Matrix4.h"
 #include "Magnum/Shaders/Generic.h"
 #include "Magnum/Shaders/visibility.h"
 
@@ -278,10 +275,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Flat: public GL::Ab
          *
          * Initial value is an identity matrix.
          */
-        Flat<dimensions>& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
-            setUniform(_transformationProjectionMatrixUniform, matrix);
-            return *this;
-        }
+        Flat<dimensions>& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix);
 
         /**
          * @brief Set color
@@ -292,10 +286,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Flat: public GL::Ab
          * texture.
          * @see @ref bindTexture()
          */
-        Flat<dimensions>& setColor(const Magnum::Color4& color) {
-            setUniform(_colorUniform, color);
-            return *this;
-        }
+        Flat<dimensions>& setColor(const Magnum::Color4& color);
 
         /**
          * @brief Bind a color texture

src/Magnum/Shaders/MeshVisualizer.cpp

@@ -30,6 +30,8 @@
 #include <Corrade/Containers/Reference.h>
 #include <Corrade/Utility/Resource.h>
 
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix4.h"
 #include "Magnum/GL/Context.h"
 #include "Magnum/GL/Extensions.h"
 #include "Magnum/GL/Shader.h"
@@ -156,6 +158,38 @@ MeshVisualizer::MeshVisualizer(const Flags flags): _flags{flags} {
     #endif
 }
 
+MeshVisualizer& MeshVisualizer::setTransformationProjectionMatrix(const Matrix4& matrix) {
+    setUniform(_transformationProjectionMatrixUniform, matrix);
+    return *this;
+}
+
+MeshVisualizer& MeshVisualizer::setViewportSize(const Vector2& size) {
+    if(_flags & Flag::Wireframe && !(_flags & Flag::NoGeometryShader))
+        setUniform(_viewportSizeUniform, size);
+    return *this;
+}
+
+MeshVisualizer& MeshVisualizer::setColor(const Color4& color) {
+    setUniform(_colorUniform, color);
+    return *this;
+}
+
+MeshVisualizer& MeshVisualizer::setWireframeColor(const Color4& color) {
+    if(_flags & Flag::Wireframe) setUniform(_wireframeColorUniform, color);
+    return *this;
+}
+
+MeshVisualizer& MeshVisualizer::setWireframeWidth(const Float width) {
+    if(_flags & Flag::Wireframe) setUniform(_wireframeWidthUniform, width);
+    return *this;
+}
+
+MeshVisualizer& MeshVisualizer::setSmoothness(const Float smoothness) {
+    if(_flags & Flag::Wireframe)
+        setUniform(_smoothnessUniform, smoothness);
+    return *this;
+}
+
 Debug& operator<<(Debug& debug, const MeshVisualizer::Flag value) {
     switch(value) {
         /* LCOV_EXCL_START */

src/Magnum/Shaders/MeshVisualizer.h

@@ -30,8 +30,6 @@
  */
 
 #include "Magnum/GL/AbstractShaderProgram.h"
-#include "Magnum/Math/Color.h"
-#include "Magnum/Math/Matrix4.h"
 #include "Magnum/Shaders/Generic.h"
 #include "Magnum/Shaders/visibility.h"
 
@@ -205,10 +203,7 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizer: public GL::AbstractShaderProgram {
          *
          * Initial value is an identity matrix.
          */
-        MeshVisualizer& setTransformationProjectionMatrix(const Matrix4& matrix) {
-            setUniform(_transformationProjectionMatrixUniform, matrix);
-            return *this;
-        }
+        MeshVisualizer& setTransformationProjectionMatrix(const Matrix4& matrix);
 
         /**
          * @brief Set viewport size
@@ -217,11 +212,7 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizer: public GL::AbstractShaderProgram {
          * Has effect only if @ref Flag::Wireframe is enabled and geometry
          * shaders are used. Initial value is a zero vector.
          */
-        MeshVisualizer& setViewportSize(const Vector2& size) {
-            if(_flags & Flag::Wireframe && !(_flags & Flag::NoGeometryShader))
-                setUniform(_viewportSizeUniform, size);
-            return *this;
-        }
+        MeshVisualizer& setViewportSize(const Vector2& size);
 
         /**
          * @brief Set base object color
@@ -229,10 +220,7 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizer: public GL::AbstractShaderProgram {
          *
          * Initial value is @cpp 0xffffffff_rgbaf @ce.
          */
-        MeshVisualizer& setColor(const Color4& color) {
-            setUniform(_colorUniform, color);
-            return *this;
-        }
+        MeshVisualizer& setColor(const Color4& color);
 
         /**
          * @brief Set wireframe color
@@ -241,10 +229,7 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizer: public GL::AbstractShaderProgram {
          * Initial value is @cpp 0x000000ff_rgbaf @ce. Has effect only if
          * @ref Flag::Wireframe is enabled.
          */
-        MeshVisualizer& setWireframeColor(const Color4& color) {
-            if(_flags & Flag::Wireframe) setUniform(_wireframeColorUniform, color);
-            return *this;
-        }
+        MeshVisualizer& setWireframeColor(const Color4& color);
 
         /**
          * @brief Set wireframe width
@@ -253,10 +238,7 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizer: public GL::AbstractShaderProgram {
          * Initial value is @cpp 1.0f @ce. Has effect only if @ref Flag::Wireframe
          * is enabled.
          */
-        MeshVisualizer& setWireframeWidth(Float width) {
-            if(_flags & Flag::Wireframe) setUniform(_wireframeWidthUniform, width);
-            return *this;
-        }
+        MeshVisualizer& setWireframeWidth(Float width);
 
         /**
          * @brief Set line smoothness
@@ -285,12 +267,6 @@ MAGNUM_SHADERS_EXPORT Debug& operator<<(Debug& debug, MeshVisualizer::Flags valu
 
 CORRADE_ENUMSET_OPERATORS(MeshVisualizer::Flags)
 
-inline MeshVisualizer& MeshVisualizer::setSmoothness(Float smoothness) {
-    if(_flags & Flag::Wireframe)
-        setUniform(_smoothnessUniform, smoothness);
-    return *this;
-}
-
 }}
 
 #endif

src/Magnum/Shaders/Phong.cpp

@@ -37,6 +37,8 @@
 #include "Magnum/GL/Extensions.h"
 #include "Magnum/GL/Shader.h"
 #include "Magnum/GL/Texture.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix4.h"
 
 #include "Magnum/Shaders/Implementation/CreateCompatibilityShader.h"
 
@@ -198,6 +200,11 @@ Phong::Phong(const Flags flags, const UnsignedInt lightCount): _flags{flags}, _l
     #endif
 }
 
+Phong& Phong::setAmbientColor(const Magnum::Color4& color) {
+    setUniform(_ambientColorUniform, color);
+    return *this;
+}
+
 Phong& Phong::bindAmbientTexture(GL::Texture2D& texture) {
     CORRADE_ASSERT(_flags & Flag::AmbientTexture,
         "Shaders::Phong::bindAmbientTexture(): the shader was not created with ambient texture enabled", *this);
@@ -205,6 +212,11 @@ Phong& Phong::bindAmbientTexture(GL::Texture2D& texture) {
     return *this;
 }
 
+Phong& Phong::setDiffuseColor(const Magnum::Color4& color) {
+    if(_lightCount) setUniform(_diffuseColorUniform, color);
+    return *this;
+}
+
 Phong& Phong::bindDiffuseTexture(GL::Texture2D& texture) {
     CORRADE_ASSERT(_flags & Flag::DiffuseTexture,
         "Shaders::Phong::bindDiffuseTexture(): the shader was not created with diffuse texture enabled", *this);
@@ -212,6 +224,11 @@ Phong& Phong::bindDiffuseTexture(GL::Texture2D& texture) {
     return *this;
 }
 
+Phong& Phong::setSpecularColor(const Magnum::Color4& color) {
+    if(_lightCount) setUniform(_specularColorUniform, color);
+    return *this;
+}
+
 Phong& Phong::bindSpecularTexture(GL::Texture2D& texture) {
     CORRADE_ASSERT(_flags & Flag::SpecularTexture,
         "Shaders::Phong::bindSpecularTexture(): the shader was not created with specular texture enabled", *this);
@@ -233,6 +250,11 @@ Phong& Phong::bindTextures(GL::Texture2D* ambient, GL::Texture2D* diffuse, GL::T
     return *this;
 }
 
+Phong& Phong::setShininess(Float shininess) {
+    if(_lightCount) setUniform(_shininessUniform, shininess);
+    return *this;
+}
+
 Phong& Phong::setAlphaMask(Float mask) {
     CORRADE_ASSERT(_flags & Flag::AlphaMask,
         "Shaders::Phong::setAlphaMask(): the shader was not created with alpha mask enabled", *this);
@@ -249,6 +271,21 @@ Phong& Phong::setObjectId(UnsignedInt id) {
 }
 #endif
 
+Phong& Phong::setTransformationMatrix(const Matrix4& matrix) {
+    setUniform(_transformationMatrixUniform, matrix);
+    return *this;
+}
+
+Phong& Phong::setNormalMatrix(const Matrix3x3& matrix) {
+    if(_lightCount) setUniform(_normalMatrixUniform, matrix);
+    return *this;
+}
+
+Phong& Phong::setProjectionMatrix(const Matrix4& matrix) {
+    setUniform(_projectionMatrixUniform, matrix);
+    return *this;
+}
+
 Phong& Phong::setLightPositions(const Containers::ArrayView<const Vector3> positions) {
     CORRADE_ASSERT(_lightCount == positions.size(),
         "Shaders::Phong::setLightPositions(): expected" << _lightCount << "items but got" << positions.size(), *this);
@@ -263,6 +300,12 @@ Phong& Phong::setLightPosition(UnsignedInt id, const Vector3& position) {
     return *this;
 }
 
+/* It's light, but can't be in the header because MSVC needs to know the size
+   of Vector3 for the initializer list use */
+Phong& Phong::setLightPositions(std::initializer_list<Vector3> lights) {
+    return setLightPositions({lights.begin(), lights.size()});
+}
+
 Phong& Phong::setLightColors(const Containers::ArrayView<const Magnum::Color4> colors) {
     CORRADE_ASSERT(_lightCount == colors.size(),
         "Shaders::Phong::setLightColors(): expected" << _lightCount << "items but got" << colors.size(), *this);
@@ -270,6 +313,12 @@ Phong& Phong::setLightColors(const Containers::ArrayView<const Magnum::Color4> c
     return *this;
 }
 
+/* It's light, but can't be in the header because MSVC needs to know the size
+   of Color for the initializer list use */
+Phong& Phong::setLightColors(std::initializer_list<Magnum::Color4> colors) {
+    return setLightColors({colors.begin(), colors.size()});
+}
+
 Phong& Phong::setLightColor(UnsignedInt id, const Magnum::Color4& color) {
     CORRADE_ASSERT(id < _lightCount,
         "Shaders::Phong::setLightColor(): light ID" << id << "is out of bounds for" << _lightCount << "lights", *this);

src/Magnum/Shaders/Phong.h

@@ -30,8 +30,6 @@
  */
 
 #include "Magnum/GL/AbstractShaderProgram.h"
-#include "Magnum/Math/Color.h"
-#include "Magnum/Math/Matrix4.h"
 #include "Magnum/Shaders/Generic.h"
 #include "Magnum/Shaders/visibility.h"
 
@@ -311,10 +309,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public GL::AbstractShaderProgram {
          * ambient texture, otherwise default value is @cpp 0x00000000_rgbaf @ce.
          * @see @ref bindAmbientTexture()
          */
-        Phong& setAmbientColor(const Magnum::Color4& color) {
-            setUniform(_ambientColorUniform, color);
-            return *this;
-        }
+        Phong& setAmbientColor(const Magnum::Color4& color);
 
         /**
          * @brief Bind an ambient texture
@@ -344,10 +339,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public GL::AbstractShaderProgram {
          * to the output in that case.
          * @see @ref bindDiffuseTexture()
          */
-        Phong& setDiffuseColor(const Magnum::Color4& color) {
-            if(_lightCount) setUniform(_diffuseColorUniform, color);
-            return *this;
-        }
+        Phong& setDiffuseColor(const Magnum::Color4& color);
 
         /**
          * @brief Bind a diffuse texture
@@ -393,10 +385,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public GL::AbstractShaderProgram {
          * output in that case.
          * @see @ref bindSpecularTexture()
          */
-        Phong& setSpecularColor(const Magnum::Color4& color) {
-            if(_lightCount) setUniform(_specularColorUniform, color);
-            return *this;
-        }
+        Phong& setSpecularColor(const Magnum::Color4& color);
 
         /**
          * @brief Bind a specular texture
@@ -455,10 +444,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public GL::AbstractShaderProgram {
          * function is a no-op, as specular color doesn't contribute to the
          * output in that case.
          */
-        Phong& setShininess(Float shininess) {
-            if(_lightCount) setUniform(_shininessUniform, shininess);
-            return *this;
-        }
+        Phong& setShininess(Float shininess);
 
         /**
          * @brief Set alpha mask value
@@ -494,10 +480,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public GL::AbstractShaderProgram {
          * You need to set also @ref setNormalMatrix() with a corresponding
          * value. Initial value is an identity matrix.
          */
-        Phong& setTransformationMatrix(const Matrix4& matrix) {
-            setUniform(_transformationMatrixUniform, matrix);
-            return *this;
-        }
+        Phong& setTransformationMatrix(const Matrix4& matrix);
 
         /**
          * @brief Set normal matrix
@@ -510,10 +493,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public GL::AbstractShaderProgram {
          * function is a no-op, as normals don't contribute to the output in
          * that case.
          */
-        Phong& setNormalMatrix(const Matrix3x3& matrix) {
-            if(_lightCount) setUniform(_normalMatrixUniform, matrix);
-            return *this;
-        }
+        Phong& setNormalMatrix(const Matrix3x3& matrix);
 
         /**
          * @brief Set projection matrix
@@ -523,10 +503,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public GL::AbstractShaderProgram {
          * projection of the default @f$ [ -\boldsymbol{1} ; \boldsymbol{1} ] @f$
          * cube).
          */
-        Phong& setProjectionMatrix(const Matrix4& matrix) {
-            setUniform(_projectionMatrixUniform, matrix);
-            return *this;
-        }
+        Phong& setProjectionMatrix(const Matrix4& matrix);
 
         /**
          * @brief Set light positions
@@ -542,9 +519,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public GL::AbstractShaderProgram {
         Phong& setLightPositions(Containers::ArrayView<const Vector3> lights);
 
         /** @overload */
-        Phong& setLightPositions(std::initializer_list<Vector3> lights) {
-            return setLightPositions({lights.begin(), lights.size()});
-        }
+        Phong& setLightPositions(std::initializer_list<Vector3> lights);
 
         /**
          * @brief Set position for given light
@@ -578,9 +553,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public GL::AbstractShaderProgram {
         Phong& setLightColors(Containers::ArrayView<const Magnum::Color4> colors);
 
         /** @overload */
-        Phong& setLightColors(std::initializer_list<Magnum::Color4> colors) {
-            return setLightColors({colors.begin(), colors.size()});
-        }
+        Phong& setLightColors(std::initializer_list<Magnum::Color4> colors);
 
         /**
          * @brief Set position for given light

src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp

@@ -28,6 +28,9 @@
 #include <Corrade/PluginManager/Manager.h>
 #include <Corrade/Utility/Directory.h>
 
+#include "Magnum/Image.h"
+#include "Magnum/ImageView.h"
+#include "Magnum/PixelFormat.h"
 #include "Magnum/DebugTools/CompareImage.h"
 #include "Magnum/GL/OpenGLTester.h"
 #include "Magnum/GL/Framebuffer.h"
@@ -36,9 +39,9 @@
 #include "Magnum/GL/RenderbufferFormat.h"
 #include "Magnum/GL/Texture.h"
 #include "Magnum/GL/TextureFormat.h"
-#include "Magnum/Image.h"
-#include "Magnum/ImageView.h"
-#include "Magnum/PixelFormat.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix3.h"
+#include "Magnum/Math/Matrix4.h"
 #include "Magnum/MeshTools/Compile.h"
 #include "Magnum/Primitives/Plane.h"
 #include "Magnum/Primitives/Square.h"

src/Magnum/Shaders/Test/FlatGLTest.cpp

@@ -43,6 +43,9 @@
 #include "Magnum/GL/Texture.h"
 #include "Magnum/GL/TextureFormat.h"
 #include "Magnum/GL/OpenGLTester.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix3.h"
+#include "Magnum/Math/Matrix4.h"
 #include "Magnum/MeshTools/Compile.h"
 #include "Magnum/Primitives/Circle.h"
 #include "Magnum/Primitives/UVSphere.h"

src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp

@@ -40,6 +40,8 @@
 #include "Magnum/Image.h"
 #include "Magnum/ImageView.h"
 #include "Magnum/PixelFormat.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix4.h"
 #include "Magnum/MeshTools/Compile.h"
 #include "Magnum/MeshTools/Duplicate.h"
 #include "Magnum/Primitives/Circle.h"

src/Magnum/Shaders/Test/PhongGLTest.cpp

@@ -43,6 +43,8 @@
 #include "Magnum/GL/RenderbufferFormat.h"
 #include "Magnum/GL/Texture.h"
 #include "Magnum/GL/TextureFormat.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix4.h"
 #include "Magnum/MeshTools/Compile.h"
 #include "Magnum/MeshTools/Transform.h"
 #include "Magnum/Primitives/Plane.h"

src/Magnum/Shaders/Test/VectorGLTest.cpp

@@ -28,6 +28,9 @@
 #include <Corrade/PluginManager/Manager.h>
 #include <Corrade/Utility/Directory.h>
 
+#include "Magnum/Image.h"
+#include "Magnum/ImageView.h"
+#include "Magnum/PixelFormat.h"
 #include "Magnum/DebugTools/CompareImage.h"
 #include "Magnum/GL/Framebuffer.h"
 #include "Magnum/GL/Mesh.h"
@@ -36,9 +39,9 @@
 #include "Magnum/GL/RenderbufferFormat.h"
 #include "Magnum/GL/Texture.h"
 #include "Magnum/GL/TextureFormat.h"
-#include "Magnum/Image.h"
-#include "Magnum/ImageView.h"
-#include "Magnum/PixelFormat.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix3.h"
+#include "Magnum/Math/Matrix4.h"
 #include "Magnum/MeshTools/Compile.h"
 #include "Magnum/Primitives/Plane.h"
 #include "Magnum/Primitives/Square.h"

src/Magnum/Shaders/Test/VertexColorGLTest.cpp

@@ -28,14 +28,17 @@
 #include <Corrade/Utility/Directory.h>
 
 #include "Magnum/DebugTools/CompareImage.h"
+#include "Magnum/Image.h"
+#include "Magnum/ImageView.h"
+#include "Magnum/PixelFormat.h"
 #include "Magnum/GL/OpenGLTester.h"
 #include "Magnum/GL/Framebuffer.h"
 #include "Magnum/GL/Mesh.h"
 #include "Magnum/GL/Renderbuffer.h"
 #include "Magnum/GL/RenderbufferFormat.h"
-#include "Magnum/Image.h"
-#include "Magnum/ImageView.h"
-#include "Magnum/PixelFormat.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix3.h"
+#include "Magnum/Math/Matrix4.h"
 #include "Magnum/MeshTools/Compile.h"
 #include "Magnum/Primitives/Circle.h"
 #include "Magnum/Primitives/UVSphere.h"

src/Magnum/Shaders/Vector.cpp

@@ -31,6 +31,9 @@
 #include "Magnum/GL/Context.h"
 #include "Magnum/GL/Extensions.h"
 #include "Magnum/GL/Shader.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix3.h"
+#include "Magnum/Math/Matrix4.h"
 
 #include "Magnum/Shaders/Implementation/CreateCompatibilityShader.h"
 
@@ -104,6 +107,21 @@ template<UnsignedInt dimensions> Vector<dimensions>::Vector() {
     #endif
 }
 
+template<UnsignedInt dimensions> Vector<dimensions>& Vector<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
+    GL::AbstractShaderProgram::setUniform(_transformationProjectionMatrixUniform, matrix);
+    return *this;
+}
+
+template<UnsignedInt dimensions> Vector<dimensions>& Vector<dimensions>::setBackgroundColor(const Color4& color) {
+    GL::AbstractShaderProgram::setUniform(_backgroundColorUniform, color);
+    return *this;
+}
+
+template<UnsignedInt dimensions> Vector<dimensions>& Vector<dimensions>::setColor(const Color4& color) {
+    GL::AbstractShaderProgram::setUniform(_colorUniform, color);
+    return *this;
+}
+
 template class Vector<2>;
 template class Vector<3>;
 

src/Magnum/Shaders/Vector.h

@@ -30,9 +30,6 @@
  */
 
 #include "Magnum/DimensionTraits.h"
-#include "Magnum/Math/Color.h"
-#include "Magnum/Math/Matrix3.h"
-#include "Magnum/Math/Matrix4.h"
 #include "Magnum/Shaders/AbstractVector.h"
 #include "Magnum/Shaders/visibility.h"
 
@@ -103,10 +100,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Vector: public Abst
          *
          * Default is an identity matrix.
          */
-        Vector<dimensions>& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
-            GL::AbstractShaderProgram::setUniform(_transformationProjectionMatrixUniform, matrix);
-            return *this;
-        }
+        Vector<dimensions>& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix);
 
         /**
          * @brief Set background color
@@ -115,10 +109,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Vector: public Abst
          * Default is @cpp 0x00000000_rgbaf @ce.
          * @see @ref setColor()
          */
-        Vector<dimensions>& setBackgroundColor(const Color4& color) {
-            GL::AbstractShaderProgram::setUniform(_backgroundColorUniform, color);
-            return *this;
-        }
+        Vector<dimensions>& setBackgroundColor(const Color4& color);
 
         /**
          * @brief Set fill color
@@ -127,10 +118,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Vector: public Abst
          * Default is @cpp 0xffffffff_rgbaf @ce.
          * @see @ref setBackgroundColor()
          */
-        Vector<dimensions>& setColor(const Color4& color) {
-            GL::AbstractShaderProgram::setUniform(_colorUniform, color);
-            return *this;
-        }
+        Vector<dimensions>& setColor(const Color4& color);
 
         #ifndef DOXYGEN_GENERATING_OUTPUT
         /* Overloads to remove WTF-factor from method chaining order */

src/Magnum/Shaders/VertexColor.cpp

@@ -31,6 +31,9 @@
 #include "Magnum/GL/Context.h"
 #include "Magnum/GL/Extensions.h"
 #include "Magnum/GL/Shader.h"
+#include "Magnum/Math/Color.h"
+#include "Magnum/Math/Matrix3.h"
+#include "Magnum/Math/Matrix4.h"
 
 #include "Magnum/Shaders/Implementation/CreateCompatibilityShader.h"
 
@@ -94,6 +97,11 @@ template<UnsignedInt dimensions> VertexColor<dimensions>::VertexColor() {
     #endif
 }
 
+template<UnsignedInt dimensions> VertexColor<dimensions>& VertexColor<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
+    setUniform(_transformationProjectionMatrixUniform, matrix);
+    return *this;
+}
+
 template class VertexColor<2>;
 template class VertexColor<3>;
 

src/Magnum/Shaders/VertexColor.h

@@ -31,9 +31,6 @@
 
 #include "Magnum/DimensionTraits.h"
 #include "Magnum/GL/AbstractShaderProgram.h"
-#include "Magnum/Math/Color.h"
-#include "Magnum/Math/Matrix3.h"
-#include "Magnum/Math/Matrix4.h"
 #include "Magnum/Shaders/Generic.h"
 #include "Magnum/Shaders/visibility.h"
 
@@ -143,10 +140,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColor: public
          *
          * Default is an identity matrix.
          */
-        VertexColor<dimensions>& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
-            setUniform(_transformationProjectionMatrixUniform, matrix);
-            return *this;
-        }
+        VertexColor<dimensions>& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix);
 
     private:
         Int _transformationProjectionMatrixUniform{0};