diff --git a/src/Physics/AbstractShape.h b/src/Physics/AbstractShape.h
index a8320aa0d..c4e6dff67 100644
--- a/src/Physics/AbstractShape.h
+++ b/src/Physics/AbstractShape.h
@@ -105,7 +105,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT AbstractShape {
          * Applies transformation to user-defined shape properties and caches
          * them for later usage in collision detection.
          */
-        virtual void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) = 0;
+        virtual void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) = 0;
 
         /**
          * @brief Detect collision with other shape
diff --git a/src/Physics/AxisAlignedBox.cpp b/src/Physics/AxisAlignedBox.cpp
index 63b288fcc..8b15efa27 100644
--- a/src/Physics/AxisAlignedBox.cpp
+++ b/src/Physics/AxisAlignedBox.cpp
@@ -20,8 +20,8 @@
 
 namespace Magnum { namespace Physics {
 
-template<std::uint8_t dimensions> void AxisAlignedBox<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
-    _transformedPosition = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_position)).vector();
+template<std::uint8_t dimensions> void AxisAlignedBox<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
+    _transformedPosition = (transformation*typename DimensionTraits<dimensions>::PointType(_position)).vector();
     _transformedSize = transformation.rotationScaling()*_size;
 }
 
diff --git a/src/Physics/AxisAlignedBox.h b/src/Physics/AxisAlignedBox.h
index 711491575..2c00e8f35 100644
--- a/src/Physics/AxisAlignedBox.h
+++ b/src/Physics/AxisAlignedBox.h
@@ -34,44 +34,44 @@ namespace Magnum { namespace Physics {
 template<std::uint8_t dimensions> class PHYSICS_EXPORT AxisAlignedBox: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline AxisAlignedBox(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position, const typename DimensionTraits<dimensions, GLfloat>::VectorType& size): _position(position), _transformedPosition(position), _size(size), _transformedSize(size) {}
+        inline AxisAlignedBox(const typename DimensionTraits<dimensions>::VectorType& position, const typename DimensionTraits<dimensions>::VectorType& size): _position(position), _transformedPosition(position), _size(size), _transformedSize(size) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::AxisAlignedBox;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         /** @brief Position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType position() const {
+        inline typename DimensionTraits<dimensions>::VectorType position() const {
             return _position;
         }
 
         /** @brief Set position */
