Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
dl_matrix_clip_tracker_unittests.cc
Go to the documentation of this file.
1// Copyright 2013 The Flutter 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 "flutter/display_list/utils/dl_matrix_clip_tracker.h"
6#include "flutter/testing/assertions_skia.h"
7#include "gtest/gtest.h"
8
9namespace flutter {
10namespace testing {
11
12using DlRect = impeller::Rect;
13using DlMatrix = impeller::Matrix;
14using Degrees = impeller::Degrees;
15
16TEST(DisplayListMatrixClipTracker, Constructor) {
17 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
18 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
19 const SkMatrix matrix = SkMatrix::Scale(4, 4);
20 const SkM44 m44 = SkM44::Scale(4, 4);
21 const DlMatrix dl_matrix = DlMatrix::MakeScale({4.0, 4.0, 1.0});
22 const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
23
24 DisplayListMatrixClipTracker tracker1(cull_rect, matrix);
25 DisplayListMatrixClipTracker tracker2(cull_rect, m44);
26 DisplayListMatrixClipTracker tracker3(dl_cull_rect, dl_matrix);
27
28 EXPECT_FALSE(tracker1.using_4x4_matrix());
29 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
30 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
31 EXPECT_EQ(tracker1.matrix_3x3(), matrix);
32 EXPECT_EQ(tracker1.matrix_4x4(), m44);
33 EXPECT_EQ(tracker1.matrix(), dl_matrix);
34
35 EXPECT_FALSE(tracker2.using_4x4_matrix());
36 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
37 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
38 EXPECT_EQ(tracker2.matrix_3x3(), matrix);
39 EXPECT_EQ(tracker2.matrix_4x4(), m44);
40 EXPECT_EQ(tracker2.matrix(), dl_matrix);
41
42 EXPECT_FALSE(tracker3.using_4x4_matrix());
43 EXPECT_EQ(tracker3.device_cull_rect(), cull_rect);
44 EXPECT_EQ(tracker3.local_cull_rect(), local_cull_rect);
45 EXPECT_EQ(tracker3.matrix_3x3(), matrix);
46 EXPECT_EQ(tracker3.matrix_4x4(), m44);
47 EXPECT_EQ(tracker3.matrix(), dl_matrix);
48}
49
50TEST(DisplayListMatrixClipState, Constructor) {
51 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
52 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
53 const SkMatrix matrix = SkMatrix::Scale(4, 4);
54 const SkM44 m44 = SkM44::Scale(4, 4);
55 const DlMatrix dl_matrix = DlMatrix::MakeScale({4.0, 4.0, 1.0});
56 const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
57
58 DisplayListMatrixClipState state1(cull_rect, matrix);
59 DisplayListMatrixClipState state2(cull_rect, m44);
60 DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
61
62 EXPECT_FALSE(state1.using_4x4_matrix());
63 EXPECT_EQ(state1.device_cull_rect(), cull_rect);
64 EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
65 EXPECT_EQ(state1.matrix_3x3(), matrix);
66 EXPECT_EQ(state1.matrix_4x4(), m44);
67 EXPECT_EQ(state1.matrix(), dl_matrix);
68
69 EXPECT_FALSE(state2.using_4x4_matrix());
70 EXPECT_EQ(state2.device_cull_rect(), cull_rect);
71 EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
72 EXPECT_EQ(state2.matrix_3x3(), matrix);
73 EXPECT_EQ(state2.matrix_4x4(), m44);
74 EXPECT_EQ(state2.matrix(), dl_matrix);
75
76 EXPECT_FALSE(state3.using_4x4_matrix());
77 EXPECT_EQ(state3.device_cull_rect(), cull_rect);
78 EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
79 EXPECT_EQ(state3.matrix_3x3(), matrix);
80 EXPECT_EQ(state3.matrix_4x4(), m44);
81 EXPECT_EQ(state3.matrix(), dl_matrix);
82}
83
84TEST(DisplayListMatrixClipTracker, Constructor4x4) {
85 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
86 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
87 // clang-format off
88 const SkM44 m44 = SkM44(4, 0, 0.5, 0,
89 0, 4, 0.5, 0,
90 0, 0, 4.0, 0,
91 0, 0, 0.0, 1);
92 const DlMatrix dl_matrix = DlMatrix::MakeRow(4, 0, 0.5, 0,
93 0, 4, 0.5, 0,
94 0, 0, 4.0, 0,
95 0, 0, 0.0, 1);
96 // clang-format on
97 const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
98
99 DisplayListMatrixClipTracker tracker1(cull_rect, m44);
100 DisplayListMatrixClipTracker tracker2(dl_cull_rect, dl_matrix);
101
102 EXPECT_TRUE(tracker1.using_4x4_matrix());
103 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
104 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
105 EXPECT_EQ(tracker1.matrix_4x4(), m44);
106 EXPECT_EQ(tracker1.matrix(), dl_matrix);
107
108 EXPECT_TRUE(tracker2.using_4x4_matrix());
109 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
110 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
111 EXPECT_EQ(tracker2.matrix_4x4(), m44);
112 EXPECT_EQ(tracker2.matrix(), dl_matrix);
113}
114
115TEST(DisplayListMatrixClipState, Constructor4x4) {
116 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
117 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
118 // clang-format off
119 const SkM44 m44 = SkM44(4, 0, 0.5, 0,
120 0, 4, 0.5, 0,
121 0, 0, 4.0, 0,
122 0, 0, 0.0, 1);
123 const DlMatrix dl_matrix = DlMatrix::MakeRow(4, 0, 0.5, 0,
124 0, 4, 0.5, 0,
125 0, 0, 4.0, 0,
126 0, 0, 0.0, 1);
127 // clang-format on
128 const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
129
130 DisplayListMatrixClipState state1(cull_rect, m44);
131 DisplayListMatrixClipState state2(dl_cull_rect, dl_matrix);
132
133 EXPECT_TRUE(state1.using_4x4_matrix());
134 EXPECT_EQ(state1.device_cull_rect(), cull_rect);
135 EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
136 EXPECT_EQ(state1.matrix_4x4(), m44);
137 EXPECT_EQ(state1.matrix(), dl_matrix);
138
139 EXPECT_TRUE(state2.using_4x4_matrix());
140 EXPECT_EQ(state2.device_cull_rect(), cull_rect);
141 EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
142 EXPECT_EQ(state2.matrix_4x4(), m44);
143 EXPECT_EQ(state2.matrix(), dl_matrix);
144}
145
146TEST(DisplayListMatrixClipTracker, TransformTo4x4) {
147 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
148 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
149 // clang-format off
150 const SkM44 m44 = SkM44(4, 0, 0.5, 0,
151 0, 4, 0.5, 0,
152 0, 0, 4.0, 0,
153 0, 0, 0.0, 1);
154 const DlMatrix dl_matrix = DlMatrix::MakeRow(4, 0, 0.5, 0,
155 0, 4, 0.5, 0,
156 0, 0, 4.0, 0,
157 0, 0, 0.0, 1);
158 // clang-format on
159 const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
160
161 DisplayListMatrixClipTracker tracker1(cull_rect, SkMatrix::I());
162 DisplayListMatrixClipTracker tracker2(dl_cull_rect, DlMatrix());
163 EXPECT_FALSE(tracker1.using_4x4_matrix());
164 EXPECT_FALSE(tracker2.using_4x4_matrix());
165
166 tracker1.transform(m44);
167 EXPECT_TRUE(tracker1.using_4x4_matrix());
168 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
169 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
170 EXPECT_EQ(tracker1.matrix_4x4(), m44);
171 EXPECT_EQ(tracker1.matrix(), dl_matrix);
172
173 tracker2.transform(dl_matrix);
174 EXPECT_TRUE(tracker2.using_4x4_matrix());
175 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
176 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
177 EXPECT_EQ(tracker2.matrix_4x4(), m44);
178 EXPECT_EQ(tracker2.matrix(), dl_matrix);
179}
180
181TEST(DisplayListMatrixClipState, TransformTo4x4) {
182 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
183 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
184 // clang-format off
185 const SkM44 m44 = SkM44(4, 0, 0.5, 0,
186 0, 4, 0.5, 0,
187 0, 0, 4.0, 0,
188 0, 0, 0.0, 1);
189 const DlMatrix dl_matrix = DlMatrix::MakeRow(4, 0, 0.5, 0,
190 0, 4, 0.5, 0,
191 0, 0, 4.0, 0,
192 0, 0, 0.0, 1);
193 // clang-format on
194 const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
195
196 DisplayListMatrixClipTracker state1(cull_rect, SkMatrix::I());
197 DisplayListMatrixClipTracker state2(dl_cull_rect, DlMatrix());
198 EXPECT_FALSE(state1.using_4x4_matrix());
199 EXPECT_FALSE(state2.using_4x4_matrix());
200
201 state1.transform(m44);
202 EXPECT_TRUE(state1.using_4x4_matrix());
203 EXPECT_EQ(state1.device_cull_rect(), cull_rect);
204 EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
205 EXPECT_EQ(state1.matrix_4x4(), m44);
206 EXPECT_EQ(state1.matrix(), dl_matrix);
207
208 state2.transform(dl_matrix);
209 EXPECT_TRUE(state2.using_4x4_matrix());
210 EXPECT_EQ(state2.device_cull_rect(), cull_rect);
211 EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
212 EXPECT_EQ(state2.matrix_4x4(), m44);
213 EXPECT_EQ(state2.matrix(), dl_matrix);
214}
215
216TEST(DisplayListMatrixClipTracker, SetTo4x4) {
217 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
218 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
219 // clang-format off
220 const SkM44 m44 = SkM44(4, 0, 0.5, 0,
221 0, 4, 0.5, 0,
222 0, 0, 4.0, 0,
223 0, 0, 0.0, 1);
224 const DlMatrix dl_matrix = DlMatrix::MakeRow(4, 0, 0.5, 0,
225 0, 4, 0.5, 0,
226 0, 0, 4.0, 0,
227 0, 0, 0.0, 1);
228 // clang-format on
229 const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
230
231 DisplayListMatrixClipTracker tracker1(cull_rect, SkMatrix::I());
232 DisplayListMatrixClipTracker tracker2(dl_cull_rect, DlMatrix());
233 EXPECT_FALSE(tracker1.using_4x4_matrix());
234 EXPECT_FALSE(tracker2.using_4x4_matrix());
235
236 tracker1.setTransform(m44);
237 EXPECT_TRUE(tracker1.using_4x4_matrix());
238 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
239 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
240 EXPECT_EQ(tracker1.matrix_4x4(), m44);
241 EXPECT_EQ(tracker1.matrix(), dl_matrix);
242
243 tracker2.setTransform(dl_matrix);
244 EXPECT_TRUE(tracker2.using_4x4_matrix());
245 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
246 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
247 EXPECT_EQ(tracker2.matrix_4x4(), m44);
248 EXPECT_EQ(tracker2.matrix(), dl_matrix);
249}
250
251TEST(DisplayListMatrixClipState, SetTo4x4) {
252 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
253 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
254 // clang-format off
255 const SkM44 m44 = SkM44(4, 0, 0.5, 0,
256 0, 4, 0.5, 0,
257 0, 0, 4.0, 0,
258 0, 0, 0.0, 1);
259 const DlMatrix dl_matrix = DlMatrix::MakeRow(4, 0, 0.5, 0,
260 0, 4, 0.5, 0,
261 0, 0, 4.0, 0,
262 0, 0, 0.0, 1);
263 // clang-format on
264 const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
265
266 DisplayListMatrixClipState state1(cull_rect, SkMatrix::I());
267 DisplayListMatrixClipState state2(dl_cull_rect, DlMatrix());
268 EXPECT_FALSE(state1.using_4x4_matrix());
269 EXPECT_FALSE(state2.using_4x4_matrix());
270
271 state1.setTransform(m44);
272 EXPECT_TRUE(state1.using_4x4_matrix());
273 EXPECT_EQ(state1.device_cull_rect(), cull_rect);
274 EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
275 EXPECT_EQ(state1.matrix_4x4(), m44);
276 EXPECT_EQ(state1.matrix(), dl_matrix);
277
278 state2.setTransform(dl_matrix);
279 EXPECT_TRUE(state2.using_4x4_matrix());
280 EXPECT_EQ(state2.device_cull_rect(), cull_rect);
281 EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
282 EXPECT_EQ(state2.matrix_4x4(), m44);
283 EXPECT_EQ(state2.matrix(), dl_matrix);
284}
285
286TEST(DisplayListMatrixClipTracker, UpgradeTo4x4SaveAndRestore) {
287 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
288 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
289 // clang-format off
290 const SkM44 m44 = SkM44(4, 0, 0.5, 0,
291 0, 4, 0.5, 0,
292 0, 0, 4.0, 0,
293 0, 0, 0.0, 1);
294 const DlMatrix dl_matrix = DlMatrix::MakeRow(4, 0, 0.5, 0,
295 0, 4, 0.5, 0,
296 0, 0, 4.0, 0,
297 0, 0, 0.0, 1);
298 // clang-format on
299 const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
300
301 DisplayListMatrixClipTracker tracker1(cull_rect, SkMatrix::I());
302 DisplayListMatrixClipTracker tracker2(dl_cull_rect, DlMatrix());
303 EXPECT_FALSE(tracker1.using_4x4_matrix());
304 EXPECT_FALSE(tracker2.using_4x4_matrix());
305
306 tracker1.save();
307 tracker2.save();
308 EXPECT_FALSE(tracker1.using_4x4_matrix());
309 EXPECT_FALSE(tracker2.using_4x4_matrix());
310
311 tracker1.transform(m44);
312 EXPECT_TRUE(tracker1.using_4x4_matrix());
313 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
314 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
315 EXPECT_EQ(tracker1.matrix_4x4(), m44);
316 EXPECT_EQ(tracker1.matrix(), dl_matrix);
317
318 tracker1.restore();
319 EXPECT_FALSE(tracker1.using_4x4_matrix());
320 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
321 EXPECT_EQ(tracker1.local_cull_rect(), cull_rect);
322 EXPECT_EQ(tracker1.matrix_4x4(), SkM44());
323 EXPECT_EQ(tracker1.matrix(), DlMatrix());
324
325 tracker2.transform(dl_matrix);
326 EXPECT_TRUE(tracker2.using_4x4_matrix());
327 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
328 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
329 EXPECT_EQ(tracker2.matrix_4x4(), m44);
330 EXPECT_EQ(tracker2.matrix(), dl_matrix);
331
332 tracker2.restore();
333 EXPECT_FALSE(tracker2.using_4x4_matrix());
334 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
335 EXPECT_EQ(tracker2.local_cull_rect(), cull_rect);
336 EXPECT_EQ(tracker2.matrix_4x4(), SkM44());
337 EXPECT_EQ(tracker2.matrix(), DlMatrix());
338}
339
340// No "State" version of UpgradeTo4x4SaveAndRestore since the State objects
341// do not have save and restore semantics.
342
343TEST(DisplayListMatrixClipTracker, Translate) {
344 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
345 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
346 const SkMatrix matrix = SkMatrix::Scale(4, 4);
347 const SkM44 m44 = SkM44::Scale(4, 4);
348 const DlMatrix dl_matrix = DlMatrix::MakeScale({4.0, 4.0, 1.0});
349 const SkMatrix translated_matrix =
350 SkMatrix::Concat(matrix, SkMatrix::Translate(5, 1));
351 const SkM44 translated_m44 = SkM44(translated_matrix);
352 const DlMatrix dl_translated_matrix =
353 dl_matrix * DlMatrix::MakeTranslation({5.0, 1.0});
354 const SkRect local_cull_rect = SkRect::MakeLTRB(0, 9, 10, 19);
355
356 DisplayListMatrixClipTracker tracker1(cull_rect, matrix);
357 DisplayListMatrixClipTracker tracker2(cull_rect, m44);
358 DisplayListMatrixClipTracker tracker3(dl_cull_rect, dl_matrix);
359 tracker1.translate(5, 1);
360 tracker2.translate(5, 1);
361 tracker3.translate(5, 1);
362
363 EXPECT_FALSE(tracker1.using_4x4_matrix());
364 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
365 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
366 EXPECT_EQ(tracker1.matrix_3x3(), translated_matrix);
367 EXPECT_EQ(tracker1.matrix_4x4(), translated_m44);
368 EXPECT_EQ(tracker1.matrix(), dl_translated_matrix);
369
370 EXPECT_FALSE(tracker2.using_4x4_matrix());
371 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
372 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
373 EXPECT_EQ(tracker2.matrix_3x3(), translated_matrix);
374 EXPECT_EQ(tracker2.matrix_4x4(), translated_m44);
375 EXPECT_EQ(tracker2.matrix(), dl_translated_matrix);
376
377 EXPECT_FALSE(tracker3.using_4x4_matrix());
378 EXPECT_EQ(tracker3.device_cull_rect(), cull_rect);
379 EXPECT_EQ(tracker3.local_cull_rect(), local_cull_rect);
380 EXPECT_EQ(tracker3.matrix_3x3(), translated_matrix);
381 EXPECT_EQ(tracker3.matrix_4x4(), translated_m44);
382 EXPECT_EQ(tracker3.matrix(), dl_translated_matrix);
383}
384
385TEST(DisplayListMatrixClipState, Translate) {
386 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
387 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
388 const SkMatrix matrix = SkMatrix::Scale(4, 4);
389 const SkM44 m44 = SkM44::Scale(4, 4);
390 const DlMatrix dl_matrix = DlMatrix::MakeScale({4.0, 4.0, 1.0});
391 const SkMatrix translated_matrix =
392 SkMatrix::Concat(matrix, SkMatrix::Translate(5, 1));
393 const SkM44 translated_m44 = SkM44(translated_matrix);
394 const DlMatrix dl_translated_matrix =
395 dl_matrix * DlMatrix::MakeTranslation({5.0, 1.0});
396 const SkRect local_cull_rect = SkRect::MakeLTRB(0, 9, 10, 19);
397
398 DisplayListMatrixClipState state1(cull_rect, matrix);
399 DisplayListMatrixClipState state2(cull_rect, m44);
400 DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
401 state1.translate(5, 1);
402 state2.translate(5, 1);
403 state3.translate(5, 1);
404
405 EXPECT_FALSE(state1.using_4x4_matrix());
406 EXPECT_EQ(state1.device_cull_rect(), cull_rect);
407 EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
408 EXPECT_EQ(state1.matrix_3x3(), translated_matrix);
409 EXPECT_EQ(state1.matrix_4x4(), translated_m44);
410 EXPECT_EQ(state1.matrix(), dl_translated_matrix);
411
412 EXPECT_FALSE(state2.using_4x4_matrix());
413 EXPECT_EQ(state2.device_cull_rect(), cull_rect);
414 EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
415 EXPECT_EQ(state2.matrix_3x3(), translated_matrix);
416 EXPECT_EQ(state2.matrix_4x4(), translated_m44);
417 EXPECT_EQ(state2.matrix(), dl_translated_matrix);
418
419 EXPECT_FALSE(state3.using_4x4_matrix());
420 EXPECT_EQ(state3.device_cull_rect(), cull_rect);
421 EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
422 EXPECT_EQ(state3.matrix_3x3(), translated_matrix);
423 EXPECT_EQ(state3.matrix_4x4(), translated_m44);
424 EXPECT_EQ(state3.matrix(), dl_translated_matrix);
425}
426
427TEST(DisplayListMatrixClipTracker, Scale) {
428 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
429 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
430 const SkMatrix matrix = SkMatrix::Scale(4, 4);
431 const SkM44 m44 = SkM44::Scale(4, 4);
432 const DlMatrix dl_matrix = DlMatrix::MakeScale({4.0, 4.0, 1.0});
433 // Scale factor carefully chosen to multiply cleanly and invert
434 // without any non-binary-power-of-2 approximation errors.
435 const SkMatrix scaled_matrix =
436 SkMatrix::Concat(matrix, SkMatrix::Scale(0.5, 2));
437 const SkM44 scaled_m44 = SkM44(scaled_matrix);
438 const DlMatrix scaled_dl_matrix = dl_matrix.Scale({0.5, 2, 1});
439 const SkRect local_cull_rect = SkRect::MakeLTRB(10, 5, 30, 10);
440
441 DisplayListMatrixClipTracker tracker1(cull_rect, matrix);
442 DisplayListMatrixClipTracker tracker2(cull_rect, m44);
443 DisplayListMatrixClipTracker tracker3(dl_cull_rect, dl_matrix);
444 tracker1.scale(0.5, 2);
445 tracker2.scale(0.5, 2);
446 tracker3.scale(0.5, 2);
447
448 EXPECT_FALSE(tracker1.using_4x4_matrix());
449 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
450 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
451 EXPECT_EQ(tracker1.matrix_3x3(), scaled_matrix);
452 EXPECT_EQ(tracker1.matrix_4x4(), scaled_m44);
453 EXPECT_EQ(tracker1.matrix(), scaled_dl_matrix);
454
455 EXPECT_FALSE(tracker2.using_4x4_matrix());
456 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
457 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
458 EXPECT_EQ(tracker2.matrix_3x3(), scaled_matrix);
459 EXPECT_EQ(tracker2.matrix_4x4(), scaled_m44);
460 EXPECT_EQ(tracker2.matrix(), scaled_dl_matrix);
461
462 EXPECT_FALSE(tracker3.using_4x4_matrix());
463 EXPECT_EQ(tracker3.device_cull_rect(), cull_rect);
464 EXPECT_EQ(tracker3.local_cull_rect(), local_cull_rect);
465 EXPECT_EQ(tracker3.matrix_3x3(), scaled_matrix);
466 EXPECT_EQ(tracker3.matrix_4x4(), scaled_m44);
467 EXPECT_EQ(tracker3.matrix(), scaled_dl_matrix);
468}
469
470TEST(DisplayListMatrixClipState, Scale) {
471 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
472 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
473 const SkMatrix matrix = SkMatrix::Scale(4, 4);
474 const SkM44 m44 = SkM44::Scale(4, 4);
475 const DlMatrix dl_matrix = DlMatrix::MakeScale({4.0, 4.0, 1.0});
476 // Scale factor carefully chosen to multiply cleanly and invert
477 // without any non-binary-power-of-2 approximation errors.
478 const SkMatrix scaled_matrix =
479 SkMatrix::Concat(matrix, SkMatrix::Scale(0.5, 2));
480 const SkM44 scaled_m44 = SkM44(scaled_matrix);
481 const DlMatrix scaled_dl_matrix = dl_matrix.Scale({0.5, 2, 1});
482 const SkRect local_cull_rect = SkRect::MakeLTRB(10, 5, 30, 10);
483
484 DisplayListMatrixClipState state1(cull_rect, matrix);
485 DisplayListMatrixClipState state2(cull_rect, m44);
486 DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
487 state1.scale(0.5, 2);
488 state2.scale(0.5, 2);
489 state3.scale(0.5, 2);
490
491 EXPECT_FALSE(state1.using_4x4_matrix());
492 EXPECT_EQ(state1.device_cull_rect(), cull_rect);
493 EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
494 EXPECT_EQ(state1.matrix_3x3(), scaled_matrix);
495 EXPECT_EQ(state1.matrix_4x4(), scaled_m44);
496 EXPECT_EQ(state1.matrix(), scaled_dl_matrix);
497
498 EXPECT_FALSE(state2.using_4x4_matrix());
499 EXPECT_EQ(state2.device_cull_rect(), cull_rect);
500 EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
501 EXPECT_EQ(state2.matrix_3x3(), scaled_matrix);
502 EXPECT_EQ(state2.matrix_4x4(), scaled_m44);
503 EXPECT_EQ(state2.matrix(), scaled_dl_matrix);
504
505 EXPECT_FALSE(state3.using_4x4_matrix());
506 EXPECT_EQ(state3.device_cull_rect(), cull_rect);
507 EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
508 EXPECT_EQ(state3.matrix_3x3(), scaled_matrix);
509 EXPECT_EQ(state3.matrix_4x4(), scaled_m44);
510 EXPECT_EQ(state3.matrix(), scaled_dl_matrix);
511}
512
513TEST(DisplayListMatrixClipTracker, Skew) {
514 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
515 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
516 const SkMatrix matrix = SkMatrix::Scale(4, 4);
517 const SkM44 m44 = SkM44::Scale(4, 4);
518 const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
519 const SkMatrix skewed_matrix =
520 SkMatrix::Concat(matrix, SkMatrix::Skew(.25, 0));
521 const SkM44 skewed_m44 = SkM44(skewed_matrix);
522 const DlMatrix skewed_dl_matrix = dl_matrix * DlMatrix::MakeSkew(0.25, 0);
523 const SkRect local_cull_rect = SkRect::MakeLTRB(0, 10, 12.5, 20);
524
525 DisplayListMatrixClipTracker tracker1(cull_rect, matrix);
526 DisplayListMatrixClipTracker tracker2(cull_rect, m44);
527 DisplayListMatrixClipTracker tracker3(dl_cull_rect, dl_matrix);
528 tracker1.skew(.25, 0);
529 tracker2.skew(.25, 0);
530 tracker3.skew(.25, 0);
531
532 EXPECT_FALSE(tracker1.using_4x4_matrix());
533 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
534 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
535 EXPECT_EQ(tracker1.matrix_3x3(), skewed_matrix);
536 EXPECT_EQ(tracker1.matrix_4x4(), skewed_m44);
537 EXPECT_EQ(tracker1.matrix(), skewed_dl_matrix);
538
539 EXPECT_FALSE(tracker2.using_4x4_matrix());
540 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
541 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
542 EXPECT_EQ(tracker2.matrix_3x3(), skewed_matrix);
543 EXPECT_EQ(tracker2.matrix_4x4(), skewed_m44);
544 EXPECT_EQ(tracker2.matrix(), skewed_dl_matrix);
545
546 EXPECT_FALSE(tracker3.using_4x4_matrix());
547 EXPECT_EQ(tracker3.device_cull_rect(), cull_rect);
548 EXPECT_EQ(tracker3.local_cull_rect(), local_cull_rect);
549 EXPECT_EQ(tracker3.matrix_3x3(), skewed_matrix);
550 EXPECT_EQ(tracker3.matrix_4x4(), skewed_m44);
551 EXPECT_EQ(tracker3.matrix(), skewed_dl_matrix);
552}
553
554TEST(DisplayListMatrixClipState, Skew) {
555 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
556 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
557 const SkMatrix matrix = SkMatrix::Scale(4, 4);
558 const SkM44 m44 = SkM44::Scale(4, 4);
559 const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
560 const SkMatrix skewed_matrix =
561 SkMatrix::Concat(matrix, SkMatrix::Skew(.25, 0));
562 const SkM44 skewed_m44 = SkM44(skewed_matrix);
563 const DlMatrix skewed_dl_matrix = dl_matrix * DlMatrix::MakeSkew(0.25, 0);
564 const SkRect local_cull_rect = SkRect::MakeLTRB(0, 10, 12.5, 20);
565
566 DisplayListMatrixClipState state1(cull_rect, matrix);
567 DisplayListMatrixClipState state2(cull_rect, m44);
568 DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
569 state1.skew(.25, 0);
570 state2.skew(.25, 0);
571 state3.skew(.25, 0);
572
573 EXPECT_FALSE(state1.using_4x4_matrix());
574 EXPECT_EQ(state1.device_cull_rect(), cull_rect);
575 EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
576 EXPECT_EQ(state1.matrix_3x3(), skewed_matrix);
577 EXPECT_EQ(state1.matrix_4x4(), skewed_m44);
578 EXPECT_EQ(state1.matrix(), skewed_dl_matrix);
579
580 EXPECT_FALSE(state2.using_4x4_matrix());
581 EXPECT_EQ(state2.device_cull_rect(), cull_rect);
582 EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
583 EXPECT_EQ(state2.matrix_3x3(), skewed_matrix);
584 EXPECT_EQ(state2.matrix_4x4(), skewed_m44);
585 EXPECT_EQ(state2.matrix(), skewed_dl_matrix);
586
587 EXPECT_FALSE(state3.using_4x4_matrix());
588 EXPECT_EQ(state3.device_cull_rect(), cull_rect);
589 EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
590 EXPECT_EQ(state3.matrix_3x3(), skewed_matrix);
591 EXPECT_EQ(state3.matrix_4x4(), skewed_m44);
592 EXPECT_EQ(state3.matrix(), skewed_dl_matrix);
593}
594
595TEST(DisplayListMatrixClipTracker, Rotate) {
596 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
597 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
598 const SkMatrix matrix = SkMatrix::Scale(4, 4);
599 const SkM44 m44 = SkM44::Scale(4, 4);
600 const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
601 const SkMatrix rotated_matrix =
602 SkMatrix::Concat(matrix, SkMatrix::RotateDeg(90));
603 const SkM44 rotated_m44 = SkM44(rotated_matrix);
604 const DlMatrix rotated_dl_matrix =
605 dl_matrix * DlMatrix::MakeRotationZ(Degrees(90));
606 const SkRect local_cull_rect = SkRect::MakeLTRB(10, -15, 20, -5);
607
608 DisplayListMatrixClipTracker tracker1(cull_rect, matrix);
609 DisplayListMatrixClipTracker tracker2(cull_rect, m44);
610 DisplayListMatrixClipTracker tracker3(dl_cull_rect, dl_matrix);
611 tracker1.rotate(90);
612 tracker2.rotate(90);
613 tracker3.rotate(90);
614
615 EXPECT_FALSE(tracker1.using_4x4_matrix());
616 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
617 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
618 EXPECT_EQ(tracker1.matrix_3x3(), rotated_matrix);
619 EXPECT_EQ(tracker1.matrix_4x4(), rotated_m44);
620 EXPECT_EQ(tracker1.matrix(), rotated_dl_matrix);
621
622 EXPECT_FALSE(tracker2.using_4x4_matrix());
623 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
624 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
625 EXPECT_EQ(tracker2.matrix_3x3(), rotated_matrix);
626 EXPECT_EQ(tracker2.matrix_4x4(), rotated_m44);
627 EXPECT_EQ(tracker2.matrix(), rotated_dl_matrix);
628
629 EXPECT_FALSE(tracker3.using_4x4_matrix());
630 EXPECT_EQ(tracker3.device_cull_rect(), cull_rect);
631 EXPECT_EQ(tracker3.local_cull_rect(), local_cull_rect);
632 EXPECT_EQ(tracker3.matrix_3x3(), rotated_matrix);
633 EXPECT_EQ(tracker3.matrix_4x4(), rotated_m44);
634 EXPECT_EQ(tracker3.matrix(), rotated_dl_matrix);
635}
636
637TEST(DisplayListMatrixClipState, Rotate) {
638 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
639 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
640 const SkMatrix matrix = SkMatrix::Scale(4, 4);
641 const SkM44 m44 = SkM44::Scale(4, 4);
642 const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
643 const SkMatrix rotated_matrix =
644 SkMatrix::Concat(matrix, SkMatrix::RotateDeg(90));
645 const SkM44 rotated_m44 = SkM44(rotated_matrix);
646 const DlMatrix rotated_dl_matrix =
647 dl_matrix * DlMatrix::MakeRotationZ(Degrees(90));
648 const SkRect local_cull_rect = SkRect::MakeLTRB(10, -15, 20, -5);
649
650 DisplayListMatrixClipState state1(cull_rect, matrix);
651 DisplayListMatrixClipState state2(cull_rect, m44);
652 DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
653 state1.rotate(90);
654 state2.rotate(90);
655 state3.rotate(90);
656
657 EXPECT_FALSE(state1.using_4x4_matrix());
658 EXPECT_EQ(state1.device_cull_rect(), cull_rect);
659 EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
660 EXPECT_EQ(state1.matrix_3x3(), rotated_matrix);
661 EXPECT_EQ(state1.matrix_4x4(), rotated_m44);
662 EXPECT_EQ(state1.matrix(), rotated_dl_matrix);
663
664 EXPECT_FALSE(state2.using_4x4_matrix());
665 EXPECT_EQ(state2.device_cull_rect(), cull_rect);
666 EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
667 EXPECT_EQ(state2.matrix_3x3(), rotated_matrix);
668 EXPECT_EQ(state2.matrix_4x4(), rotated_m44);
669 EXPECT_EQ(state2.matrix(), rotated_dl_matrix);
670
671 EXPECT_FALSE(state3.using_4x4_matrix());
672 EXPECT_EQ(state3.device_cull_rect(), cull_rect);
673 EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
674 EXPECT_EQ(state3.matrix_3x3(), rotated_matrix);
675 EXPECT_EQ(state3.matrix_4x4(), rotated_m44);
676 EXPECT_EQ(state3.matrix(), rotated_dl_matrix);
677}
678
679TEST(DisplayListMatrixClipTracker, Transform2DAffine) {
680 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
681 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
682 const SkMatrix matrix = SkMatrix::Scale(4, 4);
683 const SkM44 m44 = SkM44::Scale(4, 4);
684 const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
685
686 const SkMatrix transformed_matrix =
687 SkMatrix::Concat(matrix, SkMatrix::MakeAll(2, 0, 5, //
688 0, 2, 6, //
689 0, 0, 1));
690 const SkM44 transformed_m44 = SkM44(transformed_matrix);
691 const DlMatrix transformed_dl_matrix =
692 dl_matrix * DlMatrix::MakeRow(2, 0, 0, 5, //
693 0, 2, 0, 6, //
694 0, 0, 1, 0, //
695 0, 0, 0, 1);
696 const SkRect local_cull_rect = SkRect::MakeLTRB(0, 2, 5, 7);
697
698 DisplayListMatrixClipTracker tracker1(cull_rect, matrix);
699 DisplayListMatrixClipTracker tracker2(cull_rect, m44);
700 DisplayListMatrixClipTracker tracker3(dl_cull_rect, dl_matrix);
701 tracker1.transform2DAffine(2, 0, 5, //
702 0, 2, 6);
703 tracker2.transform2DAffine(2, 0, 5, //
704 0, 2, 6);
705 tracker3.transform2DAffine(2, 0, 5, //
706 0, 2, 6);
707
708 EXPECT_FALSE(tracker1.using_4x4_matrix());
709 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
710 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
711 EXPECT_EQ(tracker1.matrix_3x3(), transformed_matrix);
712 EXPECT_EQ(tracker1.matrix_4x4(), transformed_m44);
713 EXPECT_EQ(tracker1.matrix(), transformed_dl_matrix);
714
715 EXPECT_FALSE(tracker2.using_4x4_matrix());
716 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
717 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
718 EXPECT_EQ(tracker2.matrix_3x3(), transformed_matrix);
719 EXPECT_EQ(tracker2.matrix_4x4(), transformed_m44);
720 EXPECT_EQ(tracker2.matrix(), transformed_dl_matrix);
721
722 EXPECT_FALSE(tracker3.using_4x4_matrix());
723 EXPECT_EQ(tracker3.device_cull_rect(), cull_rect);
724 EXPECT_EQ(tracker3.local_cull_rect(), local_cull_rect);
725 EXPECT_EQ(tracker3.matrix_3x3(), transformed_matrix);
726 EXPECT_EQ(tracker3.matrix_4x4(), transformed_m44);
727 EXPECT_EQ(tracker3.matrix(), transformed_dl_matrix);
728}
729
730TEST(DisplayListMatrixClipState, Transform2DAffine) {
731 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
732 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
733 const SkMatrix matrix = SkMatrix::Scale(4, 4);
734 const SkM44 m44 = SkM44::Scale(4, 4);
735 const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
736
737 const SkMatrix transformed_matrix =
738 SkMatrix::Concat(matrix, SkMatrix::MakeAll(2, 0, 5, //
739 0, 2, 6, //
740 0, 0, 1));
741 const SkM44 transformed_m44 = SkM44(transformed_matrix);
742 const DlMatrix transformed_dl_matrix =
743 dl_matrix * DlMatrix::MakeRow(2, 0, 0, 5, //
744 0, 2, 0, 6, //
745 0, 0, 1, 0, //
746 0, 0, 0, 1);
747 const SkRect local_cull_rect = SkRect::MakeLTRB(0, 2, 5, 7);
748
749 DisplayListMatrixClipState state1(cull_rect, matrix);
750 DisplayListMatrixClipState state2(cull_rect, m44);
751 DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
752 state1.transform2DAffine(2, 0, 5, //
753 0, 2, 6);
754 state2.transform2DAffine(2, 0, 5, //
755 0, 2, 6);
756 state3.transform2DAffine(2, 0, 5, //
757 0, 2, 6);
758
759 EXPECT_FALSE(state1.using_4x4_matrix());
760 EXPECT_EQ(state1.device_cull_rect(), cull_rect);
761 EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
762 EXPECT_EQ(state1.matrix_3x3(), transformed_matrix);
763 EXPECT_EQ(state1.matrix_4x4(), transformed_m44);
764 EXPECT_EQ(state1.matrix(), transformed_dl_matrix);
765
766 EXPECT_FALSE(state2.using_4x4_matrix());
767 EXPECT_EQ(state2.device_cull_rect(), cull_rect);
768 EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
769 EXPECT_EQ(state2.matrix_3x3(), transformed_matrix);
770 EXPECT_EQ(state2.matrix_4x4(), transformed_m44);
771 EXPECT_EQ(state2.matrix(), transformed_dl_matrix);
772
773 EXPECT_FALSE(state3.using_4x4_matrix());
774 EXPECT_EQ(state3.device_cull_rect(), cull_rect);
775 EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
776 EXPECT_EQ(state3.matrix_3x3(), transformed_matrix);
777 EXPECT_EQ(state3.matrix_4x4(), transformed_m44);
778 EXPECT_EQ(state3.matrix(), transformed_dl_matrix);
779}
780
781TEST(DisplayListMatrixClipTracker, TransformFullPerspectiveUsing3x3Matrix) {
782 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
783 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
784 const SkMatrix matrix = SkMatrix::Scale(4, 4);
785 const SkM44 m44 = SkM44::Scale(4, 4);
786 const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
787
788 const SkMatrix transformed_matrix =
789 SkMatrix::Concat(matrix, SkMatrix::MakeAll(2, 0, 5, //
790 0, 2, 6, //
791 0, 0, 1));
792 const SkM44 transformed_m44 = SkM44(transformed_matrix);
793 const DlMatrix transformed_dl_matrix =
794 dl_matrix * DlMatrix::MakeRow(2, 0, 0, 5, //
795 0, 2, 0, 6, //
796 0, 0, 1, 0, //
797 0, 0, 0, 1);
798 const SkRect local_cull_rect = SkRect::MakeLTRB(0, 2, 5, 7);
799
800 DisplayListMatrixClipTracker tracker1(cull_rect, matrix);
801 DisplayListMatrixClipTracker tracker2(cull_rect, m44);
802 DisplayListMatrixClipTracker tracker3(dl_cull_rect, dl_matrix);
803 tracker1.transformFullPerspective(2, 0, 0, 5, //
804 0, 2, 0, 6, //
805 0, 0, 1, 0, //
806 0, 0, 0, 1);
807 tracker2.transformFullPerspective(2, 0, 0, 5, //
808 0, 2, 0, 6, //
809 0, 0, 1, 0, //
810 0, 0, 0, 1);
811 tracker3.transformFullPerspective(2, 0, 0, 5, //
812 0, 2, 0, 6, //
813 0, 0, 1, 0, //
814 0, 0, 0, 1);
815
816 EXPECT_FALSE(tracker1.using_4x4_matrix());
817 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
818 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
819 EXPECT_EQ(tracker1.matrix_3x3(), transformed_matrix);
820 EXPECT_EQ(tracker1.matrix_4x4(), transformed_m44);
821 EXPECT_EQ(tracker1.matrix(), transformed_dl_matrix);
822
823 EXPECT_FALSE(tracker2.using_4x4_matrix());
824 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
825 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
826 EXPECT_EQ(tracker2.matrix_3x3(), transformed_matrix);
827 EXPECT_EQ(tracker2.matrix_4x4(), transformed_m44);
828 EXPECT_EQ(tracker2.matrix(), transformed_dl_matrix);
829
830 EXPECT_FALSE(tracker3.using_4x4_matrix());
831 EXPECT_EQ(tracker3.device_cull_rect(), cull_rect);
832 EXPECT_EQ(tracker3.local_cull_rect(), local_cull_rect);
833 EXPECT_EQ(tracker3.matrix_3x3(), transformed_matrix);
834 EXPECT_EQ(tracker3.matrix_4x4(), transformed_m44);
835 EXPECT_EQ(tracker3.matrix(), transformed_dl_matrix);
836}
837
838TEST(DisplayListMatrixClipState, TransformFullPerspectiveUsing3x3Matrix) {
839 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
840 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
841 const SkMatrix matrix = SkMatrix::Scale(4, 4);
842 const SkM44 m44 = SkM44::Scale(4, 4);
843 const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
844
845 const SkMatrix transformed_matrix =
846 SkMatrix::Concat(matrix, SkMatrix::MakeAll(2, 0, 5, //
847 0, 2, 6, //
848 0, 0, 1));
849 const SkM44 transformed_m44 = SkM44(transformed_matrix);
850 const DlMatrix transformed_dl_matrix =
851 dl_matrix * DlMatrix::MakeRow(2, 0, 0, 5, //
852 0, 2, 0, 6, //
853 0, 0, 1, 0, //
854 0, 0, 0, 1);
855 const SkRect local_cull_rect = SkRect::MakeLTRB(0, 2, 5, 7);
856
857 DisplayListMatrixClipState state1(cull_rect, matrix);
858 DisplayListMatrixClipState state2(cull_rect, m44);
859 DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
860 state1.transformFullPerspective(2, 0, 0, 5, //
861 0, 2, 0, 6, //
862 0, 0, 1, 0, //
863 0, 0, 0, 1);
864 state2.transformFullPerspective(2, 0, 0, 5, //
865 0, 2, 0, 6, //
866 0, 0, 1, 0, //
867 0, 0, 0, 1);
868 state3.transformFullPerspective(2, 0, 0, 5, //
869 0, 2, 0, 6, //
870 0, 0, 1, 0, //
871 0, 0, 0, 1);
872
873 EXPECT_FALSE(state1.using_4x4_matrix());
874 EXPECT_EQ(state1.device_cull_rect(), cull_rect);
875 EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
876 EXPECT_EQ(state1.matrix_3x3(), transformed_matrix);
877 EXPECT_EQ(state1.matrix_4x4(), transformed_m44);
878 EXPECT_EQ(state1.matrix(), transformed_dl_matrix);
879
880 EXPECT_FALSE(state2.using_4x4_matrix());
881 EXPECT_EQ(state2.device_cull_rect(), cull_rect);
882 EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
883 EXPECT_EQ(state2.matrix_3x3(), transformed_matrix);
884 EXPECT_EQ(state2.matrix_4x4(), transformed_m44);
885 EXPECT_EQ(state2.matrix(), transformed_dl_matrix);
886
887 EXPECT_FALSE(state3.using_4x4_matrix());
888 EXPECT_EQ(state3.device_cull_rect(), cull_rect);
889 EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
890 EXPECT_EQ(state3.matrix_3x3(), transformed_matrix);
891 EXPECT_EQ(state3.matrix_4x4(), transformed_m44);
892 EXPECT_EQ(state3.matrix(), transformed_dl_matrix);
893}
894
895TEST(DisplayListMatrixClipTracker, TransformFullPerspectiveUsing4x4Matrix) {
896 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
897 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
898 const SkMatrix matrix = SkMatrix::Scale(4, 4);
899 const SkM44 m44 = SkM44::Scale(4, 4);
900 const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
901
902 const SkM44 transformed_m44 = SkM44(m44, SkM44(2, 0, 0, 5, //
903 0, 2, 0, 6, //
904 0, 0, 1, 7, //
905 0, 0, 0, 1));
906 const DlMatrix transformed_dl_matrix =
907 dl_matrix * DlMatrix::MakeRow(2, 0, 0, 5, //
908 0, 2, 0, 6, //
909 0, 0, 1, 7, //
910 0, 0, 0, 1);
911 const SkRect local_cull_rect = SkRect::MakeLTRB(0, 2, 5, 7);
912
913 DisplayListMatrixClipTracker tracker1(cull_rect, matrix);
914 DisplayListMatrixClipTracker tracker2(cull_rect, m44);
915 DisplayListMatrixClipTracker tracker3(dl_cull_rect, dl_matrix);
916 tracker1.transformFullPerspective(2, 0, 0, 5, //
917 0, 2, 0, 6, //
918 0, 0, 1, 7, //
919 0, 0, 0, 1);
920 tracker2.transformFullPerspective(2, 0, 0, 5, //
921 0, 2, 0, 6, //
922 0, 0, 1, 7, //
923 0, 0, 0, 1);
924 tracker3.transformFullPerspective(2, 0, 0, 5, //
925 0, 2, 0, 6, //
926 0, 0, 1, 7, //
927 0, 0, 0, 1);
928
929 EXPECT_TRUE(tracker1.using_4x4_matrix());
930 EXPECT_EQ(tracker1.device_cull_rect(), cull_rect);
931 EXPECT_EQ(tracker1.local_cull_rect(), local_cull_rect);
932 EXPECT_EQ(tracker1.matrix_4x4(), transformed_m44);
933 EXPECT_EQ(tracker1.matrix(), transformed_dl_matrix);
934
935 EXPECT_TRUE(tracker2.using_4x4_matrix());
936 EXPECT_EQ(tracker2.device_cull_rect(), cull_rect);
937 EXPECT_EQ(tracker2.local_cull_rect(), local_cull_rect);
938 EXPECT_EQ(tracker2.matrix_4x4(), transformed_m44);
939 EXPECT_EQ(tracker2.matrix(), transformed_dl_matrix);
940
941 EXPECT_TRUE(tracker3.using_4x4_matrix());
942 EXPECT_EQ(tracker3.device_cull_rect(), cull_rect);
943 EXPECT_EQ(tracker3.local_cull_rect(), local_cull_rect);
944 EXPECT_EQ(tracker3.matrix_4x4(), transformed_m44);
945 EXPECT_EQ(tracker3.matrix(), transformed_dl_matrix);
946}
947
948TEST(DisplayListMatrixClipState, TransformFullPerspectiveUsing4x4Matrix) {
949 const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
950 const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
951 const SkMatrix matrix = SkMatrix::Scale(4, 4);
952 const SkM44 m44 = SkM44::Scale(4, 4);
953 const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
954
955 const SkM44 transformed_m44 = SkM44(m44, SkM44(2, 0, 0, 5, //
956 0, 2, 0, 6, //
957 0, 0, 1, 7, //
958 0, 0, 0, 1));
959 const DlMatrix transformed_dl_matrix =
960 dl_matrix * DlMatrix::MakeRow(2, 0, 0, 5, //
961 0, 2, 0, 6, //
962 0, 0, 1, 7, //
963 0, 0, 0, 1);
964 const SkRect local_cull_rect = SkRect::MakeLTRB(0, 2, 5, 7);
965
966 DisplayListMatrixClipState state1(cull_rect, matrix);
967 DisplayListMatrixClipState state2(cull_rect, m44);
968 DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
969 state1.transformFullPerspective(2, 0, 0, 5, //
970 0, 2, 0, 6, //
971 0, 0, 1, 7, //
972 0, 0, 0, 1);
973 state2.transformFullPerspective(2, 0, 0, 5, //
974 0, 2, 0, 6, //
975 0, 0, 1, 7, //
976 0, 0, 0, 1);
977 state3.transformFullPerspective(2, 0, 0, 5, //
978 0, 2, 0, 6, //
979 0, 0, 1, 7, //
980 0, 0, 0, 1);
981
982 EXPECT_TRUE(state1.using_4x4_matrix());
983 EXPECT_EQ(state1.device_cull_rect(), cull_rect);
984 EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
985 EXPECT_EQ(state1.matrix_4x4(), transformed_m44);
986 EXPECT_EQ(state1.matrix(), transformed_dl_matrix);
987
988 EXPECT_TRUE(state2.using_4x4_matrix());
989 EXPECT_EQ(state2.device_cull_rect(), cull_rect);
990 EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
991 EXPECT_EQ(state2.matrix_4x4(), transformed_m44);
992 EXPECT_EQ(state2.matrix(), transformed_dl_matrix);
993
994 EXPECT_TRUE(state3.using_4x4_matrix());
995 EXPECT_EQ(state3.device_cull_rect(), cull_rect);
996 EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
997 EXPECT_EQ(state3.matrix_4x4(), transformed_m44);
998 EXPECT_EQ(state3.matrix(), transformed_dl_matrix);
999}
1000
1001TEST(DisplayListMatrixClipTracker, ClipDifference) {
1002 SkRect cull_rect = SkRect::MakeLTRB(20, 20, 40, 40);
1003
1004 auto non_reducing = [&cull_rect](const SkRect& diff_rect,
1005 const std::string& label) {
1006 {
1007 DisplayListMatrixClipTracker tracker(cull_rect, SkMatrix::I());
1008 tracker.clipRect(diff_rect, DlCanvas::ClipOp::kDifference, false);
1009 EXPECT_EQ(tracker.device_cull_rect(), cull_rect) << label;
1010 }
1011 {
1012 DisplayListMatrixClipTracker tracker(cull_rect, SkMatrix::I());
1013 const SkRRect diff_rrect = SkRRect::MakeRect(diff_rect);
1014 tracker.clipRRect(diff_rrect, DlCanvas::ClipOp::kDifference, false);
1015 EXPECT_EQ(tracker.device_cull_rect(), cull_rect) << label << " (RRect)";
1016 }
1017 {
1018 DisplayListMatrixClipTracker tracker(cull_rect, SkMatrix::I());
1019 const SkPath diff_path = SkPath().addRect(diff_rect);
1020 tracker.clipPath(diff_path, DlCanvas::ClipOp::kDifference, false);
1021 EXPECT_EQ(tracker.device_cull_rect(), cull_rect) << label << " (RRect)";
1022 }
1023 {
1024 DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
1025 state.clipRect(diff_rect, DlCanvas::ClipOp::kDifference, false);
1026 EXPECT_EQ(state.device_cull_rect(), cull_rect) << label;
1027 }
1028 {
1029 DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
1030 const SkRRect diff_rrect = SkRRect::MakeRect(diff_rect);
1031 state.clipRRect(diff_rrect, DlCanvas::ClipOp::kDifference, false);
1032 EXPECT_EQ(state.device_cull_rect(), cull_rect) << label << " (RRect)";
1033 }
1034 {
1035 DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
1036 const SkPath diff_path = SkPath().addRect(diff_rect);
1037 state.clipPath(diff_path, DlCanvas::ClipOp::kDifference, false);
1038 EXPECT_EQ(state.device_cull_rect(), cull_rect) << label << " (RRect)";
1039 }
1040 };
1041
1042 auto reducing = [&cull_rect](const SkRect& diff_rect,
1043 const SkRect& result_rect,
1044 const std::string& label) {
1045 EXPECT_TRUE(result_rect.isEmpty() || cull_rect.contains(result_rect));
1046 {
1047 DisplayListMatrixClipTracker tracker(cull_rect, SkMatrix::I());
1048 tracker.clipRect(diff_rect, DlCanvas::ClipOp::kDifference, false);
1049 EXPECT_EQ(tracker.device_cull_rect(), result_rect) << label;
1050 }
1051 {
1052 DisplayListMatrixClipTracker tracker(cull_rect, SkMatrix::I());
1053 const SkRRect diff_rrect = SkRRect::MakeRect(diff_rect);
1054 tracker.clipRRect(diff_rrect, DlCanvas::ClipOp::kDifference, false);
1055 EXPECT_EQ(tracker.device_cull_rect(), result_rect) << label << " (RRect)";
1056 }
1057 {
1058 DisplayListMatrixClipTracker tracker(cull_rect, SkMatrix::I());
1059 const SkPath diff_path = SkPath().addRect(diff_rect);
1060 tracker.clipPath(diff_path, DlCanvas::ClipOp::kDifference, false);
1061 EXPECT_EQ(tracker.device_cull_rect(), result_rect) << label << " (RRect)";
1062 }
1063 {
1064 DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
1065 state.clipRect(diff_rect, DlCanvas::ClipOp::kDifference, false);
1066 EXPECT_EQ(state.device_cull_rect(), result_rect) << label;
1067 }
1068 {
1069 DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
1070 const SkRRect diff_rrect = SkRRect::MakeRect(diff_rect);
1071 state.clipRRect(diff_rrect, DlCanvas::ClipOp::kDifference, false);
1072 EXPECT_EQ(state.device_cull_rect(), result_rect) << label << " (RRect)";
1073 }
1074 {
1075 DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
1076 const SkPath diff_path = SkPath().addRect(diff_rect);
1077 state.clipPath(diff_path, DlCanvas::ClipOp::kDifference, false);
1078 EXPECT_EQ(state.device_cull_rect(), result_rect) << label << " (RRect)";
1079 }
1080 };
1081
1082 // Skim the corners and edge
1083 non_reducing(SkRect::MakeLTRB(10, 10, 20, 20), "outside UL corner");
1084 non_reducing(SkRect::MakeLTRB(20, 10, 40, 20), "Above");
1085 non_reducing(SkRect::MakeLTRB(40, 10, 50, 20), "outside UR corner");
1086 non_reducing(SkRect::MakeLTRB(40, 20, 50, 40), "Right");
1087 non_reducing(SkRect::MakeLTRB(40, 40, 50, 50), "outside LR corner");
1088 non_reducing(SkRect::MakeLTRB(20, 40, 40, 50), "Below");
1089 non_reducing(SkRect::MakeLTRB(10, 40, 20, 50), "outside LR corner");
1090 non_reducing(SkRect::MakeLTRB(10, 20, 20, 40), "Left");
1091
1092 // Overlap corners
1093 non_reducing(SkRect::MakeLTRB(15, 15, 25, 25), "covering UL corner");
1094 non_reducing(SkRect::MakeLTRB(35, 15, 45, 25), "covering UR corner");
1095 non_reducing(SkRect::MakeLTRB(35, 35, 45, 45), "covering LR corner");
1096 non_reducing(SkRect::MakeLTRB(15, 35, 25, 45), "covering LL corner");
1097
1098 // Overlap edges, but not across an entire side
1099 non_reducing(SkRect::MakeLTRB(20, 15, 39, 25), "Top edge left-biased");
1100 non_reducing(SkRect::MakeLTRB(21, 15, 40, 25), "Top edge, right biased");
1101 non_reducing(SkRect::MakeLTRB(35, 20, 45, 39), "Right edge, top-biased");
1102 non_reducing(SkRect::MakeLTRB(35, 21, 45, 40), "Right edge, bottom-biased");
1103 non_reducing(SkRect::MakeLTRB(20, 35, 39, 45), "Bottom edge, left-biased");
1104 non_reducing(SkRect::MakeLTRB(21, 35, 40, 45), "Bottom edge, right-biased");
1105 non_reducing(SkRect::MakeLTRB(15, 20, 25, 39), "Left edge, top-biased");
1106 non_reducing(SkRect::MakeLTRB(15, 21, 25, 40), "Left edge, bottom-biased");
1107
1108 // Slice all the way through the middle
1109 non_reducing(SkRect::MakeLTRB(25, 15, 35, 45), "Vertical interior slice");
1110 non_reducing(SkRect::MakeLTRB(15, 25, 45, 35), "Horizontal interior slice");
1111
1112 // Slice off each edge
1113 reducing(SkRect::MakeLTRB(20, 15, 40, 25), //
1114 SkRect::MakeLTRB(20, 25, 40, 40), //
1115 "Slice off top");
1116 reducing(SkRect::MakeLTRB(35, 20, 45, 40), //
1117 SkRect::MakeLTRB(20, 20, 35, 40), //
1118 "Slice off right");
1119 reducing(SkRect::MakeLTRB(20, 35, 40, 45), //
1120 SkRect::MakeLTRB(20, 20, 40, 35), //
1121 "Slice off bottom");
1122 reducing(SkRect::MakeLTRB(15, 20, 25, 40), //
1123 SkRect::MakeLTRB(25, 20, 40, 40), //
1124 "Slice off left");
1125
1126 // cull rect contains diff rect
1127 non_reducing(SkRect::MakeLTRB(21, 21, 39, 39), "Contained, non-covering");
1128
1129 // cull rect equals diff rect
1130 reducing(cull_rect, SkRect::MakeEmpty(), "Perfectly covering");
1131
1132 // diff rect contains cull rect
1133 reducing(SkRect::MakeLTRB(15, 15, 45, 45), SkRect::MakeEmpty(), "Smothering");
1134}
1135
1136TEST(DisplayListMatrixClipTracker, ClipPathWithInvertFillType) {
1137 SkRect cull_rect = SkRect::MakeLTRB(0, 0, 100.0, 100.0);
1138 DisplayListMatrixClipTracker tracker(cull_rect, SkMatrix::I());
1139 SkPath clip = SkPath().addCircle(10.2, 11.3, 2).addCircle(20.4, 25.7, 2);
1140 clip.setFillType(SkPathFillType::kInverseWinding);
1141 tracker.clipPath(clip, DlCanvas::ClipOp::kIntersect, false);
1142
1143 EXPECT_EQ(tracker.local_cull_rect(), cull_rect);
1144 EXPECT_EQ(tracker.device_cull_rect(), cull_rect);
1145}
1146
1147TEST(DisplayListMatrixClipState, ClipPathWithInvertFillType) {
1148 SkRect cull_rect = SkRect::MakeLTRB(0, 0, 100.0, 100.0);
1149 DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
1150 SkPath clip = SkPath().addCircle(10.2, 11.3, 2).addCircle(20.4, 25.7, 2);
1151 clip.setFillType(SkPathFillType::kInverseWinding);
1152 state.clipPath(clip, DlCanvas::ClipOp::kIntersect, false);
1153
1154 EXPECT_EQ(state.local_cull_rect(), cull_rect);
1155 EXPECT_EQ(state.device_cull_rect(), cull_rect);
1156}
1157
1158TEST(DisplayListMatrixClipTracker, DiffClipPathWithInvertFillType) {
1159 SkRect cull_rect = SkRect::MakeLTRB(0, 0, 100.0, 100.0);
1160 DisplayListMatrixClipTracker tracker(cull_rect, SkMatrix::I());
1161
1162 SkPath clip = SkPath().addCircle(10.2, 11.3, 2).addCircle(20.4, 25.7, 2);
1163 clip.setFillType(SkPathFillType::kInverseWinding);
1164 SkRect clip_bounds = SkRect::MakeLTRB(8.2, 9.3, 22.4, 27.7);
1165 tracker.clipPath(clip, DlCanvas::ClipOp::kDifference, false);
1166
1167 EXPECT_EQ(tracker.local_cull_rect(), clip_bounds);
1168 EXPECT_EQ(tracker.device_cull_rect(), clip_bounds);
1169}
1170
1171TEST(DisplayListMatrixClipState, DiffClipPathWithInvertFillType) {
1172 SkRect cull_rect = SkRect::MakeLTRB(0, 0, 100.0, 100.0);
1173 DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
1174
1175 SkPath clip = SkPath().addCircle(10.2, 11.3, 2).addCircle(20.4, 25.7, 2);
1176 clip.setFillType(SkPathFillType::kInverseWinding);
1177 SkRect clip_bounds = SkRect::MakeLTRB(8.2, 9.3, 22.4, 27.7);
1178 state.clipPath(clip, DlCanvas::ClipOp::kDifference, false);
1179
1180 EXPECT_EQ(state.local_cull_rect(), clip_bounds);
1181 EXPECT_EQ(state.device_cull_rect(), clip_bounds);
1182}
1183
1184} // namespace testing
1185} // namespace flutter
TEST
#define TEST(S, s, D, expected)
Definition FitsInTest.cpp:15
clip
static SkPath clip(const SkPath &path, const SkHalfPlane &plane)
Definition SkPath.cpp:3824
SkM44
Definition SkM44.h:150
SkM44::Scale
static SkM44 Scale(SkScalar x, SkScalar y, SkScalar z=1)
Definition SkM44.h:232
SkMatrix::Scale
static SkMatrix Scale(SkScalar sx, SkScalar sy)
Definition SkMatrix.h:75
SkMatrix::RotateDeg
static SkMatrix RotateDeg(SkScalar deg)
Definition SkMatrix.h:104
SkMatrix::Translate
static SkMatrix Translate(SkScalar dx, SkScalar dy)
Definition SkMatrix.h:91
SkMatrix::MakeAll
static SkMatrix MakeAll(SkScalar scaleX, SkScalar skewX, SkScalar transX, SkScalar skewY, SkScalar scaleY, SkScalar transY, SkScalar pers0, SkScalar pers1, SkScalar pers2)
Definition SkMatrix.h:179
SkMatrix::Concat
static SkMatrix Concat(const SkMatrix &a, const SkMatrix &b)
Definition SkMatrix.h:1775
SkMatrix::I
static const SkMatrix & I()
Definition SkMatrix.cpp:1544
SkMatrix::Skew
static SkMatrix Skew(SkScalar kx, SkScalar ky)
Definition SkMatrix.h:124
SkPath::addCircle
SkPath & addCircle(SkScalar x, SkScalar y, SkScalar radius, SkPathDirection dir=SkPathDirection::kCW)
Definition SkPath.cpp:1149
SkPath::setFillType
void setFillType(SkPathFillType ft)
Definition SkPath.h:235
SkPath::addRect
SkPath & addRect(const SkRect &rect, SkPathDirection dir, unsigned start)
Definition SkPath.cpp:854
SkRRect::MakeRect
static SkRRect MakeRect(const SkRect &r)
Definition SkRRect.h:149
flutter::DisplayListMatrixClipState::scale
void scale(SkScalar sx, SkScalar sy)
Definition dl_matrix_clip_tracker.h:112
flutter::DisplayListMatrixClipState::transform2DAffine
void transform2DAffine(SkScalar mxx, SkScalar mxy, SkScalar mxt, SkScalar myx, SkScalar myy, SkScalar myt)
Definition dl_matrix_clip_tracker.h:125
flutter::DisplayListMatrixClipState::setTransform
void setTransform(const DlMatrix &matrix)
Definition dl_matrix_clip_tracker.h:148
flutter::DisplayListMatrixClipState::transformFullPerspective
void transformFullPerspective(SkScalar mxx, SkScalar mxy, SkScalar mxz, SkScalar mxt, SkScalar myx, SkScalar myy, SkScalar myz, SkScalar myt, SkScalar mzx, SkScalar mzy, SkScalar mzz, SkScalar mzt, SkScalar mwx, SkScalar mwy, SkScalar mwz, SkScalar mwt)
Definition dl_matrix_clip_tracker.h:135
flutter::DisplayListMatrixClipState::skew
void skew(SkScalar skx, SkScalar sky)
Definition dl_matrix_clip_tracker.h:115
flutter::DisplayListMatrixClipState::translate
void translate(SkScalar tx, SkScalar ty)
Definition dl_matrix_clip_tracker.h:109
flutter::DisplayListMatrixClipTracker::clipRect
void clipRect(const DlRect &rect, ClipOp op, bool is_aa)
Definition dl_matrix_clip_tracker.h:305
flutter::DisplayListMatrixClipTracker::clipPath
void clipPath(const SkPath &path, ClipOp op, bool is_aa)
Definition dl_matrix_clip_tracker.h:314
flutter::DisplayListMatrixClipTracker::transform2DAffine
void transform2DAffine(SkScalar mxx, SkScalar mxy, SkScalar mxt, SkScalar myx, SkScalar myy, SkScalar myt)
Definition dl_matrix_clip_tracker.h:267
flutter::DisplayListMatrixClipTracker::translate
void translate(SkScalar tx, SkScalar ty)
Definition dl_matrix_clip_tracker.h:259
flutter::DisplayListMatrixClipTracker::clipRRect
void clipRRect(const SkRRect &rrect, ClipOp op, bool is_aa)
Definition dl_matrix_clip_tracker.h:311
flutter::DisplayListMatrixClipTracker::transformFullPerspective
void transformFullPerspective(SkScalar mxx, SkScalar mxy, SkScalar mxz, SkScalar mxt, SkScalar myx, SkScalar myy, SkScalar myz, SkScalar myt, SkScalar mzx, SkScalar mzy, SkScalar mzz, SkScalar mzt, SkScalar mwx, SkScalar mwy, SkScalar mwz, SkScalar mwt)
Definition dl_matrix_clip_tracker.h:272
flutter::DisplayListMatrixClipTracker::skew
void skew(SkScalar skx, SkScalar sky)
Definition dl_matrix_clip_tracker.h:261
state
AtkStateType state
Definition fl_accessible_node.cc:10
impeller::Rect
TRect< Scalar > Rect
Definition rect.h:746
SkRect::MakeEmpty
static constexpr SkRect MakeEmpty()
Definition SkRect.h:595
SkRect::contains
bool contains(SkScalar x, SkScalar y) const
Definition extension.cpp:19
SkRect::MakeLTRB
static constexpr SkRect MakeLTRB(float l, float t, float r, float b)
Definition SkRect.h:646
impeller::Matrix
A 4x4 matrix using column-major storage.
Definition matrix.h:37
impeller::Matrix::MakeTranslation
static constexpr Matrix MakeTranslation(const Vector3 &t)
Definition matrix.h:95
impeller::Matrix::MakeRow
static constexpr Matrix MakeRow(Scalar m0, Scalar m1, Scalar m2, Scalar m3, Scalar m4, Scalar m5, Scalar m6, Scalar m7, Scalar m8, Scalar m9, Scalar m10, Scalar m11, Scalar m12, Scalar m13, Scalar m14, Scalar m15)
Definition matrix.h:83
impeller::Matrix::MakeSkew
static constexpr Matrix MakeSkew(Scalar sx, Scalar sy)
Definition matrix.h:117
impeller::Matrix::Scale
constexpr Matrix Scale(const Vector3 &s) const
Definition matrix.h:252
impeller::Matrix::MakeRotationZ
static Matrix MakeRotationZ(Radians r)
Definition matrix.h:213
impeller::Matrix::MakeScale
static constexpr Matrix MakeScale(const Vector3 &s)
Definition matrix.h:104
impeller::TRect< Scalar >::MakeLTRB
static constexpr TRect MakeLTRB(Type left, Type top, Type right, Type bottom)
Definition rect.h:129
EXPECT_TRUE
#define EXPECT_TRUE(handle)
Definition unit_test.h:685
Generated on Fri Apr 26 2024 06:14:03 for Flutter Engine by doxygen 1.9.8