Removed default template argument from DimensionTraits.

It's not obvious what should be the default and thus it is confusing. Sometimes Int, sometimes Float, no clear winner.
13 years ago · 2eb4e3c8ba
40 changed files with 91 additions and 91 deletions
--- a/src/DebugTools/ForceRenderer.cpp
+++ b/src/DebugTools/ForceRenderer.cpp
@ -94,8 +94,8 @@ template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneG
    ResourceManager::instance()->set<Mesh>(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
 }

-template<UnsignedInt dimensions> void ForceRenderer<dimensions>::draw(const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractBasicCamera<dimensions, Float>* camera) {
-    shader->setTransformationProjectionMatrix(camera->projectionMatrix()*Implementation::forceRendererTransformation<dimensions>(transformationMatrix.transformPoint(forcePosition), *force)*DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(options->scale())))
+template<UnsignedInt dimensions> void ForceRenderer<dimensions>::draw(const typename DimensionTraits<dimensions, Float>::MatrixType& transformationMatrix, SceneGraph::AbstractBasicCamera<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())))
        ->setColor(options->color())
        ->use();
    mesh->draw();
--- a/src/DebugTools/Implementation/AbstractShapeRenderer.h
+++ b/src/DebugTools/Implementation/AbstractShapeRenderer.h
@ -49,7 +49,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>::MatrixType& projectionMatrix) = 0;
+        virtual void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) = 0;

    protected:
        /* Call only if the mesh resource isn't already present */
--- a/src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp
+++ b/src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp
@ -33,10 +33,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>::MatrixType& projectionMatrix) {
+template<UnsignedInt dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
    this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
-        DimensionTraits<dimensions>::MatrixType::translation((axisAlignedBox.min()+axisAlignedBox.max())/2)*
-        DimensionTraits<dimensions>::MatrixType::scaling(axisAlignedBox.max()-axisAlignedBox.min()))
+        DimensionTraits<dimensions, Float>::MatrixType::translation((axisAlignedBox.min()+axisAlignedBox.max())/2)*
+        DimensionTraits<dimensions, Float>::MatrixType::scaling(axisAlignedBox.max()-axisAlignedBox.min()))
        ->setColor(options->color())
        ->use();
    this->wireframeMesh->draw();
--- a/src/DebugTools/Implementation/AxisAlignedBoxRenderer.h
+++ b/src/DebugTools/Implementation/AxisAlignedBoxRenderer.h
@ -36,7 +36,7 @@ template<UnsignedInt dimensions> class AxisAlignedBoxRenderer: public AbstractBo
    public:
        AxisAlignedBoxRenderer(const Shapes::Implementation::AbstractShape<dimensions>* axisAlignedBox);

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

    private:
        const Shapes::AxisAlignedBox<dimensions>& axisAlignedBox;
--- a/src/DebugTools/Implementation/BoxRenderer.cpp
+++ b/src/DebugTools/Implementation/BoxRenderer.cpp
@ -33,7 +33,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>::MatrixType& projectionMatrix) {
+template<UnsignedInt dimensions> void BoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
    this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*box.transformation())
        ->setColor(options->color())
        ->use();
--- a/src/DebugTools/Implementation/BoxRenderer.h
+++ b/src/DebugTools/Implementation/BoxRenderer.h
@ -36,7 +36,7 @@ template<UnsignedInt dimensions> class BoxRenderer: public AbstractBoxRenderer<d
    public:
        BoxRenderer(const Shapes::Implementation::AbstractShape<dimensions>* box);

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

    private:
        const Shapes::Box<dimensions>& box;
