gfx::Transform API clean-up

cc/math_util_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/math_util.h"
 
 #include <cmath>
 
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 313 matching lines @@
     EXPECT_ROW1_EQ(10, 14, 18, 22, B);
     EXPECT_ROW2_EQ(11, 15, 19, 23, B);
     EXPECT_ROW3_EQ(12, 16, 20, 24, B);
     EXPECT_ROW4_EQ(13, 17, 21, 25, B);
 }
 
 TEST(MathUtilGfxTransformTest, verifyMatrixInversion)
 {
     // Invert a translation
     gfx::Transform translation;
-    translation.PreconcatTranslate3d(2, 3, 4);
+    translation.Translate3d(2, 3, 4);
     EXPECT_TRUE(MathUtil::isInvertible(translation));
 
     gfx::Transform inverseTranslation = MathUtil::inverse(translation);
     EXPECT_ROW1_EQ(1, 0, 0, -2, inverseTranslation);
     EXPECT_ROW2_EQ(0, 1, 0, -3, inverseTranslation);
     EXPECT_ROW3_EQ(0, 0, 1, -4, inverseTranslation);
     EXPECT_ROW4_EQ(0, 0, 0,  1, inverseTranslation);
 
     // Note that inversion should not have changed the original matrix.
     EXPECT_ROW1_EQ(1, 0, 0, 2, translation);
     EXPECT_ROW2_EQ(0, 1, 0, 3, translation);
     EXPECT_ROW3_EQ(0, 0, 1, 4, translation);
     EXPECT_ROW4_EQ(0, 0, 0, 1, translation);
 
     // Invert a non-uniform scale
     gfx::Transform scale;
-    scale.PreconcatScale3d(4, 10, 100);
+    scale.Scale3d(4, 10, 100);
     EXPECT_TRUE(MathUtil::isInvertible(scale));
 
     gfx::Transform inverseScale = MathUtil::inverse(scale);
     EXPECT_ROW1_EQ(0.25,   0,    0, 0, inverseScale);
     EXPECT_ROW2_EQ(0,    .1f,    0, 0, inverseScale);
     EXPECT_ROW3_EQ(0,      0, .01f, 0, inverseScale);
     EXPECT_ROW4_EQ(0,      0,    0, 1, inverseScale);
 
     // Try to invert a matrix that is not invertible.
     // The inverse() function should simply return an identity matrix.
@@ skipping 143 matching lines @@
     gfx::Transform C = A * B;
     EXPECT_ROW1_EQ(2036, 2292, 2548, 2804, C);
     EXPECT_ROW2_EQ(2162, 2434, 2706, 2978, C);
     EXPECT_ROW3_EQ(2288, 2576, 2864, 3152, C);
     EXPECT_ROW4_EQ(2414, 2718, 3022, 3326, C);
 
     // Just an additional sanity check; matrix multiplication is not commutative.
     EXPECT_FALSE(A * B == B * A);
 }
 
