Skip to content
This repository was archived by the owner on Feb 25, 2025. It is now read-only.

Commit 28d9985

Browse files
liyuqianliyuqian
authored
Reland again "Remove layer integral offset snapping #17112" (#18160)
This reverts commit a7a25d3 and relands our reland #17915. Additionally, we fixed the cull rect logic in `OpacityLayer::Preroll` which is the root cause of flutter/flutter#56298. We've always had that root problem before but it did not trigger performance issues because we were using the OpacityLayer's `paint_bounds`, instead of its child's `paint_bounds` for preparing the layer raster cache. A correct handling of the cull rect should allow us to cull at any level. It also turns out that our ios32 (iPhone4s) performacne can regress a lot without snapping. My theory is that although the picture has a fractional top left corner, many drawing operations inside the picture have integral coordinations. In older hardwares, keeping those coordinates integral seems to be performance critical. To avoid flutter/flutter#41654, the snapping will still be disabled if the matrix has non-scale-translation transformations.
1 parent 5e361f5 commit 28d9985

17 files changed

+88
-119
lines changed

‎flow/layers/container_layer.cc‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -78,6 +78,15 @@ void ContainerLayer::PaintChildren(PaintContext& context) const {
7878
}
7979
}
8080

81+
void ContainerLayer::TryToPrepareRasterCache(PrerollContext* context,
82+
Layer* layer,
83+
const SkMatrix& matrix) {
84+
if (!context->has_platform_view && context->raster_cache &&
85+
SkRect::Intersects(context->cull_rect, layer->paint_bounds())) {
86+
context->raster_cache->Prepare(context, layer, matrix);
87+
}
88+
}
89+
8190
#if defined(OS_FUCHSIA)
8291

