Using default template arguments instead of GLfloat everywhere.

It was mainly in DimensionTraits usage. Also using DimensionTraits::*Type
for private members of physics shapes instead of manually specified
superclasses. The header is still included because of all the inline
accessors, so why not use the same type inside the class.

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

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;
 }
 

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;
 };
 

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);
 }
 

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;
 };
 

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;
 }
 

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;
 };

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;

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;

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());

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();

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;

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);
         }
 

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 */

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;
 };
 

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;

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);
 }
 

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
 

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>;

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 */

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);
 }

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;
 

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;
 }

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;
 };

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);
             }
 

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;
         }

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;
         }