Explicitly use *Matrix in names when appropriate.

* In shader uniforms (projectionMatrix makes more sense than projection
   alone)
 * For underlying types for SceneGraph transformation. It is already
   used in Drawable::clean() as transformationMatrix, so why not use it
   also in AbstractFeature::clean(). Moreover, clean() could be in
   future also done using something else, this helps to distinguish the
   type just from parameter name.
 * In Physics shapes - applyTransformationMatrix() (as it could be in
   future also done using something else).

src/Physics/AbstractShape.h

@@ -100,12 +100,12 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT AbstractShape {
         virtual Type type() const = 0;
 
         /**
-         * @brief Apply transformation
+         * @brief Apply transformation matrix
          *
-         * Applies transformation to user-defined shape properties and caches
-         * them for later usage in collision detection.
+         * Applies transformation matrix to user-defined shape properties and
+         * caches them for later usage in collision detection.
          */
-        virtual void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) = 0;
+        virtual void applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) = 0;
 
         /**
          * @brief Detect collision with other shape

src/Physics/AxisAlignedBox.cpp

@@ -20,9 +20,9 @@
 
 namespace Magnum { namespace Physics {
 
-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;
+template<std::uint8_t dimensions> void AxisAlignedBox<dimensions>::applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+    _transformedPosition = (matrix*typename DimensionTraits<dimensions>::PointType(_position)).vector();
+    _transformedSize = matrix.rotationScaling()*_size;
 }
 
 template class AxisAlignedBox<2>;

src/Physics/AxisAlignedBox.h

@@ -40,7 +40,7 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT AxisAlignedBox: pu
             return AbstractShape<dimensions>::Type::AxisAlignedBox;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
+        void applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) override;
 
         /** @brief Position */
         inline typename DimensionTraits<dimensions>::VectorType position() const {

src/Physics/Box.cpp

@@ -20,8 +20,8 @@
 
 namespace Magnum { namespace Physics {
 
-template<std::uint8_t dimensions> void Box<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
-    _transformedTransformation = (transformation*_transformation);
+template<std::uint8_t dimensions> void Box<dimensions>::applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+    _transformedTransformation = matrix*_transformation;
 }
 
 template class Box<2>;

src/Physics/Box.h

@@ -42,7 +42,7 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT Box: public Abstra
             return AbstractShape<dimensions>::Type::Box;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
+        void applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) override;
 
         /** @brief Transformation */
         inline typename DimensionTraits<dimensions>::MatrixType transformation() const {

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>::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/Constants::sqrt3())).length();
+template<std::uint8_t dimensions> void Capsule<dimensions>::applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+    _transformedA = (matrix*typename DimensionTraits<dimensions>::PointType(_a)).vector();
+    _transformedB = (matrix*typename DimensionTraits<dimensions>::PointType(_b)).vector();
+    float scaling = (matrix.rotationScaling()*typename DimensionTraits<dimensions>::VectorType(1/Constants::sqrt3())).length();
     _transformedRadius = scaling*_radius;
 }
 

src/Physics/Capsule.h

@@ -43,7 +43,7 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT Capsule: public Ab
             return AbstractShape<dimensions>::Type::Capsule;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
+        void applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) override;
 
         bool collides(const AbstractShape<dimensions>* other) const override;
 

src/Physics/Implementation/AxisAlignedBoxRenderer.cpp