8392
void ContainerLayer::CheckForChildLayerBelow(PrerollContext* context) {

‎flow/layers/container_layer.h‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,20 @@ class ContainerLayer : public Layer {
3838
// For OpacityLayer to restructure to have a single child.
3939
void ClearChildren() { layers_.clear(); }
4040

41+
// Try to prepare the raster cache for a given layer.
42+
//
43+
// The raster cache would fail if either of the followings is true:
44+
// 1. The context has a platform view.
45+
// 2. The context does not have a valid raster cache.
46+
// 3. The layer's paint bounds does not intersect with the cull rect.
47+
//
48+
// We make this a static function instead of a member function that directy
49+
// uses the "this" pointer as the layer because we sometimes need to raster
50+
// cache a child layer and one can't access its child's protected method.
51+
static void TryToPrepareRasterCache(PrerollContext* context,
52+
Layer* layer,
53+
const SkMatrix& matrix);
54+
4155
private:
4256
std::vector<std::shared_ptr<Layer>> layers_;
4357

‎flow/layers/image_filter_layer.cc‎

Lines changed: 1 addition & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -28,26 +28,13 @@ void ImageFilterLayer::Preroll(PrerollContext* context,
2828
set_paint_bounds(child_paint_bounds_);
2929
}
3030

31-
if (!context->has_platform_view && context->raster_cache &&
32-
SkRect::Intersects(context->cull_rect, paint_bounds())) {
33-
SkMatrix ctm = matrix;
34-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
35-
ctm = RasterCache::GetIntegralTransCTM(ctm);
36-
#endif
37-
context->raster_cache->Prepare(context, this, ctm);
38-
}
31+
TryToPrepareRasterCache(context, this, matrix);
3932
}
4033

4134
void ImageFilterLayer::Paint(PaintContext& context) const {
4235
TRACE_EVENT0("flutter", "ImageFilterLayer::Paint");
4336
FML_DCHECK(needs_painting());
4437

45-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
46-
SkAutoCanvasRestore save(context.leaf_nodes_canvas, true);
47-
context.leaf_nodes_canvas->setMatrix(RasterCache::GetIntegralTransCTM(
48-
context.leaf_nodes_canvas->getTotalMatrix()));
49-
#endif
50-
5138
if (context.raster_cache &&
5239
context.raster_cache->Draw(this, *context.leaf_nodes_canvas)) {
5340
return;

‎flow/layers/image_filter_layer_unittests.cc‎

Lines changed: 25 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -60,14 +60,11 @@ TEST_F(ImageFilterLayerTest, EmptyFilter) {
6060
layer->Paint(paint_context());
6161
EXPECT_EQ(mock_canvas().draw_calls(),
6262
std::vector({
63-
MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
64-
MockCanvas::DrawCall{1, MockCanvas::SetMatrixData{SkMatrix()}},
6563
MockCanvas::DrawCall{
66-
1, MockCanvas::SaveLayerData{child_bounds, filter_paint,
67-
nullptr, 2}},
64+
0, MockCanvas::SaveLayerData{child_bounds, filter_paint,
65+
nullptr, 1}},
6866
MockCanvas::DrawCall{
69-
2, MockCanvas::DrawPathData{child_path, child_paint}},
70-
MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
67+
1, MockCanvas::DrawPathData{child_path, child_paint}},
7168
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}},
7269
}));
7370
}
@@ -96,14 +93,11 @@ TEST_F(ImageFilterLayerTest, SimpleFilter) {
9693
layer->Paint(paint_context());
9794
EXPECT_EQ(mock_canvas().draw_calls(),
9895
std::vector({
99-
MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
100-
MockCanvas::DrawCall{1, MockCanvas::SetMatrixData{SkMatrix()}},
10196
MockCanvas::DrawCall{
102-
1, MockCanvas::SaveLayerData{child_bounds, filter_paint,
103-
nullptr, 2}},
97+
0, MockCanvas::SaveLayerData{child_bounds, filter_paint,
98+
nullptr, 1}},
10499
MockCanvas::DrawCall{
105-
2, MockCanvas::DrawPathData{child_path, child_paint}},
106-
MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
100+
1, MockCanvas::DrawPathData{child_path, child_paint}},
107101
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}},
108102
}));
109103
}
@@ -132,14 +126,11 @@ TEST_F(ImageFilterLayerTest, SimpleFilterBounds) {
132126
layer->Paint(paint_context());
133127
EXPECT_EQ(mock_canvas().draw_calls(),
134128
std::vector({
135-
MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
136-
MockCanvas::DrawCall{1, MockCanvas::SetMatrixData{SkMatrix()}},
137129
MockCanvas::DrawCall{
138-
1, MockCanvas::SaveLayerData{child_bounds, filter_paint,
139-
nullptr, 2}},
130+
0, MockCanvas::SaveLayerData{child_bounds, filter_paint,
131+
nullptr, 1}},
140132
MockCanvas::DrawCall{
141-
2, MockCanvas::DrawPathData{child_path, child_paint}},
142-
MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
133+
1, MockCanvas::DrawPathData{child_path, child_paint}},
143134
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}},
144135
}));
145136
}
@@ -177,19 +168,16 @@ TEST_F(ImageFilterLayerTest, MultipleChildren) {
177168
SkPaint filter_paint;
178169
filter_paint.setImageFilter(layer_filter);
179170
layer->Paint(paint_context());
180-
EXPECT_EQ(mock_canvas().draw_calls(),
181-
std::vector(
182-
{MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
183-
MockCanvas::DrawCall{1, MockCanvas::SetMatrixData{SkMatrix()}},
184-
MockCanvas::DrawCall{
185-
1, MockCanvas::SaveLayerData{children_bounds, filter_paint,
186-
nullptr, 2}},
187-
MockCanvas::DrawCall{
188-
2, MockCanvas::DrawPathData{child_path1, child_paint1}},
189-
MockCanvas::DrawCall{
190-
2, MockCanvas::DrawPathData{child_path2, child_paint2}},
191-
MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
192-
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
171+
EXPECT_EQ(
172+
mock_canvas().draw_calls(),
173+
std::vector({MockCanvas::DrawCall{
174+
0, MockCanvas::SaveLayerData{children_bounds,
175+
filter_paint, nullptr, 1}},
176+
MockCanvas::DrawCall{
177+
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
178+
MockCanvas::DrawCall{
179+
1, MockCanvas::DrawPathData{child_path2, child_paint2}},
180+
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
193181
}
194182

195183
TEST_F(ImageFilterLayerTest, Nested) {
@@ -237,22 +225,16 @@ TEST_F(ImageFilterLayerTest, Nested) {
237225
layer1->Paint(paint_context());
238226
EXPECT_EQ(mock_canvas().draw_calls(),
239227
std::vector({
240-
MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
241-
MockCanvas::DrawCall{1, MockCanvas::SetMatrixData{SkMatrix()}},
242228
MockCanvas::DrawCall{
243-
1, MockCanvas::SaveLayerData{children_bounds, filter_paint1,
244-
nullptr, 2}},
229+
0, MockCanvas::SaveLayerData{children_bounds, filter_paint1,
230+
nullptr, 1}},
245231
MockCanvas::DrawCall{
246-
2, MockCanvas::DrawPathData{child_path1, child_paint1}},
247-
MockCanvas::DrawCall{2, MockCanvas::SaveData{3}},
248-
MockCanvas::DrawCall{3, MockCanvas::SetMatrixData{SkMatrix()}},
232+
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
249233
MockCanvas::DrawCall{
250-
3, MockCanvas::SaveLayerData{child_path2.getBounds(),
251-
filter_paint2, nullptr, 4}},
234+
1, MockCanvas::SaveLayerData{child_path2.getBounds(),
235+
filter_paint2, nullptr, 2}},
252236
MockCanvas::DrawCall{
253-
4, MockCanvas::DrawPathData{child_path2, child_paint2}},
254-
MockCanvas::DrawCall{4, MockCanvas::RestoreData{3}},
255-
MockCanvas::DrawCall{3, MockCanvas::RestoreData{2}},
237+
2, MockCanvas::DrawPathData{child_path2, child_paint2}},
256238
MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
257239
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}},
258240
}));

‎flow/layers/opacity_layer.cc‎

Lines changed: 9 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,10 @@ void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
3535
SkMatrix child_matrix = matrix;
3636
child_matrix.postTranslate(offset_.fX, offset_.fY);
3737

38+
// Similar to what's done in TransformLayer::Preroll, we have to apply the
39+
// reverse transformation to the cull rect to properly cull child layers.
40+
context->cull_rect = context->cull_rect.makeOffset(-offset_.fX, -offset_.fY);
41+
3842
context->is_opaque = parent_is_opaque && (alpha_ == SK_AlphaOPAQUE);
3943
context->mutators_stack.PushTransform(
4044
SkMatrix::MakeTrans(offset_.fX, offset_.fY));
@@ -48,15 +52,11 @@ void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
4852

4953
{
5054
set_paint_bounds(paint_bounds().makeOffset(offset_.fX, offset_.fY));
51-
if (!context->has_platform_view && context->raster_cache &&
52-
SkRect::Intersects(context->cull_rect, paint_bounds())) {
53-
SkMatrix ctm = child_matrix;
54-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
55-
ctm = RasterCache::GetIntegralTransCTM(ctm);
56-
#endif
57-
context->raster_cache->Prepare(context, container, ctm);
58-
}
55+
TryToPrepareRasterCache(context, container, child_matrix);
5956
}
57+
58+
// Restore cull_rect
59+
context->cull_rect = context->cull_rect.makeOffset(offset_.fX, offset_.fY);
6060
}
6161

6262
void OpacityLayer::Paint(PaintContext& context) const {
@@ -69,11 +69,6 @@ void OpacityLayer::Paint(PaintContext& context) const {
6969
SkAutoCanvasRestore save(context.internal_nodes_canvas, true);
7070
context.internal_nodes_canvas->translate(offset_.fX, offset_.fY);
7171

72-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
73-
context.internal_nodes_canvas->setMatrix(RasterCache::GetIntegralTransCTM(
74-
context.leaf_nodes_canvas->getTotalMatrix()));
75-
#endif
76-
7772
if (context.raster_cache &&
7873
context.raster_cache->Draw(GetChildContainer(),
7974
*context.leaf_nodes_canvas, &paint)) {
@@ -83,8 +78,7 @@ void OpacityLayer::Paint(PaintContext& context) const {
8378
// Skia may clip the content with saveLayerBounds (although it's not a
8479
// guaranteed clip). So we have to provide a big enough saveLayerBounds. To do
8580
// so, we first remove the offset from paint bounds since it's already in the
86-
// matrix. Then we round out the bounds because of our
87-
// RasterCache::GetIntegralTransCTM optimization.
81+
// matrix. Then we round out the bounds.
8882
//
8983
// Note that the following lines are only accessible when the raster cache is
9084
// not available (e.g., when we're using the software backend in golden

‎flow/layers/opacity_layer_unittests.cc‎

Lines changed: 14 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
// Use of this source code is governed by a BSD-style license that can be
33
// found in the LICENSE file.
44

5+
#include "flutter/flow/layers/clip_rect_layer.h"
56
#include "flutter/flow/layers/opacity_layer.h"
67

78
#include "flutter/flow/testing/layer_test.h"
@@ -58,10 +59,6 @@ TEST_F(OpacityLayerTest, FullyOpaque) {
5859
const SkMatrix initial_transform = SkMatrix::MakeTrans(0.5f, 0.5f);
5960
const SkMatrix layer_transform =
6061
SkMatrix::MakeTrans(layer_offset.fX, layer_offset.fY);
61-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
62-
const SkMatrix integral_layer_transform = RasterCache::GetIntegralTransCTM(
63-
SkMatrix::Concat(initial_transform, layer_transform));
64-
#endif
6562
const SkPaint child_paint = SkPaint(SkColors::kGreen);
6663
const SkRect expected_layer_bounds =
6764
layer_transform.mapRect(child_path.getBounds());
@@ -86,10 +83,6 @@ TEST_F(OpacityLayerTest, FullyOpaque) {
8683
auto expected_draw_calls = std::vector(
8784
{MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
8885
MockCanvas::DrawCall{1, MockCanvas::ConcatMatrixData{layer_transform}},
89-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
90-
MockCanvas::DrawCall{
91-
1, MockCanvas::SetMatrixData{integral_layer_transform}},
92-
#endif
9386
MockCanvas::DrawCall{
9487
1, MockCanvas::SaveLayerData{opacity_bounds, opacity_paint, nullptr,
9588
2}},
@@ -107,10 +100,6 @@ TEST_F(OpacityLayerTest, FullyTransparent) {
107100
const SkMatrix initial_transform = SkMatrix::MakeTrans(0.5f, 0.5f);
108101
const SkMatrix layer_transform =
109102
SkMatrix::MakeTrans(layer_offset.fX, layer_offset.fY);
110-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
111-
const SkMatrix integral_layer_transform = RasterCache::GetIntegralTransCTM(
112-
SkMatrix::Concat(initial_transform, layer_transform));
113-
#endif
114103
const SkPaint child_paint = SkPaint(SkColors::kGreen);
115104
const SkRect expected_layer_bounds =
116105
layer_transform.mapRect(child_path.getBounds());
@@ -133,10 +122,6 @@ TEST_F(OpacityLayerTest, FullyTransparent) {
133122
auto expected_draw_calls = std::vector(
134123
{MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
135124
MockCanvas::DrawCall{1, MockCanvas::ConcatMatrixData{layer_transform}},
136-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
137-
MockCanvas::DrawCall{
138-
1, MockCanvas::SetMatrixData{integral_layer_transform}},
139-
#endif
140125
MockCanvas::DrawCall{1, MockCanvas::SaveData{2}},
141126
MockCanvas::DrawCall{
142127
2, MockCanvas::ClipRectData{kEmptyRect, SkClipOp::kIntersect,
@@ -155,10 +140,6 @@ TEST_F(OpacityLayerTest, HalfTransparent) {
155140
const SkMatrix initial_transform = SkMatrix::MakeTrans(0.5f, 0.5f);
156141
const SkMatrix layer_transform =
157142
SkMatrix::MakeTrans(layer_offset.fX, layer_offset.fY);
158-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
159-
const SkMatrix integral_layer_transform = RasterCache::GetIntegralTransCTM(
160-
SkMatrix::Concat(initial_transform, layer_transform));
161-
#endif
162143
const SkPaint child_paint = SkPaint(SkColors::kGreen);
163144
const SkRect expected_layer_bounds =
164145
layer_transform.mapRect(child_path.getBounds());
@@ -185,10 +166,6 @@ TEST_F(OpacityLayerTest, HalfTransparent) {
185166
auto expected_draw_calls = std::vector(
186167
{MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
187168
MockCanvas::DrawCall{1, MockCanvas::ConcatMatrixData{layer_transform}},
188-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
189-
MockCanvas::DrawCall{
190-
1, MockCanvas::SetMatrixData{integral_layer_transform}},
191-
#endif
192169
MockCanvas::DrawCall{
193170
1, MockCanvas::SaveLayerData{opacity_bounds, opacity_paint, nullptr,
194171
2}},
@@ -211,13 +188,6 @@ TEST_F(OpacityLayerTest, Nested) {
211188
SkMatrix::MakeTrans(layer1_offset.fX, layer1_offset.fY);
212189
const SkMatrix layer2_transform =
213190
SkMatrix::MakeTrans(layer2_offset.fX, layer2_offset.fY);
214-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
215-
const SkMatrix integral_layer1_transform = RasterCache::GetIntegralTransCTM(
216-
SkMatrix::Concat(initial_transform, layer1_transform));
217-
const SkMatrix integral_layer2_transform = RasterCache::GetIntegralTransCTM(
218-
SkMatrix::Concat(SkMatrix::Concat(initial_transform, layer1_transform),
219-
layer2_transform));
220-
#endif
221191
const SkPaint child1_paint = SkPaint(SkColors::kRed);
222192
const SkPaint child2_paint = SkPaint(SkColors::kBlue);
223193
const SkPaint child3_paint = SkPaint(SkColors::kGreen);
@@ -278,21 +248,13 @@ TEST_F(OpacityLayerTest, Nested) {
278248
auto expected_draw_calls = std::vector(
279249
{MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
280250
MockCanvas::DrawCall{1, MockCanvas::ConcatMatrixData{layer1_transform}},
281-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
282-
MockCanvas::DrawCall{
283-
1, MockCanvas::SetMatrixData{integral_layer1_transform}},
284-
#endif
285251
MockCanvas::DrawCall{
286252
1, MockCanvas::SaveLayerData{opacity1_bounds, opacity1_paint,
287253
nullptr, 2}},
288254
MockCanvas::DrawCall{
289255
2, MockCanvas::DrawPathData{child1_path, child1_paint}},
290256
MockCanvas::DrawCall{2, MockCanvas::SaveData{3}},
291257
MockCanvas::DrawCall{3, MockCanvas::ConcatMatrixData{layer2_transform}},
292-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
293-
MockCanvas::DrawCall{
294-
3, MockCanvas::SetMatrixData{integral_layer2_transform}},
295-
#endif
296258
MockCanvas::DrawCall{
297259
3, MockCanvas::SaveLayerData{opacity2_bounds, opacity2_paint,
298260
nullptr, 4}},
@@ -327,5 +289,18 @@ TEST_F(OpacityLayerTest, Readback) {
327289
EXPECT_FALSE(preroll_context()->surface_needs_readback);
328290
}
329291

292+
TEST_F(OpacityLayerTest, CullRectIsTransformed) {
293+
auto clipRectLayer = std::make_shared<ClipRectLayer>(
294+
SkRect::MakeLTRB(0, 0, 10, 10), flutter::hardEdge);
295+
auto opacityLayer =
296+
std::make_shared<OpacityLayer>(128, SkPoint::Make(20, 20));
297+
auto mockLayer = std::make_shared<MockLayer>(SkPath());
298+
clipRectLayer->Add(opacityLayer);
299+
opacityLayer->Add(mockLayer);
300+
clipRectLayer->Preroll(preroll_context(), SkMatrix::I());
301+
EXPECT_EQ(mockLayer->parent_cull_rect().fLeft, -20);
302+
EXPECT_EQ(mockLayer->parent_cull_rect().fTop, -20);
303+
}
304+
330305
} // namespace testing
331306
} // namespace flutter

‎flow/raster_cache.h‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -62,7 +62,21 @@ class RasterCache {
6262
return bounds;
6363
}
6464

65+
/**
66+
* @brief Snap the translation components of the matrix to integers.
67+
*
68+
* The snapping will only happen if the matrix only has scale and translation
69+
* transformations.
70+
*
71+
* @param ctm the current transformation matrix.
72+
* @return SkMatrix the snapped transformation matrix.
73+
*/
6574
static SkMatrix GetIntegralTransCTM(const SkMatrix& ctm) {
75+
// Avoid integral snapping if the matrix has complex transformation to avoid
76+
// the artifact observed in https://github.com/flutter/flutter/issues/41654.
77+
if (!ctm.isScaleTranslate()) {
78+
return ctm;
79+
}
6680
SkMatrix result = ctm;
6781
result[SkMatrix::kMTransX] = SkScalarRoundToScalar(ctm.getTranslateX());
6882
result[SkMatrix::kMTransY] = SkScalarRoundToScalar(ctm.getTranslateY());

‎flow/raster_cache_key.h‎

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -15,11 +15,8 @@ template <typename ID>
1515
class RasterCacheKey {
1616
public:
1717
RasterCacheKey(ID id, const SkMatrix& ctm) : id_(id), matrix_(ctm) {
18-
matrix_[SkMatrix::kMTransX] = SkScalarFraction(ctm.getTranslateX());
19-
matrix_[SkMatrix::kMTransY] = SkScalarFraction(ctm.getTranslateY());
20-
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
21-
FML_DCHECK(matrix_.getTranslateX() == 0 && matrix_.getTranslateY() == 0);
22-
#endif
18+
matrix_[SkMatrix::kMTransX] = 0;
19+
matrix_[SkMatrix::kMTransY] = 0;
2320
}
2421

2522
ID id() const { return id_; }

0 commit comments

Comments
 (0)