+TEST(MathUtilGfxTransformTest, verifyMultiplyAndAssignOperator)
+{
+    gfx::Transform A;
+    initializeTestMatrix(&A);
+
+    gfx::Transform B;
+    initializeTestMatrix2(&B);
+
+    A *= B;
+    EXPECT_ROW1_EQ(2036, 2292, 2548, 2804, A);
+    EXPECT_ROW2_EQ(2162, 2434, 2706, 2978, A);
+    EXPECT_ROW3_EQ(2288, 2576, 2864, 3152, A);
+    EXPECT_ROW4_EQ(2414, 2718, 3022, 3326, A);
+
+    // Just an additional sanity check; matrix multiplication is not commutative.
+    gfx::Transform C = A;
+    C *= B;
+    gfx::Transform D = B;
+    D *= A;
+    EXPECT_FALSE(C == D);
+}
+
 TEST(MathUtilGfxTransformTest, verifyMatrixMultiplication)
 {
     gfx::Transform A;
     initializeTestMatrix(&A);
 
     gfx::Transform B;
     initializeTestMatrix2(&B);
 
     A.PreconcatTransform(B);
     EXPECT_ROW1_EQ(2036, 2292, 2548, 2804, A);
@@ skipping 10 matching lines @@
     EXPECT_ROW1_EQ(1, 0, 0, 0, A);
     EXPECT_ROW2_EQ(0, 1, 0, 0, A);
     EXPECT_ROW3_EQ(0, 0, 1, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
     EXPECT_TRUE(MathUtil::isIdentity(A));
 }
 
 TEST(MathUtilGfxTransformTest, verifyTranslate)
 {
     gfx::Transform A;
-    A.PreconcatTranslate(2, 3);
+    A.Translate(2, 3);
     EXPECT_ROW1_EQ(1, 0, 0, 2, A);
     EXPECT_ROW2_EQ(0, 1, 0, 3, A);
     EXPECT_ROW3_EQ(0, 0, 1, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 
-    // Verify that PreconcatTranslate() post-multiplies the existing matrix.
+    // Verify that Translate() post-multiplies the existing matrix.
     MathUtil::makeIdentity(&A);
-    A.PreconcatScale(5, 5);
-    A.PreconcatTranslate(2, 3);
+    A.Scale(5, 5);
+    A.Translate(2, 3);
     EXPECT_ROW1_EQ(5, 0, 0, 10, A);
     EXPECT_ROW2_EQ(0, 5, 0, 15, A);
     EXPECT_ROW3_EQ(0, 0, 1, 0,  A);
     EXPECT_ROW4_EQ(0, 0, 0, 1,  A);
 }
 
 TEST(MathUtilGfxTransformTest, verifyTranslate3d)
 {
     gfx::Transform A;
-    A.PreconcatTranslate3d(2, 3, 4);
+    A.Translate3d(2, 3, 4);
     EXPECT_ROW1_EQ(1, 0, 0, 2, A);
     EXPECT_ROW2_EQ(0, 1, 0, 3, A);
     EXPECT_ROW3_EQ(0, 0, 1, 4, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 
-    // Verify that PreconcatTranslate3d() post-multiplies the existing matrix.
+    // Verify that Translate3d() post-multiplies the existing matrix.
     MathUtil::makeIdentity(&A);
-    A.PreconcatScale3d(6, 7, 8);
-    A.PreconcatTranslate3d(2, 3, 4);
+    A.Scale3d(6, 7, 8);
+    A.Translate3d(2, 3, 4);
     EXPECT_ROW1_EQ(6, 0, 0, 12, A);
     EXPECT_ROW2_EQ(0, 7, 0, 21, A);
     EXPECT_ROW3_EQ(0, 0, 8, 32, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1,  A);
 }
 
 TEST(MathUtilGfxTransformTest, verifyScale)
 {
     gfx::Transform A;
-    A.PreconcatScale(6, 7);
+    A.Scale(6, 7);
     EXPECT_ROW1_EQ(6, 0, 0, 0, A);
     EXPECT_ROW2_EQ(0, 7, 0, 0, A);
     EXPECT_ROW3_EQ(0, 0, 1, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 
-    // Verify that PreconcatScale() post-multiplies the existing matrix.
+    // Verify that Scale() post-multiplies the existing matrix.
     MathUtil::makeIdentity(&A);
-    A.PreconcatTranslate3d(2, 3, 4);
-    A.PreconcatScale(6, 7);
+    A.Translate3d(2, 3, 4);
+    A.Scale(6, 7);
     EXPECT_ROW1_EQ(6, 0, 0, 2, A);
     EXPECT_ROW2_EQ(0, 7, 0, 3, A);
     EXPECT_ROW3_EQ(0, 0, 1, 4, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 }
 
 TEST(MathUtilGfxTransformTest, verifyScale3d)
 {
     gfx::Transform A;
-    A.PreconcatScale3d(6, 7, 8);
+    A.Scale3d(6, 7, 8);
     EXPECT_ROW1_EQ(6, 0, 0, 0, A);
     EXPECT_ROW2_EQ(0, 7, 0, 0, A);
     EXPECT_ROW3_EQ(0, 0, 8, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 
     // Verify that scale3d() post-multiplies the existing matrix.
     MathUtil::makeIdentity(&A);
-    A.PreconcatTranslate3d(2, 3, 4);
-    A.PreconcatScale3d(6, 7, 8);
+    A.Translate3d(2, 3, 4);
+    A.Scale3d(6, 7, 8);
     EXPECT_ROW1_EQ(6, 0, 0, 2, A);
     EXPECT_ROW2_EQ(0, 7, 0, 3, A);
     EXPECT_ROW3_EQ(0, 0, 8, 4, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 }
 
 TEST(MathUtilGfxTransformTest, verifyRotate)
 {
     gfx::Transform A;
-    A.PreconcatRotate(90);
+    A.Rotate(90);
     EXPECT_ROW1_NEAR(0, -1, 0, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW2_NEAR(1, 0, 0, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW3_EQ(0, 0, 1, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 
-    // Verify that PreconcatRotate() post-multiplies the existing matrix.
+    // Verify that Rotate() post-multiplies the existing matrix.
     MathUtil::makeIdentity(&A);
-    A.PreconcatScale3d(6, 7, 8);
-    A.PreconcatRotate(90);
+    A.Scale3d(6, 7, 8);
+    A.Rotate(90);
     EXPECT_ROW1_NEAR(0, -6, 0, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW2_NEAR(7, 0,  0, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW3_EQ(0, 0, 8, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 }
 
 TEST(MathUtilGfxTransformTest, verifyRotateEulerAngles)
 {
     gfx::Transform A;
 
@@ skipping 17 matching lines @@
     // Note carefully, the expected pattern is inverted compared to rotating about x axis or z axis.
     MathUtil::makeIdentity(&A);
     MathUtil::rotateEulerAngles(&A, 0, 90, 0);
     EXPECT_ROW1_NEAR(0, 0, 1, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW2_EQ(0, 1, 0, 0, A);
     EXPECT_ROW3_NEAR(-1, 0, 0, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 
     // Verify that rotate3d(rx, ry, rz) post-multiplies the existing matrix.
     MathUtil::makeIdentity(&A);
-    A.PreconcatScale3d(6, 7, 8);
+    A.Scale3d(6, 7, 8);
     MathUtil::rotateEulerAngles(&A, 0, 0, 90);
     EXPECT_ROW1_NEAR(0, -6, 0, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW2_NEAR(7, 0,  0, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW3_EQ(0, 0, 8, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 }
 
 TEST(MathUtilGfxTransformTest, verifyRotateEulerAnglesOrderOfCompositeRotations)
 {
     // Rotate3d(degreesX, degreesY, degreesZ) is actually composite transform consiting of
@@ skipping 52 matching lines @@
     // Note carefully, the expected pattern is inverted compared to rotating about x axis or z axis.
     MathUtil::makeIdentity(&A);
     MathUtil::rotateAxisAngle(&A, 0, 1, 0, 90);
     EXPECT_ROW1_NEAR(0, 0, 1, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW2_EQ(0, 1, 0, 0, A);
     EXPECT_ROW3_NEAR(-1, 0, 0, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 
     // Verify that rotate3d(axis, angle) post-multiplies the existing matrix.
     MathUtil::makeIdentity(&A);
-    A.PreconcatScale3d(6, 7, 8);
+    A.Scale3d(6, 7, 8);
     MathUtil::rotateAxisAngle(&A, 0, 0, 1, 90);
     EXPECT_ROW1_NEAR(0, -6, 0, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW2_NEAR(7, 0,  0, 0, A, ERROR_THRESHOLD);
     EXPECT_ROW3_EQ(0, 0, 8, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 }
 
 TEST(MathUtilGfxTransformTest, verifyRotateAxisAngleForArbitraryAxis)
 {
     // Check rotation about an arbitrary non-axis-aligned vector.
@@ skipping 30 matching lines @@
     // Verify that A remains unchanged.
     EXPECT_ROW1_EQ(10, 14, 18, 22, A);
     EXPECT_ROW2_EQ(11, 15, 19, 23, A);
     EXPECT_ROW3_EQ(12, 16, 20, 24, A);
     EXPECT_ROW4_EQ(13, 17, 21, 25, A);
 }
 
 TEST(MathUtilGfxTransformTest, verifySkewX)
 {
     gfx::Transform A;
-    A.PreconcatSkewX(45);
+    A.SkewX(45);
     EXPECT_ROW1_EQ(1, 1, 0, 0, A);
     EXPECT_ROW2_EQ(0, 1, 0, 0, A);
     EXPECT_ROW3_EQ(0, 0, 1, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 
     // Verify that skewX() post-multiplies the existing matrix.
     // Row 1, column 2, would incorrectly have value "7" if the matrix is pre-multiplied instead of post-multiplied.
     MathUtil::makeIdentity(&A);
-    A.PreconcatScale3d(6, 7, 8);
-    A.PreconcatSkewX(45);
+    A.Scale3d(6, 7, 8);
+    A.SkewX(45);
     EXPECT_ROW1_EQ(6, 6, 0, 0, A);
     EXPECT_ROW2_EQ(0, 7, 0, 0, A);
     EXPECT_ROW3_EQ(0, 0, 8, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 }
 
 TEST(MathUtilGfxTransformTest, verifySkewY)
 {
     gfx::Transform A;
-    A.PreconcatSkewY(45);
+    A.SkewY(45);
     EXPECT_ROW1_EQ(1, 0, 0, 0, A);
     EXPECT_ROW2_EQ(1, 1, 0, 0, A);
     EXPECT_ROW3_EQ(0, 0, 1, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 
     // Verify that skewY() post-multiplies the existing matrix.
     // Row 2, column 1, would incorrectly have value "6" if the matrix is pre-multiplied instead of post-multiplied.
     MathUtil::makeIdentity(&A);
-    A.PreconcatScale3d(6, 7, 8);
-    A.PreconcatSkewY(45);
+    A.Scale3d(6, 7, 8);
+    A.SkewY(45);
     EXPECT_ROW1_EQ(6, 0, 0, 0, A);
     EXPECT_ROW2_EQ(7, 7, 0, 0, A);
     EXPECT_ROW3_EQ(0, 0, 8, 0, A);
     EXPECT_ROW4_EQ(0, 0, 0, 1, A);
 }
 
 TEST(MathUtilGfxTransformTest, verifyPerspectiveDepth)
 {
     gfx::Transform A;
-    A.PreconcatPerspectiveDepth(1);
+    A.ApplyPerspectiveDepth(1);
     EXPECT_ROW1_EQ(1, 0,  0, 0, A);
     EXPECT_ROW2_EQ(0, 1,  0, 0, A);
     EXPECT_ROW3_EQ(0, 0,  1, 0, A);
     EXPECT_ROW4_EQ(0, 0, -1, 1, A);
 
-    // Verify that PreconcatPerspectiveDepth() post-multiplies the existing matrix.
+    // Verify that PerspectiveDepth() post-multiplies the existing matrix.
     MathUtil::makeIdentity(&A);
-    A.PreconcatTranslate3d(2, 3, 4);
-    A.PreconcatPerspectiveDepth(1);
+    A.Translate3d(2, 3, 4);
+    A.ApplyPerspectiveDepth(1);
     EXPECT_ROW1_EQ(1, 0, -2, 2, A);
     EXPECT_ROW2_EQ(0, 1, -3, 3, A);
     EXPECT_ROW3_EQ(0, 0, -3, 4, A);
     EXPECT_ROW4_EQ(0, 0, -1, 1, A);
 }
 
 TEST(MathUtilGfxTransformTest, verifyHasPerspective)
 {
     gfx::Transform A;
-    A.PreconcatPerspectiveDepth(1);
+    A.ApplyPerspectiveDepth(1);
     EXPECT_TRUE(MathUtil::hasPerspective(A));
 
     MathUtil::makeIdentity(&A);
-    A.PreconcatPerspectiveDepth(0);
+    A.ApplyPerspectiveDepth(0);
     EXPECT_FALSE(MathUtil::hasPerspective(A));
 
     MathUtil::makeIdentity(&A);
     A.matrix().setDouble(3, 0, -1);
     EXPECT_TRUE(MathUtil::hasPerspective(A));
 
     MathUtil::makeIdentity(&A);
     A.matrix().setDouble(3, 1, -1);
     EXPECT_TRUE(MathUtil::hasPerspective(A));
 
@@ skipping 12 matching lines @@
 
 TEST(MathUtilGfxTransformTest, verifyIsInvertible)
 {
     gfx::Transform A;
 
     // Translations, rotations, scales, skews and arbitrary combinations of them are invertible.
     MathUtil::makeIdentity(&A);
     EXPECT_TRUE(MathUtil::isInvertible(A));
 
     MathUtil::makeIdentity(&A);
-    A.PreconcatTranslate3d(2, 3, 4);
+    A.Translate3d(2, 3, 4);
     EXPECT_TRUE(MathUtil::isInvertible(A));
 
     MathUtil::makeIdentity(&A);
-    A.PreconcatScale3d(6, 7, 8);
+    A.Scale3d(6, 7, 8);
     EXPECT_TRUE(MathUtil::isInvertible(A));
 
     MathUtil::makeIdentity(&A);
     MathUtil::rotateEulerAngles(&A, 10, 20, 30);
     EXPECT_TRUE(MathUtil::isInvertible(A));
 
     MathUtil::makeIdentity(&A);
-    A.PreconcatSkewX(45);
+    A.SkewX(45);
     EXPECT_TRUE(MathUtil::isInvertible(A));
 
     // A perspective matrix (projection plane at z=0) is invertible. The intuitive
     // explanation is that perspective is eqivalent to a skew of the w-axis; skews are
     // invertible.
     MathUtil::makeIdentity(&A);
-    A.PreconcatPerspectiveDepth(1);
+    A.ApplyPerspectiveDepth(1);
     EXPECT_TRUE(MathUtil::isInvertible(A));
 
     // A "pure" perspective matrix derived by similar triangles, with m44() set to zero
     // (i.e. camera positioned at the origin), is not invertible.
     MathUtil::makeIdentity(&A);
-    A.PreconcatPerspectiveDepth(1);
+    A.ApplyPerspectiveDepth(1);
     A.matrix().setDouble(3, 3, 0);
     EXPECT_FALSE(MathUtil::isInvertible(A));
 
     // Adding more to a non-invertible matrix will not make it invertible in the general case.
     MathUtil::makeIdentity(&A);
-    A.PreconcatPerspectiveDepth(1);
+    A.ApplyPerspectiveDepth(1);
     A.matrix().setDouble(3, 3, 0);
-    A.PreconcatScale3d(6, 7, 8);
+    A.Scale3d(6, 7, 8);
     MathUtil::rotateEulerAngles(&A, 10, 20, 30);
-    A.PreconcatTranslate3d(6, 7, 8);
+    A.Translate3d(6, 7, 8);
     EXPECT_FALSE(MathUtil::isInvertible(A));
 
     // A degenerate matrix of all zeros is not invertible.
     MathUtil::makeIdentity(&A);
     A.matrix().setDouble(0, 0, 0);
     A.matrix().setDouble(1, 1, 0);
     A.matrix().setDouble(2, 2, 0);
     A.matrix().setDouble(3, 3, 0);
     EXPECT_FALSE(MathUtil::isInvertible(A));
 }
@@ skipping 150 matching lines @@
     A.matrix().setDouble(2, 3, 2);
     EXPECT_TRUE(MathUtil::isIdentityOrTranslation(A));
 
     MathUtil::makeIdentity(&A);
     A.matrix().setDouble(3, 3, 2);
     EXPECT_FALSE(MathUtil::isIdentityOrTranslation(A));
 }
 
 }  // namespace
 }  // namespace cc