Use VectorTypeFor and MatrixTypeFor instead of DimensionTraits.

Much shorter lines. I like that.
12 years ago · 757ca6d1ad
71 changed files with 200 additions and 200 deletions
--- a/src/Magnum/BufferImage.cpp
+++ b/src/Magnum/BufferImage.cpp
@ -28,13 +28,13 @@
 namespace Magnum {

 #ifndef MAGNUM_TARGET_GLES2
-template<UnsignedInt dimensions> BufferImage<dimensions>::BufferImage(ColorFormat format, ColorType type, const typename DimensionTraits< Dimensions, Int >::VectorType& size, const void* data, BufferUsage usage): AbstractImage(format, type), _size(size), _buffer(Buffer::Target::PixelPack) {
+template<UnsignedInt dimensions> BufferImage<dimensions>::BufferImage(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size, const void* data, BufferUsage usage): AbstractImage(format, type), _size(size), _buffer(Buffer::Target::PixelPack) {
    _buffer.setData({data, dataSize(size)}, usage);
 }

 template<UnsignedInt dimensions> BufferImage<dimensions>::BufferImage(ColorFormat format, ColorType type): AbstractImage(format, type), _buffer(Buffer::Target::PixelPack) {}

-template<UnsignedInt dimensions> void BufferImage<dimensions>::setData(ColorFormat format, ColorType type, const typename DimensionTraits<Dimensions, Int>::VectorType& size, const void* data, BufferUsage usage) {
+template<UnsignedInt dimensions> void BufferImage<dimensions>::setData(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size, const void* data, BufferUsage usage) {
    _format = format;
    _type = type;
    _size = size;
--- a/src/Magnum/BufferImage.h
+++ b/src/Magnum/BufferImage.h
@ -64,7 +64,7 @@ template<UnsignedInt dimensions> class BufferImage: public AbstractImage {
         * @todo Make it more flexible (usable with
         *      @extension{ARB,buffer_storage}, avoiding relocations...)
         */
-        explicit BufferImage(ColorFormat format, ColorType type, const typename DimensionTraits<Dimensions, Int>::VectorType& size, const void* data, BufferUsage usage);
+        explicit BufferImage(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size, const void* data, BufferUsage usage);

        /**
         * @brief Constructor
@ -89,10 +89,10 @@ template<UnsignedInt dimensions> class BufferImage: public AbstractImage {
        BufferImage<dimensions>& operator=(BufferImage<dimensions>&& other) noexcept;

        /** @brief %Image size */
-        typename DimensionTraits<Dimensions, Int>::VectorType size() const { return _size; }
+        VectorTypeFor<Dimensions, Int> size() const { return _size; }

        /** @copydoc Image::dataSize() */
-        std::size_t dataSize(const typename DimensionTraits<Dimensions, Int>::VectorType& size) const {
+        std::size_t dataSize(const VectorTypeFor<dimensions, Int>& size) const {
            return AbstractImage::dataSize<dimensions>(size);
        }

@ -113,14 +113,14 @@ template<UnsignedInt dimensions> class BufferImage: public AbstractImage {
         * @todo Make it more flexible (usable with
         *      @extension{ARB,buffer_storage}, avoiding relocations...)
         */
-        void setData(ColorFormat format, ColorType type, const typename DimensionTraits<Dimensions, Int>::VectorType& size, const void* data, BufferUsage usage);
+        void setData(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size, const void* data, BufferUsage usage);

        #ifdef MAGNUM_BUILD_DEPRECATED
        /**
-         * @copybrief setData(ColorFormat, ColorType, const typename DimensionTraits<Dimensions, Int>::VectorType&, const void*, BufferUsage)
-         * @deprecated Use @ref Magnum::BufferImage::setData(ColorFormat, ColorType, const typename DimensionTraits<Dimensions, Int>::VectorType&, const void*, BufferUsage) "setData(ColorFormat, ColorType, const typename DimensionTraits<Dimensions, Int>::VectorType&, const void*, BufferUsage)" instead.
+         * @copybrief setData(ColorFormat, ColorType, const VectorTypeFor<dimensions, Int>&, const void*, BufferUsage)
+         * @deprecated Use @ref Magnum::BufferImage::setData(ColorFormat, ColorType, const VectorTypeFor<dimensions, Int>&, const void*, BufferUsage) "setData(ColorFormat, ColorType, const VectorTypeFor<dimensions, Int>&, const void*, BufferUsage)" instead.
         */
-        CORRADE_DEPRECATED("use setData(ColorFormat, ColorType, VectorNi, const void*, BufferUsage) instead") void setData(const typename DimensionTraits<Dimensions, Int>::VectorType& size, ColorFormat format, ColorType type, const void* data, BufferUsage usage) {
+        CORRADE_DEPRECATED("use setData(ColorFormat, ColorType, VectorNi, const void*, BufferUsage) instead") void setData(const VectorTypeFor<dimensions, Int>& size, ColorFormat format, ColorType type, const void* data, BufferUsage usage) {
            setData(format, type, size, data, usage);
        }
        #endif
--- a/src/Magnum/DebugTools/ForceRenderer.cpp
+++ b/src/Magnum/DebugTools/ForceRenderer.cpp
@ -56,7 +56,7 @@ constexpr std::array<UnsignedByte, 6> indices{{

 }

-template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneGraph::AbstractObject<dimensions, Float>& object, const typename DimensionTraits<dimensions, Float>::VectorType& forcePosition, const typename DimensionTraits<dimensions, Float>::VectorType& force, ResourceKey options, SceneGraph::DrawableGroup<dimensions, Float>* drawables): SceneGraph::Drawable<dimensions, Float>(object, drawables), forcePosition(forcePosition), force(force), options(ResourceManager::instance().get<ForceRendererOptions>(options)) {
+template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneGraph::AbstractObject<dimensions, Float>& object, const VectorTypeFor<dimensions, Float>& forcePosition, const VectorTypeFor<dimensions, Float>& force, ResourceKey options, SceneGraph::DrawableGroup<dimensions, Float>* drawables): SceneGraph::Drawable<dimensions, Float>(object, drawables), forcePosition(forcePosition), force(force), options(ResourceManager::instance().get<ForceRendererOptions>(options)) {
    /* Shader */
    shader = ResourceManager::instance().get<AbstractShaderProgram, Shaders::Flat<dimensions>>(shaderKey<dimensions>());
    if(!shader) ResourceManager::instance().set<AbstractShaderProgram>(shader.key(), new Shaders::Flat<dimensions>);
@ -86,8 +86,8 @@ template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneG
    ResourceManager::instance().set(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
 }

-template<UnsignedInt dimensions> void ForceRenderer<dimensions>::draw(const typename DimensionTraits<dimensions, Float>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) {
-    shader->setTransformationProjectionMatrix(camera.projectionMatrix()*Implementation::forceRendererTransformation<dimensions>(transformationMatrix.transformPoint(forcePosition), force)*DimensionTraits<dimensions, Float>::MatrixType::scaling(typename DimensionTraits<dimensions, Float>::VectorType(options->scale())))
+template<UnsignedInt dimensions> void ForceRenderer<dimensions>::draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) {
+    shader->setTransformationProjectionMatrix(camera.projectionMatrix()*Implementation::forceRendererTransformation<dimensions>(transformationMatrix.transformPoint(forcePosition), force)*MatrixTypeFor<dimensions, Float>::scaling(VectorTypeFor<dimensions, Float>{options->scale()}))
        .setColor(options->color());
    mesh->draw(*shader);
 }
--- a/src/Magnum/DebugTools/ForceRenderer.h
+++ b/src/Magnum/DebugTools/ForceRenderer.h
@ -117,16 +117,16 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ForceRenderer: p
         * saved as reference to original vector and thus it must be available
         * for the whole lifetime of the renderer.
         */
-        explicit ForceRenderer(SceneGraph::AbstractObject<dimensions, Float>& object, const typename DimensionTraits<dimensions, Float>::VectorType& forcePosition, const typename DimensionTraits<dimensions, Float>::VectorType& force, ResourceKey options = ResourceKey(), SceneGraph::DrawableGroup<dimensions, Float>* drawables = nullptr);
+        explicit ForceRenderer(SceneGraph::AbstractObject<dimensions, Float>& object, const VectorTypeFor<dimensions, Float>& forcePosition, const VectorTypeFor<dimensions, Float>& force, ResourceKey options = ResourceKey(), SceneGraph::DrawableGroup<dimensions, Float>* drawables = nullptr);

        /** @overload */
-        ForceRenderer(SceneGraph::AbstractObject<dimensions, Float>&, const typename DimensionTraits<dimensions, Float>::VectorType&, typename DimensionTraits<dimensions, Float>::VectorType&&, ResourceKey = ResourceKey(), SceneGraph::DrawableGroup<dimensions, Float>* = nullptr) = delete;
+        ForceRenderer(SceneGraph::AbstractObject<dimensions, Float>&, const VectorTypeFor<dimensions, Float>&, VectorTypeFor<dimensions, Float>&&, ResourceKey = ResourceKey(), SceneGraph::DrawableGroup<dimensions, Float>* = nullptr) = delete;

    private:
-        void draw(const typename DimensionTraits<dimensions, Float>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) override;
+        void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) override;

-        const typename DimensionTraits<dimensions, Float>::VectorType forcePosition;
-        const typename DimensionTraits<dimensions, Float>::VectorType& force;
+        const VectorTypeFor<dimensions, Float> forcePosition;
+        const VectorTypeFor<dimensions, Float>& force;

        Resource<ForceRendererOptions> options;
        Resource<AbstractShaderProgram, Shaders::Flat<dimensions>> shader;
--- a/src/Magnum/DebugTools/Implementation/AbstractShapeRenderer.h
+++ b/src/Magnum/DebugTools/Implementation/AbstractShapeRenderer.h
@ -50,7 +50,7 @@ template<UnsignedInt dimensions> class AbstractShapeRenderer {
        AbstractShapeRenderer(ResourceKey mesh, ResourceKey vertexBuffer, ResourceKey indexBuffer);
        virtual ~AbstractShapeRenderer();

-        virtual void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) = 0;
+        virtual void draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) = 0;

    protected:
        /* Call only if the mesh resource isn't already present */
--- a/src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp
+++ b/src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp
@ -34,10 +34,10 @@ namespace Magnum { namespace DebugTools { namespace Implementation {

 template<UnsignedInt dimensions> AxisAlignedBoxRenderer<dimensions>::AxisAlignedBoxRenderer(const Shapes::Implementation::AbstractShape<dimensions>& axisAlignedBox): axisAlignedBox(static_cast<const Shapes::Implementation::Shape<Shapes::AxisAlignedBox<dimensions>>&>(axisAlignedBox).shape) {}

-template<UnsignedInt dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
+template<UnsignedInt dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) {
    AbstractBoxRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
-        DimensionTraits<dimensions, Float>::MatrixType::translation((axisAlignedBox.min()+axisAlignedBox.max())/2)*
-        DimensionTraits<dimensions, Float>::MatrixType::scaling(axisAlignedBox.max()-axisAlignedBox.min()))
+        MatrixTypeFor<dimensions, Float>::translation((axisAlignedBox.min()+axisAlignedBox.max())/2)*
+        MatrixTypeFor<dimensions, Float>::scaling(axisAlignedBox.max()-axisAlignedBox.min()))
        .setColor(options->color());
    AbstractBoxRenderer<dimensions>::wireframeMesh->draw(*AbstractBoxRenderer<dimensions>::wireframeShader);
 }
--- a/src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.h
+++ b/src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.h
@ -36,7 +36,7 @@ template<UnsignedInt dimensions> class AxisAlignedBoxRenderer: public AbstractBo
        explicit AxisAlignedBoxRenderer(const Shapes::Implementation::AbstractShape<dimensions>& axisAlignedBox);
        AxisAlignedBoxRenderer(Shapes::Implementation::AbstractShape<dimensions>&&) = delete;

-        void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) override;
+        void draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) override;

    private:
        const Shapes::AxisAlignedBox<dimensions>& axisAlignedBox;
--- a/src/Magnum/DebugTools/Implementation/BoxRenderer.cpp
+++ b/src/Magnum/DebugTools/Implementation/BoxRenderer.cpp
@ -34,7 +34,7 @@ namespace Magnum { namespace DebugTools { namespace Implementation {

 template<UnsignedInt dimensions> BoxRenderer<dimensions>::BoxRenderer(const Shapes::Implementation::AbstractShape<dimensions>& box): box(static_cast<const Shapes::Implementation::Shape<Shapes::Box<dimensions>>&>(box).shape) {}

-template<UnsignedInt dimensions> void BoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
+template<UnsignedInt dimensions> void BoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) {
    AbstractBoxRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*box.transformation())
        .setColor(options->color());
    AbstractBoxRenderer<dimensions>::wireframeMesh->draw(*AbstractBoxRenderer<dimensions>::wireframeShader);
--- a/src/Magnum/DebugTools/Implementation/BoxRenderer.h
+++ b/src/Magnum/DebugTools/Implementation/BoxRenderer.h
@ -36,7 +36,7 @@ template<UnsignedInt dimensions> class BoxRenderer: public AbstractBoxRenderer<d
        explicit BoxRenderer(const Shapes::Implementation::AbstractShape<dimensions>& box);
        BoxRenderer(const Shapes::Implementation::AbstractShape<dimensions>&&) = delete;

-        void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) override;
+        void draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) override;

    private:
        const Shapes::Box<dimensions>& box;
--- a/src/Magnum/DebugTools/Implementation/CapsuleRenderer.cpp
+++ b/src/Magnum/DebugTools/Implementation/CapsuleRenderer.cpp
@ -104,8 +104,8 @@ AbstractCapsuleRenderer<3>::~AbstractCapsuleRenderer() = default;

 template<UnsignedInt dimensions> CapsuleRenderer<dimensions>::CapsuleRenderer(const Shapes::Implementation::AbstractShape<dimensions>& capsule): capsule(static_cast<const Shapes::Implementation::Shape<Shapes::Capsule<dimensions>>&>(capsule).shape) {}

-template<UnsignedInt dimensions> void CapsuleRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
-    std::array<typename DimensionTraits<dimensions, Float>::MatrixType, 3> transformations = Implementation::capsuleRendererTransformation<dimensions>(capsule.a(), capsule.b(), capsule.radius());
+template<UnsignedInt dimensions> void CapsuleRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) {
+    std::array<MatrixTypeFor<dimensions, Float>, 3> transformations = Implementation::capsuleRendererTransformation<dimensions>(capsule.a(), capsule.b(), capsule.radius());
    AbstractShapeRenderer<dimensions>::wireframeShader->setColor(options->color());

    /* Bottom */
--- a/src/Magnum/DebugTools/Implementation/CapsuleRenderer.h
+++ b/src/Magnum/DebugTools/Implementation/CapsuleRenderer.h
@ -56,7 +56,7 @@ template<UnsignedInt dimensions> class CapsuleRenderer: public AbstractCapsuleRe
        explicit CapsuleRenderer(const Shapes::Implementation::AbstractShape<dimensions>& capsule);
        CapsuleRenderer(const Shapes::Implementation::AbstractShape<dimensions>&&) = delete;

-        void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) override;
+        void draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) override;

    private:
        const Shapes::Capsule<dimensions>& capsule;
--- a/src/Magnum/DebugTools/Implementation/CapsuleRendererTransformation.h
+++ b/src/Magnum/DebugTools/Implementation/CapsuleRendererTransformation.h
@ -35,7 +35,7 @@

 namespace Magnum { namespace DebugTools { namespace Implementation {

-template<UnsignedInt dimensions> std::array<typename DimensionTraits<dimensions, Float>::MatrixType, 3> capsuleRendererTransformation(const typename DimensionTraits<dimensions, Float>::VectorType& a, const typename DimensionTraits<dimensions, Float>::VectorType& b, Float radius);
+template<UnsignedInt dimensions> std::array<MatrixTypeFor<dimensions, Float>, 3> capsuleRendererTransformation(const VectorTypeFor<dimensions, Float>& a, const VectorTypeFor<dimensions, Float>& b, Float radius);

 template<> std::array<Matrix3, 3> capsuleRendererTransformation<2>(const Vector2& a, const Vector2& b, const Float radius) {
    /* Vector from capsule center to top hemisphere center */
--- a/src/Magnum/DebugTools/Implementation/CylinderRenderer.cpp
+++ b/src/Magnum/DebugTools/Implementation/CylinderRenderer.cpp
@ -48,7 +48,7 @@ AbstractCylinderRenderer<3>::AbstractCylinderRenderer(): AbstractShapeRenderer<3

 template<UnsignedInt dimensions> CylinderRenderer<dimensions>::CylinderRenderer(const Shapes::Implementation::AbstractShape<dimensions>& cylinder): cylinder(static_cast<const Shapes::Implementation::Shape<Shapes::Cylinder<dimensions>>&>(cylinder).shape) {}

-template<UnsignedInt dimensions> void CylinderRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
+template<UnsignedInt dimensions> void CylinderRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) {
    AbstractShapeRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
        Implementation::cylinderRendererTransformation<dimensions>(cylinder.a(), cylinder.b(), cylinder.radius()))
        .setColor(options->color());
--- a/src/Magnum/DebugTools/Implementation/CylinderRenderer.h
+++ b/src/Magnum/DebugTools/Implementation/CylinderRenderer.h
@ -48,7 +48,7 @@ template<UnsignedInt dimensions> class CylinderRenderer: public AbstractCylinder
        explicit CylinderRenderer(const Shapes::Implementation::AbstractShape<dimensions>& cylinder);
        CylinderRenderer(const Shapes::Implementation::AbstractShape<dimensions>&&) = delete;

-        void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) override;
+        void draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) override;

    private:
        const Shapes::Cylinder<dimensions>& cylinder;
--- a/src/Magnum/DebugTools/Implementation/CylinderRendererTransformation.h
+++ b/src/Magnum/DebugTools/Implementation/CylinderRendererTransformation.h
@ -33,7 +33,7 @@

 namespace Magnum { namespace DebugTools { namespace Implementation {

-template<UnsignedInt dimensions> typename DimensionTraits<dimensions, Float>::MatrixType cylinderRendererTransformation(const typename DimensionTraits<dimensions, Float>::VectorType& a, const typename DimensionTraits<dimensions, Float>::VectorType& b, Float radius);
+template<UnsignedInt dimensions> MatrixTypeFor<dimensions, Float> cylinderRendererTransformation(const VectorTypeFor<dimensions, Float>& a, const VectorTypeFor<dimensions, Float>& b, Float radius);

 template<> Matrix3 cylinderRendererTransformation<2>(const Vector2& a, const Vector2& b, const Float radius) {
    /* Vector from cylinder center to top hemisphere center */
--- a/src/Magnum/DebugTools/Implementation/ForceRendererTransformation.h
+++ b/src/Magnum/DebugTools/Implementation/ForceRendererTransformation.h
@ -33,7 +33,7 @@

 namespace Magnum { namespace DebugTools { namespace Implementation {

-template<UnsignedInt dimensions> typename DimensionTraits<dimensions, Float>::MatrixType forceRendererTransformation(const typename DimensionTraits<dimensions, Float>::VectorType& forcePosition, const typename DimensionTraits<dimensions, Float>::VectorType& force);
+template<UnsignedInt dimensions> MatrixTypeFor<dimensions, Float> forceRendererTransformation(const VectorTypeFor<dimensions, Float>& forcePosition, const VectorTypeFor<dimensions, Float>& force);

 template<> inline Matrix3 forceRendererTransformation<2>(const Vector2& forcePosition, const Vector2& force) {
    return Matrix3::from({force, force.perpendicular()}, forcePosition);
--- a/src/Magnum/DebugTools/Implementation/LineSegmentRenderer.cpp
+++ b/src/Magnum/DebugTools/Implementation/LineSegmentRenderer.cpp
@ -55,7 +55,7 @@ template<UnsignedInt dimensions> LineSegmentRenderer<dimensions>::LineSegmentRen
    if(!AbstractShapeRenderer<dimensions>::wireframeMesh) AbstractShapeRenderer<dimensions>::createResources(meshData<dimensions>());
 }

-template<UnsignedInt dimensions> void LineSegmentRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
+template<UnsignedInt dimensions> void LineSegmentRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) {
    AbstractShapeRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
        Implementation::lineSegmentRendererTransformation<dimensions>(line.a(), line.b()))
        .setColor(options->color());
--- a/src/Magnum/DebugTools/Implementation/LineSegmentRenderer.h
+++ b/src/Magnum/DebugTools/Implementation/LineSegmentRenderer.h
@ -36,7 +36,7 @@ template<UnsignedInt dimensions> class LineSegmentRenderer: public AbstractShape
        explicit LineSegmentRenderer(const Shapes::Implementation::AbstractShape<dimensions>& line);
        LineSegmentRenderer(const Shapes::Implementation::AbstractShape<dimensions>&&) = delete;

-        void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) override;
+        void draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) override;

    private:
        const Shapes::LineSegment<dimensions>& line;
--- a/src/Magnum/DebugTools/Implementation/LineSegmentRendererTransformation.h
+++ b/src/Magnum/DebugTools/Implementation/LineSegmentRendererTransformation.h
@ -29,8 +29,8 @@

 namespace Magnum { namespace DebugTools { namespace Implementation {

-template<UnsignedInt dimensions> typename DimensionTraits<dimensions, Float>::MatrixType lineSegmentRendererTransformation(const typename DimensionTraits<dimensions, Float>::VectorType& a, const typename DimensionTraits<dimensions, Float>::VectorType& b) {
-    auto transformation = DimensionTraits<dimensions, Float>::MatrixType::translation(a);
+template<UnsignedInt dimensions> MatrixTypeFor<dimensions, Float> lineSegmentRendererTransformation(const VectorTypeFor<dimensions, Float>& a, const VectorTypeFor<dimensions, Float>& b) {
+    auto transformation = MatrixTypeFor<dimensions, Float>::translation(a);
    transformation.right() = b - a;
    return transformation;
 }
--- a/src/Magnum/DebugTools/Implementation/PointRenderer.cpp
+++ b/src/Magnum/DebugTools/Implementation/PointRenderer.cpp
@ -53,11 +53,11 @@ template<UnsignedInt dimensions> PointRenderer<dimensions>::PointRenderer(const
    if(!AbstractShapeRenderer<dimensions>::wireframeMesh) AbstractShapeRenderer<dimensions>::createResources(meshData<dimensions>());
 }

-template<UnsignedInt dimensions> void PointRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
+template<UnsignedInt dimensions> void PointRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) {
    /* Half scale, because the point is 2x2(x2) */
    AbstractShapeRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
-        DimensionTraits<dimensions, Float>::MatrixType::translation(point.position())*
-        DimensionTraits<dimensions, Float>::MatrixType::scaling(typename DimensionTraits<dimensions, Float>::VectorType(options->pointSize()/2)))
+        MatrixTypeFor<dimensions, Float>::translation(point.position())*
+        MatrixTypeFor<dimensions, Float>::scaling(VectorTypeFor<dimensions, Float>{options->pointSize()/2}))
        .setColor(options->color());
    AbstractShapeRenderer<dimensions>::wireframeMesh->draw(*AbstractShapeRenderer<dimensions>::wireframeShader);
 }
--- a/src/Magnum/DebugTools/Implementation/PointRenderer.h
+++ b/src/Magnum/DebugTools/Implementation/PointRenderer.h
@ -36,7 +36,7 @@ template<UnsignedInt dimensions> class PointRenderer: public AbstractShapeRender
        explicit PointRenderer(const Shapes::Implementation::AbstractShape<dimensions>& point);
        PointRenderer(Shapes::Implementation::AbstractShape<dimensions>&&) = delete;

-        void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) override;
+        void draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) override;

    private:
        const Shapes::Point<dimensions>& point;
--- a/src/Magnum/DebugTools/Implementation/SphereRenderer.cpp
+++ b/src/Magnum/DebugTools/Implementation/SphereRenderer.cpp
@ -46,10 +46,10 @@ AbstractSphereRenderer<3>::AbstractSphereRenderer(): AbstractShapeRenderer<3>("s

 template<UnsignedInt dimensions> SphereRenderer<dimensions>::SphereRenderer(const Shapes::Implementation::AbstractShape<dimensions>& sphere): sphere(static_cast<const Shapes::Implementation::Shape<Shapes::Sphere<dimensions>>&>(sphere).shape) {}

-template<UnsignedInt dimensions> void SphereRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
+template<UnsignedInt dimensions> void SphereRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) {
    AbstractShapeRenderer<dimensions>::wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
-        DimensionTraits<dimensions, Float>::MatrixType::translation(sphere.position())*
-        DimensionTraits<dimensions, Float>::MatrixType::scaling(typename DimensionTraits<dimensions, Float>::VectorType(sphere.radius())))
+        MatrixTypeFor<dimensions, Float>::translation(sphere.position())*
+        MatrixTypeFor<dimensions, Float>::scaling(VectorTypeFor<dimensions, Float>{sphere.radius()}))
        .setColor(options->color());
    AbstractShapeRenderer<dimensions>::wireframeMesh->draw(*AbstractShapeRenderer<dimensions>::wireframeShader);
 }
--- a/src/Magnum/DebugTools/Implementation/SphereRenderer.h
+++ b/src/Magnum/DebugTools/Implementation/SphereRenderer.h
@ -48,7 +48,7 @@ template<UnsignedInt dimensions> class SphereRenderer: public AbstractSphereRend
        explicit SphereRenderer(const Shapes::Implementation::AbstractShape<dimensions>& sphere);
        SphereRenderer(const Shapes::Implementation::AbstractShape<dimensions>&&) = delete;

-        void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) override;
+        void draw(Resource<ShapeRendererOptions>& options, const MatrixTypeFor<dimensions, Float>& projectionMatrix) override;

    private:
        const Shapes::Sphere<dimensions>& sphere;
--- a/src/Magnum/DebugTools/ObjectRenderer.cpp
+++ b/src/Magnum/DebugTools/ObjectRenderer.cpp
@ -175,8 +175,8 @@ template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(Scen
    ResourceManager::instance().set<Mesh>(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
 }

-template<UnsignedInt dimensions> void ObjectRenderer<dimensions>::draw(const typename DimensionTraits<dimensions, Float>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) {
-    shader->setTransformationProjectionMatrix(camera.projectionMatrix()*transformationMatrix*DimensionTraits<dimensions, Float>::MatrixType::scaling(typename DimensionTraits<dimensions, Float>::VectorType(options->size())));
+template<UnsignedInt dimensions> void ObjectRenderer<dimensions>::draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) {
+    shader->setTransformationProjectionMatrix(camera.projectionMatrix()*transformationMatrix*MatrixTypeFor<dimensions, Float>::scaling(VectorTypeFor<dimensions, Float>{options->size()}));
    mesh->draw(*shader);
 }

--- a/src/Magnum/DebugTools/ObjectRenderer.h
+++ b/src/Magnum/DebugTools/ObjectRenderer.h
@ -98,7 +98,7 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer:
        explicit ObjectRenderer(SceneGraph::AbstractObject<dimensions, Float>& object, ResourceKey options = ResourceKey(), SceneGraph::DrawableGroup<dimensions, Float>* drawables = nullptr);

    private:
-        void draw(const typename DimensionTraits<dimensions, Float>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) override;
+        void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) override;

        Resource<ObjectRendererOptions> options;
        Resource<AbstractShaderProgram, Shaders::VertexColor<dimensions>> shader;
--- a/src/Magnum/DebugTools/ShapeRenderer.cpp
+++ b/src/Magnum/DebugTools/ShapeRenderer.cpp
@ -122,8 +122,8 @@ template<UnsignedInt dimensions> ShapeRenderer<dimensions>::~ShapeRenderer() {
    for(auto i: renderers) delete i;
 }

-template<UnsignedInt dimensions> void ShapeRenderer<dimensions>::draw(const typename DimensionTraits<dimensions, Float>::MatrixType&, SceneGraph::AbstractCamera<dimensions, Float>& camera) {
-    typename DimensionTraits<dimensions, Float>::MatrixType projectionMatrix = camera.projectionMatrix()*camera.cameraMatrix();
+template<UnsignedInt dimensions> void ShapeRenderer<dimensions>::draw(const MatrixTypeFor<dimensions, Float>&, SceneGraph::AbstractCamera<dimensions, Float>& camera) {
+    const MatrixTypeFor<dimensions, Float> projectionMatrix = camera.projectionMatrix()*camera.cameraMatrix();
    for(auto i: renderers) i->draw(options, projectionMatrix);
 }

--- a/src/Magnum/DebugTools/ShapeRenderer.h
+++ b/src/Magnum/DebugTools/ShapeRenderer.h
@ -160,7 +160,7 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: p
        ~ShapeRenderer();

    private:
-        void draw(const typename DimensionTraits<dimensions, Float>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) override;
+        void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>& camera) override;

        Resource<ShapeRendererOptions> options;
        std::vector<Implementation::AbstractShapeRenderer<dimensions>*> renderers;
--- a/src/Magnum/Image.cpp
+++ b/src/Magnum/Image.cpp
@ -27,7 +27,7 @@

 namespace Magnum {

-template<UnsignedInt dimensions> void Image<dimensions>::setData(ColorFormat format, ColorType type, const typename DimensionTraits<Dimensions, Int>::VectorType& size, void* data) {
+template<UnsignedInt dimensions> void Image<dimensions>::setData(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size, void* data) {
    delete[] _data;
    _format = format;
    _type = type;
--- a/src/Magnum/Image.h
+++ b/src/Magnum/Image.h
@ -54,7 +54,7 @@ template<UnsignedInt dimensions> class Image: public AbstractImage {
         * Note that the image data are not copied on construction, but they
         * are deleted on class destruction.
         */
-        explicit Image(ColorFormat format, ColorType type, const typename DimensionTraits<Dimensions, Int>::VectorType& size, void* data): AbstractImage(format, type), _size(size), _data(reinterpret_cast<unsigned char*>(data)) {}
+        explicit Image(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size, void* data): AbstractImage(format, type), _size(size), _data(reinterpret_cast<unsigned char*>(data)) {}

        /**
         * @brief Constructor
@ -95,7 +95,7 @@ template<UnsignedInt dimensions> class Image: public AbstractImage {
        #endif

        /** @brief %Image size */
-        typename DimensionTraits<Dimensions, Int>::VectorType size() const { return _size; }
+        VectorTypeFor<dimensions, Int> size() const { return _size; }

        /**
         * @brief Size of data required to store image of given size
@ -104,7 +104,7 @@ template<UnsignedInt dimensions> class Image: public AbstractImage {
         * account.
         * @see @ref pixelSize()
         */
-        std::size_t dataSize(const typename DimensionTraits<Dimensions, Int>::VectorType& size) const {
+        std::size_t dataSize(const VectorTypeFor<dimensions, Int>& size) const {
            return AbstractImage::dataSize<dimensions>(size);
        }

@ -133,7 +133,7 @@ template<UnsignedInt dimensions> class Image: public AbstractImage {
         * data are not copied, but they are deleted on destruction.
         * @see @ref release()
         */
-        void setData(ColorFormat format, ColorType type, const typename DimensionTraits<Dimensions, Int>::VectorType& size, void* data);
+        void setData(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size, void* data);

        /**
         * @brief Release data storage
--- a/src/Magnum/ImageReference.h
+++ b/src/Magnum/ImageReference.h
@ -61,7 +61,7 @@ template<UnsignedInt dimensions> class ImageReference: public AbstractImage {
         * @param size              %Image size
         * @param data              %Image data
         */
-        constexpr explicit ImageReference(ColorFormat format, ColorType type, const typename DimensionTraits<Dimensions, Int>::VectorType& size, const void* data): AbstractImage(format, type), _size(size), _data(reinterpret_cast<const unsigned char*>(data)) {}
+        constexpr explicit ImageReference(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size, const void* data): AbstractImage(format, type), _size(size), _data(reinterpret_cast<const unsigned char*>(data)) {}

        /**
         * @brief Constructor
@ -72,13 +72,13 @@ template<UnsignedInt dimensions> class ImageReference: public AbstractImage {
         * Data pointer is set to `nullptr`, call @ref setData() to fill the
         * image with data.
         */
-        constexpr explicit ImageReference(ColorFormat format, ColorType type, const typename DimensionTraits<Dimensions, Int>::VectorType& size): AbstractImage(format, type), _size(size), _data(nullptr) {}
+        constexpr explicit ImageReference(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size): AbstractImage(format, type), _size(size), _data(nullptr) {}

        /** @brief %Image size */
-        constexpr typename DimensionTraits<Dimensions, Int>::VectorType size() const { return _size; }
+        constexpr VectorTypeFor<dimensions, Int> size() const { return _size; }

        /** @copydoc Image::dataSize() */
-        std::size_t dataSize(const typename DimensionTraits<Dimensions, Int>::VectorType& size) const {
+        std::size_t dataSize(const VectorTypeFor<dimensions, Int>& size) const {
            return AbstractImage::dataSize<dimensions>(size);
        }

--- a/src/Magnum/MultisampleTexture.h
+++ b/src/Magnum/MultisampleTexture.h
@ -43,7 +43,7 @@ namespace Implementation {
    template<> inline constexpr GLenum multisampleTextureTarget<2>() { return GL_TEXTURE_2D_MULTISAMPLE; }
    template<> inline constexpr GLenum multisampleTextureTarget<3>() { return GL_TEXTURE_2D_MULTISAMPLE_ARRAY; }

-    template<UnsignedInt dimensions> typename DimensionTraits<dimensions, Int>::VectorType maxMultisampleTextureSize();
+    template<UnsignedInt dimensions> VectorTypeFor<dimensions, Int> maxMultisampleTextureSize();
    template<> MAGNUM_EXPORT Vector2i maxMultisampleTextureSize<2>();
    template<> MAGNUM_EXPORT Vector3i maxMultisampleTextureSize<3>();
 }
@ -98,7 +98,7 @@ template<UnsignedInt dimensions> class MultisampleTexture: public AbstractTextur
         * @see @fn_gl{Get} with @def_gl{MAX_TEXTURE_SIZE} and
         *      @def_gl{MAX_3D_TEXTURE_SIZE}
         */
-        static typename DimensionTraits<dimensions, Int>::VectorType maxSize() {
+        static VectorTypeFor<dimensions, Int> maxSize() {
            return Implementation::maxMultisampleTextureSize<dimensions>();
        }

@ -122,7 +122,7 @@ template<UnsignedInt dimensions> class MultisampleTexture: public AbstractTextur
         *      with @def_gl{TEXTURE_WIDTH}, @def_gl{TEXTURE_HEIGHT} or
         *      @def_gl{TEXTURE_DEPTH}
         */
-        typename DimensionTraits<dimensions, Int>::VectorType imageSize() {
+        VectorTypeFor<dimensions, Int> imageSize() {
            return DataHelper<dimensions>::imageSize(*this, _target, 0);
        }

@ -155,7 +155,7 @@ template<UnsignedInt dimensions> class MultisampleTexture: public AbstractTextur
        /* The default parameter value was chosen based on discussion in
           ARB_texture_multisample specs (fixed locations is treated as the
           special case) */
-        MultisampleTexture<dimensions>& setStorage(Int samples, TextureFormat internalFormat, const typename DimensionTraits<dimensions, Int>::VectorType& size, MultisampleTextureSampleLocations sampleLocations =
+        MultisampleTexture<dimensions>& setStorage(Int samples, TextureFormat internalFormat, const VectorTypeFor<dimensions, Int>& size, MultisampleTextureSampleLocations sampleLocations =
            #ifndef DOXYGEN_GENERATING_OUTPUT
            MultisampleTextureSampleLocations::NotFixed
            #else
@ -170,7 +170,7 @@ template<UnsignedInt dimensions> class MultisampleTexture: public AbstractTextur
        void invalidateImage() { AbstractTexture::invalidateImage(0); }

        /** @copydoc RectangleTexture::invalidateSubImage() */
-        void invalidateSubImage(const typename DimensionTraits<dimensions, Int>::VectorType& offset, const typename DimensionTraits<dimensions, Int>::VectorType& size) {
+        void invalidateSubImage(const VectorTypeFor<dimensions, Int>& offset, const VectorTypeFor<dimensions, Int>& size) {
            DataHelper<dimensions>::invalidateSubImage(*this, 0, offset, size);
        }

--- a/src/Magnum/SceneGraph/AbstractCamera.h
+++ b/src/Magnum/SceneGraph/AbstractCamera.h
@ -48,7 +48,7 @@ enum class AspectRatioPolicy: UnsignedByte {
 };

 namespace Implementation {
-    template<UnsignedInt dimensions, class T> typename DimensionTraits<dimensions, T>::MatrixType aspectRatioFix(AspectRatioPolicy aspectRatioPolicy, const Math::Vector2<T>& projectionScale, const Vector2i& viewport);
+    template<UnsignedInt dimensions, class T> MatrixTypeFor<dimensions, T> aspectRatioFix(AspectRatioPolicy aspectRatioPolicy, const Math::Vector2<T>& projectionScale, const Vector2i& viewport);
 }

 /**
@ -90,7 +90,7 @@ template<UnsignedInt dimensions, class T> class AbstractCamera: public AbstractF
         * Camera matrix describes world position relative to the camera and is
         * applied as first.
         */
-        typename DimensionTraits<dimensions, T>::MatrixType cameraMatrix() {
+        MatrixTypeFor<dimensions, T> cameraMatrix() {
            AbstractFeature<dimensions, T>::object().setClean();
            return _cameraMatrix;
        }
@ -102,7 +102,7 @@ template<UnsignedInt dimensions, class T> class AbstractCamera: public AbstractF
         * as last.
         * @see @ref projectionSize()
         */
-        typename DimensionTraits<dimensions, T>::MatrixType projectionMatrix() const { return _projectionMatrix; }
+        MatrixTypeFor<dimensions, T> projectionMatrix() const { return _projectionMatrix; }

        /**
         * @brief Size of (near) XY plane in current projection
@ -143,7 +143,7 @@ template<UnsignedInt dimensions, class T> class AbstractCamera: public AbstractF
        ~AbstractCamera();

        /** Recalculates camera matrix */
-        void cleanInverted(const typename DimensionTraits<dimensions, T>::MatrixType& invertedAbsoluteTransformationMatrix) override {
+        void cleanInverted(const MatrixTypeFor<dimensions, T>& invertedAbsoluteTransformationMatrix) override {
            _cameraMatrix = invertedAbsoluteTransformationMatrix;
        }

@ -152,13 +152,13 @@ template<UnsignedInt dimensions, class T> class AbstractCamera: public AbstractF
            _projectionMatrix = Implementation::aspectRatioFix<dimensions, T>(_aspectRatioPolicy, {rawProjectionMatrix[0].x(), rawProjectionMatrix[1].y()}, _viewport)*rawProjectionMatrix;
        }

-        typename DimensionTraits<dimensions, T>::MatrixType rawProjectionMatrix;
+        MatrixTypeFor<dimensions, T> rawProjectionMatrix;
        AspectRatioPolicy _aspectRatioPolicy;
        #endif

    private:
-        typename DimensionTraits<dimensions, T>::MatrixType _projectionMatrix;
-        typename DimensionTraits<dimensions, T>::MatrixType _cameraMatrix;
+        MatrixTypeFor<dimensions, T> _projectionMatrix;
+        MatrixTypeFor<dimensions, T> _cameraMatrix;

        Vector2i _viewport;
 };
--- a/src/Magnum/SceneGraph/AbstractCamera.hpp
+++ b/src/Magnum/SceneGraph/AbstractCamera.hpp
@ -51,7 +51,7 @@ template<class T> class Camera<3, T> {
        }
 };

-template<UnsignedInt dimensions, class T> typename DimensionTraits<dimensions, T>::MatrixType aspectRatioFix(AspectRatioPolicy aspectRatioPolicy, const Math::Vector2<T>& projectionScale, const Vector2i& viewport) {
+template<UnsignedInt dimensions, class T> MatrixTypeFor<dimensions, T> aspectRatioFix(AspectRatioPolicy aspectRatioPolicy, const Math::Vector2<T>& projectionScale, const Vector2i& viewport) {
    /* Don't divide by zero / don't preserve anything */
    if(projectionScale.x() == 0 || projectionScale.y() == 0 || viewport.x() == 0 || viewport.y() == 0 || aspectRatioPolicy == AspectRatioPolicy::NotPreserved)
        return {};
@ -97,7 +97,7 @@ template<UnsignedInt dimensions, class T> void AbstractCamera<dimensions, T>::dr
    objects.reserve(group.size());
    for(std::size_t i = 0; i != group.size(); ++i)
        objects.push_back(group[i].object());
-    std::vector<typename DimensionTraits<dimensions, T>::MatrixType> transformations =
+    std::vector<MatrixTypeFor<dimensions, T>> transformations =
        scene->transformationMatrices(objects, _cameraMatrix);

    /* Perform the drawing */
--- a/src/Magnum/SceneGraph/AbstractFeature.h
+++ b/src/Magnum/SceneGraph/AbstractFeature.h
@ -270,7 +270,7 @@ template<UnsignedInt dimensions, class T> class AbstractFeature
         * Default implementation does nothing.
         * @see @ref scenegraph-caching, @ref cleanInverted()
         */
-        virtual void clean(const typename DimensionTraits<dimensions, T>::MatrixType& absoluteTransformationMatrix);
+        virtual void clean(const MatrixTypeFor<dimensions, T>& absoluteTransformationMatrix);

        /**
         * @brief Clean data based on inverted absolute transformation
@ -283,7 +283,7 @@ template<UnsignedInt dimensions, class T> class AbstractFeature
         * Default implementation does nothing.
         * @see @ref scenegraph-caching, @ref clean()
         */
-        virtual void cleanInverted(const typename DimensionTraits<dimensions, T>::MatrixType& invertedAbsoluteTransformationMatrix);
+        virtual void cleanInverted(const MatrixTypeFor<dimensions, T>& invertedAbsoluteTransformationMatrix);

        /*@}*/

--- a/src/Magnum/SceneGraph/AbstractFeature.hpp
+++ b/src/Magnum/SceneGraph/AbstractFeature.hpp
@ -41,9 +41,9 @@ template<UnsignedInt dimensions, class T> AbstractFeature<dimensions, T>::~Abstr

 template<UnsignedInt dimensions, class T> void AbstractFeature<dimensions, T>::markDirty() {}

-template<UnsignedInt dimensions, class T> void AbstractFeature<dimensions, T>::clean(const typename DimensionTraits<dimensions, T>::MatrixType&) {}
+template<UnsignedInt dimensions, class T> void AbstractFeature<dimensions, T>::clean(const MatrixTypeFor<dimensions, T>&) {}

-template<UnsignedInt dimensions, class T> void AbstractFeature<dimensions, T>::cleanInverted(const typename DimensionTraits<dimensions, T>::MatrixType&) {}
+template<UnsignedInt dimensions, class T> void AbstractFeature<dimensions, T>::cleanInverted(const MatrixTypeFor<dimensions, T>&) {}

 }}

--- a/src/Magnum/SceneGraph/AbstractObject.h
+++ b/src/Magnum/SceneGraph/AbstractObject.h
@ -81,7 +81,7 @@ template<UnsignedInt dimensions, class T> class AbstractObject

    public:
        /** @brief Matrix type */
-        typedef typename DimensionTraits<dimensions, T>::MatrixType MatrixType;
+        typedef MatrixTypeFor<dimensions, T> MatrixType;

        /** @brief Feature object type */
        typedef AbstractFeature<dimensions, T> FeatureType;
--- a/src/Magnum/SceneGraph/AbstractTranslation.h
+++ b/src/Magnum/SceneGraph/AbstractTranslation.h
@ -65,7 +65,7 @@ class AbstractTranslation: public AbstractTransformation<dimensions, T> {
         *      @ref Math::Vector3::xAxis(), @ref Math::Vector3::yAxis(),
         *      @ref Math::Vector3::zAxis()
         */
-        AbstractTranslation<dimensions, T, TranslationType>& translate(const typename DimensionTraits<dimensions, TranslationType>::VectorType& vector, TransformationType type = TransformationType::Global) {
+        AbstractTranslation<dimensions, T, TranslationType>& translate(const VectorTypeFor<dimensions, TranslationType>& vector, TransformationType type = TransformationType::Global) {
            doTranslate(vector, type);
            return *this;
        }
@ -79,7 +79,7 @@ class AbstractTranslation: public AbstractTransformation<dimensions, T> {
    private:
    #endif
        /** @brief Polymorphic implementation for @ref translate() */
-        virtual void doTranslate(const typename DimensionTraits<dimensions, TranslationType>::VectorType& vector, TransformationType type) = 0;
+        virtual void doTranslate(const VectorTypeFor<dimensions, TranslationType>& vector, TransformationType type) = 0;
 };

 /**
--- a/src/Magnum/SceneGraph/Drawable.h
+++ b/src/Magnum/SceneGraph/Drawable.h
@ -165,7 +165,7 @@ template<UnsignedInt dimensions, class T> class Drawable: public AbstractGrouped
         * Projection matrix can be retrieved from
         * @ref SceneGraph::AbstractCamera::projectionMatrix() "AbstractCamera::projectionMatrix()".
         */
-        virtual void draw(const typename DimensionTraits<dimensions, T>::MatrixType& transformationMatrix, AbstractCamera<dimensions, T>& camera) = 0;
+        virtual void draw(const MatrixTypeFor<dimensions, T>& transformationMatrix, AbstractCamera<dimensions, T>& camera) = 0;
 };

 /**
--- a/src/Magnum/SceneGraph/Object.h
+++ b/src/Magnum/SceneGraph/Object.h
@ -106,7 +106,7 @@ template<class Transformation> class Object: public AbstractObject<Transformatio

    public:
        /** @brief Matrix type */
-        typedef typename DimensionTraits<Transformation::Dimensions, typename Transformation::Type>::MatrixType MatrixType;
+        typedef MatrixTypeFor<Transformation::Dimensions, typename Transformation::Type> MatrixType;

        /**
         * @brief Constructor
--- a/src/Magnum/SceneGraph/TranslationTransformation.h
+++ b/src/Magnum/SceneGraph/TranslationTransformation.h
@ -60,16 +60,16 @@ template<UnsignedInt dimensions, class T, class TranslationType>
 class TranslationTransformation: public AbstractTranslation<dimensions, T, TranslationType> {
    public:
        /** @brief Underlying transformation type */
-        typedef typename DimensionTraits<dimensions, TranslationType>::VectorType DataType;
+        typedef VectorTypeFor<dimensions, TranslationType> DataType;

        /** @brief %Object transformation */
-        typename DimensionTraits<dimensions, TranslationType>::VectorType transformation() const { return _transformation; }
+        VectorTypeFor<dimensions, TranslationType> transformation() const { return _transformation; }

        /**
         * @brief Set transformation
         * @return Reference to self (for method chaining)
         */
-        Object<TranslationTransformation<dimensions, T, TranslationType>>& setTransformation(const typename DimensionTraits<dimensions, TranslationType>::VectorType& transformation) {
+        Object<TranslationTransformation<dimensions, T, TranslationType>>& setTransformation(const VectorTypeFor<dimensions, TranslationType>& transformation) {
            /* Setting transformation is forbidden for the scene */
            /** @todo Assert for this? */
            /** @todo Do this in some common code so we don't need to include Object? */
@ -94,7 +94,7 @@ class TranslationTransformation: public AbstractTranslation<dimensions, T, Trans
         * Equivalent to @ref translate(), provided only for compatibility with
         * other implementations.
         */
-        Object<TranslationTransformation<dimensions, T, TranslationType>>& transform(const typename DimensionTraits<dimensions, TranslationType>::VectorType& transformation, TransformationType = TransformationType::Global) {
+        Object<TranslationTransformation<dimensions, T, TranslationType>>& transform(const VectorTypeFor<dimensions, TranslationType>& transformation, TransformationType = TransformationType::Global) {
            return translate(transformation);
        }

@ -107,7 +107,7 @@ class TranslationTransformation: public AbstractTranslation<dimensions, T, Trans
         *      @ref Math::Vector3::xAxis(), @ref Math::Vector3::yAxis(),
         *      @ref Math::Vector3::zAxis()
         */
-        Object<TranslationTransformation<dimensions, T, TranslationType>>& translate(const typename DimensionTraits<dimensions, TranslationType>::VectorType& vector, TransformationType = TransformationType::Global) {
+        Object<TranslationTransformation<dimensions, T, TranslationType>>& translate(const VectorTypeFor<dimensions, TranslationType>& vector, TransformationType = TransformationType::Global) {
            _transformation += vector;
            return static_cast<Object<TranslationTransformation<dimensions, T, TranslationType>>&>(*this);
        }
@ -119,11 +119,11 @@ class TranslationTransformation: public AbstractTranslation<dimensions, T, Trans
    private:
        void doResetTransformation() override final { resetTransformation(); }

-        void doTranslate(const typename DimensionTraits<dimensions, TranslationType>::VectorType& vector, TransformationType) override final {
+        void doTranslate(const VectorTypeFor<dimensions, TranslationType>& vector, TransformationType) override final {
            translate(vector);
        }

-        typename DimensionTraits<dimensions, TranslationType>::VectorType _transformation;
+        VectorTypeFor<dimensions, TranslationType> _transformation;
 };

 /**
@ -171,21 +171,21 @@ typedef BasicTranslationTransformation3D<Float> TranslationTransformation3D;
 namespace Implementation {

 template<UnsignedInt dimensions, class T, class TranslationType> struct Transformation<TranslationTransformation<dimensions, T, TranslationType>> {
-    static typename DimensionTraits<dimensions, TranslationType>::VectorType fromMatrix(const typename DimensionTraits<dimensions, T>::MatrixType& matrix) {
+    static VectorTypeFor<dimensions, TranslationType> fromMatrix(const MatrixTypeFor<dimensions, T>& matrix) {
        CORRADE_ASSERT((matrix.rotationScaling() == Math::Matrix<dimensions, T>()),
           "SceneGraph::TranslationTransformation: the matrix doesn't represent pure translation", {});
-        return typename DimensionTraits<dimensions, TranslationType>::VectorType(matrix.translation());
+        return VectorTypeFor<dimensions, TranslationType>{matrix.translation()};
    }

-    constexpr static typename DimensionTraits<dimensions, T>::MatrixType toMatrix(const typename DimensionTraits<dimensions, TranslationType>::VectorType& transformation) {
-        return DimensionTraits<dimensions, T>::MatrixType::translation(typename DimensionTraits<dimensions, T>::VectorType(transformation));
+    constexpr static MatrixTypeFor<dimensions, T> toMatrix(const VectorTypeFor<dimensions, TranslationType>& transformation) {
+        return MatrixTypeFor<dimensions, T>::translation(VectorTypeFor<dimensions, T>{transformation});
    }

-    static typename DimensionTraits<dimensions, TranslationType>::VectorType compose(const typename DimensionTraits<dimensions, TranslationType>::VectorType& parent, const typename DimensionTraits<dimensions, TranslationType>::VectorType& child) {
+    static VectorTypeFor<dimensions, TranslationType> compose(const VectorTypeFor<dimensions, TranslationType>& parent, const VectorTypeFor<dimensions, TranslationType>& child) {
        return parent+child;
    }

-    static typename DimensionTraits<dimensions, TranslationType>::VectorType inverted(const typename DimensionTraits<dimensions, TranslationType>::VectorType& transformation) {
+    static VectorTypeFor<dimensions, TranslationType> inverted(const VectorTypeFor<dimensions, TranslationType>& transformation) {
        return -transformation;
    }
 };
--- a/src/Magnum/Shaders/DistanceFieldVector.h
+++ b/src/Magnum/Shaders/DistanceFieldVector.h
@ -57,7 +57,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
         * @brief Set transformation and projection matrix
         * @return Reference to self (for method chaining)
         */
-        DistanceFieldVector& setTransformationProjectionMatrix(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) {
+        DistanceFieldVector& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
            AbstractShaderProgram::setUniform(transformationProjectionMatrixUniform, matrix);
            return *this;
        }
--- a/src/Magnum/Shaders/Flat.h
+++ b/src/Magnum/Shaders/Flat.h
@ -116,7 +116,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Flat: public Abstra
         * @brief Set transformation and projection matrix
         * @return Reference to self (for method chaining)
         */
-        Flat<dimensions>& setTransformationProjectionMatrix(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) {
+        Flat<dimensions>& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
            setUniform(transformationProjectionMatrixUniform, matrix);
            return *this;
        }
--- a/src/Magnum/Shaders/Vector.h
+++ b/src/Magnum/Shaders/Vector.h
@ -54,7 +54,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Vector: public Abst
         * @brief Set transformation and projection matrix
         * @return Reference to self (for method chaining)
         */
-        Vector& setTransformationProjectionMatrix(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) {
+        Vector& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
            AbstractShaderProgram::setUniform(transformationProjectionMatrixUniform, matrix);
            return *this;
        }
--- a/src/Magnum/Shaders/VertexColor.cpp
+++ b/src/Magnum/Shaders/VertexColor.cpp
@ -83,7 +83,7 @@ template<UnsignedInt dimensions> VertexColor<dimensions>::VertexColor(): transfo

    /* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
    #ifdef MAGNUM_TARGET_GLES
-    setTransformationProjectionMatrix(typename DimensionTraits<dimensions, Float>::MatrixType());
+    setTransformationProjectionMatrix(MatrixTypeFor<dimensions, Float>{});
    #endif
 }

--- a/src/Magnum/Shaders/VertexColor.h
+++ b/src/Magnum/Shaders/VertexColor.h
@ -60,7 +60,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColor: public
         *
         * Default is identity matrix.
         */
-        VertexColor<dimensions>& setTransformationProjectionMatrix(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) {
+        VertexColor<dimensions>& setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
            setUniform(transformationProjectionMatrixUniform, matrix);
            return *this;
        }
--- a/src/Magnum/Shapes/AxisAlignedBox.cpp
+++ b/src/Magnum/Shapes/AxisAlignedBox.cpp
@ -31,7 +31,7 @@

 namespace Magnum { namespace Shapes {

-template<UnsignedInt dimensions> AxisAlignedBox<dimensions> AxisAlignedBox<dimensions>::transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
+template<UnsignedInt dimensions> AxisAlignedBox<dimensions> AxisAlignedBox<dimensions>::transformed(const MatrixTypeFor<dimensions, Float>& matrix) const {
    return AxisAlignedBox<dimensions>(matrix.transformPoint(_min),
                                      matrix.transformPoint(_max));
 }
--- a/src/Magnum/Shapes/AxisAlignedBox.h
+++ b/src/Magnum/Shapes/AxisAlignedBox.h
@ -57,28 +57,28 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT AxisAlignedBox {
        constexpr /*implicit*/ AxisAlignedBox() {}

        /** @brief Constructor */
-        constexpr /*implicit*/ AxisAlignedBox(const typename DimensionTraits<dimensions, Float>::VectorType& min, const typename DimensionTraits<dimensions, Float>::VectorType& max): _min(min), _max(max) {}
+        constexpr /*implicit*/ AxisAlignedBox(const VectorTypeFor<dimensions, Float>& min, const typename DimensionTraits<dimensions, Float>::VectorType& max): _min(min), _max(max) {}

        /** @brief Transformed shape */
-        AxisAlignedBox<dimensions> transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const;
+        AxisAlignedBox<dimensions> transformed(const MatrixTypeFor<dimensions, Float>& matrix) const;

        /** @brief Minimal coordinates */
-        constexpr typename DimensionTraits<dimensions, Float>::VectorType min() const {
+        constexpr VectorTypeFor<dimensions, Float> min() const {
            return _min;
        }

        /** @brief Set minimal coordinates */
-        void setMin(const typename DimensionTraits<dimensions, Float>::VectorType& min) {
+        void setMin(const VectorTypeFor<dimensions, Float>& min) {
            _min = min;
        }

        /** @brief Maximal coordinates */
-        constexpr typename DimensionTraits<dimensions, Float>::VectorType max() const {
+        constexpr VectorTypeFor<dimensions, Float> max() const {
            return _max;
        }

        /** @brief Set maximal coordinates */
-        void setMax(const typename DimensionTraits<dimensions, Float>::VectorType& max) {
+        void setMax(const VectorTypeFor<dimensions, Float>& max) {
            _max = max;
        }

@ -86,7 +86,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT AxisAlignedBox {
        bool operator%(const Point<dimensions>& other) const;

    private:
-        typename DimensionTraits<dimensions, Float>::VectorType _min, _max;
+        VectorTypeFor<dimensions, Float> _min, _max;
 };

 /** @brief Two-dimensional axis-aligned box */
--- a/src/Magnum/Shapes/Box.cpp
+++ b/src/Magnum/Shapes/Box.cpp
@ -27,7 +27,7 @@

 namespace Magnum { namespace Shapes {

-template<UnsignedInt dimensions> Box<dimensions> Box<dimensions>::transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
+template<UnsignedInt dimensions> Box<dimensions> Box<dimensions>::transformed(const MatrixTypeFor<dimensions, Float>& matrix) const {
    return Box<dimensions>(matrix*_transformation);
 }

--- a/src/Magnum/Shapes/Box.h
+++ b/src/Magnum/Shapes/Box.h
@ -56,26 +56,26 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Box {
         *
         * Creates zero-sized box positioned at origin.
         */
-        constexpr /*implicit*/ Box(): _transformation(DimensionTraits<dimensions, Float>::MatrixType::Zero) {}
+        constexpr /*implicit*/ Box(): _transformation(MatrixTypeFor<dimensions, Float>::Zero) {}

        /** @brief Constructor */
-        constexpr /*implicit*/ Box(const typename DimensionTraits<dimensions, Float>::MatrixType& transformation): _transformation(transformation) {}
+        constexpr /*implicit*/ Box(const MatrixTypeFor<dimensions, Float>& transformation): _transformation(transformation) {}

        /** @brief Transformed shape */
-        Box<dimensions> transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const;
+        Box<dimensions> transformed(const MatrixTypeFor<dimensions, Float>& matrix) const;

        /** @brief Transformation */
-        constexpr typename DimensionTraits<dimensions, Float>::MatrixType transformation() const {
+        constexpr MatrixTypeFor<dimensions, Float> transformation() const {
            return _transformation;
        }

        /** @brief Set transformation */
-        void setTransformation(const typename DimensionTraits<dimensions, Float>::MatrixType& transformation) {
+        void setTransformation(const MatrixTypeFor<dimensions, Float>& transformation) {
            _transformation = transformation;
        }

    private:
-        typename DimensionTraits<dimensions, Float>::MatrixType _transformation;
+        MatrixTypeFor<dimensions, Float> _transformation;
 };

 /** @brief Two-dimensional box */
--- a/src/Magnum/Shapes/Capsule.cpp
+++ b/src/Magnum/Shapes/Capsule.cpp
@ -37,7 +37,7 @@ using namespace Magnum::Math::Geometry;

 namespace Magnum { namespace Shapes {

-template<UnsignedInt dimensions> Capsule<dimensions> Capsule<dimensions>::transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
+template<UnsignedInt dimensions> Capsule<dimensions> Capsule<dimensions>::transformed(const MatrixTypeFor<dimensions, Float>& matrix) const {
    return Capsule<dimensions>(matrix.transformPoint(_a), matrix.transformPoint(_b), matrix.uniformScaling()*_radius);
 }

--- a/src/Magnum/Shapes/Capsule.h
+++ b/src/Magnum/Shapes/Capsule.h
@ -59,28 +59,28 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Capsule {
        constexpr /*implicit*/ Capsule(): _radius(0.0f) {}

        /** @brief Constructor */
-        constexpr /*implicit*/ Capsule(const typename DimensionTraits<dimensions, Float>::VectorType& a, const typename DimensionTraits<dimensions, Float>::VectorType& b, Float radius): _a(a), _b(b), _radius(radius) {}
+        constexpr /*implicit*/ Capsule(const VectorTypeFor<dimensions, Float>& a, const VectorTypeFor<dimensions, Float>& b, Float radius): _a(a), _b(b), _radius(radius) {}

        /** @brief Transformed shape */
-        Capsule<dimensions> transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const;
+        Capsule<dimensions> transformed(const MatrixTypeFor<dimensions, Float>& matrix) const;

        /** @brief Start point */
-        constexpr typename DimensionTraits<dimensions, Float>::VectorType a() const {
+        constexpr VectorTypeFor<dimensions, Float> a() const {
            return _a;
        }

        /** @brief Set start point */
-        void setA(const typename DimensionTraits<dimensions, Float>::VectorType& a) {
+        void setA(const VectorTypeFor<dimensions, Float>& a) {
            _a = a;
        }

        /** @brief End point */
-        constexpr typename DimensionTraits<dimensions, Float>::VectorType b() const {
+        constexpr VectorTypeFor<dimensions, Float> b() const {
            return _b;
        }

        /** @brief Set end point */
-        void setB(const typename DimensionTraits<dimensions, Float>::VectorType& b) {
+        void setB(const VectorTypeFor<dimensions, Float>& b) {
            _b = b;
        }

@ -97,7 +97,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Capsule {
        bool operator%(const Sphere<dimensions>& other) const;

    private:
-        typename DimensionTraits<dimensions, Float>::VectorType _a, _b;
+        VectorTypeFor<dimensions, Float> _a, _b;
        Float _radius;
 };

--- a/src/Magnum/Shapes/Collision.h
+++ b/src/Magnum/Shapes/Collision.h
@ -67,7 +67,7 @@ template<UnsignedInt dimensions> class Collision {
         * If separation distance is positive, the separation normal is
         * expected to be normalized.
         */
-        explicit Collision(typename DimensionTraits<dimensions, Float>::VectorType position, typename DimensionTraits<dimensions, Float>::VectorType separationNormal, Float separationDistance) noexcept: _position(position), _separationNormal(separationNormal), _separationDistance(separationDistance) {
+        explicit Collision(const VectorTypeFor<dimensions, Float>& position, const VectorTypeFor<dimensions, Float>& separationNormal, Float separationDistance) noexcept: _position(position), _separationNormal(separationNormal), _separationDistance(separationDistance) {
            CORRADE_ASSERT(_separationDistance < Math::TypeTraits<Float>::epsilon() || separationNormal.isNormalized(), "Shapes::Collision::Collision: separation normal is not normalized", );
        }

@ -81,7 +81,7 @@ template<UnsignedInt dimensions> class Collision {
        operator bool() const { return _separationDistance > 0.0f; }

        /** @brief %Collision position */
-        typename DimensionTraits<dimensions, Float>::VectorType position() const {
+        VectorTypeFor<dimensions, Float> position() const {
            return _position;
        }

@ -90,7 +90,7 @@ template<UnsignedInt dimensions> class Collision {
         *
         * @see @ref separationDistance(), @ref flipped()
         */
-        typename DimensionTraits<dimensions, Float>::VectorType separationNormal() const {
+        VectorTypeFor<dimensions, Float> separationNormal() const {
            return _separationNormal;
        }

@ -117,8 +117,8 @@ template<UnsignedInt dimensions> class Collision {
        }

    private:
-        typename DimensionTraits<dimensions, Float>::VectorType _position;
-        typename DimensionTraits<dimensions, Float>::VectorType _separationNormal;
+        VectorTypeFor<dimensions, Float> _position;
+        VectorTypeFor<dimensions, Float> _separationNormal;
        Float _separationDistance;
 };

--- a/src/Magnum/Shapes/Composition.cpp
+++ b/src/Magnum/Shapes/Composition.cpp
@ -113,7 +113,7 @@ template<UnsignedInt dimensions> void Composition<dimensions>::copyNodes(std::si
    std::copy(other._nodes.begin(), other._nodes.end(), _nodes.begin()+offset);
 }

-template<UnsignedInt dimensions> Composition<dimensions> Composition<dimensions>::transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
+template<UnsignedInt dimensions> Composition<dimensions> Composition<dimensions>::transformed(const MatrixTypeFor<dimensions, Float>& matrix) const {
    Composition<dimensions> out(*this);
    for(Implementation::AbstractShape<dimensions> * const* i = _shapes.begin(), * const* o = out._shapes.begin(); i != _shapes.end(); ++i, ++o)
        (*i)->transform(matrix, *o);
--- a/src/Magnum/Shapes/Composition.h
+++ b/src/Magnum/Shapes/Composition.h
@ -129,7 +129,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Composition {
        Composition<dimensions>& operator=(Composition<dimensions>&& other);

        /** @brief Transformed shape */
-        Composition<dimensions> transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const;
+        Composition<dimensions> transformed(const MatrixTypeFor<dimensions, Float>& matrix) const;

        /** @brief Count of shapes in the hierarchy */
        std::size_t size() const { return _shapes.size(); }
--- a/src/Magnum/Shapes/Cylinder.cpp
+++ b/src/Magnum/Shapes/Cylinder.cpp
@ -37,7 +37,7 @@ using namespace Magnum::Math::Geometry;

 namespace Magnum { namespace Shapes {

-template<UnsignedInt dimensions> Cylinder<dimensions> Cylinder<dimensions>::transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
+template<UnsignedInt dimensions> Cylinder<dimensions> Cylinder<dimensions>::transformed(const MatrixTypeFor<dimensions, Float>& matrix) const {
    return Cylinder<dimensions>(matrix.transformPoint(_a), matrix.transformPoint(_b), matrix.uniformScaling()*_radius);
 }

--- a/src/Magnum/Shapes/Cylinder.h
+++ b/src/Magnum/Shapes/Cylinder.h
@ -59,28 +59,28 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Cylinder {
        constexpr /*implicit*/ Cylinder(): _radius(0.0f) {}

        /** @brief Constructor */
-        constexpr /*implicit*/ Cylinder(const typename DimensionTraits<dimensions, Float>::VectorType& a, const typename DimensionTraits<dimensions, Float>::VectorType& b, Float radius): _a(a), _b(b), _radius(radius) {}
+        constexpr /*implicit*/ Cylinder(const VectorTypeFor<dimensions, Float>& a, const VectorTypeFor<dimensions, Float>& b, Float radius): _a(a), _b(b), _radius(radius) {}

        /** @brief Transformed shape */
-        Cylinder<dimensions> transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const;
+        Cylinder<dimensions> transformed(const MatrixTypeFor<dimensions, Float>& matrix) const;

        /** @brief First point */
-        constexpr typename DimensionTraits<dimensions, Float>::VectorType a() const {
+        constexpr VectorTypeFor<dimensions, Float> a() const {
            return _a;
        }

        /** @brief Set first point */
-        void setA(const typename DimensionTraits<dimensions, Float>::VectorType& a) {
+        void setA(const VectorTypeFor<dimensions, Float>& a) {
            _a = a;
        }

        /** @brief Second point */
-        constexpr typename DimensionTraits<dimensions, Float>::VectorType b() const {
+        constexpr VectorTypeFor<dimensions, Float> b() const {
            return _b;
        }

        /** @brief Set second point */
-        void setB(const typename DimensionTraits<dimensions, Float>::VectorType& b) {
+        void setB(const VectorTypeFor<dimensions, Float>& b) {
            _b = b;
        }

@ -97,7 +97,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Cylinder {
        bool operator%(const Sphere<dimensions>& other) const;

    private:
-        typename DimensionTraits<dimensions, Float>::VectorType _a, _b;
+        VectorTypeFor<dimensions, Float> _a, _b;
        Float _radius;
 };

--- a/src/Magnum/Shapes/Line.cpp
+++ b/src/Magnum/Shapes/Line.cpp
@ -30,7 +30,7 @@

 namespace Magnum { namespace Shapes {

-template<UnsignedInt dimensions> Line<dimensions> Line<dimensions>::transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
+template<UnsignedInt dimensions> Line<dimensions> Line<dimensions>::transformed(const MatrixTypeFor<dimensions, Float>& matrix) const {
    return Line<dimensions>(matrix.transformPoint(_a),
                            matrix.transformPoint(_b));
 }
--- a/src/Magnum/Shapes/Line.h
+++ b/src/Magnum/Shapes/Line.h
@ -56,33 +56,33 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Line {
        constexpr /*implicit*/ Line() {}

        /** @brief Constructor */
-        constexpr /*implicit*/ Line(const typename DimensionTraits<dimensions, Float>::VectorType& a, const typename DimensionTraits<dimensions, Float>::VectorType& b): _a(a), _b(b) {}
+        constexpr /*implicit*/ Line(const VectorTypeFor<dimensions, Float>& a, const typename DimensionTraits<dimensions, Float>::VectorType& b): _a(a), _b(b) {}

        /** @brief Transformed shape */
-        Line<dimensions> transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const;
+        Line<dimensions> transformed(const MatrixTypeFor<dimensions, Float>& matrix) const;

        /** @brief First point */
-        constexpr typename DimensionTraits<dimensions, Float>::VectorType a() const {
+        constexpr VectorTypeFor<dimensions, Float> a() const {
            return _a;
        }

        /** @brief Set first point */
-        void setA(const typename DimensionTraits<dimensions, Float>::VectorType& a) {
+        void setA(const VectorTypeFor<dimensions, Float>& a) {
            _a = a;
        }

        /** @brief Second point */
-        constexpr typename DimensionTraits<dimensions, Float>::VectorType b() const {
+        constexpr VectorTypeFor<dimensions, Float> b() const {
            return _b;
        }

        /** @brief Set second point */
-        void setB(const typename DimensionTraits<dimensions, Float>::VectorType& b) {
+        void setB(const VectorTypeFor<dimensions, Float>& b) {
            _b = b;
        }

    private:
-        typename DimensionTraits<dimensions, Float>::VectorType _a, _b;
+        VectorTypeFor<dimensions, Float> _a, _b;
 };

 /** @brief Infinite two-dimensional line */
--- a/src/Magnum/Shapes/LineSegment.h
+++ b/src/Magnum/Shapes/LineSegment.h
@ -49,10 +49,10 @@ template<UnsignedInt dimensions> class LineSegment: public Line<dimensions> {
        constexpr /*implicit*/ LineSegment() {}

        /** @brief Constructor */
-        constexpr /*implicit*/ LineSegment(const typename DimensionTraits<dimensions, Float>::VectorType& a, const typename DimensionTraits<dimensions, Float>::VectorType& b): Line<dimensions>(a, b) {}
+        constexpr /*implicit*/ LineSegment(const VectorTypeFor<dimensions, Float>& a, const VectorTypeFor<dimensions, Float>& b): Line<dimensions>(a, b) {}

        /** @brief Transformed shape */
-        LineSegment<dimensions> transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
+        LineSegment<dimensions> transformed(const MatrixTypeFor<dimensions, Float>& matrix) const {
            return Line<dimensions>::transformed(matrix);
        }

--- a/src/Magnum/Shapes/Point.cpp
+++ b/src/Magnum/Shapes/Point.cpp
@ -30,7 +30,7 @@

 namespace Magnum { namespace Shapes {

-template<UnsignedInt dimensions> Point<dimensions> Point<dimensions>::transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
+template<UnsignedInt dimensions> Point<dimensions> Point<dimensions>::transformed(const MatrixTypeFor<dimensions, Float>& matrix) const {
    return Point<dimensions>(matrix.transformPoint(_position));
 }

--- a/src/Magnum/Shapes/Point.h
+++ b/src/Magnum/Shapes/Point.h
@ -55,23 +55,23 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Point {
        constexpr /*implicit*/ Point() {}

        /** @brief Constructor */
-        constexpr /*implicit*/ Point(const typename DimensionTraits<dimensions, Float>::VectorType& position): _position(position) {}
+        constexpr /*implicit*/ Point(const VectorTypeFor<dimensions, Float>& position): _position(position) {}

        /** @brief Transformed shape */
-        Point<dimensions> transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const;
+        Point<dimensions> transformed(const MatrixTypeFor<dimensions, Float>& matrix) const;

        /** @brief Position */
-        constexpr typename DimensionTraits<dimensions, Float>::VectorType position() const {
+        constexpr VectorTypeFor<dimensions, Float> position() const {
            return _position;
        }

        /** @brief Set position */
-        void setPosition(const typename DimensionTraits<dimensions, Float>::VectorType& position) {
+        void setPosition(const VectorTypeFor<dimensions, Float>& position) {
            _position = position;
        }

    private:
-        typename DimensionTraits<dimensions, Float>::VectorType _position;
+        VectorTypeFor<dimensions, Float> _position;
 };

 /** @brief Two-dimensional point */
--- a/src/Magnum/Shapes/Shape.cpp
+++ b/src/Magnum/Shapes/Shape.cpp
@ -37,7 +37,7 @@ template<UnsignedInt dimensions> void ShapeHelper<Composition<dimensions>>::set(
    shape._transformedShape.shape = shape._shape.shape = std::move(composition);
 }

-template<UnsignedInt dimensions> void ShapeHelper<Composition<dimensions>>::transform(Shapes::Shape<Composition<dimensions>>& shape, const typename DimensionTraits<dimensions, Float>::MatrixType& absoluteTransformationMatrix) {
+template<UnsignedInt dimensions> void ShapeHelper<Composition<dimensions>>::transform(Shapes::Shape<Composition<dimensions>>& shape, const MatrixTypeFor<dimensions, Float>& absoluteTransformationMatrix) {
    CORRADE_INTERNAL_ASSERT(shape._shape.shape.size() == shape._transformedShape.shape.size());
    for(std::size_t i = 0; i != shape.shape().size(); ++i)
        shape._shape.shape._shapes[i]->transform(absoluteTransformationMatrix, shape._transformedShape.shape._shapes[i]);
--- a/src/Magnum/Shapes/Shape.h
+++ b/src/Magnum/Shapes/Shape.h
@ -108,7 +108,7 @@ template<class T> class Shape: public AbstractShape<T::Dimensions> {

    protected:
        /** Applies transformation to associated shape. */
-        void clean(const typename DimensionTraits<T::Dimensions, Float>::MatrixType& absoluteTransformationMatrix) override;
+        void clean(const MatrixTypeFor<T::Dimensions, Float>& absoluteTransformationMatrix) override;

    private:
        const Implementation::AbstractShape<T::Dimensions>& abstractTransformedShape() const override {
@ -129,7 +129,7 @@ template<class T> inline const T& Shape<T>::transformedShape() {
    return _transformedShape.shape;
 }

-template<class T> void Shape<T>::clean(const typename DimensionTraits<T::Dimensions, Float>::MatrixType& absoluteTransformationMatrix) {
+template<class T> void Shape<T>::clean(const MatrixTypeFor<T::Dimensions, Float>& absoluteTransformationMatrix) {
    Implementation::ShapeHelper<T>::transform(*this, absoluteTransformationMatrix);
 }

@ -139,7 +139,7 @@ namespace Implementation {
            shape._shape.shape = s;
        }

-        static void transform(Shapes::Shape<T>& shape, const typename DimensionTraits<T::Dimensions, Float>::MatrixType& absoluteTransformationMatrix) {
+        static void transform(Shapes::Shape<T>& shape, const MatrixTypeFor<T::Dimensions, Float>& absoluteTransformationMatrix) {
            shape._transformedShape.shape = shape._shape.shape.transformed(absoluteTransformationMatrix);
        }
    };
@ -148,7 +148,7 @@ namespace Implementation {
        static void set(Shapes::Shape<Composition<dimensions>>& shape, const Composition<dimensions>& composition);
        static void set(Shapes::Shape<Composition<dimensions>>& shape, Composition<dimensions>&& composition);

-        static void transform(Shapes::Shape<Composition<dimensions>>& shape, const typename DimensionTraits<dimensions, Float>::MatrixType& absoluteTransformationMatrix);
+        static void transform(Shapes::Shape<Composition<dimensions>>& shape, const MatrixTypeFor<dimensions, Float>& absoluteTransformationMatrix);
    };
 }

--- a/src/Magnum/Shapes/Sphere.cpp
+++ b/src/Magnum/Shapes/Sphere.cpp
@ -37,7 +37,7 @@ using namespace Magnum::Math::Geometry;

 namespace Magnum { namespace Shapes {

-template<UnsignedInt dimensions> Sphere<dimensions> Sphere<dimensions>::transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
+template<UnsignedInt dimensions> Sphere<dimensions> Sphere<dimensions>::transformed(const MatrixTypeFor<dimensions, Float>& matrix) const {
    return Sphere<dimensions>(matrix.transformPoint(_position), matrix.uniformScaling()*_radius);
 }

@ -50,7 +50,7 @@ template<UnsignedInt dimensions> bool InvertedSphere<dimensions>::operator%(cons
 }

 template<UnsignedInt dimensions> Collision<dimensions> Sphere<dimensions>::operator/(const Point<dimensions>& other) const {
-    const typename DimensionTraits<dimensions, Float>::VectorType separating = _position - other.position();
+    const VectorTypeFor<dimensions, Float> separating = _position - other.position();
    const Float dot = separating.dot();

    /* No collision occured */
@ -61,9 +61,9 @@ template<UnsignedInt dimensions> Collision<dimensions> Sphere<dimensions>::opera

    /* Separating normal. If can't decide on direction, just move up. */
    /** @todo How to handle this in a configurable way? */
-    const typename DimensionTraits<dimensions, Float>::VectorType separatingNormal =
+    const VectorTypeFor<dimensions, Float> separatingNormal =
        Math::TypeTraits<Float>::equals(dot, 0.0f) ?
-        DimensionTraits<dimensions, Float>::VectorType::yAxis() :
+        VectorTypeFor<dimensions, Float>::yAxis() :
        separating/distance;

    /* Collision position is on the point */
@ -71,7 +71,7 @@ template<UnsignedInt dimensions> Collision<dimensions> Sphere<dimensions>::opera
 }

 template<UnsignedInt dimensions> Collision<dimensions> InvertedSphere<dimensions>::operator/(const Point<dimensions>& other) const {
-    const typename DimensionTraits<dimensions, Float>::VectorType separating = other.position() - position();
+    const VectorTypeFor<dimensions, Float> separating = other.position() - position();
    const Float dot = separating.dot();

    /* No collision occured */
@ -81,7 +81,7 @@ template<UnsignedInt dimensions> Collision<dimensions> InvertedSphere<dimensions
    const Float distance = Math::sqrt(dot);

    /* Separating normal */
-    const typename DimensionTraits<dimensions, Float>::VectorType separatingNormal = separating/distance;
+    const VectorTypeFor<dimensions, Float> separatingNormal = separating/distance;

    /* Collision position is on the point */
    return Collision<dimensions>(other.position(), separatingNormal, distance - radius());
@ -105,7 +105,7 @@ template<UnsignedInt dimensions> bool InvertedSphere<dimensions>::operator%(cons

 template<UnsignedInt dimensions> Collision<dimensions> Sphere<dimensions>::operator/(const Sphere<dimensions>& other) const {
    const Float minDistance = _radius + other._radius;
-    const typename DimensionTraits<dimensions, Float>::VectorType separating = _position - other._position;
+    const VectorTypeFor<dimensions, Float> separating = _position - other._position;
    const Float dot = separating.dot();

    /* No collision occured */
@ -116,9 +116,9 @@ template<UnsignedInt dimensions> Collision<dimensions> Sphere<dimensions>::opera

    /* Separating normal. If can't decide on direction, just move up. */
    /** @todo How to handle this in a configurable way? */
-    const typename DimensionTraits<dimensions, Float>::VectorType separatingNormal =
+    const VectorTypeFor<dimensions, Float> separatingNormal =
        Math::TypeTraits<Float>::equals(dot, 0.0f) ?
-        DimensionTraits<dimensions, Float>::VectorType::yAxis() :
+        VectorTypeFor<dimensions, Float>::yAxis() :
        separating/distance;

    /* Contact position is on the surface of `other`, minDistace > distance */
@ -129,7 +129,7 @@ template<UnsignedInt dimensions> Collision<dimensions> InvertedSphere<dimensions
    const Float maxDistance = radius() - other.radius();
    /** @todo How to handle inseparable shapes or shapes which can't be separated by movement only (i.e. two half-spaces)? */
    CORRADE_INTERNAL_ASSERT(maxDistance > 0.0f);
-    const typename DimensionTraits<dimensions, Float>::VectorType separating = other.position() - position();
+    const VectorTypeFor<dimensions, Float> separating = other.position() - position();
    const Float dot = separating.dot();

    /* No collision occured */
@ -139,7 +139,7 @@ template<UnsignedInt dimensions> Collision<dimensions> InvertedSphere<dimensions
    const Float distance = Math::sqrt(dot);

    /* Separating normal */
-    const typename DimensionTraits<dimensions, Float>::VectorType separatingNormal = separating/distance;
+    const VectorTypeFor<dimensions, Float> separatingNormal = separating/distance;

    /* Contact position is on the surface of `other`, distance > maxDistance */
    return Collision<dimensions>(other.position() + separatingNormal*other.radius(), separatingNormal, distance - maxDistance);
--- a/src/Magnum/Shapes/Sphere.h
+++ b/src/Magnum/Shapes/Sphere.h
@ -60,18 +60,18 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Sphere {
        constexpr /*implicit*/ Sphere(): _radius(0.0f) {}

        /** @brief Constructor */
-        constexpr /*implicit*/ Sphere(const typename DimensionTraits<dimensions, Float>::VectorType& position, Float radius): _position(position), _radius(radius) {}
+        constexpr /*implicit*/ Sphere(const VectorTypeFor<dimensions, Float>& position, Float radius): _position(position), _radius(radius) {}

        /** @brief Transformed shape */
-        Sphere<dimensions> transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const;
+        Sphere<dimensions> transformed(const MatrixTypeFor<dimensions, Float>& matrix) const;

        /** @brief Position */
-        constexpr typename DimensionTraits<dimensions, Float>::VectorType position() const {
+        constexpr VectorTypeFor<dimensions, Float> position() const {
            return _position;
        }

        /** @brief Set position */
-        void setPosition(const typename DimensionTraits<dimensions, Float>::VectorType& position) {
+        void setPosition(const VectorTypeFor<dimensions, Float>& position) {
            _position = position;
        }

@ -100,7 +100,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Sphere {
        Collision<dimensions> operator/(const Sphere<dimensions>& other) const;

    private:
-        typename DimensionTraits<dimensions, Float>::VectorType _position;
+        VectorTypeFor<dimensions, Float> _position;
        Float _radius;
 };

@ -133,12 +133,12 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT InvertedSphere:
        constexpr /*implicit*/ InvertedSphere() = default;

        /** @brief Constructor */
-        constexpr /*implicit*/ InvertedSphere(const typename DimensionTraits<dimensions, Float>::VectorType& position, Float radius): Sphere<dimensions>(position, radius) {}
+        constexpr /*implicit*/ InvertedSphere(const VectorTypeFor<dimensions, Float>& position, Float radius): Sphere<dimensions>(position, radius) {}

        using Sphere<dimensions>::Dimensions;

        /** @brief Transformed shape */
-        InvertedSphere<dimensions> transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
+        InvertedSphere<dimensions> transformed(const MatrixTypeFor<dimensions, Float>& matrix) const {
            return Sphere<dimensions>::transformed(matrix);
        }

--- a/src/Magnum/Shapes/shapeImplementation.h
+++ b/src/Magnum/Shapes/shapeImplementation.h
@ -158,7 +158,7 @@ template<UnsignedInt dimensions> struct MAGNUM_SHAPES_EXPORT AbstractShape {

    virtual typename ShapeDimensionTraits<dimensions>::Type MAGNUM_SHAPES_LOCAL type() const = 0;
    virtual AbstractShape<dimensions> MAGNUM_SHAPES_LOCAL * clone() const = 0;
-    virtual void MAGNUM_SHAPES_LOCAL transform(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix, AbstractShape<dimensions>* result) const = 0;
+    virtual void MAGNUM_SHAPES_LOCAL transform(const MatrixTypeFor<dimensions, Float>& matrix, AbstractShape<dimensions>* result) const = 0;
 };

 template<class T> struct Shape: AbstractShape<T::Dimensions> {
@ -176,7 +176,7 @@ template<class T> struct Shape: AbstractShape<T::Dimensions> {
        return new Shape<T>(shape);
    }

-    void transform(const typename DimensionTraits<T::Dimensions, Float>::MatrixType& matrix, AbstractShape<T::Dimensions>* result) const override {
+    void transform(const MatrixTypeFor<T::Dimensions, Float>& matrix, AbstractShape<T::Dimensions>* result) const override {
        CORRADE_INTERNAL_ASSERT(result->type() == type());
        static_cast<Shape<T>*>(result)->shape = shape.transformed(matrix);
    }
--- a/src/Magnum/Texture.cpp
+++ b/src/Magnum/Texture.cpp
@ -34,8 +34,8 @@

 namespace Magnum { namespace Implementation {

-template<UnsignedInt dimensions> typename DimensionTraits<dimensions, Int>::VectorType maxTextureSize() {
-    return typename DimensionTraits<dimensions, Int>::VectorType{Implementation::maxTextureSideSize()};
+template<UnsignedInt dimensions> VectorTypeFor<dimensions, Int> maxTextureSize() {
+    return VectorTypeFor<dimensions, Int>{Implementation::maxTextureSideSize()};
 }

 #ifndef MAGNUM_TARGET_GLES
--- a/src/Magnum/Texture.h
+++ b/src/Magnum/Texture.h
@ -52,7 +52,7 @@ namespace Implementation {
        #endif
    }

-    template<UnsignedInt dimensions> typename DimensionTraits<dimensions, Int>::VectorType maxTextureSize();
+    template<UnsignedInt dimensions> VectorTypeFor<dimensions, Int> maxTextureSize();
    template<> MAGNUM_EXPORT Vector3i maxTextureSize<3>();
 }

@ -152,7 +152,7 @@ template<UnsignedInt dimensions> class Texture: public AbstractTexture {
         * @see @fn_gl{Get} with @def_gl{MAX_TEXTURE_SIZE},
         *      @def_gl{MAX_3D_TEXTURE_SIZE}
         */
-        static typename DimensionTraits<dimensions, Int>::VectorType maxSize() {
+        static VectorTypeFor<dimensions, Int> maxSize() {
            return Implementation::maxTextureSize<dimensions>();
        }

@ -198,7 +198,7 @@ template<UnsignedInt dimensions> class Texture: public AbstractTexture {
         *      @def_gl{TEXTURE_DEPTH}
         * @requires_gl %Texture image queries are not available in OpenGL ES.
         */
-        typename DimensionTraits<dimensions, Int>::VectorType imageSize(Int level) {
+        VectorTypeFor<dimensions, Int> imageSize(Int level) {
            return DataHelper<dimensions>::imageSize(*this, _target, level);
        }
        #endif
@ -585,7 +585,7 @@ template<UnsignedInt dimensions> class Texture: public AbstractTexture {
         * @todo allow the user to specify ColorType explicitly to avoid
         *      issues in WebGL (see setSubImage())
         */
-        Texture<dimensions>& setStorage(Int levels, TextureFormat internalFormat, const typename DimensionTraits<dimensions, Int>::VectorType& size) {
+        Texture<dimensions>& setStorage(Int levels, TextureFormat internalFormat, const VectorTypeFor<dimensions, Int>& size) {
            DataHelper<dimensions>::setStorage(*this, _target, levels, internalFormat, size);
            return *this;
        }
@ -695,20 +695,20 @@ template<UnsignedInt dimensions> class Texture: public AbstractTexture {
         *      @fn_gl_extension{TextureSubImage2D,EXT,direct_state_access}/
         *      @fn_gl_extension{TextureSubImage3D,EXT,direct_state_access}
         */
-        Texture<dimensions>& setSubImage(Int level, const typename DimensionTraits<dimensions, Int>::VectorType& offset, const ImageReference<dimensions>& image) {
+        Texture<dimensions>& setSubImage(Int level, const VectorTypeFor<dimensions, Int>& offset, const ImageReference<dimensions>& image) {
            DataHelper<Dimensions>::setSubImage(*this, _target, level, offset, image);
            return *this;
        }

        #ifndef MAGNUM_TARGET_GLES2
        /** @overload */
-        Texture<dimensions>& setSubImage(Int level, const typename DimensionTraits<dimensions, Int>::VectorType& offset, BufferImage<dimensions>& image) {
+        Texture<dimensions>& setSubImage(Int level, const VectorTypeFor<dimensions, Int>& offset, BufferImage<dimensions>& image) {
            DataHelper<Dimensions>::setSubImage(*this, _target, level, offset, image);
            return *this;
        }

        /** @overload */
-        Texture<dimensions>& setSubImage(Int level, const typename DimensionTraits<dimensions, Int>::VectorType& offset, BufferImage<dimensions>&& image) {
+        Texture<dimensions>& setSubImage(Int level, const VectorTypeFor<dimensions, Int>& offset, BufferImage<dimensions>&& image) {
            return setSubImage(level, offset, image);
        }
        #endif
@ -749,7 +749,7 @@ template<UnsignedInt dimensions> class Texture: public AbstractTexture {
         * (part of OpenGL 4.3) is not available, this function does nothing.
         * @see @ref invalidateImage(), @fn_gl{InvalidateTexSubImage}
         */
-        void invalidateSubImage(Int level, const typename DimensionTraits<dimensions, Int>::VectorType& offset, const typename DimensionTraits<dimensions, Int>::VectorType& size) {
+        void invalidateSubImage(Int level, const VectorTypeFor<dimensions, Int>& offset, const VectorTypeFor<dimensions, Int>& size) {
            DataHelper<dimensions>::invalidateSubImage(*this, level, offset, size);
        }

--- a/src/Magnum/TextureArray.cpp
+++ b/src/Magnum/TextureArray.cpp
@ -39,7 +39,7 @@ namespace {
    template<> struct VectorOrScalar<2> { typedef Vector2i Type; };
 }

-template<UnsignedInt dimensions> typename DimensionTraits<dimensions+1, Int>::VectorType TextureArray<dimensions>::maxSize() {
+template<UnsignedInt dimensions> VectorTypeFor<dimensions+1, Int> TextureArray<dimensions>::maxSize() {
    #ifndef MAGNUM_TARGET_GLES
    if(!Context::current()->isExtensionSupported<Extensions::GL::EXT::texture_array>())
        return {};
--- a/src/Magnum/TextureArray.h
+++ b/src/Magnum/TextureArray.h
@ -105,7 +105,7 @@ template<UnsignedInt dimensions> class TextureArray: public AbstractTexture {
         * @see @fn_gl{Get} with @def_gl{MAX_TEXTURE_SIZE} and
         *      @def_gl{MAX_ARRAY_TEXTURE_LAYERS}
         */
-        static typename DimensionTraits<dimensions+1, Int>::VectorType maxSize();
+        static VectorTypeFor<dimensions+1, Int> maxSize();

        /**
         * @brief Constructor
@ -251,7 +251,7 @@ template<UnsignedInt dimensions> class TextureArray: public AbstractTexture {

        #ifndef MAGNUM_TARGET_GLES
        /** @copydoc Texture::imageSize() */
-        typename DimensionTraits<dimensions+1, Int>::VectorType imageSize(Int level) {
+        VectorTypeFor<dimensions+1, Int> imageSize(Int level) {
            return DataHelper<dimensions+1>::imageSize(*this, _target, level);
        }
        #endif
@ -282,7 +282,7 @@ template<UnsignedInt dimensions> class TextureArray: public AbstractTexture {
         *      @fn_gl_extension{TextureImage2D,EXT,direct_state_access}/
         *      @fn_gl_extension{TextureImage3D,EXT,direct_state_access}.
         */
-        TextureArray<dimensions>& setStorage(Int levels, TextureFormat internalFormat, const typename DimensionTraits<dimensions+1, Int>::VectorType& size) {
+        TextureArray<dimensions>& setStorage(Int levels, TextureFormat internalFormat, const VectorTypeFor<dimensions+1, Int>& size) {
            DataHelper<dimensions+1>::setStorage(*this, _target, levels, internalFormat, size);
            return *this;
        }
@ -351,20 +351,20 @@ template<UnsignedInt dimensions> class TextureArray: public AbstractTexture {
         *      or @fn_gl_extension{TextureSubImage2D,EXT,direct_state_access}/
         *      @fn_gl_extension{TextureSubImage3D,EXT,direct_state_access}
         */
-        TextureArray<dimensions>& setSubImage(Int level, const typename DimensionTraits<dimensions+1, Int>::VectorType& offset, const ImageReference<dimensions+1>& image) {
+        TextureArray<dimensions>& setSubImage(Int level, const VectorTypeFor<dimensions+1, Int>& offset, const ImageReference<dimensions+1>& image) {
            DataHelper<dimensions+1>::setSubImage(*this, _target, level, offset, image);
            return *this;
        }

        #ifndef MAGNUM_TARGET_GLES2
        /** @overload */
-        TextureArray<dimensions>& setSubImage(Int level, const typename DimensionTraits<dimensions+1, Int>::VectorType& offset, BufferImage<dimensions+1>& image) {
+        TextureArray<dimensions>& setSubImage(Int level, const VectorTypeFor<dimensions+1, Int>& offset, BufferImage<dimensions+1>& image) {
            DataHelper<dimensions+1>::setSubImage(*this, _target, level, offset, image);
            return *this;
        }

        /** @overload */
-        TextureArray<dimensions>& setSubImage(Int level, const typename DimensionTraits<dimensions+1, Int>::VectorType& offset, BufferImage<dimensions+1>&& image) {
+        TextureArray<dimensions>& setSubImage(Int level, const VectorTypeFor<dimensions+1, Int>& offset, BufferImage<dimensions+1>&& image) {
            return setSubImage(level, offset, image);
        }
        #endif
@ -379,7 +379,7 @@ template<UnsignedInt dimensions> class TextureArray: public AbstractTexture {
        void invalidateImage(Int level) { AbstractTexture::invalidateImage(level); }

        /** @copydoc Texture::invalidateSubImage() */
-        void invalidateSubImage(Int level, const typename DimensionTraits<dimensions+1, Int>::VectorType& offset, const typename DimensionTraits<dimensions+1, Int>::VectorType& size) {
+        void invalidateSubImage(Int level, const VectorTypeFor<dimensions+1, Int>& offset, const VectorTypeFor<dimensions+1, Int>& size) {
            DataHelper<dimensions+1>::invalidateSubImage(*this, level, offset, size);
        }

--- a/src/Magnum/Trade/ImageData.h
+++ b/src/Magnum/Trade/ImageData.h
@ -54,7 +54,7 @@ template<UnsignedInt dimensions> class ImageData: public AbstractImage {
         * Note that the image data are not copied on construction, but they
         * are deleted on class destruction.
         */
-        explicit ImageData(ColorFormat format, ColorType type, const typename DimensionTraits<Dimensions, Int>::VectorType& size, void* data): AbstractImage(format, type), _size(size), _data(reinterpret_cast<unsigned char*>(data)) {}
+        explicit ImageData(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size, void* data): AbstractImage(format, type), _size(size), _data(reinterpret_cast<unsigned char*>(data)) {}

        /** @brief Copying is not allowed */
        ImageData(const ImageData<dimensions>&) = delete;
@ -85,10 +85,10 @@ template<UnsignedInt dimensions> class ImageData: public AbstractImage {
        #endif

        /** @brief %Image size */
-        typename DimensionTraits<Dimensions, Int>::VectorType size() const { return _size; }
+        VectorTypeFor<dimensions, Int> size() const { return _size; }

        /** @copydoc Image::dataSize() */
-        std::size_t dataSize(const typename DimensionTraits<Dimensions, Int>::VectorType& size) const {
+        std::size_t dataSize(const VectorTypeFor<dimensions, Int>& size) const {
            return AbstractImage::dataSize<dimensions>(size);
        }