cc/animation/transform_operations_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <limits>
   6
   7 #include "base/memory/scoped_vector.h"
   8 #include "cc/animation/transform_operations.h"
   9 #include "cc/test/geometry_test_utils.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "ui/gfx/vector3d_f.h"
  12
  13 namespace cc {
  14 namespace {
  15
  16 TEST(TransformOperationTest, TransformTypesAreUnique) {
  17   ScopedVector<TransformOperations> transforms;
  18
  19   TransformOperations* to_add = new TransformOperations();
  20   to_add->AppendTranslate(1, 0, 0);
  21   transforms.push_back(to_add);
  22
  23   to_add = new TransformOperations();
  24   to_add->AppendRotate(0, 0, 1, 2);
  25   transforms.push_back(to_add);
  26
  27   to_add = new TransformOperations();
  28   to_add->AppendScale(2, 2, 2);
  29   transforms.push_back(to_add);
  30
  31   to_add = new TransformOperations();
  32   to_add->AppendSkew(1, 0);
  33   transforms.push_back(to_add);
  34
  35   to_add = new TransformOperations();
  36   to_add->AppendPerspective(800);
  37   transforms.push_back(to_add);
  38
  39   for (size_t i = 0; i < transforms.size(); ++i) {
  40     for (size_t j = 0; j < transforms.size(); ++j) {
  41       bool matches_type = transforms[i]->MatchesTypes(*transforms[j]);
  42       EXPECT_TRUE((i == j && matches_type) || !matches_type);
  43     }
  44   }
  45 }
  46
  47 TEST(TransformOperationTest, MatchTypesSameLength) {
  48   TransformOperations translates;
  49   translates.AppendTranslate(1, 0, 0);
  50   translates.AppendTranslate(1, 0, 0);
  51   translates.AppendTranslate(1, 0, 0);
  52
  53   TransformOperations skews;
  54   skews.AppendSkew(0, 2);
  55   skews.AppendSkew(0, 2);
  56   skews.AppendSkew(0, 2);
  57
  58   TransformOperations translates2;
  59   translates2.AppendTranslate(0, 2, 0);
  60   translates2.AppendTranslate(0, 2, 0);
  61   translates2.AppendTranslate(0, 2, 0);
  62
  63   TransformOperations translates3 = translates2;
  64
  65   EXPECT_FALSE(translates.MatchesTypes(skews));
  66   EXPECT_TRUE(translates.MatchesTypes(translates2));
  67   EXPECT_TRUE(translates.MatchesTypes(translates3));
  68 }
  69
  70 TEST(TransformOperationTest, MatchTypesDifferentLength) {
  71   TransformOperations translates;
  72   translates.AppendTranslate(1, 0, 0);
  73   translates.AppendTranslate(1, 0, 0);
  74   translates.AppendTranslate(1, 0, 0);
  75
  76   TransformOperations skews;
  77   skews.AppendSkew(2, 0);
  78   skews.AppendSkew(2, 0);
  79
  80   TransformOperations translates2;
  81   translates2.AppendTranslate(0, 2, 0);
  82   translates2.AppendTranslate(0, 2, 0);
  83
  84   EXPECT_FALSE(translates.MatchesTypes(skews));
  85   EXPECT_FALSE(translates.MatchesTypes(translates2));
  86 }
  87
  88 void GetIdentityOperations(ScopedVector<TransformOperations>* operations) {
  89   TransformOperations* to_add = new TransformOperations();
  90   operations->push_back(to_add);
  91
  92   to_add = new TransformOperations();
  93   to_add->AppendTranslate(0, 0, 0);
  94   operations->push_back(to_add);
  95
  96   to_add = new TransformOperations();
  97   to_add->AppendTranslate(0, 0, 0);
  98   to_add->AppendTranslate(0, 0, 0);
  99   operations->push_back(to_add);
 100
 101   to_add = new TransformOperations();
 102   to_add->AppendScale(1, 1, 1);
 103   operations->push_back(to_add);
 104
 105   to_add = new TransformOperations();
 106   to_add->AppendScale(1, 1, 1);
 107   to_add->AppendScale(1, 1, 1);
 108   operations->push_back(to_add);
 109
 110   to_add = new TransformOperations();
 111   to_add->AppendSkew(0, 0);
 112   operations->push_back(to_add);
 113
 114   to_add = new TransformOperations();
 115   to_add->AppendSkew(0, 0);
 116   to_add->AppendSkew(0, 0);
 117   operations->push_back(to_add);
 118
 119   to_add = new TransformOperations();
 120   to_add->AppendRotate(0, 0, 1, 0);
 121   operations->push_back(to_add);
 122
 123   to_add = new TransformOperations();
 124   to_add->AppendRotate(0, 0, 1, 0);
 125   to_add->AppendRotate(0, 0, 1, 0);
 126   operations->push_back(to_add);
 127
 128   to_add = new TransformOperations();
 129   to_add->AppendMatrix(gfx::Transform());
 130   operations->push_back(to_add);
 131
 132   to_add = new TransformOperations();
 133   to_add->AppendMatrix(gfx::Transform());
 134   to_add->AppendMatrix(gfx::Transform());
 135   operations->push_back(to_add);
 136 }
 137
 138 TEST(TransformOperationTest, IdentityAlwaysMatches) {
 139   ScopedVector<TransformOperations> operations;
 140   GetIdentityOperations(&operations);
 141
 142   for (size_t i = 0; i < operations.size(); ++i) {
 143     for (size_t j = 0; j < operations.size(); ++j)
 144       EXPECT_TRUE(operations[i]->MatchesTypes(*operations[j]));
 145   }
 146 }
 147
 148 TEST(TransformOperationTest, ApplyTranslate) {
 149   double x = 1;
 150   double y = 2;
 151   double z = 3;
 152   TransformOperations operations;
 153   operations.AppendTranslate(x, y, z);
 154   gfx::Transform expected;
 155   expected.Translate3d(x, y, z);
 156   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
 157 }
 158
 159 TEST(TransformOperationTest, ApplyRotate) {
 160   double x = 1;
 161   double y = 2;
 162   double z = 3;
 163   double degrees = 80;
 164   TransformOperations operations;
 165   operations.AppendRotate(x, y, z, degrees);
 166   gfx::Transform expected;
 167   expected.RotateAbout(gfx::Vector3dF(x, y, z), degrees);
 168   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
 169 }
 170
 171 TEST(TransformOperationTest, ApplyScale) {
 172   double x = 1;
 173   double y = 2;
 174   double z = 3;
 175   TransformOperations operations;
 176   operations.AppendScale(x, y, z);
 177   gfx::Transform expected;
 178   expected.Scale3d(x, y, z);
 179   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
 180 }
 181
 182 TEST(TransformOperationTest, ApplySkew) {
 183   double x = 1;
 184   double y = 2;
 185   TransformOperations operations;
 186   operations.AppendSkew(x, y);
 187   gfx::Transform expected;
 188   expected.SkewX(x);
 189   expected.SkewY(y);
 190   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
 191 }
 192
 193 TEST(TransformOperationTest, ApplyPerspective) {
 194   double depth = 800;
 195   TransformOperations operations;
 196   operations.AppendPerspective(depth);
 197   gfx::Transform expected;
 198   expected.ApplyPerspectiveDepth(depth);
 199   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
 200 }
 201
 202 TEST(TransformOperationTest, ApplyMatrix) {
 203   double dx = 1;
 204   double dy = 2;
 205   double dz = 3;
 206   gfx::Transform expected_matrix;
 207   expected_matrix.Translate3d(dx, dy, dz);
 208   TransformOperations matrix_transform;
 209   matrix_transform.AppendMatrix(expected_matrix);
 210   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_matrix, matrix_transform.Apply());
 211 }
 212
 213 TEST(TransformOperationTest, ApplyOrder) {
 214   double sx = 2;
 215   double sy = 4;
 216   double sz = 8;
 217
 218   double dx = 1;
 219   double dy = 2;
 220   double dz = 3;
 221
 222   TransformOperations operations;
 223   operations.AppendScale(sx, sy, sz);
 224   operations.AppendTranslate(dx, dy, dz);
 225
 226   gfx::Transform expected_scale_matrix;
 227   expected_scale_matrix.Scale3d(sx, sy, sz);
 228
 229   gfx::Transform expected_translate_matrix;
 230   expected_translate_matrix.Translate3d(dx, dy, dz);
 231
 232   gfx::Transform expected_combined_matrix = expected_scale_matrix;
 233   expected_combined_matrix.PreconcatTransform(expected_translate_matrix);
 234
 235   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_combined_matrix, operations.Apply());
 236 }
 237
 238 TEST(TransformOperationTest, BlendOrder) {
 239   double sx1 = 2;
 240   double sy1 = 4;
 241   double sz1 = 8;
 242
 243   double dx1 = 1;
 244   double dy1 = 2;
 245   double dz1 = 3;
 246
 247   double sx2 = 4;
 248   double sy2 = 8;
 249   double sz2 = 16;
 250
 251   double dx2 = 10;
 252   double dy2 = 20;
 253   double dz2 = 30;
 254
 255   TransformOperations operations_from;
 256   operations_from.AppendScale(sx1, sy1, sz1);
 257   operations_from.AppendTranslate(dx1, dy1, dz1);
 258
 259   TransformOperations operations_to;
 260   operations_to.AppendScale(sx2, sy2, sz2);
 261   operations_to.AppendTranslate(dx2, dy2, dz2);
 262
 263   gfx::Transform scale_from;
 264   scale_from.Scale3d(sx1, sy1, sz1);
 265   gfx::Transform translate_from;
 266   translate_from.Translate3d(dx1, dy1, dz1);
 267
 268   gfx::Transform scale_to;
 269   scale_to.Scale3d(sx2, sy2, sz2);
 270   gfx::Transform translate_to;
 271   translate_to.Translate3d(dx2, dy2, dz2);
 272
 273   double progress = 0.25;
 274
 275   gfx::Transform blended_scale = scale_to;
 276   blended_scale.Blend(scale_from, progress);
 277
 278   gfx::Transform blended_translate = translate_to;
 279   blended_translate.Blend(translate_from, progress);
 280
 281   gfx::Transform expected = blended_scale;
 282   expected.PreconcatTransform(blended_translate);
 283
 284   EXPECT_TRANSFORMATION_MATRIX_EQ(
 285       expected, operations_to.Blend(operations_from, progress));
 286 }
 287
 288 static void CheckProgress(double progress,
 289               const gfx::Transform& from_matrix,
 290               const gfx::Transform& to_matrix,
 291               const TransformOperations& from_transform,
 292               const TransformOperations& to_transform) {
 293   gfx::Transform expected_matrix = to_matrix;
 294   expected_matrix.Blend(from_matrix, progress);
 295   EXPECT_TRANSFORMATION_MATRIX_EQ(
 296       expected_matrix, to_transform.Blend(from_transform, progress));
 297 }
 298
 299 TEST(TransformOperationTest, BlendProgress) {
 300   double sx = 2;
 301   double sy = 4;
 302   double sz = 8;
 303   TransformOperations operations_from;
 304   operations_from.AppendScale(sx, sy, sz);
 305
 306   gfx::Transform matrix_from;
 307   matrix_from.Scale3d(sx, sy, sz);
 308
 309   sx = 4;
 310   sy = 8;
 311   sz = 16;
 312   TransformOperations operations_to;
 313   operations_to.AppendScale(sx, sy, sz);
 314
 315   gfx::Transform matrix_to;
 316   matrix_to.Scale3d(sx, sy, sz);
 317
 318   CheckProgress(-1, matrix_from, matrix_to, operations_from, operations_to);
 319   CheckProgress(0, matrix_from, matrix_to, operations_from, operations_to);
 320   CheckProgress(0.25, matrix_from, matrix_to, operations_from, operations_to);
 321   CheckProgress(0.5, matrix_from, matrix_to, operations_from, operations_to);
 322   CheckProgress(1, matrix_from, matrix_to, operations_from, operations_to);
 323   CheckProgress(2, matrix_from, matrix_to, operations_from, operations_to);
 324 }
 325
 326 TEST(TransformOperationTest, BlendWhenTypesDoNotMatch) {
 327   double sx1 = 2;
 328   double sy1 = 4;
 329   double sz1 = 8;
 330
 331   double dx1 = 1;
 332   double dy1 = 2;
 333   double dz1 = 3;
 334
 335   double sx2 = 4;
 336   double sy2 = 8;
 337   double sz2 = 16;
 338
 339   double dx2 = 10;
 340   double dy2 = 20;
 341   double dz2 = 30;
 342
 343   TransformOperations operations_from;
 344   operations_from.AppendScale(sx1, sy1, sz1);
 345   operations_from.AppendTranslate(dx1, dy1, dz1);
 346
 347   TransformOperations operations_to;
 348   operations_to.AppendTranslate(dx2, dy2, dz2);
 349   operations_to.AppendScale(sx2, sy2, sz2);
 350
 351   gfx::Transform from;
 352   from.Scale3d(sx1, sy1, sz1);
 353   from.Translate3d(dx1, dy1, dz1);
 354
 355   gfx::Transform to;
 356   to.Translate3d(dx2, dy2, dz2);
 357   to.Scale3d(sx2, sy2, sz2);
 358
 359   double progress = 0.25;
 360
 361   gfx::Transform expected = to;
 362   expected.Blend(from, progress);
 363
 364   EXPECT_TRANSFORMATION_MATRIX_EQ(
 365       expected, operations_to.Blend(operations_from, progress));
 366 }
 367
 368 TEST(TransformOperationTest, LargeRotationsWithSameAxis) {
 369   TransformOperations operations_from;
 370   operations_from.AppendRotate(0, 0, 1, 0);
 371
 372   TransformOperations operations_to;
 373   operations_to.AppendRotate(0, 0, 2, 360);
 374
 375   double progress = 0.5;
 376
 377   gfx::Transform expected;
 378   expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
 379
 380   EXPECT_TRANSFORMATION_MATRIX_EQ(
 381       expected, operations_to.Blend(operations_from, progress));
 382 }
 383
 384 TEST(TransformOperationTest, LargeRotationsWithSameAxisInDifferentDirection) {
 385   TransformOperations operations_from;
 386   operations_from.AppendRotate(0, 0, 1, 180);
 387
 388   TransformOperations operations_to;
 389   operations_to.AppendRotate(0, 0, -1, 180);
 390
 391   double progress = 0.5;
 392
 393   gfx::Transform expected;
 394
 395   EXPECT_TRANSFORMATION_MATRIX_EQ(
 396       expected, operations_to.Blend(operations_from, progress));
 397 }
 398
 399 TEST(TransformOperationTest, LargeRotationsWithDifferentAxes) {
 400   TransformOperations operations_from;
 401   operations_from.AppendRotate(0, 0, 1, 175);
 402
 403   TransformOperations operations_to;
 404   operations_to.AppendRotate(0, 1, 0, 175);
 405
 406   double progress = 0.5;
 407   gfx::Transform matrix_from;
 408   matrix_from.RotateAbout(gfx::Vector3dF(0, 0, 1), 175);
 409
 410   gfx::Transform matrix_to;
 411   matrix_to.RotateAbout(gfx::Vector3dF(0, 1, 0), 175);
 412
 413   gfx::Transform expected = matrix_to;
 414   expected.Blend(matrix_from, progress);
 415
 416   EXPECT_TRANSFORMATION_MATRIX_EQ(
 417       expected, operations_to.Blend(operations_from, progress));
 418 }
 419
 420 TEST(TransformOperationTest, BlendRotationFromIdentity) {
 421   ScopedVector<TransformOperations> identity_operations;
 422   GetIdentityOperations(&identity_operations);
 423
 424   for (size_t i = 0; i < identity_operations.size(); ++i) {
 425     TransformOperations operations;
 426     operations.AppendRotate(0, 0, 1, 360);
 427
 428     double progress = 0.5;
 429
 430     gfx::Transform expected;
 431     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
 432
 433     EXPECT_TRANSFORMATION_MATRIX_EQ(
 434         expected, operations.Blend(*identity_operations[i], progress));
 435   }
 436 }
 437
 438 TEST(TransformOperationTest, BlendTranslationFromIdentity) {
 439   ScopedVector<TransformOperations> identity_operations;
 440   GetIdentityOperations(&identity_operations);
 441
 442   for (size_t i = 0; i < identity_operations.size(); ++i) {
 443     TransformOperations operations;
 444     operations.AppendTranslate(2, 2, 2);
 445
 446     double progress = 0.5;
 447
 448     gfx::Transform expected;
 449     expected.Translate3d(1, 1, 1);
 450
 451     EXPECT_TRANSFORMATION_MATRIX_EQ(
 452         expected, operations.Blend(*identity_operations[i], progress));
 453   }
 454 }
 455
 456 TEST(TransformOperationTest, BlendScaleFromIdentity) {
 457   ScopedVector<TransformOperations> identity_operations;
 458   GetIdentityOperations(&identity_operations);
 459
 460   for (size_t i = 0; i < identity_operations.size(); ++i) {
 461     TransformOperations operations;
 462     operations.AppendScale(3, 3, 3);
 463
 464     double progress = 0.5;
 465
 466     gfx::Transform expected;
 467     expected.Scale3d(2, 2, 2);
 468
 469     EXPECT_TRANSFORMATION_MATRIX_EQ(
 470         expected, operations.Blend(*identity_operations[i], progress));
 471   }
 472 }
 473
 474 TEST(TransformOperationTest, BlendSkewFromIdentity) {
 475   ScopedVector<TransformOperations> identity_operations;
 476   GetIdentityOperations(&identity_operations);
 477
 478   for (size_t i = 0; i < identity_operations.size(); ++i) {
 479     TransformOperations operations;
 480     operations.AppendSkew(2, 2);
 481
 482     double progress = 0.5;
 483
 484     gfx::Transform expected;
 485     expected.SkewX(1);
 486     expected.SkewY(1);
 487
 488     EXPECT_TRANSFORMATION_MATRIX_EQ(
 489         expected, operations.Blend(*identity_operations[i], progress));
 490   }
 491 }
 492
 493 TEST(TransformOperationTest, BlendPerspectiveFromIdentity) {
 494   ScopedVector<TransformOperations> identity_operations;
 495   GetIdentityOperations(&identity_operations);
 496
 497   for (size_t i = 0; i < identity_operations.size(); ++i) {
 498     TransformOperations operations;
 499     operations.AppendPerspective(1000);
 500
 501     double progress = 0.5;
 502
 503     gfx::Transform expected;
 504     expected.ApplyPerspectiveDepth(
 505         500 + 0.5 * std::numeric_limits<double>::max());
 506
 507     EXPECT_TRANSFORMATION_MATRIX_EQ(
 508         expected, operations.Blend(*identity_operations[i], progress));
 509   }
 510 }
 511
 512 TEST(TransformOperationTest, BlendRotationToIdentity) {
 513   ScopedVector<TransformOperations> identity_operations;
 514   GetIdentityOperations(&identity_operations);
 515
 516   for (size_t i = 0; i < identity_operations.size(); ++i) {
 517     TransformOperations operations;
 518     operations.AppendRotate(0, 0, 1, 360);
 519
 520     double progress = 0.5;
 521
 522     gfx::Transform expected;
 523     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
 524
 525     EXPECT_TRANSFORMATION_MATRIX_EQ(
 526         expected, identity_operations[i]->Blend(operations, progress));
 527   }
 528 }
 529
 530 TEST(TransformOperationTest, BlendTranslationToIdentity) {
 531   ScopedVector<TransformOperations> identity_operations;
 532   GetIdentityOperations(&identity_operations);
 533
 534   for (size_t i = 0; i < identity_operations.size(); ++i) {
 535     TransformOperations operations;
 536     operations.AppendTranslate(2, 2, 2);
 537
 538     double progress = 0.5;
 539
 540     gfx::Transform expected;
 541     expected.Translate3d(1, 1, 1);
 542
 543     EXPECT_TRANSFORMATION_MATRIX_EQ(
 544         expected, identity_operations[i]->Blend(operations, progress));
 545   }
 546 }
 547
 548 TEST(TransformOperationTest, BlendScaleToIdentity) {
 549   ScopedVector<TransformOperations> identity_operations;
 550   GetIdentityOperations(&identity_operations);
 551
 552   for (size_t i = 0; i < identity_operations.size(); ++i) {
 553     TransformOperations operations;
 554     operations.AppendScale(3, 3, 3);
 555
 556     double progress = 0.5;
 557
 558     gfx::Transform expected;
 559     expected.Scale3d(2, 2, 2);
 560
 561     EXPECT_TRANSFORMATION_MATRIX_EQ(
 562         expected, identity_operations[i]->Blend(operations, progress));
 563   }
 564 }
 565
 566 TEST(TransformOperationTest, BlendSkewToIdentity) {
 567   ScopedVector<TransformOperations> identity_operations;
 568   GetIdentityOperations(&identity_operations);
 569
 570   for (size_t i = 0; i < identity_operations.size(); ++i) {
 571     TransformOperations operations;
 572     operations.AppendSkew(2, 2);
 573
 574     double progress = 0.5;
 575
 576     gfx::Transform expected;
 577     expected.SkewX(1);
 578     expected.SkewY(1);
 579
 580     EXPECT_TRANSFORMATION_MATRIX_EQ(
 581         expected, identity_operations[i]->Blend(operations, progress));
 582   }
 583 }
 584
 585 TEST(TransformOperationTest, BlendPerspectiveToIdentity) {
 586   ScopedVector<TransformOperations> identity_operations;
 587   GetIdentityOperations(&identity_operations);
 588
 589   for (size_t i = 0; i < identity_operations.size(); ++i) {
 590     TransformOperations operations;
 591     operations.AppendPerspective(1000);
 592
 593     double progress = 0.5;
 594
 595     gfx::Transform expected;
 596     expected.ApplyPerspectiveDepth(
 597         500 + 0.5 * std::numeric_limits<double>::max());
 598
 599     EXPECT_TRANSFORMATION_MATRIX_EQ(
 600         expected, identity_operations[i]->Blend(operations, progress));
 601   }
 602 }
 603
 604 }  // namespace
 605 }  // namespace cc