@@ -26,7 +26,7 @@ template<std::uint8_t dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(
     typename DimensionTraits<dimensions>::MatrixType transformation =
         DimensionTraits<dimensions>::MatrixType::translation(axisAlignedBox.transformedPosition())*
         DimensionTraits<dimensions>::MatrixType::scaling(axisAlignedBox.transformedSize());
-    this->shader->setTransformationProjection(camera->projectionMatrix()*camera->cameraMatrix()*transformation)
+    this->shader->setTransformationProjectionMatrix(camera->projectionMatrix()*camera->cameraMatrix()*transformation)
         ->setColor(options->color)
         ->use();
     this->mesh->draw();

src/Physics/Implementation/BoxRenderer.cpp

@@ -23,7 +23,7 @@
 namespace Magnum { namespace Physics { namespace Implementation {
 
 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())
+    this->shader->setTransformationProjectionMatrix(camera->projectionMatrix()*camera->cameraMatrix()*box.transformedTransformation())
         ->setColor(options->color)
         ->use();
     this->mesh->draw();

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>::MatrixType& transformation) {
-    _transformedA = (transformation*typename DimensionTraits<dimensions>::PointType(_a)).vector();
-    _transformedB = (transformation*typename DimensionTraits<dimensions>::PointType(_b)).vector();
+template<std::uint8_t dimensions> void Line<dimensions>::applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+    _transformedA = (matrix*typename DimensionTraits<dimensions>::PointType(_a)).vector();
+    _transformedB = (matrix*typename DimensionTraits<dimensions>::PointType(_b)).vector();
 }
 
 /* Explicitly instantiate the templates */

src/Physics/Line.h

@@ -41,7 +41,7 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT Line: public Abstr
             return AbstractShape<dimensions>::Type::Line;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
+        void applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) override;
 
         /** @brief First point */
         inline typename DimensionTraits<dimensions>::VectorType a() const {

src/Physics/ObjectShape.cpp

@@ -36,8 +36,8 @@ template<uint8_t dimensions> void ObjectShape<dimensions>::markDirty() {
     group()->setDirty();
 }
 
-template<uint8_t dimensions> void ObjectShape<dimensions>::clean(const typename DimensionTraits<dimensions>::MatrixType& absoluteTransformation) {
-    if(_shape) _shape->applyTransformation(absoluteTransformation);
+template<uint8_t dimensions> void ObjectShape<dimensions>::clean(const typename DimensionTraits<dimensions>::MatrixType& absoluteTransformationMatrix) {
+    if(_shape) _shape->applyTransformationMatrix(absoluteTransformationMatrix);
 }
 
 template class ObjectShape<2>;

src/Physics/ObjectShape.h

@@ -78,7 +78,7 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT ObjectShape: publi
         void markDirty() override;
 
         /** Applies transformation to associated shape. */
-        void clean(const typename DimensionTraits<dimensions>::MatrixType& absoluteTransformation) override;
+        void clean(const typename DimensionTraits<dimensions>::MatrixType& absoluteTransformationMatrix) override;
 
     private:
         AbstractShape<dimensions>* _shape;

src/Physics/Plane.cpp

@@ -27,9 +27,9 @@ using namespace Magnum::Math::Geometry;
 
 namespace Magnum { namespace Physics {
 
-void Plane::applyTransformation(const Matrix4& transformation) {
-    _transformedPosition = (transformation*Magnum::Point3D(_position)).xyz();
-    _transformedNormal = transformation.rotation()*_normal;
+void Plane::applyTransformationMatrix(const Matrix4& matrix) {
+    _transformedPosition = (matrix*Magnum::Point3D(_position)).xyz();
+    _transformedNormal = matrix.rotation()*_normal;
 }
 
 bool Plane::collides(const AbstractShape<3>* other) const {

src/Physics/Plane.h

@@ -36,10 +36,10 @@ class MAGNUM_PHYSICS_EXPORT Plane: public AbstractShape<3> {
         inline Type type() const override { return Type::Plane; }
 
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        void applyTransformation(const Matrix4& transformation) override;
+        void applyTransformationMatrix(const Matrix4& matrix) override;
         bool collides(const AbstractShape<3>* other) const override;
         #else
-        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
+        void applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) 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>::MatrixType& transformation) {
-    _transformedPosition = (transformation*typename DimensionTraits<dimensions>::PointType(_position)).vector();
+template<std::uint8_t dimensions> void Point<dimensions>::applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+    _transformedPosition = (matrix*typename DimensionTraits<dimensions>::PointType(_position)).vector();
 }
 
 template class Point<2>;

src/Physics/Point.h

@@ -40,7 +40,7 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT Point: public Abst
             return AbstractShape<dimensions>::Type::Point;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
+        void applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) override;
 
         /** @brief Position */
         inline typename DimensionTraits<dimensions>::VectorType position() const {

src/Physics/ShapeGroup.cpp

@@ -43,9 +43,9 @@ template<std::uint8_t dimensions> ShapeGroup<dimensions>& ShapeGroup<dimensions>
     return *this;
 }
 
-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);
+template<std::uint8_t dimensions> void ShapeGroup<dimensions>::applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+    if(a) a->applyTransformationMatrix(matrix);
+    if(b) b->applyTransformationMatrix(matrix);
 }
 
 template<std::uint8_t dimensions> bool ShapeGroup<dimensions>::collides(const AbstractShape<dimensions>* other) const {

src/Physics/ShapeGroup.h

@@ -105,7 +105,7 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT ShapeGroup: public
             return AbstractShape<dimensions>::Type::ShapeGroup;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
+        void applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) override;
 
         bool collides(const AbstractShape<dimensions>* other) const override;
 

src/Physics/Sphere.cpp

@@ -39,9 +39,9 @@ namespace {
     }
 }
 
-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();
+template<std::uint8_t dimensions> void Sphere<dimensions>::applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+    _transformedPosition = (matrix*typename DimensionTraits<dimensions>::PointType(_position)).vector();
+    float scaling = (matrix.rotationScaling()*unitVector<dimensions>()).length();
     _transformedRadius = scaling*_radius;
 }
 

src/Physics/Sphere.h

@@ -43,7 +43,7 @@ template<std::uint8_t dimensions> class MAGNUM_PHYSICS_EXPORT Sphere: public Abs
             return AbstractShape<dimensions>::Type::Sphere;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
+        void applyTransformationMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) override;
 
         bool collides(const AbstractShape<dimensions>* other) const override;
 

