| // 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 "base/memory/scoped_vector.h" |
| #include "cc/test/geometry_test_utils.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/WebKit/Source/Platform/chromium/public/WebTransformOperations.h" |
| #include "third_party/WebKit/Source/Platform/chromium/public/WebTransformationMatrix.h" |
| |
| using namespace WebKit; |
| |
| TEST(WebTransformOperationTest, transformTypesAreUnique) |
| { |
| ScopedVector<WebTransformOperations> transforms; |
| |
| WebTransformOperations* toAdd = new WebTransformOperations(); |
| toAdd->appendTranslate(1, 0, 0); |
| transforms.push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendRotate(0, 0, 1, 2); |
| transforms.push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendScale(2, 2, 2); |
| transforms.push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendSkew(1, 0); |
| transforms.push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendPerspective(800); |
| transforms.push_back(toAdd); |
| |
| for (size_t i = 0; i < transforms.size(); ++i) { |
| for (size_t j = 0; j < transforms.size(); ++j) { |
| bool matchesType = transforms[i]->matchesTypes(*transforms[j]); |
| EXPECT_TRUE((i == j && matchesType) || !matchesType); |
| } |
| } |
| } |
| |
| TEST(WebTransformOperationTest, matchTypesSameLength) |
| { |
| WebTransformOperations translates; |
| translates.appendTranslate(1, 0, 0); |
| translates.appendTranslate(1, 0, 0); |
| translates.appendTranslate(1, 0, 0); |
| |
| WebTransformOperations skews; |
| skews.appendSkew(0, 2); |
| skews.appendSkew(0, 2); |
| skews.appendSkew(0, 2); |
| |
| WebTransformOperations translates2; |
| translates2.appendTranslate(0, 2, 0); |
| translates2.appendTranslate(0, 2, 0); |
| translates2.appendTranslate(0, 2, 0); |
| |
| WebTransformOperations translates3 = translates2; |
| |
| EXPECT_FALSE(translates.matchesTypes(skews)); |
| EXPECT_TRUE(translates.matchesTypes(translates2)); |
| EXPECT_TRUE(translates.matchesTypes(translates3)); |
| } |
| |
| TEST(WebTransformOperationTest, matchTypesDifferentLength) |
| { |
| WebTransformOperations translates; |
| translates.appendTranslate(1, 0, 0); |
| translates.appendTranslate(1, 0, 0); |
| translates.appendTranslate(1, 0, 0); |
| |
| WebTransformOperations skews; |
| skews.appendSkew(2, 0); |
| skews.appendSkew(2, 0); |
| |
| WebTransformOperations translates2; |
| translates2.appendTranslate(0, 2, 0); |
| translates2.appendTranslate(0, 2, 0); |
| |
| EXPECT_FALSE(translates.matchesTypes(skews)); |
| EXPECT_FALSE(translates.matchesTypes(translates2)); |
| } |
| |
| void getIdentityOperations(ScopedVector<WebTransformOperations>* operations) |
| { |
| WebTransformOperations* toAdd = new WebTransformOperations(); |
| operations->push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendTranslate(0, 0, 0); |
| operations->push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendTranslate(0, 0, 0); |
| toAdd->appendTranslate(0, 0, 0); |
| operations->push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendScale(1, 1, 1); |
| operations->push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendScale(1, 1, 1); |
| toAdd->appendScale(1, 1, 1); |
| operations->push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendSkew(0, 0); |
| operations->push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendSkew(0, 0); |
| toAdd->appendSkew(0, 0); |
| operations->push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendRotate(0, 0, 1, 0); |
| operations->push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendRotate(0, 0, 1, 0); |
| toAdd->appendRotate(0, 0, 1, 0); |
| operations->push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendMatrix(WebTransformationMatrix()); |
| operations->push_back(toAdd); |
| |
| toAdd = new WebTransformOperations(); |
| toAdd->appendMatrix(WebTransformationMatrix()); |
| toAdd->appendMatrix(WebTransformationMatrix()); |
| operations->push_back(toAdd); |
| } |
| |
| TEST(WebTransformOperationTest, identityAlwaysMatches) |
| { |
| ScopedVector<WebTransformOperations> operations; |
| getIdentityOperations(&operations); |
| |
| for (size_t i = 0; i < operations.size(); ++i) { |
| for (size_t j = 0; j < operations.size(); ++j) |
| EXPECT_TRUE(operations[i]->matchesTypes(*operations[j])); |
| } |
| } |
| |
| TEST(WebTransformOperationTest, applyTranslate) |
| { |
| double x = 1; |
| double y = 2; |
| double z = 3; |
| WebTransformOperations operations; |
| operations.appendTranslate(x, y, z); |
| WebTransformationMatrix expected; |
| expected.translate3d(x, y, z); |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply()); |
| } |
| |
| TEST(WebTransformOperationTest, applyRotate) |
| { |
| double x = 1; |
| double y = 2; |
| double z = 3; |
| double degrees = 80; |
| WebTransformOperations operations; |
| operations.appendRotate(x, y, z, degrees); |
| WebTransformationMatrix expected; |
| expected.rotate3d(x, y, z, degrees); |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply()); |
| } |
| |
| TEST(WebTransformOperationTest, applyScale) |
| { |
| double x = 1; |
| double y = 2; |
| double z = 3; |
| WebTransformOperations operations; |
| operations.appendScale(x, y, z); |
| WebTransformationMatrix expected; |
| expected.scale3d(x, y, z); |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply()); |
| } |
| |
| TEST(WebTransformOperationTest, applySkew) |
| { |
| double x = 1; |
| double y = 2; |
| WebTransformOperations operations; |
| operations.appendSkew(x, y); |
| WebTransformationMatrix expected; |
| expected.skewX(x); |
| expected.skewY(y); |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply()); |
| } |
| |
| TEST(WebTransformOperationTest, applyPerspective) |
| { |
| double depth = 800; |
| WebTransformOperations operations; |
| operations.appendPerspective(depth); |
| WebTransformationMatrix expected; |
| expected.applyPerspective(depth); |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply()); |
| } |
| |
| TEST(WebTransformOperationTest, applyMatrix) |
| { |
| double dx = 1; |
| double dy = 2; |
| double dz = 3; |
| WebTransformationMatrix expectedMatrix; |
| expectedMatrix.translate3d(dx, dy, dz); |
| WebTransformOperations matrixTransform; |
| matrixTransform.appendMatrix(expectedMatrix); |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expectedMatrix, matrixTransform.apply()); |
| } |
| |
| TEST(WebTransformOperationTest, applyOrder) |
| { |
| double sx = 2; |
| double sy = 4; |
| double sz = 8; |
| |
| double dx = 1; |
| double dy = 2; |
| double dz = 3; |
| |
| WebTransformOperations operations; |
| operations.appendScale(sx, sy, sz); |
| operations.appendTranslate(dx, dy, dz); |
| |
| WebTransformationMatrix expectedScaleMatrix; |
| expectedScaleMatrix.scale3d(sx, sy, sz); |
| |
| WebTransformationMatrix expectedTranslateMatrix; |
| expectedTranslateMatrix.translate3d(dx, dy, dz); |
| |
| WebTransformationMatrix expectedCombinedMatrix = expectedScaleMatrix; |
| expectedCombinedMatrix.multiply(expectedTranslateMatrix); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expectedCombinedMatrix, operations.apply()); |
| } |
| |
| TEST(WebTransformOperationTest, blendOrder) |
| { |
| double sx1 = 2; |
| double sy1 = 4; |
| double sz1 = 8; |
| |
| double dx1 = 1; |
| double dy1 = 2; |
| double dz1 = 3; |
| |
| double sx2 = 4; |
| double sy2 = 8; |
| double sz2 = 16; |
| |
| double dx2 = 10; |
| double dy2 = 20; |
| double dz2 = 30; |
| |
| WebTransformOperations operationsFrom; |
| operationsFrom.appendScale(sx1, sy1, sz1); |
| operationsFrom.appendTranslate(dx1, dy1, dz1); |
| |
| WebTransformOperations operationsTo; |
| operationsTo.appendScale(sx2, sy2, sz2); |
| operationsTo.appendTranslate(dx2, dy2, dz2); |
| |
| WebTransformationMatrix scaleFrom; |
| scaleFrom.scale3d(sx1, sy1, sz1); |
| WebTransformationMatrix translateFrom; |
| translateFrom.translate3d(dx1, dy1, dz1); |
| |
| WebTransformationMatrix scaleTo; |
| scaleTo.scale3d(sx2, sy2, sz2); |
| WebTransformationMatrix translateTo; |
| translateTo.translate3d(dx2, dy2, dz2); |
| |
| double progress = 0.25; |
| |
| WebTransformationMatrix blendedScale = scaleTo; |
| blendedScale.blend(scaleFrom, progress); |
| |
| WebTransformationMatrix blendedTranslate = translateTo; |
| blendedTranslate.blend(translateFrom, progress); |
| |
| WebTransformationMatrix expected = blendedScale; |
| expected.multiply(blendedTranslate); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress)); |
| } |
| |
| static void checkProgress(double progress, |
| const WebTransformationMatrix& fromMatrix, |
| const WebTransformationMatrix& toMatrix, |
| const WebTransformOperations& fromTransform, |
| const WebTransformOperations& toTransform) |
| { |
| WebTransformationMatrix expectedMatrix = toMatrix; |
| expectedMatrix.blend(fromMatrix, progress); |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expectedMatrix, toTransform.blend(fromTransform, progress)); |
| } |
| |
| TEST(WebTransformOperationTest, blendProgress) |
| { |
| double sx = 2; |
| double sy = 4; |
| double sz = 8; |
| WebTransformOperations operationsFrom; |
| operationsFrom.appendScale(sx, sy, sz); |
| |
| WebTransformationMatrix matrixFrom; |
| matrixFrom.scale3d(sx, sy, sz); |
| |
| sx = 4; |
| sy = 8; |
| sz = 16; |
| WebTransformOperations operationsTo; |
| operationsTo.appendScale(sx, sy, sz); |
| |
| WebTransformationMatrix matrixTo; |
| matrixTo.scale3d(sx, sy, sz); |
| |
| checkProgress(-1, matrixFrom, matrixTo, operationsFrom, operationsTo); |
| checkProgress(0, matrixFrom, matrixTo, operationsFrom, operationsTo); |
| checkProgress(0.25, matrixFrom, matrixTo, operationsFrom, operationsTo); |
| checkProgress(0.5, matrixFrom, matrixTo, operationsFrom, operationsTo); |
| checkProgress(1, matrixFrom, matrixTo, operationsFrom, operationsTo); |
| checkProgress(2, matrixFrom, matrixTo, operationsFrom, operationsTo); |
| } |
| |
| TEST(WebTransformOperationTest, blendWhenTypesDoNotMatch) |
| { |
| double sx1 = 2; |
| double sy1 = 4; |
| double sz1 = 8; |
| |
| double dx1 = 1; |
| double dy1 = 2; |
| double dz1 = 3; |
| |
| double sx2 = 4; |
| double sy2 = 8; |
| double sz2 = 16; |
| |
| double dx2 = 10; |
| double dy2 = 20; |
| double dz2 = 30; |
| |
| WebTransformOperations operationsFrom; |
| operationsFrom.appendScale(sx1, sy1, sz1); |
| operationsFrom.appendTranslate(dx1, dy1, dz1); |
| |
| WebTransformOperations operationsTo; |
| operationsTo.appendTranslate(dx2, dy2, dz2); |
| operationsTo.appendScale(sx2, sy2, sz2); |
| |
| WebTransformationMatrix from; |
| from.scale3d(sx1, sy1, sz1); |
| from.translate3d(dx1, dy1, dz1); |
| |
| WebTransformationMatrix to; |
| to.translate3d(dx2, dy2, dz2); |
| to.scale3d(sx2, sy2, sz2); |
| |
| double progress = 0.25; |
| |
| WebTransformationMatrix expected = to; |
| expected.blend(from, progress); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress)); |
| } |
| |
| TEST(WebTransformOperationTest, largeRotationsWithSameAxis) |
| { |
| WebTransformOperations operationsFrom; |
| operationsFrom.appendRotate(0, 0, 1, 0); |
| |
| WebTransformOperations operationsTo; |
| operationsTo.appendRotate(0, 0, 2, 360); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| expected.rotate3d(0, 0, 1, 180); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress)); |
| } |
| |
| TEST(WebTransformOperationTest, largeRotationsWithSameAxisInDifferentDirection) |
| { |
| WebTransformOperations operationsFrom; |
| operationsFrom.appendRotate(0, 0, 1, 180); |
| |
| WebTransformOperations operationsTo; |
| operationsTo.appendRotate(0, 0, -1, 180); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress)); |
| } |
| |
| TEST(WebTransformOperationTest, largeRotationsWithDifferentAxes) |
| { |
| WebTransformOperations operationsFrom; |
| operationsFrom.appendRotate(0, 0, 1, 180); |
| |
| WebTransformOperations operationsTo; |
| operationsTo.appendRotate(0, 1, 0, 180); |
| |
| double progress = 0.5; |
| WebTransformationMatrix matrixFrom; |
| matrixFrom.rotate3d(0, 0, 1, 180); |
| |
| WebTransformationMatrix matrixTo; |
| matrixTo.rotate3d(0, 1, 0, 180); |
| |
| WebTransformationMatrix expected = matrixTo; |
| expected.blend(matrixFrom, progress); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress)); |
| } |
| |
| TEST(WebTransformOperationTest, blendRotationFromIdentity) |
| { |
| ScopedVector<WebTransformOperations> identityOperations; |
| getIdentityOperations(&identityOperations); |
| |
| for (size_t i = 0; i < identityOperations.size(); ++i) { |
| WebTransformOperations operations; |
| operations.appendRotate(0, 0, 1, 360); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| expected.rotate3d(0, 0, 1, 180); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOperations[i], progress)); |
| } |
| } |
| |
| TEST(WebTransformOperationTest, blendTranslationFromIdentity) |
| { |
| ScopedVector<WebTransformOperations> identityOperations; |
| getIdentityOperations(&identityOperations); |
| |
| for (size_t i = 0; i < identityOperations.size(); ++i) { |
| WebTransformOperations operations; |
| operations.appendTranslate(2, 2, 2); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| expected.translate3d(1, 1, 1); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOperations[i], progress)); |
| } |
| } |
| |
| TEST(WebTransformOperationTest, blendScaleFromIdentity) |
| { |
| ScopedVector<WebTransformOperations> identityOperations; |
| getIdentityOperations(&identityOperations); |
| |
| for (size_t i = 0; i < identityOperations.size(); ++i) { |
| WebTransformOperations operations; |
| operations.appendScale(3, 3, 3); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| expected.scale3d(2, 2, 2); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOperations[i], progress)); |
| } |
| } |
| |
| TEST(WebTransformOperationTest, blendSkewFromIdentity) |
| { |
| ScopedVector<WebTransformOperations> identityOperations; |
| getIdentityOperations(&identityOperations); |
| |
| for (size_t i = 0; i < identityOperations.size(); ++i) { |
| WebTransformOperations operations; |
| operations.appendSkew(2, 2); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| expected.skewX(1); |
| expected.skewY(1); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOperations[i], progress)); |
| } |
| } |
| |
| TEST(WebTransformOperationTest, blendPerspectiveFromIdentity) |
| { |
| ScopedVector<WebTransformOperations> identityOperations; |
| getIdentityOperations(&identityOperations); |
| |
| for (size_t i = 0; i < identityOperations.size(); ++i) { |
| WebTransformOperations operations; |
| operations.appendPerspective(1000); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| expected.applyPerspective(500 + 0.5 * std::numeric_limits<double>::max()); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOperations[i], progress)); |
| } |
| } |
| |
| TEST(WebTransformOperationTest, blendRotationToIdentity) |
| { |
| ScopedVector<WebTransformOperations> identityOperations; |
| getIdentityOperations(&identityOperations); |
| |
| for (size_t i = 0; i < identityOperations.size(); ++i) { |
| WebTransformOperations operations; |
| operations.appendRotate(0, 0, 1, 360); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| expected.rotate3d(0, 0, 1, 180); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(operations, progress)); |
| } |
| } |
| |
| TEST(WebTransformOperationTest, blendTranslationToIdentity) |
| { |
| ScopedVector<WebTransformOperations> identityOperations; |
| getIdentityOperations(&identityOperations); |
| |
| for (size_t i = 0; i < identityOperations.size(); ++i) { |
| WebTransformOperations operations; |
| operations.appendTranslate(2, 2, 2); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| expected.translate3d(1, 1, 1); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(operations, progress)); |
| } |
| } |
| |
| TEST(WebTransformOperationTest, blendScaleToIdentity) |
| { |
| ScopedVector<WebTransformOperations> identityOperations; |
| getIdentityOperations(&identityOperations); |
| |
| for (size_t i = 0; i < identityOperations.size(); ++i) { |
| WebTransformOperations operations; |
| operations.appendScale(3, 3, 3); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| expected.scale3d(2, 2, 2); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(operations, progress)); |
| } |
| } |
| |
| TEST(WebTransformOperationTest, blendSkewToIdentity) |
| { |
| ScopedVector<WebTransformOperations> identityOperations; |
| getIdentityOperations(&identityOperations); |
| |
| for (size_t i = 0; i < identityOperations.size(); ++i) { |
| WebTransformOperations operations; |
| operations.appendSkew(2, 2); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| expected.skewX(1); |
| expected.skewY(1); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(operations, progress)); |
| } |
| } |
| |
| TEST(WebTransformOperationTest, blendPerspectiveToIdentity) |
| { |
| ScopedVector<WebTransformOperations> identityOperations; |
| getIdentityOperations(&identityOperations); |
| |
| for (size_t i = 0; i < identityOperations.size(); ++i) { |
| WebTransformOperations operations; |
| operations.appendPerspective(1000); |
| |
| double progress = 0.5; |
| |
| WebTransformationMatrix expected; |
| expected.applyPerspective(500 + 0.5 * std::numeric_limits<double>::max()); |
| |
| EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(operations, progress)); |
| } |
| } |