?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update V8 to version 4.7.42.
[chromium-blink-merge.git] / cc / animation / transform_operations_unittest.cc
blob572ab47ec7af73a05af0425d51bf068cadcb17ba
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/basictypes.h"
8 #include "base/memory/scoped_vector.h"
9 #include "cc/animation/transform_operations.h"
10 #include "cc/test/geometry_test_utils.h"
11 #include "testing/gtest/include/gtest/gtest.h"
12 #include "ui/gfx/animation/tween.h"
13 #include "ui/gfx/geometry/box_f.h"
14 #include "ui/gfx/geometry/rect_conversions.h"
15 #include "ui/gfx/geometry/vector3d_f.h"
16
17 namespace cc {
18 namespace {
19
20 TEST(TransformOperationTest, TransformTypesAreUnique) {
21 ScopedVector<TransformOperations> transforms;
22
23 TransformOperations* to_add = new TransformOperations();
24 to_add->AppendTranslate(1, 0, 0);
25 transforms.push_back(to_add);
26
27 to_add = new TransformOperations();
28 to_add->AppendRotate(0, 0, 1, 2);
29 transforms.push_back(to_add);
30
31 to_add = new TransformOperations();
32 to_add->AppendScale(2, 2, 2);
33 transforms.push_back(to_add);
34
35 to_add = new TransformOperations();
36 to_add->AppendSkew(1, 0);
37 transforms.push_back(to_add);
38
39 to_add = new TransformOperations();
40 to_add->AppendPerspective(800);
41 transforms.push_back(to_add);
42
43 for (size_t i = 0; i < transforms.size(); ++i) {
44 for (size_t j = 0; j < transforms.size(); ++j) {
45 bool matches_type = transforms[i]->MatchesTypes(*transforms[j]);
46 EXPECT_TRUE((i == j && matches_type) || !matches_type);
47 }
48 }
49 }
50
51 TEST(TransformOperationTest, MatchTypesSameLength) {
52 TransformOperations translates;
53 translates.AppendTranslate(1, 0, 0);
54 translates.AppendTranslate(1, 0, 0);
55 translates.AppendTranslate(1, 0, 0);
56
57 TransformOperations skews;
58 skews.AppendSkew(0, 2);
59 skews.AppendSkew(0, 2);
60 skews.AppendSkew(0, 2);
61
62 TransformOperations translates2;
63 translates2.AppendTranslate(0, 2, 0);
64 translates2.AppendTranslate(0, 2, 0);
65 translates2.AppendTranslate(0, 2, 0);
66
67 TransformOperations translates3 = translates2;
68
69 EXPECT_FALSE(translates.MatchesTypes(skews));
70 EXPECT_TRUE(translates.MatchesTypes(translates2));
71 EXPECT_TRUE(translates.MatchesTypes(translates3));
72 }
73
74 TEST(TransformOperationTest, MatchTypesDifferentLength) {
75 TransformOperations translates;
76 translates.AppendTranslate(1, 0, 0);
77 translates.AppendTranslate(1, 0, 0);
78 translates.AppendTranslate(1, 0, 0);
79
80 TransformOperations skews;
81 skews.AppendSkew(2, 0);
82 skews.AppendSkew(2, 0);
83
84 TransformOperations translates2;
85 translates2.AppendTranslate(0, 2, 0);
86 translates2.AppendTranslate(0, 2, 0);
87
88 EXPECT_FALSE(translates.MatchesTypes(skews));
89 EXPECT_FALSE(translates.MatchesTypes(translates2));
90 }
91
92 void GetIdentityOperations(ScopedVector<TransformOperations>* operations) {
93 TransformOperations* to_add = new TransformOperations();
94 operations->push_back(to_add);
95
96 to_add = new TransformOperations();
97 to_add->AppendTranslate(0, 0, 0);
98 operations->push_back(to_add);
99
100 to_add = new TransformOperations();
101 to_add->AppendTranslate(0, 0, 0);
102 to_add->AppendTranslate(0, 0, 0);
103 operations->push_back(to_add);
104
105 to_add = new TransformOperations();
106 to_add->AppendScale(1, 1, 1);
107 operations->push_back(to_add);
108
109 to_add = new TransformOperations();
110 to_add->AppendScale(1, 1, 1);
111 to_add->AppendScale(1, 1, 1);
112 operations->push_back(to_add);
113
114 to_add = new TransformOperations();
115 to_add->AppendSkew(0, 0);
116 operations->push_back(to_add);
117
118 to_add = new TransformOperations();
119 to_add->AppendSkew(0, 0);
120 to_add->AppendSkew(0, 0);
121 operations->push_back(to_add);
122
123 to_add = new TransformOperations();
124 to_add->AppendRotate(0, 0, 1, 0);
125 operations->push_back(to_add);
126
127 to_add = new TransformOperations();
128 to_add->AppendRotate(0, 0, 1, 0);
129 to_add->AppendRotate(0, 0, 1, 0);
130 operations->push_back(to_add);
131
132 to_add = new TransformOperations();
133 to_add->AppendMatrix(gfx::Transform());
134 operations->push_back(to_add);
135
136 to_add = new TransformOperations();
137 to_add->AppendMatrix(gfx::Transform());
138 to_add->AppendMatrix(gfx::Transform());
139 operations->push_back(to_add);
140 }
141
142 TEST(TransformOperationTest, MatchTypesOrder) {
143 TransformOperations mix_order_identity;
144 mix_order_identity.AppendTranslate(0, 0, 0);
145 mix_order_identity.AppendScale(1, 1, 1);
146 mix_order_identity.AppendTranslate(0, 0, 0);
147
148 TransformOperations mix_order_one;
149 mix_order_one.AppendTranslate(0, 1, 0);
150 mix_order_one.AppendScale(2, 1, 3);
151 mix_order_one.AppendTranslate(1, 0, 0);
152
153 TransformOperations mix_order_two;
154 mix_order_two.AppendTranslate(0, 1, 0);
155 mix_order_two.AppendTranslate(1, 0, 0);
156 mix_order_two.AppendScale(2, 1, 3);
157
158 EXPECT_TRUE(mix_order_identity.MatchesTypes(mix_order_one));
159 EXPECT_FALSE(mix_order_identity.MatchesTypes(mix_order_two));
160 EXPECT_FALSE(mix_order_one.MatchesTypes(mix_order_two));
161 }
162
163 TEST(TransformOperationTest, NoneAlwaysMatches) {
164 ScopedVector<TransformOperations> operations;
165 GetIdentityOperations(&operations);
166
167 TransformOperations none_operation;
168 for (size_t i = 0; i < operations.size(); ++i)
169 EXPECT_TRUE(operations[i]->MatchesTypes(none_operation));
170 }
171
172 TEST(TransformOperationTest, ApplyTranslate) {
173 SkMScalar x = 1;
174 SkMScalar y = 2;
175 SkMScalar z = 3;
176 TransformOperations operations;
177 operations.AppendTranslate(x, y, z);
178 gfx::Transform expected;
179 expected.Translate3d(x, y, z);
180 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
181 }
182
183 TEST(TransformOperationTest, ApplyRotate) {
184 SkMScalar x = 1;
185 SkMScalar y = 2;
186 SkMScalar z = 3;
187 SkMScalar degrees = 80;
188 TransformOperations operations;
189 operations.AppendRotate(x, y, z, degrees);
190 gfx::Transform expected;
191 expected.RotateAbout(gfx::Vector3dF(x, y, z), degrees);
192 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
193 }
194
195 TEST(TransformOperationTest, ApplyScale) {
196 SkMScalar x = 1;
197 SkMScalar y = 2;
198 SkMScalar z = 3;
199 TransformOperations operations;
200 operations.AppendScale(x, y, z);
201 gfx::Transform expected;
202 expected.Scale3d(x, y, z);
203 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
204 }
205
206 TEST(TransformOperationTest, ApplySkew) {
207 SkMScalar x = 1;
208 SkMScalar y = 2;
209 TransformOperations operations;
210 operations.AppendSkew(x, y);
211 gfx::Transform expected;
212 expected.Skew(x, y);
213 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
214 }
215
216 TEST(TransformOperationTest, ApplyPerspective) {
217 SkMScalar depth = 800;
218 TransformOperations operations;
219 operations.AppendPerspective(depth);
220 gfx::Transform expected;
221 expected.ApplyPerspectiveDepth(depth);
222 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
223 }
224
225 TEST(TransformOperationTest, ApplyMatrix) {
226 SkMScalar dx = 1;
227 SkMScalar dy = 2;
228 SkMScalar dz = 3;
229 gfx::Transform expected_matrix;
230 expected_matrix.Translate3d(dx, dy, dz);
231 TransformOperations matrix_transform;
232 matrix_transform.AppendMatrix(expected_matrix);
233 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_matrix, matrix_transform.Apply());
234 }
235
236 TEST(TransformOperationTest, ApplyOrder) {
237 SkMScalar sx = 2;
238 SkMScalar sy = 4;
239 SkMScalar sz = 8;
240
241 SkMScalar dx = 1;
242 SkMScalar dy = 2;
243 SkMScalar dz = 3;
244
245 TransformOperations operations;
246 operations.AppendScale(sx, sy, sz);
247 operations.AppendTranslate(dx, dy, dz);
248
249 gfx::Transform expected_scale_matrix;
250 expected_scale_matrix.Scale3d(sx, sy, sz);
251
252 gfx::Transform expected_translate_matrix;
253 expected_translate_matrix.Translate3d(dx, dy, dz);
254
255 gfx::Transform expected_combined_matrix = expected_scale_matrix;
256 expected_combined_matrix.PreconcatTransform(expected_translate_matrix);
257
258 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_combined_matrix, operations.Apply());
259 }
260
261 TEST(TransformOperationTest, BlendOrder) {
262 SkMScalar sx1 = 2;
263 SkMScalar sy1 = 4;
264 SkMScalar sz1 = 8;
265
266 SkMScalar dx1 = 1;
267 SkMScalar dy1 = 2;
268 SkMScalar dz1 = 3;
269
270 SkMScalar sx2 = 4;
271 SkMScalar sy2 = 8;
272 SkMScalar sz2 = 16;
273
274 SkMScalar dx2 = 10;
275 SkMScalar dy2 = 20;
276 SkMScalar dz2 = 30;
277
278 TransformOperations operations_from;
279 operations_from.AppendScale(sx1, sy1, sz1);
280 operations_from.AppendTranslate(dx1, dy1, dz1);
281
282 TransformOperations operations_to;
283 operations_to.AppendScale(sx2, sy2, sz2);
284 operations_to.AppendTranslate(dx2, dy2, dz2);
285
286 gfx::Transform scale_from;
287 scale_from.Scale3d(sx1, sy1, sz1);
288 gfx::Transform translate_from;
289 translate_from.Translate3d(dx1, dy1, dz1);
290
291 gfx::Transform scale_to;
292 scale_to.Scale3d(sx2, sy2, sz2);
293 gfx::Transform translate_to;
294 translate_to.Translate3d(dx2, dy2, dz2);
295
296 SkMScalar progress = 0.25f;
297
298 gfx::Transform blended_scale = scale_to;
299 blended_scale.Blend(scale_from, progress);
300
301 gfx::Transform blended_translate = translate_to;
302 blended_translate.Blend(translate_from, progress);
303
304 gfx::Transform expected = blended_scale;
305 expected.PreconcatTransform(blended_translate);
306
307 EXPECT_TRANSFORMATION_MATRIX_EQ(
308 expected, operations_to.Blend(operations_from, progress));
309 }
310
311 static void CheckProgress(SkMScalar progress,
312 const gfx::Transform& from_matrix,
313 const gfx::Transform& to_matrix,
314 const TransformOperations& from_transform,
315 const TransformOperations& to_transform) {
316 gfx::Transform expected_matrix = to_matrix;
317 expected_matrix.Blend(from_matrix, progress);
318 EXPECT_TRANSFORMATION_MATRIX_EQ(
319 expected_matrix, to_transform.Blend(from_transform, progress));
320 }
321
322 TEST(TransformOperationTest, BlendProgress) {
323 SkMScalar sx = 2;
324 SkMScalar sy = 4;
325 SkMScalar sz = 8;
326 TransformOperations operations_from;
327 operations_from.AppendScale(sx, sy, sz);
328
329 gfx::Transform matrix_from;
330 matrix_from.Scale3d(sx, sy, sz);
331
332 sx = 4;
333 sy = 8;
334 sz = 16;
335 TransformOperations operations_to;
336 operations_to.AppendScale(sx, sy, sz);
337
338 gfx::Transform matrix_to;
339 matrix_to.Scale3d(sx, sy, sz);
340
341 CheckProgress(-1, matrix_from, matrix_to, operations_from, operations_to);
342 CheckProgress(0, matrix_from, matrix_to, operations_from, operations_to);
343 CheckProgress(0.25f, matrix_from, matrix_to, operations_from, operations_to);
344 CheckProgress(0.5f, matrix_from, matrix_to, operations_from, operations_to);
345 CheckProgress(1, matrix_from, matrix_to, operations_from, operations_to);
346 CheckProgress(2, matrix_from, matrix_to, operations_from, operations_to);
347 }
348
349 TEST(TransformOperationTest, BlendWhenTypesDoNotMatch) {
350 SkMScalar sx1 = 2;
351 SkMScalar sy1 = 4;
352 SkMScalar sz1 = 8;
353
354 SkMScalar dx1 = 1;
355 SkMScalar dy1 = 2;
356 SkMScalar dz1 = 3;
357
358 SkMScalar sx2 = 4;
359 SkMScalar sy2 = 8;
360 SkMScalar sz2 = 16;
361
362 SkMScalar dx2 = 10;
363 SkMScalar dy2 = 20;
364 SkMScalar dz2 = 30;
365
366 TransformOperations operations_from;
367 operations_from.AppendScale(sx1, sy1, sz1);
368 operations_from.AppendTranslate(dx1, dy1, dz1);
369
370 TransformOperations operations_to;
371 operations_to.AppendTranslate(dx2, dy2, dz2);
372 operations_to.AppendScale(sx2, sy2, sz2);
373
374 gfx::Transform from;
375 from.Scale3d(sx1, sy1, sz1);
376 from.Translate3d(dx1, dy1, dz1);
377
378 gfx::Transform to;
379 to.Translate3d(dx2, dy2, dz2);
380 to.Scale3d(sx2, sy2, sz2);
381
382 SkMScalar progress = 0.25f;
383
384 gfx::Transform expected = to;
385 expected.Blend(from, progress);
386
387 EXPECT_TRANSFORMATION_MATRIX_EQ(
388 expected, operations_to.Blend(operations_from, progress));
389 }
390
391 TEST(TransformOperationTest, LargeRotationsWithSameAxis) {
392 TransformOperations operations_from;
393 operations_from.AppendRotate(0, 0, 1, 0);
394
395 TransformOperations operations_to;
396 operations_to.AppendRotate(0, 0, 2, 360);
397
398 SkMScalar progress = 0.5f;
399
400 gfx::Transform expected;
401 expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
402
403 EXPECT_TRANSFORMATION_MATRIX_EQ(
404 expected, operations_to.Blend(operations_from, progress));
405 }
406
407 TEST(TransformOperationTest, LargeRotationsWithSameAxisInDifferentDirection) {
408 TransformOperations operations_from;
409 operations_from.AppendRotate(0, 0, 1, 180);
410
411 TransformOperations operations_to;
412 operations_to.AppendRotate(0, 0, -1, 180);
413
414 SkMScalar progress = 0.5f;
415
416 gfx::Transform expected;
417
418 EXPECT_TRANSFORMATION_MATRIX_EQ(
419 expected, operations_to.Blend(operations_from, progress));
420 }
421
422 TEST(TransformOperationTest, LargeRotationsWithDifferentAxes) {
423 TransformOperations operations_from;
424 operations_from.AppendRotate(0, 0, 1, 175);
425
426 TransformOperations operations_to;
427 operations_to.AppendRotate(0, 1, 0, 175);
428
429 SkMScalar progress = 0.5f;
430 gfx::Transform matrix_from;
431 matrix_from.RotateAbout(gfx::Vector3dF(0, 0, 1), 175);
432
433 gfx::Transform matrix_to;
434 matrix_to.RotateAbout(gfx::Vector3dF(0, 1, 0), 175);
435
436 gfx::Transform expected = matrix_to;
437 expected.Blend(matrix_from, progress);
438
439 EXPECT_TRANSFORMATION_MATRIX_EQ(
440 expected, operations_to.Blend(operations_from, progress));
441 }
442
443 TEST(TransformOperationTest, RotationFromZeroDegDifferentAxes) {
444 TransformOperations operations_from;
445 operations_from.AppendRotate(0, 0, 1, 0);
446
447 TransformOperations operations_to;
448 operations_to.AppendRotate(0, 1, 0, 450);
449
450 SkMScalar progress = 0.5f;
451 gfx::Transform expected;
452 expected.RotateAbout(gfx::Vector3dF(0, 1, 0), 225);
453 EXPECT_TRANSFORMATION_MATRIX_EQ(
454 expected, operations_to.Blend(operations_from, progress));
455 }
456
457 TEST(TransformOperationTest, RotationFromZeroDegSameAxes) {
458 TransformOperations operations_from;
459 operations_from.AppendRotate(0, 0, 1, 0);
460
461 TransformOperations operations_to;
462 operations_to.AppendRotate(0, 0, 1, 450);
463
464 SkMScalar progress = 0.5f;
465 gfx::Transform expected;
466 expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 225);
467 EXPECT_TRANSFORMATION_MATRIX_EQ(
468 expected, operations_to.Blend(operations_from, progress));
469 }
470
471 TEST(TransformOperationTest, RotationToZeroDegDifferentAxes) {
472 TransformOperations operations_from;
473 operations_from.AppendRotate(0, 1, 0, 450);
474
475 TransformOperations operations_to;
476 operations_to.AppendRotate(0, 0, 1, 0);
477
478 SkMScalar progress = 0.5f;
479 gfx::Transform expected;
480 expected.RotateAbout(gfx::Vector3dF(0, 1, 0), 225);
481 EXPECT_TRANSFORMATION_MATRIX_EQ(
482 expected, operations_to.Blend(operations_from, progress));
483 }
484
485 TEST(TransformOperationTest, RotationToZeroDegSameAxes) {
486 TransformOperations operations_from;
487 operations_from.AppendRotate(0, 0, 1, 450);
488
489 TransformOperations operations_to;
490 operations_to.AppendRotate(0, 0, 1, 0);
491
492 SkMScalar progress = 0.5f;
493 gfx::Transform expected;
494 expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 225);
495 EXPECT_TRANSFORMATION_MATRIX_EQ(
496 expected, operations_to.Blend(operations_from, progress));
497 }
498
499 TEST(TransformOperationTest, BlendRotationFromIdentity) {
500 ScopedVector<TransformOperations> identity_operations;
501 GetIdentityOperations(&identity_operations);
502
503 for (size_t i = 0; i < identity_operations.size(); ++i) {
504 TransformOperations operations;
505 operations.AppendRotate(0, 0, 1, 90);
506
507 SkMScalar progress = 0.5f;
508
509 gfx::Transform expected;
510 expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 45);
511
512 EXPECT_TRANSFORMATION_MATRIX_EQ(
513 expected, operations.Blend(*identity_operations[i], progress));
514
515 progress = -0.5f;
516
517 expected.MakeIdentity();
518 expected.RotateAbout(gfx::Vector3dF(0, 0, 1), -45);
519
520 EXPECT_TRANSFORMATION_MATRIX_EQ(
521 expected, operations.Blend(*identity_operations[i], progress));
522
523 progress = 1.5f;
524
525 expected.MakeIdentity();
526 expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 135);
527
528 EXPECT_TRANSFORMATION_MATRIX_EQ(
529 expected, operations.Blend(*identity_operations[i], progress));
530 }
531 }
532
533 TEST(TransformOperationTest, BlendTranslationFromIdentity) {
534 ScopedVector<TransformOperations> identity_operations;
535 GetIdentityOperations(&identity_operations);
536
537 for (size_t i = 0; i < identity_operations.size(); ++i) {
538 TransformOperations operations;
539 operations.AppendTranslate(2, 2, 2);
540
541 SkMScalar progress = 0.5f;
542
543 gfx::Transform expected;
544 expected.Translate3d(1, 1, 1);
545
546 EXPECT_TRANSFORMATION_MATRIX_EQ(
547 expected, operations.Blend(*identity_operations[i], progress));
548
549 progress = -0.5f;
550
551 expected.MakeIdentity();
552 expected.Translate3d(-1, -1, -1);
553
554 EXPECT_TRANSFORMATION_MATRIX_EQ(
555 expected, operations.Blend(*identity_operations[i], progress));
556
557 progress = 1.5f;
558
559 expected.MakeIdentity();
560 expected.Translate3d(3, 3, 3);
561
562 EXPECT_TRANSFORMATION_MATRIX_EQ(
563 expected, operations.Blend(*identity_operations[i], progress));
564 }
565 }
566
567 TEST(TransformOperationTest, BlendScaleFromIdentity) {
568 ScopedVector<TransformOperations> identity_operations;
569 GetIdentityOperations(&identity_operations);
570
571 for (size_t i = 0; i < identity_operations.size(); ++i) {
572 TransformOperations operations;
573 operations.AppendScale(3, 3, 3);
574
575 SkMScalar progress = 0.5f;
576
577 gfx::Transform expected;
578 expected.Scale3d(2, 2, 2);
579
580 EXPECT_TRANSFORMATION_MATRIX_EQ(
581 expected, operations.Blend(*identity_operations[i], progress));
582
583 progress = -0.5f;
584
585 expected.MakeIdentity();
586 expected.Scale3d(0, 0, 0);
587
588 EXPECT_TRANSFORMATION_MATRIX_EQ(
589 expected, operations.Blend(*identity_operations[i], progress));
590
591 progress = 1.5f;
592
593 expected.MakeIdentity();
594 expected.Scale3d(4, 4, 4);
595
596 EXPECT_TRANSFORMATION_MATRIX_EQ(
597 expected, operations.Blend(*identity_operations[i], progress));
598 }
599 }
600
601 TEST(TransformOperationTest, BlendSkewFromEmpty) {
602 TransformOperations empty_operation;
603
604 TransformOperations operations;
605 operations.AppendSkew(2, 2);
606
607 SkMScalar progress = 0.5f;
608
609 gfx::Transform expected;
610 expected.Skew(1, 1);
611
612 EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
613 operations.Blend(empty_operation, progress));
614
615 progress = -0.5f;
616
617 expected.MakeIdentity();
618 expected.Skew(-1, -1);
619
620 EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
621 operations.Blend(empty_operation, progress));
622
623 progress = 1.5f;
624
625 expected.MakeIdentity();
626 expected.Skew(3, 3);
627
628 EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
629 operations.Blend(empty_operation, progress));
630 }
631
632 TEST(TransformOperationTest, BlendPerspectiveFromIdentity) {
633 ScopedVector<TransformOperations> identity_operations;
634 GetIdentityOperations(&identity_operations);
635
636 for (size_t i = 0; i < identity_operations.size(); ++i) {
637 TransformOperations operations;
638 operations.AppendPerspective(1000);
639
640 SkMScalar progress = 0.5f;
641
642 gfx::Transform expected;
643 expected.ApplyPerspectiveDepth(2000);
644
645 EXPECT_TRANSFORMATION_MATRIX_EQ(
646 expected, operations.Blend(*identity_operations[i], progress));
647 }
648 }
649
650 TEST(TransformOperationTest, BlendRotationToIdentity) {
651 ScopedVector<TransformOperations> identity_operations;
652 GetIdentityOperations(&identity_operations);
653
654 for (size_t i = 0; i < identity_operations.size(); ++i) {
655 TransformOperations operations;
656 operations.AppendRotate(0, 0, 1, 90);
657
658 SkMScalar progress = 0.5f;
659
660 gfx::Transform expected;
661 expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 45);
662
663 EXPECT_TRANSFORMATION_MATRIX_EQ(
664 expected, identity_operations[i]->Blend(operations, progress));
665 }
666 }
667
668 TEST(TransformOperationTest, BlendTranslationToIdentity) {
669 ScopedVector<TransformOperations> identity_operations;
670 GetIdentityOperations(&identity_operations);
671
672 for (size_t i = 0; i < identity_operations.size(); ++i) {
673 TransformOperations operations;
674 operations.AppendTranslate(2, 2, 2);
675
676 SkMScalar progress = 0.5f;
677
678 gfx::Transform expected;
679 expected.Translate3d(1, 1, 1);
680
681 EXPECT_TRANSFORMATION_MATRIX_EQ(
682 expected, identity_operations[i]->Blend(operations, progress));
683 }
684 }
685
686 TEST(TransformOperationTest, BlendScaleToIdentity) {
687 ScopedVector<TransformOperations> identity_operations;
688 GetIdentityOperations(&identity_operations);
689
690 for (size_t i = 0; i < identity_operations.size(); ++i) {
691 TransformOperations operations;
692 operations.AppendScale(3, 3, 3);
693
694 SkMScalar progress = 0.5f;
695
696 gfx::Transform expected;
697 expected.Scale3d(2, 2, 2);
698
699 EXPECT_TRANSFORMATION_MATRIX_EQ(
700 expected, identity_operations[i]->Blend(operations, progress));
701 }
702 }
703
704 TEST(TransformOperationTest, BlendSkewToEmpty) {
705 TransformOperations empty_operation;
706
707 TransformOperations operations;
708 operations.AppendSkew(2, 2);
709
710 SkMScalar progress = 0.5f;
711
712 gfx::Transform expected;
713 expected.Skew(1, 1);
714
715 EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
716 empty_operation.Blend(operations, progress));
717 }
718
719 TEST(TransformOperationTest, BlendPerspectiveToIdentity) {
720 ScopedVector<TransformOperations> identity_operations;
721 GetIdentityOperations(&identity_operations);
722
723 for (size_t i = 0; i < identity_operations.size(); ++i) {
724 TransformOperations operations;
725 operations.AppendPerspective(1000);
726
727 SkMScalar progress = 0.5f;
728
729 gfx::Transform expected;
730 expected.ApplyPerspectiveDepth(2000);
731
732 EXPECT_TRANSFORMATION_MATRIX_EQ(
733 expected, identity_operations[i]->Blend(operations, progress));
734 }
735 }
736
737 TEST(TransformOperationTest, ExtrapolatePerspectiveBlending) {
738 TransformOperations operations1;
739 operations1.AppendPerspective(1000);
740
741 TransformOperations operations2;
742 operations2.AppendPerspective(500);
743
744 gfx::Transform expected;
745 expected.ApplyPerspectiveDepth(400);
746
747 EXPECT_TRANSFORMATION_MATRIX_EQ(
748 expected, operations1.Blend(operations2, -0.5));
749
750 expected.MakeIdentity();
751 expected.ApplyPerspectiveDepth(2000);
752
753 EXPECT_TRANSFORMATION_MATRIX_EQ(
754 expected, operations1.Blend(operations2, 1.5));
755 }
756
757 TEST(TransformOperationTest, ExtrapolateMatrixBlending) {
758 gfx::Transform transform1;
759 transform1.Translate3d(1, 1, 1);
760 TransformOperations operations1;
761 operations1.AppendMatrix(transform1);
762
763 gfx::Transform transform2;
764 transform2.Translate3d(3, 3, 3);
765 TransformOperations operations2;
766 operations2.AppendMatrix(transform2);
767
768 gfx::Transform expected;
769 EXPECT_TRANSFORMATION_MATRIX_EQ(
770 expected, operations1.Blend(operations2, 1.5));
771
772 expected.Translate3d(4, 4, 4);
773 EXPECT_TRANSFORMATION_MATRIX_EQ(
774 expected, operations1.Blend(operations2, -0.5));
775 }
776
777 TEST(TransformOperationTest, BlendedBoundsWhenTypesDoNotMatch) {
778 TransformOperations operations_from;
779 operations_from.AppendScale(2.0, 4.0, 8.0);
780 operations_from.AppendTranslate(1.0, 2.0, 3.0);
781
782 TransformOperations operations_to;
783 operations_to.AppendTranslate(10.0, 20.0, 30.0);
784 operations_to.AppendScale(4.0, 8.0, 16.0);
785
786 gfx::BoxF box(1.f, 1.f, 1.f);
787 gfx::BoxF bounds;
788
789 SkMScalar min_progress = 0.f;
790 SkMScalar max_progress = 1.f;
791
792 EXPECT_FALSE(operations_to.BlendedBoundsForBox(
793 box, operations_from, min_progress, max_progress, &bounds));
794 }
795
796 TEST(TransformOperationTest, BlendedBoundsForIdentity) {
797 TransformOperations operations_from;
798 operations_from.AppendIdentity();
799 TransformOperations operations_to;
800 operations_to.AppendIdentity();
801
802 gfx::BoxF box(1.f, 2.f, 3.f);
803 gfx::BoxF bounds;
804
805 SkMScalar min_progress = 0.f;
806 SkMScalar max_progress = 1.f;
807
808 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
809 box, operations_from, min_progress, max_progress, &bounds));
810 EXPECT_EQ(box.ToString(), bounds.ToString());
811 }
812
813 TEST(TransformOperationTest, BlendedBoundsForTranslate) {
814 TransformOperations operations_from;
815 operations_from.AppendTranslate(3.0, -4.0, 2.0);
816 TransformOperations operations_to;
817 operations_to.AppendTranslate(7.0, 4.0, -2.0);
818
819 gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
820 gfx::BoxF bounds;
821
822 SkMScalar min_progress = -0.5f;
823 SkMScalar max_progress = 1.5f;
824 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
825 box, operations_from, min_progress, max_progress, &bounds));
826 EXPECT_EQ(gfx::BoxF(2.f, -6.f, -1.f, 12.f, 20.f, 12.f).ToString(),
827 bounds.ToString());
828
829 min_progress = 0.f;
830 max_progress = 1.f;
831 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
832 box, operations_from, min_progress, max_progress, &bounds));
833 EXPECT_EQ(gfx::BoxF(4.f, -2.f, 1.f, 8.f, 12.f, 8.f).ToString(),
834 bounds.ToString());
835
836 TransformOperations identity;
837 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
838 box, identity, min_progress, max_progress, &bounds));
839 EXPECT_EQ(gfx::BoxF(1.f, 2.f, 1.f, 11.f, 8.f, 6.f).ToString(),
840 bounds.ToString());
841
842 EXPECT_TRUE(identity.BlendedBoundsForBox(
843 box, operations_from, min_progress, max_progress, &bounds));
844 EXPECT_EQ(gfx::BoxF(1.f, -2.f, 3.f, 7.f, 8.f, 6.f).ToString(),
845 bounds.ToString());
846 }
847
848 TEST(TransformOperationTest, BlendedBoundsForScale) {
849 TransformOperations operations_from;
850 operations_from.AppendScale(3.0, 0.5, 2.0);
851 TransformOperations operations_to;
852 operations_to.AppendScale(7.0, 4.0, -2.0);
853
854 gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
855 gfx::BoxF bounds;
856
857 SkMScalar min_progress = -0.5f;
858 SkMScalar max_progress = 1.5f;
859 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
860 box, operations_from, min_progress, max_progress, &bounds));
861 EXPECT_EQ(gfx::BoxF(1.f, -7.5f, -28.f, 44.f, 42.f, 56.f).ToString(),
862 bounds.ToString());
863
864 min_progress = 0.f;
865 max_progress = 1.f;
866 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
867 box, operations_from, min_progress, max_progress, &bounds));
868 EXPECT_EQ(gfx::BoxF(3.f, 1.f, -14.f, 32.f, 23.f, 28.f).ToString(),
869 bounds.ToString());
870
871 TransformOperations identity;
872 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
873 box, identity, min_progress, max_progress, &bounds));
874 EXPECT_EQ(gfx::BoxF(1.f, 2.f, -14.f, 34.f, 22.f, 21.f).ToString(),
875 bounds.ToString());
876
877 EXPECT_TRUE(identity.BlendedBoundsForBox(
878 box, operations_from, min_progress, max_progress, &bounds));
879 EXPECT_EQ(gfx::BoxF(1.f, 1.f, 3.f, 14.f, 5.f, 11.f).ToString(),
880 bounds.ToString());
881 }
882
883 TEST(TransformOperationTest, BlendedBoundsWithZeroScale) {
884 TransformOperations zero_scale;
885 zero_scale.AppendScale(0.0, 0.0, 0.0);
886 TransformOperations non_zero_scale;
887 non_zero_scale.AppendScale(2.0, -4.0, 5.0);
888
889 gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
890 gfx::BoxF bounds;
891
892 SkMScalar min_progress = 0.f;
893 SkMScalar max_progress = 1.f;
894 EXPECT_TRUE(zero_scale.BlendedBoundsForBox(
895 box, non_zero_scale, min_progress, max_progress, &bounds));
896 EXPECT_EQ(gfx::BoxF(0.f, -24.f, 0.f, 10.f, 24.f, 35.f).ToString(),
897 bounds.ToString());
898
899 EXPECT_TRUE(non_zero_scale.BlendedBoundsForBox(
900 box, zero_scale, min_progress, max_progress, &bounds));
901 EXPECT_EQ(gfx::BoxF(0.f, -24.f, 0.f, 10.f, 24.f, 35.f).ToString(),
902 bounds.ToString());
903
904 EXPECT_TRUE(zero_scale.BlendedBoundsForBox(
905 box, zero_scale, min_progress, max_progress, &bounds));
906 EXPECT_EQ(gfx::BoxF().ToString(), bounds.ToString());
907 }
908
909 TEST(TransformOperationTest, BlendedBoundsForRotationTrivial) {
910 TransformOperations operations_from;
911 operations_from.AppendRotate(0.f, 0.f, 1.f, 0.f);
912 TransformOperations operations_to;
913 operations_to.AppendRotate(0.f, 0.f, 1.f, 360.f);
914
915 float sqrt_2 = sqrt(2.f);
916 gfx::BoxF box(
917 -sqrt_2, -sqrt_2, 0.f, sqrt_2, sqrt_2, 0.f);
918 gfx::BoxF bounds;
919
920 // Since we're rotating 360 degrees, any box with dimensions between 0 and
921 // 2 * sqrt(2) should give the same result.
922 float sizes[] = { 0.f, 0.1f, sqrt_2, 2.f * sqrt_2 };
923 for (size_t i = 0; i < arraysize(sizes); ++i) {
924 box.set_size(sizes[i], sizes[i], 0.f);
925 SkMScalar min_progress = 0.f;
926 SkMScalar max_progress = 1.f;
927 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
928 box, operations_from, min_progress, max_progress, &bounds));
929 EXPECT_EQ(gfx::BoxF(-2.f, -2.f, 0.f, 4.f, 4.f, 0.f).ToString(),
930 bounds.ToString());
931 }
932 }
933
934 TEST(TransformOperationTest, BlendedBoundsForRotationAllExtrema) {
935 // If the normal is out of the plane, we can have up to 6 extrema (a min/max
936 // in each dimension) between the endpoints of the arc. This test ensures that
937 // we consider all 6.
938 TransformOperations operations_from;
939 operations_from.AppendRotate(1.f, 1.f, 1.f, 30.f);
940 TransformOperations operations_to;
941 operations_to.AppendRotate(1.f, 1.f, 1.f, 390.f);
942
943 gfx::BoxF box(1.f, 0.f, 0.f, 0.f, 0.f, 0.f);
944 gfx::BoxF bounds;
945
946 float min = -1.f / 3.f;
947 float max = 1.f;
948 float size = max - min;
949 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
950 box, operations_from, 0.f, 1.f, &bounds));
951 EXPECT_EQ(gfx::BoxF(min, min, min, size, size, size).ToString(),
952 bounds.ToString());
953 }
954
955 TEST(TransformOperationTest, BlendedBoundsForRotationDifferentAxes) {
956 // We can handle rotations about a single axis. If the axes are different,
957 // we revert to matrix interpolation for which inflated bounds cannot be
958 // computed.
959 TransformOperations operations_from;
960 operations_from.AppendRotate(1.f, 1.f, 1.f, 30.f);
961 TransformOperations operations_to_same;
962 operations_to_same.AppendRotate(1.f, 1.f, 1.f, 390.f);
963 TransformOperations operations_to_opposite;
964 operations_to_opposite.AppendRotate(-1.f, -1.f, -1.f, 390.f);
965 TransformOperations operations_to_different;
966 operations_to_different.AppendRotate(1.f, 3.f, 1.f, 390.f);
967
968 gfx::BoxF box(1.f, 0.f, 0.f, 0.f, 0.f, 0.f);
969 gfx::BoxF bounds;
970
971 EXPECT_TRUE(operations_to_same.BlendedBoundsForBox(
972 box, operations_from, 0.f, 1.f, &bounds));
973 EXPECT_TRUE(operations_to_opposite.BlendedBoundsForBox(
974 box, operations_from, 0.f, 1.f, &bounds));
975 EXPECT_FALSE(operations_to_different.BlendedBoundsForBox(
976 box, operations_from, 0.f, 1.f, &bounds));
977 }
978
979 TEST(TransformOperationTest, BlendedBoundsForRotationPointOnAxis) {
980 // Checks that if the point to rotate is sitting on the axis of rotation, that
981 // it does not get affected.
982 TransformOperations operations_from;
983 operations_from.AppendRotate(1.f, 1.f, 1.f, 30.f);
984 TransformOperations operations_to;
985 operations_to.AppendRotate(1.f, 1.f, 1.f, 390.f);
986
987 gfx::BoxF box(1.f, 1.f, 1.f, 0.f, 0.f, 0.f);
988 gfx::BoxF bounds;
989
990 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
991 box, operations_from, 0.f, 1.f, &bounds));
992 EXPECT_EQ(box.ToString(), bounds.ToString());
993 }
994
995 TEST(TransformOperationTest, BlendedBoundsForRotationProblematicAxes) {
996 // Zeros in the components of the axis of rotation turned out to be tricky to
997 // deal with in practice. This function tests some potentially problematic
998 // axes to ensure sane behavior.
999
1000 // Some common values used in the expected boxes.
1001 float dim1 = 0.292893f;
1002 float dim2 = sqrt(2.f);
1003 float dim3 = 2.f * dim2;
1004
1005 struct {
1006 float x;
1007 float y;
1008 float z;
1009 gfx::BoxF expected;
1010 } tests[] = {{0.f, 0.f, 0.f, gfx::BoxF(1.f, 1.f, 1.f, 0.f, 0.f, 0.f)},
1011 {1.f, 0.f, 0.f, gfx::BoxF(1.f, -dim2, -dim2, 0.f, dim3, dim3)},
1012 {0.f, 1.f, 0.f, gfx::BoxF(-dim2, 1.f, -dim2, dim3, 0.f, dim3)},
1013 {0.f, 0.f, 1.f, gfx::BoxF(-dim2, -dim2, 1.f, dim3, dim3, 0.f)},
1014 {1.f, 1.f, 0.f, gfx::BoxF(dim1, dim1, -1.f, dim2, dim2, 2.f)},
1015 {0.f, 1.f, 1.f, gfx::BoxF(-1.f, dim1, dim1, 2.f, dim2, dim2)},
1016 {1.f, 0.f, 1.f, gfx::BoxF(dim1, -1.f, dim1, dim2, 2.f, dim2)}};
1017
1018 for (size_t i = 0; i < arraysize(tests); ++i) {
1019 float x = tests[i].x;
1020 float y = tests[i].y;
1021 float z = tests[i].z;
1022 TransformOperations operations_from;
1023 operations_from.AppendRotate(x, y, z, 0.f);
1024 TransformOperations operations_to;
1025 operations_to.AppendRotate(x, y, z, 360.f);
1026 gfx::BoxF box(1.f, 1.f, 1.f, 0.f, 0.f, 0.f);
1027 gfx::BoxF bounds;
1028
1029 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
1030 box, operations_from, 0.f, 1.f, &bounds));
1031 EXPECT_EQ(tests[i].expected.ToString(), bounds.ToString());
1032 }
1033 }
1034
1035 static void ExpectBoxesApproximatelyEqual(const gfx::BoxF& lhs,
1036 const gfx::BoxF& rhs,
1037 float tolerance) {
1038 EXPECT_NEAR(lhs.x(), rhs.x(), tolerance);
1039 EXPECT_NEAR(lhs.y(), rhs.y(), tolerance);
1040 EXPECT_NEAR(lhs.z(), rhs.z(), tolerance);
1041 EXPECT_NEAR(lhs.width(), rhs.width(), tolerance);
1042 EXPECT_NEAR(lhs.height(), rhs.height(), tolerance);
1043 EXPECT_NEAR(lhs.depth(), rhs.depth(), tolerance);
1044 }
1045
1046 static void EmpiricallyTestBounds(const TransformOperations& from,
1047 const TransformOperations& to,
1048 SkMScalar min_progress,
1049 SkMScalar max_progress,
1050 bool test_containment_only) {
1051 gfx::BoxF box(200.f, 500.f, 100.f, 100.f, 300.f, 200.f);
1052 gfx::BoxF bounds;
1053 EXPECT_TRUE(
1054 to.BlendedBoundsForBox(box, from, min_progress, max_progress, &bounds));
1055
1056 bool first_time = true;
1057 gfx::BoxF empirical_bounds;
1058 static const size_t kNumSteps = 10;
1059 for (size_t step = 0; step < kNumSteps; ++step) {
1060 float t = step / (kNumSteps - 1.f);
1061 t = gfx::Tween::FloatValueBetween(t, min_progress, max_progress);
1062 gfx::Transform partial_transform = to.Blend(from, t);
1063 gfx::BoxF transformed = box;
1064 partial_transform.TransformBox(&transformed);
1065
1066 if (first_time) {
1067 empirical_bounds = transformed;
1068 first_time = false;
1069 } else {
1070 empirical_bounds.Union(transformed);
1071 }
1072 }
1073
1074 if (test_containment_only) {
1075 gfx::BoxF unified_bounds = bounds;
1076 unified_bounds.Union(empirical_bounds);
1077 // Convert to the screen space rects these boxes represent.
1078 gfx::Rect bounds_rect = ToEnclosingRect(
1079 gfx::RectF(bounds.x(), bounds.y(), bounds.width(), bounds.height()));
1080 gfx::Rect unified_bounds_rect =
1081 ToEnclosingRect(gfx::RectF(unified_bounds.x(),
1082 unified_bounds.y(),
1083 unified_bounds.width(),
1084 unified_bounds.height()));
1085 EXPECT_EQ(bounds_rect.ToString(), unified_bounds_rect.ToString());
1086 } else {
1087 // Our empirical estimate will be a little rough since we're only doing
1088 // 100 samples.
1089 static const float kTolerance = 1e-2f;
1090 ExpectBoxesApproximatelyEqual(empirical_bounds, bounds, kTolerance);
1091 }
1092 }
1093
1094 static void EmpiricallyTestBoundsEquality(const TransformOperations& from,
1095 const TransformOperations& to,
1096 SkMScalar min_progress,
1097 SkMScalar max_progress) {
1098 EmpiricallyTestBounds(from, to, min_progress, max_progress, false);
1099 }
1100
1101 static void EmpiricallyTestBoundsContainment(const TransformOperations& from,
1102 const TransformOperations& to,
1103 SkMScalar min_progress,
1104 SkMScalar max_progress) {
1105 EmpiricallyTestBounds(from, to, min_progress, max_progress, true);
1106 }
1107
1108 TEST(TransformOperationTest, BlendedBoundsForRotationEmpiricalTests) {
1109 // Sets up various axis angle combinations, computes the bounding box and
1110 // empirically tests that the transformed bounds are indeed contained by the
1111 // computed bounding box.
1112
1113 struct {
1114 float x;
1115 float y;
1116 float z;
1117 } axes[] = {{1.f, 1.f, 1.f},
1118 {-1.f, -1.f, -1.f},
1119 {-1.f, 2.f, 3.f},
1120 {1.f, -2.f, 3.f},
1121 {1.f, 2.f, -3.f},
1122 {0.f, 0.f, 0.f},
1123 {1.f, 0.f, 0.f},
1124 {0.f, 1.f, 0.f},
1125 {0.f, 0.f, 1.f},
1126 {1.f, 1.f, 0.f},
1127 {0.f, 1.f, 1.f},
1128 {1.f, 0.f, 1.f},
1129 {-1.f, 0.f, 0.f},
1130 {0.f, -1.f, 0.f},
1131 {0.f, 0.f, -1.f},
1132 {-1.f, -1.f, 0.f},
1133 {0.f, -1.f, -1.f},
1134 {-1.f, 0.f, -1.f}};
1135
1136 struct {
1137 float theta_from;
1138 float theta_to;
1139 } angles[] = {{5.f, 10.f},
1140 {10.f, 5.f},
1141 {0.f, 360.f},
1142 {20.f, 180.f},
1143 {-20.f, -180.f},
1144 {180.f, -220.f},
1145 {220.f, 320.f}};
1146
1147 // We can go beyond the range [0, 1] (the bezier might slide out of this range
1148 // at either end), but since the first and last knots are at (0, 0) and (1, 1)
1149 // we will never go within it, so these tests are sufficient.
1150 struct {
1151 float min_progress;
1152 float max_progress;
1153 } progress[] = {
1154 {0.f, 1.f}, {-.25f, 1.25f},
1155 };
1156
1157 for (size_t i = 0; i < arraysize(axes); ++i) {
1158 for (size_t j = 0; j < arraysize(angles); ++j) {
1159 for (size_t k = 0; k < arraysize(progress); ++k) {
1160 float x = axes[i].x;
1161 float y = axes[i].y;
1162 float z = axes[i].z;
1163 TransformOperations operations_from;
1164 operations_from.AppendRotate(x, y, z, angles[j].theta_from);
1165 TransformOperations operations_to;
1166 operations_to.AppendRotate(x, y, z, angles[j].theta_to);
1167 EmpiricallyTestBoundsContainment(operations_from,
1168 operations_to,
1169 progress[k].min_progress,
1170 progress[k].max_progress);
1171 }
1172 }
1173 }
1174 }
1175
1176 TEST(TransformOperationTest, PerspectiveMatrixAndTransformBlendingEquivalency) {
1177 TransformOperations from_operations;
1178 from_operations.AppendPerspective(200);
1179
1180 TransformOperations to_operations;
1181 to_operations.AppendPerspective(1000);
1182
1183 gfx::Transform from_transform;
1184 from_transform.ApplyPerspectiveDepth(200);
1185
1186 gfx::Transform to_transform;
1187 to_transform.ApplyPerspectiveDepth(1000);
1188
1189 static const int steps = 20;
1190 for (int i = 0; i < steps; ++i) {
1191 double progress = static_cast<double>(i) / (steps - 1);
1192
1193 gfx::Transform blended_matrix = to_transform;
1194 EXPECT_TRUE(blended_matrix.Blend(from_transform, progress));
1195
1196 gfx::Transform blended_transform =
1197 to_operations.Blend(from_operations, progress);
1198
1199 EXPECT_TRANSFORMATION_MATRIX_EQ(blended_matrix, blended_transform);
1200 }
1201 }
1202
1203 TEST(TransformOperationTest, BlendedBoundsForPerspective) {
1204 struct {
1205 float from_depth;
1206 float to_depth;
1207 } perspective_depths[] = {
1208 {600.f, 400.f},
1209 {800.f, 1000.f},
1210 {800.f, std::numeric_limits<float>::infinity()},
1211 };
1212
1213 struct {
1214 float min_progress;
1215 float max_progress;
1216 } progress[] = {
1217 {0.f, 1.f}, {-0.1f, 1.1f},
1218 };
1219
1220 for (size_t i = 0; i < arraysize(perspective_depths); ++i) {
1221 for (size_t j = 0; j < arraysize(progress); ++j) {
1222 TransformOperations operations_from;
1223 operations_from.AppendPerspective(perspective_depths[i].from_depth);
1224 TransformOperations operations_to;
1225 operations_to.AppendPerspective(perspective_depths[i].to_depth);
1226 EmpiricallyTestBoundsEquality(operations_from,
1227 operations_to,
1228 progress[j].min_progress,
1229 progress[j].max_progress);
1230 }
1231 }
1232 }
1233
1234 TEST(TransformOperationTest, BlendedBoundsForSkew) {
1235 struct {
1236 float from_x;
1237 float from_y;
1238 float to_x;
1239 float to_y;
1240 } skews[] = {
1241 {1.f, 0.5f, 0.5f, 1.f}, {2.f, 1.f, 0.5f, 0.5f},
1242 };
1243
1244 struct {
1245 float min_progress;
1246 float max_progress;
1247 } progress[] = {
1248 {0.f, 1.f}, {-0.1f, 1.1f},
1249 };
1250
1251 for (size_t i = 0; i < arraysize(skews); ++i) {
1252 for (size_t j = 0; j < arraysize(progress); ++j) {
1253 TransformOperations operations_from;
1254 operations_from.AppendSkew(skews[i].from_x, skews[i].from_y);
1255 TransformOperations operations_to;
1256 operations_to.AppendSkew(skews[i].to_x, skews[i].to_y);
1257 EmpiricallyTestBoundsEquality(operations_from,
1258 operations_to,
1259 progress[j].min_progress,
1260 progress[j].max_progress);
1261 }
1262 }
1263 }
1264
1265 TEST(TransformOperationTest, NonCommutativeRotations) {
1266 TransformOperations operations_from;
1267 operations_from.AppendRotate(1.0, 0.0, 0.0, 0.0);
1268 operations_from.AppendRotate(0.0, 1.0, 0.0, 0.0);
1269 TransformOperations operations_to;
1270 operations_to.AppendRotate(1.0, 0.0, 0.0, 45.0);
1271 operations_to.AppendRotate(0.0, 1.0, 0.0, 135.0);
1272
1273 gfx::BoxF box(0, 0, 0, 1, 1, 1);
1274 gfx::BoxF bounds;
1275
1276 SkMScalar min_progress = 0.0f;
1277 SkMScalar max_progress = 1.0f;
1278 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
1279 box, operations_from, min_progress, max_progress, &bounds));
1280 gfx::Transform blended_transform =
1281 operations_to.Blend(operations_from, max_progress);
1282 gfx::Point3F blended_point(0.9f, 0.9f, 0.0f);
1283 blended_transform.TransformPoint(&blended_point);
1284 gfx::BoxF expanded_bounds = bounds;
1285 expanded_bounds.ExpandTo(blended_point);
1286 EXPECT_EQ(bounds.ToString(), expanded_bounds.ToString());
1287 }
1288
1289 TEST(TransformOperationTest, BlendedBoundsForSequence) {
1290 TransformOperations operations_from;
1291 operations_from.AppendTranslate(1.0, -5.0, 1.0);
1292 operations_from.AppendScale(-1.0, 2.0, 3.0);
1293 operations_from.AppendTranslate(2.0, 4.0, -1.0);
1294 TransformOperations operations_to;
1295 operations_to.AppendTranslate(13.0, -1.0, 5.0);
1296 operations_to.AppendScale(-3.0, -2.0, 5.0);
1297 operations_to.AppendTranslate(6.0, -2.0, 3.0);
1298
1299 gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
1300 gfx::BoxF bounds;
1301
1302 SkMScalar min_progress = -0.5f;
1303 SkMScalar max_progress = 1.5f;
1304 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
1305 box, operations_from, min_progress, max_progress, &bounds));
1306 EXPECT_EQ(gfx::BoxF(-57.f, -59.f, -1.f, 76.f, 112.f, 80.f).ToString(),
1307 bounds.ToString());
1308
1309 min_progress = 0.f;
1310 max_progress = 1.f;
1311 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
1312 box, operations_from, min_progress, max_progress, &bounds));
1313 EXPECT_EQ(gfx::BoxF(-32.f, -25.f, 7.f, 42.f, 44.f, 48.f).ToString(),
1314 bounds.ToString());
1315
1316 TransformOperations identity;
1317 EXPECT_TRUE(operations_to.BlendedBoundsForBox(
1318 box, identity, min_progress, max_progress, &bounds));
1319 EXPECT_EQ(gfx::BoxF(-33.f, -13.f, 3.f, 57.f, 19.f, 52.f).ToString(),
1320 bounds.ToString());
1321
1322 EXPECT_TRUE(identity.BlendedBoundsForBox(
1323 box, operations_from, min_progress, max_progress, &bounds));
1324 EXPECT_EQ(gfx::BoxF(-7.f, -3.f, 2.f, 15.f, 23.f, 20.f).ToString(),
1325 bounds.ToString());
1326 }
1327
1328 TEST(TransformOperationTest, AffectsScaleWithSingleOperation) {
1329 TransformOperations empty_operations;
1330 EXPECT_FALSE(empty_operations.AffectsScale());
1331
1332 TransformOperations identity;
1333 identity.AppendIdentity();
1334 EXPECT_FALSE(identity.AffectsScale());
1335
1336 TransformOperations translate;
1337 translate.AppendTranslate(1.f, 2.f, 3.f);
1338 EXPECT_FALSE(translate.AffectsScale());
1339
1340 TransformOperations rotate;
1341 rotate.AppendRotate(1.f, 2.f, 3.f, 4.f);
1342 EXPECT_FALSE(rotate.AffectsScale());
1343
1344 TransformOperations scale;
1345 scale.AppendScale(1.f, 2.f, 3.f);
1346 EXPECT_TRUE(scale.AffectsScale());
1347
1348 TransformOperations skew;
1349 skew.AppendSkew(1.f, 2.f);
1350 EXPECT_FALSE(skew.AffectsScale());
1351
1352 TransformOperations perspective;
1353 perspective.AppendPerspective(1.f);
1354 EXPECT_FALSE(perspective.AffectsScale());
1355
1356 TransformOperations identity_matrix;
1357 identity_matrix.AppendMatrix(gfx::Transform());
1358 EXPECT_FALSE(identity_matrix.AffectsScale());
1359
1360 TransformOperations translation_matrix;
1361 gfx::Transform translation_transform;
1362 translation_transform.Translate3d(1.f, 2.f, 3.f);
1363 translation_matrix.AppendMatrix(translation_transform);
1364 EXPECT_FALSE(translation_matrix.AffectsScale());
1365
1366 TransformOperations scaling_matrix;
1367 gfx::Transform scaling_transform;
1368 scaling_transform.Scale(2.f, 2.f);
1369 scaling_matrix.AppendMatrix(scaling_transform);
1370 EXPECT_TRUE(scaling_matrix.AffectsScale());
1371 }
1372
1373 TEST(TransformOperationTest, AffectsScaleWithMultipleOperations) {
1374 TransformOperations operations1;
1375 operations1.AppendSkew(1.f, 2.f);
1376 operations1.AppendTranslate(1.f, 2.f, 3.f);
1377 operations1.AppendIdentity();
1378 EXPECT_FALSE(operations1.AffectsScale());
1379
1380 TransformOperations operations2;
1381 operations2.AppendPerspective(2.f);
1382 operations2.AppendScale(1.f, 2.f, 3.f);
1383 operations2.AppendTranslate(3.f, 2.f, 1.f);
1384 EXPECT_TRUE(operations2.AffectsScale());
1385 }
1386
1387 TEST(TransformOperationTest, IsTranslationWithSingleOperation) {
1388 TransformOperations empty_operations;
1389 EXPECT_TRUE(empty_operations.IsTranslation());
1390
1391 TransformOperations identity;
1392 identity.AppendIdentity();
1393 EXPECT_TRUE(identity.IsTranslation());
1394
1395 TransformOperations translate;
1396 translate.AppendTranslate(1.f, 2.f, 3.f);
1397 EXPECT_TRUE(translate.IsTranslation());
1398
1399 TransformOperations rotate;
1400 rotate.AppendRotate(1.f, 2.f, 3.f, 4.f);
1401 EXPECT_FALSE(rotate.IsTranslation());
1402
1403 TransformOperations scale;
1404 scale.AppendScale(1.f, 2.f, 3.f);
1405 EXPECT_FALSE(scale.IsTranslation());
1406
1407 TransformOperations skew;
1408 skew.AppendSkew(1.f, 2.f);
1409 EXPECT_FALSE(skew.IsTranslation());
1410
1411 TransformOperations perspective;
1412 perspective.AppendPerspective(1.f);
1413 EXPECT_FALSE(perspective.IsTranslation());
1414
1415 TransformOperations identity_matrix;
1416 identity_matrix.AppendMatrix(gfx::Transform());
1417 EXPECT_TRUE(identity_matrix.IsTranslation());
1418
1419 TransformOperations translation_matrix;
1420 gfx::Transform translation_transform;
1421 translation_transform.Translate3d(1.f, 2.f, 3.f);
1422 translation_matrix.AppendMatrix(translation_transform);
1423 EXPECT_TRUE(translation_matrix.IsTranslation());
1424
1425 TransformOperations scaling_matrix;
1426 gfx::Transform scaling_transform;
1427 scaling_transform.Scale(2.f, 2.f);
1428 scaling_matrix.AppendMatrix(scaling_transform);
1429 EXPECT_FALSE(scaling_matrix.IsTranslation());
1430 }
1431
1432 TEST(TransformOperationTest, IsTranslationWithMultipleOperations) {
1433 TransformOperations operations1;
1434 operations1.AppendSkew(1.f, 2.f);
1435 operations1.AppendTranslate(1.f, 2.f, 3.f);
1436 operations1.AppendIdentity();
1437 EXPECT_FALSE(operations1.IsTranslation());
1438
1439 TransformOperations operations2;
1440 operations2.AppendIdentity();
1441 operations2.AppendTranslate(3.f, 2.f, 1.f);
1442 gfx::Transform translation_transform;
1443 translation_transform.Translate3d(1.f, 2.f, 3.f);
1444 operations2.AppendMatrix(translation_transform);
1445 EXPECT_TRUE(operations2.IsTranslation());
1446 }
1447
1448 TEST(TransformOperationTest, ScaleComponent) {
1449 gfx::Vector3dF scale;
1450
1451 // Scale.
1452 TransformOperations operations1;
1453 operations1.AppendScale(-3.f, 2.f, 5.f);
1454 EXPECT_TRUE(operations1.ScaleComponent(&scale));
1455 EXPECT_EQ(gfx::Vector3dF(-3.f, 2.f, 5.f), scale);
1456
1457 // Translate + Scale.
1458 TransformOperations operations5;
1459 operations5.AppendTranslate(1.f, 2.f, 3.f);
1460 operations5.AppendScale(2.f, 5.f, 4.f);
1461 EXPECT_TRUE(operations5.ScaleComponent(&scale));
1462 EXPECT_EQ(gfx::Vector3dF(2.f, 5.f, 4.f), scale);
1463
1464 // Translate + Scale + Matrix with translate.
1465 gfx::Transform translation_transform;
1466 translation_transform.Translate3d(1.f, 2.f, 3.f);
1467 operations5.AppendMatrix(translation_transform);
1468 EXPECT_TRUE(operations5.ScaleComponent(&scale));
1469 EXPECT_EQ(gfx::Vector3dF(2.f, 5.f, 4.f), scale);
1470 }
1471
1472 TEST(TransformOperationTest, ScaleComponentCannotBeComputed) {
1473 gfx::Vector3dF scale;
1474
1475 // Scale can.
1476 TransformOperations operations1;
1477 operations1.AppendScale(2.f, 2.f, 2.f);
1478 EXPECT_TRUE(operations1.ScaleComponent(&scale));
1479 EXPECT_EQ(gfx::Vector3dF(2.f, 2.f, 2.f), scale);
1480
1481 // Translate can.
1482 TransformOperations operations2;
1483 operations2.AppendTranslate(1.f, 2.f, 3.f);
1484 EXPECT_TRUE(operations2.ScaleComponent(&scale));
1485 EXPECT_EQ(gfx::Vector3dF(1.f, 1.f, 1.f), scale);
1486
1487 // Scale + translate can.
1488 TransformOperations operations3;
1489 operations3.AppendScale(2.f, 3.f, 2.f);
1490 operations3.AppendTranslate(1.f, 2.f, 3.f);
1491 EXPECT_TRUE(operations3.ScaleComponent(&scale));
1492 EXPECT_EQ(gfx::Vector3dF(2.f, 3.f, 2.f), scale);
1493
1494 // Two Scales can't.
1495 TransformOperations operations4;
1496 operations4.AppendScale(2.f, 3.f, 2.f);
1497 operations4.AppendScale(3.f, 2.f, 3.f);
1498 EXPECT_FALSE(operations4.ScaleComponent(&scale));
1499
1500 // Matrix can't.
1501 TransformOperations operations5;
1502 operations5.AppendScale(2.f, 2.f, 2.f);
1503 gfx::Transform scaling_transform;
1504 scaling_transform.Scale(2.f, 2.f);
1505 operations5.AppendMatrix(scaling_transform);
1506 EXPECT_FALSE(operations5.ScaleComponent(&scale));
1507
1508 // Scale + Rotate can't.
1509 TransformOperations operations7;
1510 operations7.AppendScale(2.f, 2.f, 2.f);
1511 operations7.AppendRotate(1.f, 2.f, 3.f, 4.f);
1512 EXPECT_FALSE(operations7.ScaleComponent(&scale));
1513
1514 // Scale + Skew can't.
1515 TransformOperations operations9;
1516 operations9.AppendScale(2.f, 2.f, 2.f);
1517 operations9.AppendSkew(1.f, 2.f);
1518 EXPECT_FALSE(operations9.ScaleComponent(&scale));
1519
1520 // Scale + Perspective can't.
1521 TransformOperations operations11;
1522 operations11.AppendScale(2.f, 2.f, 2.f);
1523 operations11.AppendPerspective(1.f);
1524 EXPECT_FALSE(operations11.ScaleComponent(&scale));
1525 }
1526
1527 } // namespace
1528 } // namespace cc