-        inline void setPosition(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position) {
+        inline void setPosition(const typename DimensionTraits<dimensions>::VectorType& position) {
             _position = position;
         }
 
         /** @brief Size */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType size() const { return _size; }
+        inline typename DimensionTraits<dimensions>::VectorType size() const { return _size; }
 
         /** @brief Set size */
-        inline void setSize(const typename DimensionTraits<dimensions, GLfloat>::VectorType& size) {
+        inline void setSize(const typename DimensionTraits<dimensions>::VectorType& size) {
             _size = size;
         }
 
         /** @brief Transformed position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedPosition() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedPosition() const {
             return _transformedPosition;
         }
 
         /** @brief Transformed size */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedSize() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedSize() const {
             return _transformedSize;
         }
 
     private:
-        Math::Vector<dimensions, GLfloat> _position, _transformedPosition,
+        typename DimensionTraits<dimensions>::VectorType _position, _transformedPosition,
             _size, _transformedSize;
 };
 
diff --git a/src/Physics/Box.cpp b/src/Physics/Box.cpp
index 2b0eb5725..e1ed39501 100644
--- a/src/Physics/Box.cpp
+++ b/src/Physics/Box.cpp
@@ -20,7 +20,7 @@
 
 namespace Magnum { namespace Physics {
 
-template<std::uint8_t dimensions> void Box<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
+template<std::uint8_t dimensions> void Box<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
     _transformedTransformation = (transformation*_transformation);
 }
 
diff --git a/src/Physics/Box.h b/src/Physics/Box.h
index 81959172e..87f259a12 100644
--- a/src/Physics/Box.h
+++ b/src/Physics/Box.h
@@ -36,31 +36,31 @@ namespace Magnum { namespace Physics {
 template<std::uint8_t dimensions> class PHYSICS_EXPORT Box: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline Box(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation): _transformation(transformation), _transformedTransformation(transformation) {}
+        inline Box(const typename DimensionTraits<dimensions>::MatrixType& transformation): _transformation(transformation), _transformedTransformation(transformation) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::Box;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         /** @brief Transformation */
-        inline typename DimensionTraits<dimensions, GLfloat>::MatrixType transformation() const {
+        inline typename DimensionTraits<dimensions>::MatrixType transformation() const {
             return _transformation;
         }
 
         /** @brief Set transformation */
-        inline void setTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
+        inline void setTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
             _transformation = transformation;
         }
 
         /** @brief Transformed transformation */
-        inline typename DimensionTraits<dimensions, GLfloat>::MatrixType transformedTransformation() const {
+        inline typename DimensionTraits<dimensions>::MatrixType transformedTransformation() const {
             return _transformedTransformation;
         }
 
     private:
-        Math::Matrix<dimensions+1, GLfloat> _transformation,
+        typename DimensionTraits<dimensions>::MatrixType _transformation,
             _transformedTransformation;
 };
 
diff --git a/src/Physics/Capsule.cpp b/src/Physics/Capsule.cpp
index 0c9c1b288..0c9a8882e 100644
--- a/src/Physics/Capsule.cpp
+++ b/src/Physics/Capsule.cpp
@@ -27,10 +27,10 @@ using namespace Magnum::Math::Geometry;
 
 namespace Magnum { namespace Physics {
 
-template<std::uint8_t dimensions> void Capsule<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
-    _transformedA = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_a)).vector();
-    _transformedB = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_b)).vector();
-    float scaling = (transformation.rotationScaling()*typename DimensionTraits<dimensions, GLfloat>::VectorType(1/Math::Constants<float>::sqrt3())).length();
+template<std::uint8_t dimensions> void Capsule<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
+    _transformedA = (transformation*typename DimensionTraits<dimensions>::PointType(_a)).vector();
+    _transformedB = (transformation*typename DimensionTraits<dimensions>::PointType(_b)).vector();
+    float scaling = (transformation.rotationScaling()*typename DimensionTraits<dimensions>::VectorType(1/Math::Constants<float>::sqrt3())).length();
     _transformedRadius = scaling*_radius;
 }
 
diff --git a/src/Physics/Capsule.h b/src/Physics/Capsule.h
index af8a19a36..3c5aad2d6 100644
--- a/src/Physics/Capsule.h
+++ b/src/Physics/Capsule.h
@@ -37,33 +37,33 @@ applying transformation, the scale factor is averaged from all axes.
 template<std::uint8_t dimensions> class PHYSICS_EXPORT Capsule: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline Capsule(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a, const typename DimensionTraits<dimensions, GLfloat>::VectorType& b, float radius): _a(a), _transformedA(a), _b(b), _transformedB(b), _radius(radius), _transformedRadius(radius) {}
+        inline Capsule(const typename DimensionTraits<dimensions>::VectorType& a, const typename DimensionTraits<dimensions>::VectorType& b, float radius): _a(a), _transformedA(a), _b(b), _transformedB(b), _radius(radius), _transformedRadius(radius) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::Capsule;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         bool collides(const AbstractShape<dimensions>* other) const override;
 
         /** @brief Start point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType a() const {
+        inline typename DimensionTraits<dimensions>::VectorType a() const {
             return _a;
         }
 
         /** @brief End point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType b() const {
+        inline typename DimensionTraits<dimensions>::VectorType b() const {
             return _a;
         }
 
         /** @brief Set start point */
-        inline void setA(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a) {
+        inline void setA(const typename DimensionTraits<dimensions>::VectorType& a) {
             _a = a;
         }
 
         /** @brief Set end point */
-        inline void setB(const typename DimensionTraits<dimensions, GLfloat>::VectorType& b) {
+        inline void setB(const typename DimensionTraits<dimensions>::VectorType& b) {
             _b = b;
         }
 
@@ -74,12 +74,12 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Capsule: public AbstractS
         inline void setRadius(float radius) { _radius = radius; }
 
         /** @brief Transformed first point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedA() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedA() const {
             return _transformedA;
         }
 
         /** @brief Transformed second point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedB() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedB() const {
             return _transformedB;
         }
 
@@ -95,7 +95,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Capsule: public AbstractS
         bool operator%(const Sphere<dimensions>& other) const;
 
     private:
-        Math::Vector<dimensions, GLfloat> _a, _transformedA,
+        typename DimensionTraits<dimensions>::VectorType _a, _transformedA,
             _b, _transformedB;
         float _radius, _transformedRadius;
 };
diff --git a/src/Physics/Implementation/AbstractDebugRenderer.h b/src/Physics/Implementation/AbstractDebugRenderer.h
index 0b3af89c2..3d699899b 100644
--- a/src/Physics/Implementation/AbstractDebugRenderer.h
+++ b/src/Physics/Implementation/AbstractDebugRenderer.h
@@ -38,7 +38,7 @@ template<std::uint8_t dimensions> class AbstractDebugRenderer {
 
         virtual ~AbstractDebugRenderer();
 
-        virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) = 0;
+        virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) = 0;
 
     protected:
         Resource<AbstractShaderProgram, Shaders::FlatShader<dimensions>> shader;
diff --git a/src/Physics/Implementation/AbstractShapeRenderer.h b/src/Physics/Implementation/AbstractShapeRenderer.h
index 276d53ba2..737e29895 100644
--- a/src/Physics/Implementation/AbstractShapeRenderer.h
+++ b/src/Physics/Implementation/AbstractShapeRenderer.h
@@ -38,7 +38,7 @@ template<std::uint8_t dimensions> class AbstractShapeRenderer {
 
         virtual ~AbstractShapeRenderer();
 
-        virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) = 0;
+        virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) = 0;
 
     protected:
         Resource<AbstractShaderProgram, Shaders::FlatShader<dimensions>> shader;
diff --git a/src/Physics/Implementation/AxisAlignedBoxRenderer.cpp b/src/Physics/Implementation/AxisAlignedBoxRenderer.cpp
index 57e701116..d53732742 100644
--- a/src/Physics/Implementation/AxisAlignedBoxRenderer.cpp
+++ b/src/Physics/Implementation/AxisAlignedBoxRenderer.cpp
@@ -22,7 +22,7 @@
 
 namespace Magnum { namespace Physics { namespace Implementation {
 
-template<std::uint8_t dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions, GLfloat>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
+template<std::uint8_t dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
     typename DimensionTraits<dimensions>::MatrixType transformation =
         DimensionTraits<dimensions>::MatrixType::translation(axisAlignedBox.transformedPosition())*
         DimensionTraits<dimensions>::MatrixType::scaling(axisAlignedBox.transformedSize());
diff --git a/src/Physics/Implementation/BoxRenderer.cpp b/src/Physics/Implementation/BoxRenderer.cpp
index 1624e7aa3..ea4531324 100644
--- a/src/Physics/Implementation/BoxRenderer.cpp
+++ b/src/Physics/Implementation/BoxRenderer.cpp
@@ -22,7 +22,7 @@
 
 namespace Magnum { namespace Physics { namespace Implementation {
 
-template<std::uint8_t dimensions> void BoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions, GLfloat>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
+template<std::uint8_t dimensions> void BoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
     this->shader->setTransformationProjection(camera->projectionMatrix()*camera->cameraMatrix()*box.transformedTransformation())
         ->setColor(options->color)
         ->use();
diff --git a/src/Physics/Implementation/BoxRenderer.h b/src/Physics/Implementation/BoxRenderer.h
index c1e248478..4513155c1 100644
--- a/src/Physics/Implementation/BoxRenderer.h
+++ b/src/Physics/Implementation/BoxRenderer.h
@@ -27,7 +27,7 @@ template<std::uint8_t dimensions> class BoxRenderer: public AbstractBoxRenderer<
     public:
         inline BoxRenderer(Box<dimensions>& box): box(box) {}
 
-        void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformation, typename SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) override;
+        void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformation, typename SceneGraph::AbstractCamera<dimensions>* camera) override;
 
     private:
         Box<dimensions>& box;
diff --git a/src/Physics/Implementation/DebugRenderer.h b/src/Physics/Implementation/DebugRenderer.h
index fdb19e268..87e806392 100644
--- a/src/Physics/Implementation/DebugRenderer.h
+++ b/src/Physics/Implementation/DebugRenderer.h
@@ -44,7 +44,7 @@ template<std::uint8_t dimensions> class DebugRenderer: public SceneGraph::Drawab
             renderers.push_back(renderer);
         }
 
-        inline void draw(const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) override {
+        inline void draw(const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) override {
             for(auto i: renderers) i->draw(options, transformationMatrix, camera);
         }
 
diff --git a/src/Physics/Line.cpp b/src/Physics/Line.cpp
index c067306c0..65533e3ef 100644
--- a/src/Physics/Line.cpp
+++ b/src/Physics/Line.cpp
@@ -20,9 +20,9 @@
 
 namespace Magnum { namespace Physics {
 
-template<std::uint8_t dimensions> void Line<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
-    _transformedA = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_a)).vector();
-    _transformedB = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_b)).vector();
+template<std::uint8_t dimensions> void Line<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
+    _transformedA = (transformation*typename DimensionTraits<dimensions>::PointType(_a)).vector();
+    _transformedB = (transformation*typename DimensionTraits<dimensions>::PointType(_b)).vector();
 }
 
 /* Explicitly instantiate the templates */
diff --git a/src/Physics/Line.h b/src/Physics/Line.h
index 39cb70363..df509d87d 100644
--- a/src/Physics/Line.h
+++ b/src/Physics/Line.h
@@ -35,46 +35,46 @@ namespace Magnum { namespace Physics {
 template<std::uint8_t dimensions> class PHYSICS_EXPORT Line: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline Line(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a, const typename DimensionTraits<dimensions, GLfloat>::VectorType& b): _a(a), _transformedA(a), _b(b), _transformedB(b) {}
+        inline Line(const typename DimensionTraits<dimensions>::VectorType& a, const typename DimensionTraits<dimensions>::VectorType& b): _a(a), _transformedA(a), _b(b), _transformedB(b) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::Line;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         /** @brief First point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType a() const {
+        inline typename DimensionTraits<dimensions>::VectorType a() const {
             return _a;
         }
 
         /** @brief Second point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType b() const {
+        inline typename DimensionTraits<dimensions>::VectorType b() const {
             return _a;
         }
 
         /** @brief Set first point */
-        inline void setA(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a) {
+        inline void setA(const typename DimensionTraits<dimensions>::VectorType& a) {
             _a = a;
         }
 
         /** @brief Set second point */
-        inline void setB(const typename DimensionTraits<dimensions, GLfloat>::VectorType& b) {
+        inline void setB(const typename DimensionTraits<dimensions>::VectorType& b) {
             _b = b;
         }
 
         /** @brief Transformed first point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedA() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedA() const {
             return _transformedA;
         }
 
         /** @brief Transformed second point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedB() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedB() const {
             return _transformedB;
         }
 
     private:
-        Math::Vector<dimensions, GLfloat> _a, _transformedA,
+        typename DimensionTraits<dimensions>::VectorType _a, _transformedA,
             _b, _transformedB;
 };
 
diff --git a/src/Physics/LineSegment.h b/src/Physics/LineSegment.h
index 8c0d00242..4ed4b9449 100644
--- a/src/Physics/LineSegment.h
+++ b/src/Physics/LineSegment.h
@@ -31,7 +31,7 @@ namespace Magnum { namespace Physics {
 template<std::uint8_t dimensions> class LineSegment: public Line<dimensions> {
     public:
         /** @brief Constructor */
-        inline LineSegment(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a, const typename DimensionTraits<dimensions, GLfloat>::VectorType& b): Line<dimensions>(a, b) {}
+        inline LineSegment(const typename DimensionTraits<dimensions>::VectorType& a, const typename DimensionTraits<dimensions>::VectorType& b): Line<dimensions>(a, b) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::LineSegment;
diff --git a/src/Physics/ObjectShape.cpp b/src/Physics/ObjectShape.cpp
index 4ce8e4ce7..446433d5a 100644
--- a/src/Physics/ObjectShape.cpp
+++ b/src/Physics/ObjectShape.cpp
@@ -36,7 +36,7 @@ template<uint8_t dimensions> void ObjectShape<dimensions>::markDirty() {
     group()->setDirty();
 }
 
-template<uint8_t dimensions> void ObjectShape<dimensions>::clean(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& absoluteTransformation) {
+template<uint8_t dimensions> void ObjectShape<dimensions>::clean(const typename DimensionTraits<dimensions>::MatrixType& absoluteTransformation) {
     if(_shape) _shape->applyTransformation(absoluteTransformation);
 }
 
diff --git a/src/Physics/Plane.h b/src/Physics/Plane.h
index 2397aa2e2..253e41484 100644
--- a/src/Physics/Plane.h
+++ b/src/Physics/Plane.h
@@ -39,7 +39,7 @@ class PHYSICS_EXPORT Plane: public AbstractShape<3> {
         void applyTransformation(const Matrix4& transformation) override;
         bool collides(const AbstractShape<3>* other) const override;
         #else
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
         bool collides(const AbstractShape* other) const override;
         #endif
 
diff --git a/src/Physics/Point.cpp b/src/Physics/Point.cpp
index 6ca6df6f4..06850fd68 100644
--- a/src/Physics/Point.cpp
+++ b/src/Physics/Point.cpp
@@ -20,8 +20,8 @@
 
 namespace Magnum { namespace Physics {
 
-template<std::uint8_t dimensions> void Point<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
-    _transformedPosition = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_position)).vector();
+template<std::uint8_t dimensions> void Point<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
+    _transformedPosition = (transformation*typename DimensionTraits<dimensions>::PointType(_position)).vector();
 }
 
 template class Point<2>;
diff --git a/src/Physics/Point.h b/src/Physics/Point.h
index 142b315e0..a228173f9 100644
--- a/src/Physics/Point.h
+++ b/src/Physics/Point.h
@@ -34,31 +34,31 @@ namespace Magnum { namespace Physics {
 template<std::uint8_t dimensions> class PHYSICS_EXPORT Point: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline Point(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position): _position(position), _transformedPosition(position) {}
+        inline Point(const typename DimensionTraits<dimensions>::VectorType& position): _position(position), _transformedPosition(position) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::Point;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         /** @brief Position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType position() const {
+        inline typename DimensionTraits<dimensions>::VectorType position() const {
             return _position;
         }
 
         /** @brief Set position */
-        inline void setPosition(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position) {
+        inline void setPosition(const typename DimensionTraits<dimensions>::VectorType& position) {
             _position = position;
         }
 
         /** @brief Transformed position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedPosition() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedPosition() const {
             return _transformedPosition;
         }
 
     private:
-        Math::Vector<dimensions, GLfloat> _position, _transformedPosition;
+        typename DimensionTraits<dimensions>::VectorType _position, _transformedPosition;
 };
 
 /** @brief Two-dimensional point */
diff --git a/src/Physics/ShapeGroup.cpp b/src/Physics/ShapeGroup.cpp
index 83a5f7178..3352a2664 100644
--- a/src/Physics/ShapeGroup.cpp
+++ b/src/Physics/ShapeGroup.cpp
@@ -43,7 +43,7 @@ template<std::uint8_t dimensions> ShapeGroup<dimensions>& ShapeGroup<dimensions>
     return *this;
 }
 
-template<std::uint8_t dimensions> void ShapeGroup<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
+template<std::uint8_t dimensions> void ShapeGroup<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
     if(a) a->applyTransformation(transformation);
     if(b) b->applyTransformation(transformation);
 }
diff --git a/src/Physics/ShapeGroup.h b/src/Physics/ShapeGroup.h
index 8a3533e84..04992413d 100644
--- a/src/Physics/ShapeGroup.h
+++ b/src/Physics/ShapeGroup.h
@@ -105,7 +105,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT ShapeGroup: public Abstra
             return AbstractShape<dimensions>::Type::ShapeGroup;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         bool collides(const AbstractShape<dimensions>* other) const override;
 
diff --git a/src/Physics/Sphere.cpp b/src/Physics/Sphere.cpp
index b0f578871..91caac41d 100644
--- a/src/Physics/Sphere.cpp
+++ b/src/Physics/Sphere.cpp
@@ -28,7 +28,7 @@ using namespace Magnum::Math::Geometry;
 namespace Magnum { namespace Physics {
 
 namespace {
-    template<std::uint8_t dimensions> static typename DimensionTraits<dimensions, GLfloat>::VectorType unitVector();
+    template<std::uint8_t dimensions> static typename DimensionTraits<dimensions>::VectorType unitVector();
 
     template<> inline Vector2 unitVector<2>() {
         return Vector2(1/Math::Constants<float>::sqrt2());
@@ -39,8 +39,8 @@ namespace {
     }
 }
 
-template<std::uint8_t dimensions> void Sphere<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
-    _transformedPosition = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_position)).vector();
+template<std::uint8_t dimensions> void Sphere<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
+    _transformedPosition = (transformation*typename DimensionTraits<dimensions>::PointType(_position)).vector();
     float scaling = (transformation.rotationScaling()*unitVector<dimensions>()).length();
     _transformedRadius = scaling*_radius;
 }
diff --git a/src/Physics/Sphere.h b/src/Physics/Sphere.h
index 1fd8cc378..f77cf8415 100644
--- a/src/Physics/Sphere.h
+++ b/src/Physics/Sphere.h
@@ -37,23 +37,23 @@ applying transformation, the scale factor is averaged from all axes.
 template<std::uint8_t dimensions> class PHYSICS_EXPORT Sphere: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline Sphere(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position, float radius): _position(position), _transformedPosition(position), _radius(radius), _transformedRadius(radius) {}
+        inline Sphere(const typename DimensionTraits<dimensions>::VectorType& position, float radius): _position(position), _transformedPosition(position), _radius(radius), _transformedRadius(radius) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::Sphere;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         bool collides(const AbstractShape<dimensions>* other) const override;
 
         /** @brief Position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType position() const {
+        inline typename DimensionTraits<dimensions>::VectorType position() const {
             return _position;
         }
 
         /** @brief Set position */
-        inline void setPosition(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position) {
+        inline void setPosition(const typename DimensionTraits<dimensions>::VectorType& position) {
             _position = position;
         }
 
@@ -64,7 +64,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Sphere: public AbstractSh
         inline void setRadius(float radius) { _radius = radius; }
 
         /** @brief Transformed position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedPosition() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedPosition() const {
             return _transformedPosition;
         }
 
@@ -86,7 +86,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Sphere: public AbstractSh
         bool operator%(const Sphere<dimensions>& other) const;
 
     private:
-        Math::Vector<dimensions, GLfloat> _position,
+        typename DimensionTraits<dimensions>::VectorType _position,
             _transformedPosition;
         float _radius, _transformedRadius;
 };
diff --git a/src/SceneGraph/Test/ObjectTest.cpp b/src/SceneGraph/Test/ObjectTest.cpp
index 376f859b3..abe60f4c7 100644
--- a/src/SceneGraph/Test/ObjectTest.cpp
+++ b/src/SceneGraph/Test/ObjectTest.cpp
@@ -27,12 +27,12 @@ CORRADE_TEST_MAIN(Magnum::SceneGraph::Test::ObjectTest)
 
 namespace Magnum { namespace SceneGraph { namespace Test {
 
-typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<GLfloat>> Object3D;
-typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<GLfloat>> Scene3D;
+typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D;
+typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<>> Scene3D;
 
-class CachingObject: public Object3D, AbstractFeature<3, GLfloat> {
+class CachingObject: public Object3D, AbstractFeature<3> {
     public:
-        inline CachingObject(Object3D* parent = nullptr): Object3D(parent), AbstractFeature<3, GLfloat>(this) {
+        inline CachingObject(Object3D* parent = nullptr): Object3D(parent), AbstractFeature<3>(this) {
             setCachedTransformations(CachedTransformation::Absolute);
         }
 
@@ -189,9 +189,9 @@ void ObjectTest::transformations() {
 void ObjectTest::setClean() {
     Scene3D scene;
 
-    class CachingFeature: public AbstractFeature<3, GLfloat> {
+    class CachingFeature: public AbstractFeature<3> {
         public:
-            CachingFeature(AbstractObject<3, GLfloat>* object): AbstractFeature<3, GLfloat>(object) {
+            CachingFeature(AbstractObject<3>* object): AbstractFeature<3>(object) {
                 setCachedTransformations(CachedTransformation::Absolute);
             }
 
@@ -202,9 +202,9 @@ void ObjectTest::setClean() {
             }
     };
 
-    class CachingInvertedFeature: public AbstractFeature<3, GLfloat> {
+    class CachingInvertedFeature: public AbstractFeature<3> {
         public:
-            CachingInvertedFeature(AbstractObject<3, GLfloat>* object): AbstractFeature<3, GLfloat>(object) {
+            CachingInvertedFeature(AbstractObject<3>* object): AbstractFeature<3>(object) {
                 setCachedTransformations(CachedTransformation::InvertedAbsolute);
             }
 
diff --git a/src/Shaders/FlatShader.h b/src/Shaders/FlatShader.h
index bbdca99e5..af839d760 100644
--- a/src/Shaders/FlatShader.h
+++ b/src/Shaders/FlatShader.h
@@ -38,7 +38,7 @@ Draws whole mesh with one color.
 template<std::uint8_t dimensions> class SHADERS_EXPORT FlatShader: public AbstractShaderProgram {
     public:
         /** @brief Vertex position */
-        typedef Attribute<0, typename DimensionTraits<dimensions, GLfloat>::PointType> Position;
+        typedef Attribute<0, typename DimensionTraits<dimensions>::PointType> Position;
 
         FlatShader();
 
@@ -46,7 +46,7 @@ template<std::uint8_t dimensions> class SHADERS_EXPORT FlatShader: public Abstra
          * @brief Set transformation and projection matrix
          * @return Pointer to self (for method chaining)
          */
-        FlatShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& matrix) {
+        FlatShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
             setUniform(transformationProjectionUniform, matrix);
             return this;
         }
diff --git a/src/Shaders/VertexColorShader.h b/src/Shaders/VertexColorShader.h
index 1c68a147a..437e1a7ed 100644
--- a/src/Shaders/VertexColorShader.h
+++ b/src/Shaders/VertexColorShader.h
@@ -38,7 +38,7 @@ Draws vertex-colored mesh.
 template<std::uint8_t dimensions> class SHADERS_EXPORT VertexColorShader: public AbstractShaderProgram {
     public:
         /** @brief Vertex position */
-        typedef Attribute<0, typename DimensionTraits<dimensions, GLfloat>::PointType> Position;
+        typedef Attribute<0, typename DimensionTraits<dimensions>::PointType> Position;
 
         /** @brief Vertex color */
         typedef Attribute<1, Color3<GLfloat>> Color;
@@ -49,7 +49,7 @@ template<std::uint8_t dimensions> class SHADERS_EXPORT VertexColorShader: public
          * @brief Set transformation and projection
          * @return Pointer to self (for method chaining)
          */
-        inline VertexColorShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& matrix) {
+        inline VertexColorShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
             setUniform(transformationProjectionUniform, matrix);
             return this;
         }