src/Physics/Test/AxisAlignedBoxTest.cpp

@@ -30,11 +30,11 @@ AxisAlignedBoxTest::AxisAlignedBoxTest() {
 void AxisAlignedBoxTest::applyTransformation() {
     Physics::AxisAlignedBox3D box({-1.0f, -2.0f, -3.0f}, {1.0f, 2.0f, 3.0f});
 
-    box.applyTransformation(Matrix4::scaling({2.0f, -1.0f, 1.5f}));
+    box.applyTransformationMatrix(Matrix4::scaling({2.0f, -1.0f, 1.5f}));
     CORRADE_COMPARE(box.transformedPosition(), Vector3(-2.0f, 2.0f, -4.5f));
     CORRADE_COMPARE(box.transformedSize(), Vector3(2.0f, -2.0f, 4.5f));
 
-    box.applyTransformation(Matrix4::translation(Vector3(1.0f))*Matrix4::rotation(deg(90.0f), Vector3::xAxis()));
+    box.applyTransformationMatrix(Matrix4::translation(Vector3(1.0f))*Matrix4::rotation(deg(90.0f), Vector3::xAxis()));
     CORRADE_COMPARE(box.transformedPosition(), Vector3(0.0f, 4.0f, -1.0f));
     CORRADE_COMPARE(box.transformedSize(), Vector3(1.0f, -3.0f, 2.0f));
 }

src/Physics/Test/BoxTest.cpp

@@ -29,7 +29,7 @@ BoxTest::BoxTest() {
 void BoxTest::applyTransformation() {
     Physics::Box3D box(Matrix4::translation({1.0f, 2.0f, -3.0f}));
 
-    box.applyTransformation(Matrix4::scaling({2.0f, -1.0f, 1.5f}));
+    box.applyTransformationMatrix(Matrix4::scaling({2.0f, -1.0f, 1.5f}));
     CORRADE_COMPARE(box.transformedTransformation(), Matrix4::scaling({2.0f, -1.0f, 1.5f})*Matrix4::translation({1.0f, 2.0f, -3.0f}));
 }
 

src/Physics/Test/CapsuleTest.cpp

@@ -32,13 +32,13 @@ CapsuleTest::CapsuleTest() {
 void CapsuleTest::applyTransformation() {
     Physics::Capsule3D capsule({1.0f, 2.0f, 3.0f}, {-1.0f, -2.0f, -3.0f}, 7.0f);
 
-    capsule.applyTransformation(Matrix4::rotation(deg(90.0f), Vector3::zAxis()));
+    capsule.applyTransformationMatrix(Matrix4::rotation(deg(90.0f), Vector3::zAxis()));
     CORRADE_COMPARE(capsule.transformedA(), Vector3(-2.0f, 1.0f, 3.0f));
     CORRADE_COMPARE(capsule.transformedB(), Vector3(2.0f, -1.0f, -3.0f));
     CORRADE_COMPARE(capsule.radius(), 7.0f);
 
     /* Apply average scaling to radius */
-    capsule.applyTransformation(Matrix4::scaling({Constants::sqrt3(), -Constants::sqrt2(), 2.0f}));
+    capsule.applyTransformationMatrix(Matrix4::scaling({Constants::sqrt3(), -Constants::sqrt2(), 2.0f}));
     CORRADE_COMPARE(capsule.transformedRadius(), Constants::sqrt3()*7.0f);
 }
 

src/Physics/Test/LineTest.cpp

@@ -29,7 +29,7 @@ LineTest::LineTest() {
 
 void LineTest::applyTransformation() {
     Physics::Line3D line({1.0f, 2.0f, 3.0f}, {-1.0f, -2.0f, -3.0f});
-    line.applyTransformation(Matrix4::rotation(deg(90.0f), Vector3::zAxis()));
+    line.applyTransformationMatrix(Matrix4::rotation(deg(90.0f), Vector3::zAxis()));
     CORRADE_COMPARE(line.transformedA(), Vector3(-2.0f, 1.0f, 3.0f));
     CORRADE_COMPARE(line.transformedB(), Vector3(2.0f, -1.0f, -3.0f));
 }

src/Physics/Test/PlaneTest.cpp

@@ -33,12 +33,12 @@ PlaneTest::PlaneTest() {
 void PlaneTest::applyTransformation() {
     Physics::Plane plane({1.0f, 2.0f, 3.0f}, {Constants::sqrt2(), -Constants::sqrt2(), 0});
 
-    plane.applyTransformation(Matrix4::rotation(deg(90.0f), Vector3::xAxis()));
+    plane.applyTransformationMatrix(Matrix4::rotation(deg(90.0f), Vector3::xAxis()));
     CORRADE_COMPARE(plane.transformedPosition(), Vector3(1.0f, -3.0f, 2.0f));
     CORRADE_COMPARE(plane.transformedNormal(), Vector3(Constants::sqrt2(), 0, -Constants::sqrt2()));
 
     /* The normal should stay normalized */
-    plane.applyTransformation(Matrix4::scaling({1.5f, 2.0f, 3.0f}));
+    plane.applyTransformationMatrix(Matrix4::scaling({1.5f, 2.0f, 3.0f}));
     CORRADE_COMPARE(plane.transformedPosition(), Vector3(1.5f, 4.0f, 9.0f));
     CORRADE_COMPARE(plane.transformedNormal(), Vector3(Constants::sqrt2(), -Constants::sqrt2(), 0));
 }

src/Physics/Test/PointTest.cpp

@@ -28,7 +28,7 @@ PointTest::PointTest() {
 
 void PointTest::applyTransformation() {
     Physics::Point3D point({1.0f, 2.0f, 3.0f});
-    point.applyTransformation(Matrix4::translation({5.0f, 6.0f, 7.0f}));
+    point.applyTransformationMatrix(Matrix4::translation({5.0f, 6.0f, 7.0f}));
     CORRADE_COMPARE(point.transformedPosition(), Vector3(6.0f, 8.0f, 10.0f));
 }
 

src/Physics/Test/ShapeGroupTest.cpp

@@ -41,7 +41,7 @@ void ShapeGroupTest::copy() {
     }
 
     /* Just to test that it doesn't crash */
-    group.applyTransformation(Matrix4::translation(Vector3::xAxis(1.0f)));
+    group.applyTransformationMatrix(Matrix4::translation(Vector3::xAxis(1.0f)));
 
     CORRADE_VERIFY(true);
 }
@@ -52,7 +52,7 @@ void ShapeGroupTest::reference() {
 
     ShapeGroup3D group = !(ref(point) || ref(segment));
 
-    group.applyTransformation(Matrix4::translation(Vector3(1.0f)));
+    group.applyTransformationMatrix(Matrix4::translation(Vector3(1.0f)));
 
     CORRADE_VERIFY((point.transformedPosition() == Vector3(2.0f, 3.0f, 4.0f)));
     CORRADE_VERIFY((segment.transformedA() == Vector3(3.0f, 2.0f, 31.0f)));

src/Physics/Test/ShapeTestBase.h

@@ -25,7 +25,7 @@ namespace Magnum { namespace Physics { namespace Test {
 class ShapeTestBase {
     protected:
         template<class T> void randomTransformation(T& shape) {
-            shape.applyTransformation(Matrix4::translation({7.0f, 8.0f, -9.0f}));
+            shape.applyTransformationMatrix(Matrix4::translation({7.0f, 8.0f, -9.0f}));
         }
 };
 

src/Physics/Test/SphereTest.cpp

@@ -35,17 +35,17 @@ SphereTest::SphereTest() {
 void SphereTest::applyTransformation() {
     Physics::Sphere3D sphere({1.0f, 2.0f, 3.0f}, 7.0f);
 
-    sphere.applyTransformation(Matrix4::rotation(deg(90.0f), Vector3::yAxis()));
+    sphere.applyTransformationMatrix(Matrix4::rotation(deg(90.0f), Vector3::yAxis()));
     CORRADE_COMPARE(sphere.transformedPosition(), Vector3(3.0f, 2.0f, -1.0f));
     CORRADE_COMPARE(sphere.transformedRadius(), 7.0f);
 
     /* Symmetric scaling */
-    sphere.applyTransformation(Matrix4::scaling(Vector3(2.0f)));
+    sphere.applyTransformationMatrix(Matrix4::scaling(Vector3(2.0f)));
     CORRADE_COMPARE(sphere.transformedPosition(), Vector3(2.0f, 4.0f, 6.0f));
     CORRADE_COMPARE(sphere.transformedRadius(), 14.0f);
 
     /* Apply average scaling to radius */
-    sphere.applyTransformation(Matrix4::scaling({Constants::sqrt3(), -Constants::sqrt2(), 2.0f}));
+    sphere.applyTransformationMatrix(Matrix4::scaling({Constants::sqrt3(), -Constants::sqrt2(), 2.0f}));
     CORRADE_COMPARE(sphere.transformedRadius(), Constants::sqrt3()*7.0f);
 }
 

src/SceneGraph/AbstractCamera.h

@@ -141,8 +141,8 @@ class MAGNUM_SCENEGRAPH_EXPORT AbstractCamera: public AbstractFeature<dimensions
 
     protected:
         /** Recalculates camera matrix */
-        inline void cleanInverted(const typename DimensionTraits<dimensions, T>::MatrixType& invertedAbsoluteTransformation) override {
-            _cameraMatrix = invertedAbsoluteTransformation;
+        inline void cleanInverted(const typename DimensionTraits<dimensions, T>::MatrixType& invertedAbsoluteTransformationMatrix) override {
+            _cameraMatrix = invertedAbsoluteTransformationMatrix;
         }
 
         #ifndef DOXYGEN_GENERATING_OUTPUT

src/SceneGraph/AbstractFeature.h

@@ -72,8 +72,8 @@ class CachingFeature: public SceneGraph::AbstractFeature3D<> {
         }
 
     protected:
-        void clean(const Matrix4& absoluteTransformation) override {
-            absolutePosition = absoluteTransformation.translation();
+        void clean(const Matrix4& absoluteTransformationMatrix) override {
+            absolutePosition = absoluteTransformationMatrix.translation();
         }
 
     private:
@@ -258,7 +258,7 @@ template<std::uint8_t dimensions, class T = GLfloat> class AbstractFeature
          * Default implementation does nothing.
          * @see @ref scenegraph-caching, cleanInverted()
          */
-        virtual void clean(const typename DimensionTraits<dimensions, T>::MatrixType& absoluteTransformation);
+        virtual void clean(const typename DimensionTraits<dimensions, T>::MatrixType& absoluteTransformationMatrix);
 
         /**
          * @brief Clean data based on inverted absolute transformation
@@ -272,7 +272,7 @@ template<std::uint8_t dimensions, class T = GLfloat> class AbstractFeature
          * Default implementation does nothing.
          * @see @ref scenegraph-caching, clean()
          */
-        virtual void cleanInverted(const typename DimensionTraits<dimensions, T>::MatrixType& invertedAbsoluteTransformation);
+        virtual void cleanInverted(const typename DimensionTraits<dimensions, T>::MatrixType& invertedAbsoluteTransformationMatrix);
 
         /*@}*/
 

src/Shaders/FlatShader.cpp

@@ -65,7 +65,7 @@ template<std::uint8_t dimensions> FlatShader<dimensions>::FlatShader() {
 
     link();
 
-    transformationProjectionUniform = uniformLocation("transformationProjection");
+    transformationProjectionMatrixUniform = uniformLocation("transformationProjectionMatrix");
     colorUniform = uniformLocation("color");
 }
 

src/Shaders/FlatShader.h

@@ -46,8 +46,8 @@ template<std::uint8_t dimensions> class MAGNUM_SHADERS_EXPORT FlatShader: public
          * @brief Set transformation and projection matrix
          * @return Pointer to self (for method chaining)
          */
-        FlatShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
-            setUniform(transformationProjectionUniform, matrix);
+        FlatShader<dimensions>* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+            setUniform(transformationProjectionMatrixUniform, matrix);
             return this;
         }
 
@@ -61,7 +61,7 @@ template<std::uint8_t dimensions> class MAGNUM_SHADERS_EXPORT FlatShader: public
         }
 
     private:
-        GLint transformationProjectionUniform,
+        GLint transformationProjectionMatrixUniform,
             colorUniform;
 };
 

src/Shaders/FlatShader2D.vert

@@ -2,7 +2,7 @@
 #define in attribute
 #endif
 
-uniform highp mat3 transformationProjection;
+uniform highp mat3 transformationProjectionMatrix;
 
 #ifdef EXPLICIT_ATTRIB_LOCATION
 layout(location = 0) in highp vec3 position;
@@ -11,5 +11,5 @@ in highp vec3 position;
 #endif
 
 void main() {
-    gl_Position.xywz = vec4(transformationProjection*position, 0.0);
+    gl_Position.xywz = vec4(transformationProjectionMatrix*position, 0.0);
 }

src/Shaders/PhongShader.h

@@ -84,10 +84,10 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
         }
 
         /**
-         * @brief Set transformation matrix and normal matrix
+         * @brief Set transformation and normal matrix
          * @return Pointer to self (for method chaining)
          */
-        inline PhongShader* setTransformation(const Matrix4& matrix) {
+        inline PhongShader* setTransformationMatrix(const Matrix4& matrix) {
             setUniform(transformationMatrixUniform, matrix);
             setUniform(normalMatrixUniform, matrix.rotation());
             return this;
@@ -97,7 +97,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          * @brief Set projection matrix
          * @return Pointer to self (for method chaining)
          */
-        inline PhongShader* setProjection(const Matrix4& matrix) {
+        inline PhongShader* setProjectionMatrix(const Matrix4& matrix) {
             setUniform(projectionMatrixUniform, matrix);
             return this;
         }

src/Shaders/VertexColorShader.cpp

@@ -66,7 +66,7 @@ template<std::uint8_t dimensions> VertexColorShader<dimensions>::VertexColorShad
 
     link();
 
-    transformationProjectionUniform = uniformLocation("transformationProjection");
+    transformationProjectionMatrixUniform = uniformLocation("transformationProjectionMatrix");
 }
 
 template class VertexColorShader<2>;

src/Shaders/VertexColorShader.h

@@ -46,16 +46,16 @@ template<std::uint8_t dimensions> class MAGNUM_SHADERS_EXPORT VertexColorShader:
         VertexColorShader();
 
         /**
-         * @brief Set transformation and projection
+         * @brief Set transformation and projection matrix
          * @return Pointer to self (for method chaining)
          */
-        inline VertexColorShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
-            setUniform(transformationProjectionUniform, matrix);
+        inline VertexColorShader<dimensions>* setTransformationProjectionMatrix(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
+            setUniform(transformationProjectionMatrixUniform, matrix);
             return this;
         }
 
     private:
-        GLint transformationProjectionUniform;
+        GLint transformationProjectionMatrixUniform;
 };
 
 /** @brief 2D vertex color shader */

src/Shaders/VertexColorShader2D.vert

@@ -3,7 +3,7 @@
 #define out varying
 #endif
 
-uniform highp mat3 transformationProjection;
+uniform highp mat3 transformationProjectionMatrix;
 
 #ifdef EXPLICIT_ATTRIB_LOCATION
 layout(location = 0) in highp vec3 position;
@@ -16,6 +16,6 @@ in lowp vec3 color;
 out lowp vec3 interpolatedColor;
 
 void main() {
-    gl_Position.xywz = vec4(transformationProjection*position, 0.0);
+    gl_Position.xywz = vec4(transformationProjectionMatrix*position, 0.0);
     interpolatedColor = color;
 }