Math: renamed Quaternion::rotateVector*() to transformVector*().

Now it is consistent with Matrix and can be easily used in templates.

src/Math/DualQuaternion.h

@@ -246,11 +246,11 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
         /**
          * @brief Rotate and translate point with dual quaternion
          *
-         * See rotateVectorNormalized(), which is faster for normalized dual
+         * See transformPointNormalized(), which is faster for normalized dual
          * quaternions. @f[
          *      v' = qv \overline{\hat q^{-1}} = q ([\boldsymbol 0, 1] + \epsilon [\boldsymbol v, 0]) \overline{\hat q^{-1}}
          * @f]
-         * @see DualQuaternion(const Vector3&), Matrix4::transformPoint(), Quaternion::rotateVectorNormalized()
+         * @see DualQuaternion(const Vector3&), Matrix4::transformPoint(), Quaternion::transformVector()
          */
         inline Vector3<T> transformPoint(const Vector3<T>& vector) const {
             return ((*this)*DualQuaternion<T>(vector)*inverted().dualConjugated()).dual().vector();
@@ -263,7 +263,7 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
          * quaternion is normalized. @f[
          *      v' = qv \overline{\hat q^{-1}} = qv \overline{\hat q^*} = q ([\boldsymbol 0, 1] + \epsilon [\boldsymbol v, 0]) \overline{\hat q^*}
          * @f]
-         * @see DualQuaternion(const Vector3&), Matrix4::transformPoint(), Quaternion::rotateVectorNormalized()
+         * @see DualQuaternion(const Vector3&), Matrix4::transformPoint(), Quaternion::transformVectorNormalized()
          */
         inline Vector3<T> transformPointNormalized(const Vector3<T>& vector) const {
             CORRADE_ASSERT(MathTypeTraits<Dual<T>>::equals(lengthSquared(), Dual<T>(1)),

src/Math/Matrix4.h

@@ -356,7 +356,7 @@ template<class T> class Matrix4: public Matrix<4, T> {
          * Translation is not involved in the transformation. @f[
          *      \boldsymbol v' = \boldsymbol M (v_x, v_y, v_z, 0)^T
          * @f]
-         * @see transformPoint(), Quaternion::rotateVector(),
+         * @see transformPoint(), Quaternion::transformVector(),
          *      Matrix3::transformVector()
          */
         inline Vector3<T> transformVector(const Vector3<T>& vector) const {

src/Math/Quaternion.h

@@ -149,7 +149,7 @@ template<class T> class Quaternion {
          * To be used in transformations later. @f[
          *      q = [\boldsymbol v, 0]
          * @f]
-         * @see rotateVector(), rotateVectorNormalized()
+         * @see transformVector(), transformVectorNormalized()
          */
         inline constexpr explicit Quaternion(const Vector3<T>& vector): _vector(vector), _scalar(T(0)) {}
 
@@ -403,28 +403,28 @@ template<class T> class Quaternion {
         /**
          * @brief Rotate vector with quaternion
          *
-         * See rotateVectorNormalized(), which is faster for normalized
+         * See transformVectorNormalized(), which is faster for normalized
          * quaternions. @f[
          *      v' = qvq^{-1} = q [\boldsymbol v, 0] q^{-1}
          * @f]
          * @see Quaternion(const Vector3&), Matrix4::transformVector(), DualQuaternion::transformPoint()
          */
-        inline Vector3<T> rotateVector(const Vector3<T>& vector) const {
+        inline Vector3<T> transformVector(const Vector3<T>& vector) const {
             return ((*this)*Quaternion<T>(vector)*inverted()).vector();
         }
 
         /**
          * @brief Rotate vector with normalized quaternion
          *
-         * Faster alternative to rotateVector(), expects that the quaternion is
+         * Faster alternative to transformVector(), expects that the quaternion is
          * normalized. @f[
          *      v' = qvq^{-1} = qvq^* = q [\boldsymbol v, 0] q^*
          * @f]
          * @see Quaternion(const Vector3&), Matrix4::transformVector(), DualQuaternion::transformPointNormalized()
          */
-        inline Vector3<T> rotateVectorNormalized(const Vector3<T>& vector) const {
+        inline Vector3<T> transformVectorNormalized(const Vector3<T>& vector) const {
             CORRADE_ASSERT(MathTypeTraits<T>::equals(dot(), T(1)),
-                           "Math::Quaternion::rotateVectorNormalized(): quaternion must be normalized",
+                           "Math::Quaternion::transformVectorNormalized(): quaternion must be normalized",
                            Vector3<T>(std::numeric_limits<T>::quiet_NaN()));
             return ((*this)*Quaternion<T>(vector)*conjugated()).vector();
         }

src/Math/Test/DualQuaternionTest.cpp

@@ -199,7 +199,7 @@ void DualQuaternionTest::combinedTransformParts() {
     CORRADE_COMPARE_AS(b.rotationAngle(), Deg(23.0f), Rad);
 
     CORRADE_COMPARE(a.translation(), translation);
-    CORRADE_COMPARE(b.translation(), Quaternion::rotation(Deg(23.0f), Vector3::xAxis()).rotateVectorNormalized(translation));
+    CORRADE_COMPARE(b.translation(), Quaternion::rotation(Deg(23.0f), Vector3::xAxis()).transformVector(translation));
 }
 
 void DualQuaternionTest::matrix() {

src/Math/Test/QuaternionTest.cpp

@@ -51,8 +51,8 @@ class QuaternionTest: public Corrade::TestSuite::Tester {
         void matrix();
         void lerp();
         void slerp();
-        void rotateVector();
+        void transformVector();
-        void rotateVectorNormalized();
+        void transformVectorNormalized();
 
         void debug();
 };
@@ -92,8 +92,8 @@ QuaternionTest::QuaternionTest() {
              &QuaternionTest::matrix,
              &QuaternionTest::lerp,
              &QuaternionTest::slerp,
-             &QuaternionTest::rotateVector,
+             &QuaternionTest::transformVector,
-             &QuaternionTest::rotateVectorNormalized,
+             &QuaternionTest::transformVectorNormalized,
 
              &QuaternionTest::debug);
 }
@@ -320,30 +320,30 @@ void QuaternionTest::slerp() {
     CORRADE_COMPARE(slerp, Quaternion({0.119165f, 0.0491109f, 0.0491109f}, 0.990442f));
 }
 
-void QuaternionTest::rotateVector() {
+void QuaternionTest::transformVector() {
     Quaternion a = Quaternion::rotation(Deg(23.0f), Vector3::xAxis());
     Matrix4 m = Matrix4::rotationX(Deg(23.0f));
     Vector3 v(5.0f, -3.6f, 0.7f);
 
-    Vector3 rotated = a.rotateVector(v);
+    Vector3 rotated = a.transformVector(v);
     CORRADE_COMPARE(rotated, m.transformVector(v));
     CORRADE_COMPARE(rotated, Vector3(5.0f, -3.58733f, -0.762279f));
 }
 
-void QuaternionTest::rotateVectorNormalized() {
+void QuaternionTest::transformVectorNormalized() {
     Quaternion a = Quaternion::rotation(Deg(23.0f), Vector3::xAxis());
     Matrix4 m = Matrix4::rotationX(Deg(23.0f));
     Vector3 v(5.0f, -3.6f, 0.7f);
 
     std::ostringstream o;
     Corrade::Utility::Error::setOutput(&o);
-    Vector3 notRotated = (a*2).rotateVectorNormalized(v);
+    Vector3 notRotated = (a*2).transformVectorNormalized(v);
     CORRADE_VERIFY(notRotated != notRotated);
-    CORRADE_COMPARE(o.str(), "Math::Quaternion::rotateVectorNormalized(): quaternion must be normalized\n");
+    CORRADE_COMPARE(o.str(), "Math::Quaternion::transformVectorNormalized(): quaternion must be normalized\n");
 
-    Vector3 rotated = a.rotateVectorNormalized(v);
+    Vector3 rotated = a.transformVectorNormalized(v);
     CORRADE_COMPARE(rotated, m.transformVector(v));
-    CORRADE_COMPARE(rotated, a.rotateVector(v));
+    CORRADE_COMPARE(rotated, a.transformVector(v));
 }
 
 void QuaternionTest::debug() {