--- a/src/DebugTools/Implementation/ForceRendererTransformation.h
+++ b/src/DebugTools/Implementation/ForceRendererTransformation.h
@ -31,7 +31,7 @@

 namespace Magnum { namespace DebugTools { namespace Implementation {

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

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

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

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

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

 namespace Magnum { namespace DebugTools { namespace Implementation {

-template<UnsignedInt dimensions> typename DimensionTraits<dimensions>::MatrixType lineSegmentRendererTransformation(const typename DimensionTraits<dimensions>::VectorType& a, const typename DimensionTraits<dimensions>::VectorType& b) {
-    auto transformation = DimensionTraits<dimensions>::MatrixType::translation(a);
+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);
    transformation.right() = b - a;
    return transformation;
 }
--- a/src/DebugTools/Implementation/PointRenderer.cpp
+++ b/src/DebugTools/Implementation/PointRenderer.cpp
@ -52,11 +52,11 @@ template<UnsignedInt dimensions> PointRenderer<dimensions>::PointRenderer(const
    if(!this->wireframeMesh) this->createResources(meshData<dimensions>());
 }

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

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

    private:
        const Shapes::Point<dimensions>& point;
--- a/src/DebugTools/Implementation/SphereRenderer.cpp
+++ b/src/DebugTools/Implementation/SphereRenderer.cpp
@ -39,10 +39,10 @@ AbstractSphereRenderer<2>::AbstractSphereRenderer(): AbstractShapeRenderer<2>("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>::MatrixType& projectionMatrix) {
+template<UnsignedInt dimensions> void SphereRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions, Float>::MatrixType& projectionMatrix) {
    this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
-        DimensionTraits<dimensions>::MatrixType::translation(sphere.position())*
-        DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(sphere.radius())))
+        DimensionTraits<dimensions, Float>::MatrixType::translation(sphere.position())*
+        DimensionTraits<dimensions, Float>::MatrixType::scaling(typename DimensionTraits<dimensions, Float>::VectorType(sphere.radius())))
        ->setColor(options->color())
        ->use();
    this->wireframeMesh->draw();
--- a/src/DebugTools/Implementation/SphereRenderer.h
+++ b/src/DebugTools/Implementation/SphereRenderer.h
@ -43,7 +43,7 @@ template<UnsignedInt dimensions> class SphereRenderer: public AbstractSphereRend
    public:
        SphereRenderer(const Shapes::Implementation::AbstractShape<dimensions>* sphere);

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

    private:
        const Shapes::Sphere<dimensions>& sphere;
--- a/src/DebugTools/ObjectRenderer.cpp
+++ b/src/DebugTools/ObjectRenderer.cpp
@ -173,8 +173,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>::MatrixType& transformationMatrix, SceneGraph::AbstractBasicCamera<dimensions, Float>* camera) {
-    shader->setTransformationProjectionMatrix(camera->projectionMatrix()*transformationMatrix*DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(options->size())))
+template<UnsignedInt dimensions> void ObjectRenderer<dimensions>::draw(const typename DimensionTraits<dimensions, Float>::MatrixType& transformationMatrix, SceneGraph::AbstractBasicCamera<dimensions, Float>* camera) {
+    shader->setTransformationProjectionMatrix(camera->projectionMatrix()*transformationMatrix*DimensionTraits<dimensions, Float>::MatrixType::scaling(typename DimensionTraits<dimensions, Float>::VectorType(options->size())))
        ->use();

    mesh->draw();
--- a/src/DebugTools/ShapeRenderer.cpp
+++ b/src/DebugTools/ShapeRenderer.cpp
@ -102,8 +102,8 @@ template<UnsignedInt dimensions> ShapeRenderer<dimensions>::~ShapeRenderer() {
    for(auto i: renderers) delete i;
 }

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

--- a/src/DimensionTraits.h
+++ b/src/DimensionTraits.h
@ -33,8 +33,8 @@

 namespace Magnum {

-/** @brief Matrix, point and vector specializations for given dimension count */
-template<UnsignedInt dimensions, class T = Float> struct DimensionTraits {
+/** @brief Matrix and vector specializations for given dimension count */
+template<UnsignedInt dimensions, class T> struct DimensionTraits {
    DimensionTraits() = delete;

    #ifdef DOXYGEN_GENERATING_OUTPUT
--- a/src/Shaders/AbstractVector.h
+++ b/src/Shaders/AbstractVector.h
@ -42,7 +42,7 @@ namespace Magnum { namespace Shaders {
 template<UnsignedInt dimensions> class AbstractVector: public AbstractShaderProgram {
    public:
        /** @brief Vertex position */
-        typedef Attribute<0, typename DimensionTraits<dimensions>::VectorType> Position;
+        typedef Attribute<0, typename DimensionTraits<dimensions, Float>::VectorType> Position;

        /** @brief Texture coordinates */
        typedef Attribute<1, Vector2> TextureCoordinates;
--- a/src/Shaders/DistanceFieldVector.h
+++ b/src/Shaders/DistanceFieldVector.h
@ -52,7 +52,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
        DistanceFieldVector();

        /** @brief Set transformation and projection matrix */
-        DistanceFieldVector* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+        DistanceFieldVector* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) {
            AbstractShaderProgram::setUniform(transformationProjectionMatrixUniform, matrix);
            return this;
        }
--- a/src/Shaders/Flat.h
+++ b/src/Shaders/Flat.h
@ -47,7 +47,7 @@ Draws whole mesh with one color.
 template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Flat: public AbstractShaderProgram {
    public:
        /** @brief Vertex position */
-        typedef Attribute<0, typename DimensionTraits<dimensions>::VectorType> Position;
+        typedef Attribute<0, typename DimensionTraits<dimensions, Float>::VectorType> Position;

        explicit Flat();

@ -55,7 +55,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Flat: public Abstra
         * @brief Set transformation and projection matrix
         * @return Pointer to self (for method chaining)
         */
-        Flat<dimensions>* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+        Flat<dimensions>* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) {
            setUniform(transformationProjectionMatrixUniform, matrix);
            return this;
        }
--- a/src/Shaders/Vector.h
+++ b/src/Shaders/Vector.h
@ -51,7 +51,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Vector: public Abst
         * @brief Set transformation and projection matrix
         * @return Pointer to self (for method chaining)
         */
-        Vector* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+        Vector* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) {
            AbstractShaderProgram::setUniform(transformationProjectionMatrixUniform, matrix);
            return this;
        }
--- a/src/Shaders/VertexColor.h
+++ b/src/Shaders/VertexColor.h
@ -47,7 +47,7 @@ Draws vertex-colored mesh.
 template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColor: public AbstractShaderProgram {
    public:
        /** @brief Vertex position */
-        typedef Attribute<0, typename DimensionTraits<dimensions>::VectorType> Position;
+        typedef Attribute<0, typename DimensionTraits<dimensions, Float>::VectorType> Position;

        /** @brief Vertex color */
        typedef Attribute<1, Color3> Color;
@ -60,7 +60,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColor: public
         *
         * Default is identity matrix.
         */
-        VertexColor<dimensions>* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+        VertexColor<dimensions>* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) {
            setUniform(transformationProjectionMatrixUniform, matrix);
            return this;
        }
--- a/src/Shapes/AxisAlignedBox.cpp
+++ b/src/Shapes/AxisAlignedBox.cpp
@ -30,7 +30,7 @@

 namespace Magnum { namespace Shapes {

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

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

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

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

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

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

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

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

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

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

 namespace Magnum { namespace Shapes {

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

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

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

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

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

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

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

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

 namespace Magnum { namespace Shapes {

-template<UnsignedInt dimensions> Capsule<dimensions> Capsule<dimensions>::transformed(const typename DimensionTraits<dimensions>::MatrixType& matrix) const {
+template<UnsignedInt dimensions> Capsule<dimensions> Capsule<dimensions>::transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
    return Capsule<dimensions>(matrix.transformPoint(_a), matrix.transformPoint(_b),
-        (matrix.rotationScaling()*typename DimensionTraits<dimensions>::VectorType(1/Constants::sqrt3())).length()*_radius);
+        (matrix.rotationScaling()*typename DimensionTraits<dimensions, Float>::VectorType(1/Constants::sqrt3())).length()*_radius);
 }

 template<UnsignedInt dimensions> bool Capsule<dimensions>::operator%(const Point<dimensions>& other) const {
--- a/src/Shapes/Capsule.h
+++ b/src/Shapes/Capsule.h
@ -58,28 +58,28 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Capsule {
        constexpr /*implicit*/ Capsule(): _radius(0.0f) {}

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

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

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

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

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

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

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

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

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

-template<UnsignedInt dimensions> Composition<dimensions> Composition<dimensions>::transformed(const typename DimensionTraits<dimensions>::MatrixType& matrix) const {
+template<UnsignedInt dimensions> Composition<dimensions> Composition<dimensions>::transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
    Composition<dimensions> out(*this);
    for(std::size_t i = 0; i != _shapeCount; ++i)
        _shapes[i]->transform(matrix, out._shapes[i]);
--- a/src/Shapes/Composition.h
+++ b/src/Shapes/Composition.h
@ -125,7 +125,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>::MatrixType& matrix) const;
+        Composition<dimensions> transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const;

        /** @brief Count of shapes in the hierarchy */
        std::size_t size() const { return _shapeCount; }
--- a/src/Shapes/Line.cpp
+++ b/src/Shapes/Line.cpp
@ -29,7 +29,7 @@

 namespace Magnum { namespace Shapes {

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

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

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

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

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

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

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

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

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

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

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

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

 namespace Magnum { namespace Shapes {

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

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

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

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

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

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

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

 /** @brief Two-dimensional point */
--- a/src/Shapes/Shape.cpp
+++ b/src/Shapes/Shape.cpp
@ -36,7 +36,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>::MatrixType& absoluteTransformationMatrix) {
+template<UnsignedInt dimensions> void ShapeHelper<Composition<dimensions>>::transform(Shapes::Shape<Composition<dimensions>>& shape, const typename DimensionTraits<dimensions, Float>::MatrixType& 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/Shapes/Shape.h
+++ b/src/Shapes/Shape.h
@ -107,7 +107,7 @@ template<class T> class MAGNUM_SHAPES_EXPORT Shape: public AbstractShape<T::Dime

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

    private:
        const Implementation::AbstractShape<T::Dimensions>* abstractTransformedShape() const override {
@ -128,7 +128,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>::MatrixType& absoluteTransformationMatrix) {
+template<class T> void Shape<T>::clean(const typename DimensionTraits<T::Dimensions, Float>::MatrixType& absoluteTransformationMatrix) {
    Implementation::ShapeHelper<T>::transform(*this, absoluteTransformationMatrix);
 }

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

-        static void transform(Shapes::Shape<T>& shape, const typename DimensionTraits<T::Dimensions>::MatrixType& absoluteTransformationMatrix) {
+        static void transform(Shapes::Shape<T>& shape, const typename DimensionTraits<T::Dimensions, Float>::MatrixType& absoluteTransformationMatrix) {
            shape._transformedShape.shape = shape._shape.shape.transformed(absoluteTransformationMatrix);
        }
    };
@ -147,7 +147,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>::MatrixType& absoluteTransformationMatrix);
+        static void transform(Shapes::Shape<Composition<dimensions>>& shape, const typename DimensionTraits<dimensions, Float>::MatrixType& absoluteTransformationMatrix);
    };
 }

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

 namespace {
-    template<UnsignedInt dimensions> static typename DimensionTraits<dimensions>::VectorType unitVector();
+    template<UnsignedInt dimensions> static typename DimensionTraits<dimensions, Float>::VectorType unitVector();

    template<> inline Vector2 unitVector<2>() {
        return Vector2(1/Constants::sqrt2());
@ -48,7 +48,7 @@ namespace {
    }
 }

-template<UnsignedInt dimensions> Sphere<dimensions> Sphere<dimensions>::transformed(const typename DimensionTraits<dimensions>::MatrixType& matrix) const {
+template<UnsignedInt dimensions> Sphere<dimensions> Sphere<dimensions>::transformed(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix) const {
    return Sphere<dimensions>(matrix.transformPoint(_position),
        (matrix.rotationScaling()*unitVector<dimensions>()).length()*_radius);
 }
--- a/src/Shapes/Sphere.h
+++ b/src/Shapes/Sphere.h
@ -58,18 +58,18 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Sphere {
        constexpr /*implicit*/ Sphere(): _radius(0.0f) {}

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

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

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

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

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

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

--- a/src/Shapes/shapeImplementation.h
+++ b/src/Shapes/shapeImplementation.h
@ -126,7 +126,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>::MatrixType& matrix, AbstractShape<dimensions>* result) const = 0;
+    virtual void MAGNUM_SHAPES_LOCAL transform(const typename DimensionTraits<dimensions, Float>::MatrixType& matrix, AbstractShape<dimensions>* result) const = 0;
 };

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

-    void transform(const typename DimensionTraits<T::Dimensions>::MatrixType& matrix, AbstractShape<T::Dimensions>* result) const override {
+    void transform(const typename DimensionTraits<T::Dimensions, Float>::MatrixType& matrix, AbstractShape<T::Dimensions>* result) const override {
        CORRADE_INTERNAL_ASSERT(result->type() == type());
        static_cast<Shape<T>*>(result)->shape = shape.transformed(matrix);
    }