| // Copyright 2013 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "flutter/flow/display_list_canvas.h" |
| #include "flutter/flow/layers/physical_shape_layer.h" |
| |
| #include "third_party/skia/include/core/SkColor.h" |
| #include "third_party/skia/include/core/SkImageInfo.h" |
| #include "third_party/skia/include/core/SkPath.h" |
| #include "third_party/skia/include/core/SkPictureRecorder.h" |
| #include "third_party/skia/include/core/SkRRect.h" |
| #include "third_party/skia/include/core/SkRSXform.h" |
| #include "third_party/skia/include/core/SkSurface.h" |
| #include "third_party/skia/include/core/SkTextBlob.h" |
| #include "third_party/skia/include/core/SkVertices.h" |
| #include "third_party/skia/include/effects/SkBlenders.h" |
| #include "third_party/skia/include/effects/SkDashPathEffect.h" |
| #include "third_party/skia/include/effects/SkDiscretePathEffect.h" |
| #include "third_party/skia/include/effects/SkGradientShader.h" |
| #include "third_party/skia/include/effects/SkImageFilters.h" |
| |
| #include <cmath> |
| |
| #include "gtest/gtest.h" |
| |
| namespace flutter { |
| namespace testing { |
| |
| constexpr int TestWidth = 200; |
| constexpr int TestHeight = 200; |
| constexpr int RenderWidth = 100; |
| constexpr int RenderHeight = 100; |
| constexpr int RenderLeft = (TestWidth - RenderWidth) / 2; |
| constexpr int RenderTop = (TestHeight - RenderHeight) / 2; |
| constexpr int RenderRight = RenderLeft + RenderWidth; |
| constexpr int RenderBottom = RenderTop + RenderHeight; |
| constexpr int RenderCenterX = (RenderLeft + RenderRight) / 2; |
| constexpr int RenderCenterY = (RenderTop + RenderBottom) / 2; |
| constexpr SkScalar RenderRadius = std::min(RenderWidth, RenderHeight) / 2.0; |
| constexpr SkScalar RenderCornerRadius = RenderRadius / 5.0; |
| |
| constexpr SkPoint TestCenter = SkPoint::Make(TestWidth / 2, TestHeight / 2); |
| constexpr SkRect TestBounds = SkRect::MakeWH(TestWidth, TestHeight); |
| constexpr SkRect RenderBounds = |
| SkRect::MakeLTRB(RenderLeft, RenderTop, RenderRight, RenderBottom); |
| |
| class CanvasCompareTester { |
| private: |
| // If a test is using any shadow operations then we cannot currently |
| // record those in an SkCanvas and play it back into a DisplayList |
| // because internally the operation gets encapsulated in a Skia |
| // ShadowRec which is not exposed by their headers. For operations |
| // that use shadows, we can perform a lot of tests, but not the tests |
| // that require SkCanvas->DisplayList transfers. |
| // See: https://bugs.chromium.org/p/skia/issues/detail?id=12125 |
| static bool TestingDrawShadows; |
| // The CPU renders nothing for drawVertices with a Blender. |
| // See: https://bugs.chromium.org/p/skia/issues/detail?id=12200 |
| static bool TestingDrawVertices; |
| // The CPU renders nothing for drawAtlas with a Blender. |
| // See: https://bugs.chromium.org/p/skia/issues/detail?id=12199 |
| static bool TestingDrawAtlas; |
| |
| public: |
| typedef const std::function<void(SkCanvas*, SkPaint&)> CvRenderer; |
| typedef const std::function<void(DisplayListBuilder&)> DlRenderer; |
| |
| // All of the tests should eventually use this method except for the |
| // tests that call |RenderNoAttributes| because they do not use the |
| // SkPaint object. |
| // But there are a couple of conditions beyond our control which require |
| // the use of one of the variant methods below (|RenderShadows|, |
| // |RenderVertices|, |RenderAtlas|). |
| static void RenderAll(CvRenderer& cv_renderer, DlRenderer& dl_renderer) { |
| RenderWithAttributes(cv_renderer, dl_renderer); |
| RenderWithTransforms(cv_renderer, dl_renderer); |
| RenderWithClips(cv_renderer, dl_renderer); |
| } |
| |
| // Used by the tests that render shadows to deal with a condition where |
| // we cannot recapture the shadow information from an SkCanvas stream |
| // due to the DrawShadowRec used by Skia is not properly exported. |
| // See: https://bugs.chromium.org/p/skia/issues/detail?id=12125 |
| static void RenderShadows(CvRenderer& cv_renderer, DlRenderer& dl_renderer) { |
| TestingDrawShadows = true; |
| RenderNoAttributes(cv_renderer, dl_renderer); |
| TestingDrawShadows = false; |
| } |
| |
| // Used by the tests that call drawVertices to avoid using an SkBlender |
| // during testing because the CPU renderer appears not to render anything. |
| // See: https://bugs.chromium.org/p/skia/issues/detail?id=12200 |
| static void RenderVertices(CvRenderer& cv_renderer, DlRenderer& dl_renderer) { |
| TestingDrawVertices = true; |
| RenderAll(cv_renderer, dl_renderer); |
| TestingDrawVertices = false; |
| } |
| |
| // Used by the tests that call drawAtlas to avoid using an SkBlender |
| // during testing because the CPU renderer appears not to render anything. |
| // See: https://bugs.chromium.org/p/skia/issues/detail?id=12199 |
| static void RenderAtlas(CvRenderer& cv_renderer, DlRenderer& dl_renderer) { |
| TestingDrawAtlas = true; |
| RenderAll(cv_renderer, dl_renderer); |
| TestingDrawAtlas = false; |
| } |
| |
| // Used by the tests that call a draw method that does not take a paint |
| // call. Those tests could use |RenderAll| but there would be a lot of |
| // wasted test runs that prepare an SkPaint that is never used. |
| static void RenderNoAttributes(CvRenderer& cv_renderer, |
| DlRenderer& dl_renderer) { |
| RenderWith([=](SkCanvas*, SkPaint& p) {}, // |
| [=](DisplayListBuilder& d) {}, // |
| cv_renderer, dl_renderer, "Base Test"); |
| RenderWithTransforms(cv_renderer, dl_renderer); |
| RenderWithClips(cv_renderer, dl_renderer); |
| } |
| |
| static void RenderWithSaveRestore(CvRenderer& cv_renderer, |
| DlRenderer& dl_renderer) { |
| SkRect clip = SkRect::MakeLTRB(0, 0, 10, 10); |
| SkRect rect = SkRect::MakeLTRB(5, 5, 15, 15); |
| SkColor save_layer_color = SkColorSetARGB(0x7f, 0x00, 0xff, 0xff); |
| RenderWith( |
| [=](SkCanvas* cv, SkPaint& p) { |
| cv->save(); |
| cv->clipRect(clip, SkClipOp::kIntersect, false); |
| cv->drawRect(rect, p); |
| cv->restore(); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.save(); |
| b.clipRect(clip, false, SkClipOp::kIntersect); |
| b.drawRect(rect); |
| b.restore(); |
| }, |
| cv_renderer, dl_renderer, "With prior save/clip/restore"); |
| RenderWith( |
| [=](SkCanvas* cv, SkPaint& p) { |
| SkPaint save_p; |
| save_p.setColor(save_layer_color); |
| cv->saveLayer(RenderBounds, &save_p); |
| cv->drawRect(rect, p); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setColor(save_layer_color); |
| b.saveLayer(&RenderBounds, true); |
| b.setColor(SkPaint().getColor()); |
| b.drawRect(rect); |
| }, |
| cv_renderer, dl_renderer, "With saveLayer"); |
| } |
| |
| static void RenderWithAttributes(CvRenderer& cv_renderer, |
| DlRenderer& dl_renderer) { |
| RenderWith([=](SkCanvas*, SkPaint& p) {}, // |
| [=](DisplayListBuilder& d) {}, // |
| cv_renderer, dl_renderer, "Base Test"); |
| |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setAntiAlias(true); }, // |
| [=](DisplayListBuilder& b) { b.setAA(true); }, // |
| cv_renderer, dl_renderer, "AA == True"); |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setAntiAlias(false); }, // |
| [=](DisplayListBuilder& b) { b.setAA(false); }, // |
| cv_renderer, dl_renderer, "AA == False"); |
| |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setDither(true); }, // |
| [=](DisplayListBuilder& b) { b.setDither(true); }, // |
| cv_renderer, dl_renderer, "Dither == True"); |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setDither(false); }, // |
| [=](DisplayListBuilder& b) { b.setDither(false); }, // |
| cv_renderer, dl_renderer, "Dither = False"); |
| |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setColor(SK_ColorBLUE); }, // |
| [=](DisplayListBuilder& b) { b.setColor(SK_ColorBLUE); }, // |
| cv_renderer, dl_renderer, "Color == Blue"); |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setColor(SK_ColorGREEN); }, // |
| [=](DisplayListBuilder& b) { b.setColor(SK_ColorGREEN); }, // |
| cv_renderer, dl_renderer, "Color == Green"); |
| |
| RenderWithStrokes(cv_renderer, dl_renderer); |
| |
| { |
| // half opaque cyan |
| SkColor blendableColor = SkColorSetARGB(0x7f, 0x00, 0xff, 0xff); |
| SkColor bg = SK_ColorWHITE; |
| |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setBlendMode(SkBlendMode::kSrcIn); |
| p.setColor(blendableColor); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setBlendMode(SkBlendMode::kSrcIn); |
| b.setColor(blendableColor); |
| }, |
| cv_renderer, dl_renderer, "Blend == SrcIn", &bg); |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setBlendMode(SkBlendMode::kDstIn); |
| p.setColor(blendableColor); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setBlendMode(SkBlendMode::kDstIn); |
| b.setColor(blendableColor); |
| }, |
| cv_renderer, dl_renderer, "Blend == DstIn", &bg); |
| } |
| |
| if (!(TestingDrawAtlas || TestingDrawVertices)) { |
| sk_sp<SkBlender> blender = |
| SkBlenders::Arithmetic(0.25, 0.25, 0.25, 0.25, false); |
| { |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setBlender(blender); }, |
| [=](DisplayListBuilder& b) { b.setBlender(blender); }, |
| cv_renderer, dl_renderer, |
| "ImageFilter == Blender Arithmetic 0.25-false"); |
| } |
| ASSERT_TRUE(blender->unique()) << "Blender Cleanup"; |
| blender = SkBlenders::Arithmetic(0.25, 0.25, 0.25, 0.25, true); |
| { |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setBlender(blender); }, |
| [=](DisplayListBuilder& b) { b.setBlender(blender); }, |
| cv_renderer, dl_renderer, |
| "ImageFilter == Blender Arithmetic 0.25-true"); |
| } |
| ASSERT_TRUE(blender->unique()) << "Blender Cleanup"; |
| } |
| |
| { |
| sk_sp<SkImageFilter> filter = |
| SkImageFilters::Blur(5.0, 5.0, SkTileMode::kDecal, nullptr, nullptr); |
| { |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setImageFilter(filter); }, |
| [=](DisplayListBuilder& b) { b.setImageFilter(filter); }, |
| cv_renderer, dl_renderer, "ImageFilter == Decal Blur 5"); |
| } |
| ASSERT_TRUE(filter->unique()) << "ImageFilter Cleanup"; |
| filter = |
| SkImageFilters::Blur(5.0, 5.0, SkTileMode::kClamp, nullptr, nullptr); |
| { |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setImageFilter(filter); }, |
| [=](DisplayListBuilder& b) { b.setImageFilter(filter); }, |
| cv_renderer, dl_renderer, "ImageFilter == Clamp Blur 5"); |
| } |
| ASSERT_TRUE(filter->unique()) << "ImageFilter Cleanup"; |
| } |
| |
| { |
| // clang-format off |
| constexpr float rotate_color_matrix[20] = { |
| 0, 1, 0, 0, 0, |
| 0, 0, 1, 0, 0, |
| 1, 0, 0, 0, 0, |
| 0, 0, 0, 1, 0, |
| }; |
| constexpr float invert_color_matrix[20] = { |
| -1.0, 0, 0, 1.0, 0, |
| 0, -1.0, 0, 1.0, 0, |
| 0, 0, -1.0, 1.0, 0, |
| 1.0, 1.0, 1.0, 1.0, 0, |
| }; |
| // clang-format on |
| sk_sp<SkColorFilter> filter = SkColorFilters::Matrix(rotate_color_matrix); |
| { |
| SkColor bg = SK_ColorWHITE; |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setColor(SK_ColorYELLOW); |
| p.setColorFilter(filter); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setColor(SK_ColorYELLOW); |
| b.setColorFilter(filter); |
| }, |
| cv_renderer, dl_renderer, "ColorFilter == RotateRGB", &bg); |
| } |
| ASSERT_TRUE(filter->unique()) << "ColorFilter Cleanup"; |
| filter = SkColorFilters::Matrix(invert_color_matrix); |
| { |
| SkColor bg = SK_ColorWHITE; |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setColor(SK_ColorYELLOW); |
| p.setColorFilter(filter); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setColor(SK_ColorYELLOW); |
| b.setInvertColors(true); |
| }, |
| cv_renderer, dl_renderer, "ColorFilter == Invert", &bg); |
| } |
| ASSERT_TRUE(filter->unique()) << "ColorFilter Cleanup"; |
| } |
| |
| { |
| // Discrete path effects need a stroke width for drawPointsAsPoints |
| // to do something realistic |
| sk_sp<SkPathEffect> effect = SkDiscretePathEffect::Make(3, 5); |
| { |
| // Discrete path effects need a stroke width for drawPointsAsPoints |
| // to do something realistic |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStrokeWidth(5.0); |
| p.setPathEffect(effect); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setStrokeWidth(5.0); |
| b.setPathEffect(effect); |
| }, |
| cv_renderer, dl_renderer, "PathEffect == Discrete-3-5"); |
| } |
| ASSERT_TRUE(effect->unique()) << "PathEffect Cleanup"; |
| effect = SkDiscretePathEffect::Make(2, 3); |
| { |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStrokeWidth(5.0); |
| p.setPathEffect(effect); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setStrokeWidth(5.0); |
| b.setPathEffect(effect); |
| }, |
| cv_renderer, dl_renderer, "PathEffect == Discrete-2-3"); |
| } |
| ASSERT_TRUE(effect->unique()) << "PathEffect Cleanup"; |
| } |
| |
| { |
| sk_sp<SkMaskFilter> filter = |
| SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 5.0); |
| { |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setMaskFilter(filter); }, |
| [=](DisplayListBuilder& b) { b.setMaskFilter(filter); }, |
| cv_renderer, dl_renderer, "MaskFilter == Blur 5"); |
| } |
| ASSERT_TRUE(filter->unique()) << "MaskFilter Cleanup"; |
| { |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setMaskFilter(filter); }, |
| [=](DisplayListBuilder& b) { |
| b.setMaskBlurFilter(kNormal_SkBlurStyle, 5.0); |
| }, |
| cv_renderer, dl_renderer, "MaskFilter == Blur(Normal, 5.0)"); |
| } |
| ASSERT_TRUE(filter->unique()) << "MaskFilter Cleanup"; |
| } |
| |
| { |
| SkPoint end_points[] = { |
| SkPoint::Make(RenderBounds.fLeft, RenderBounds.fTop), |
| SkPoint::Make(RenderBounds.fRight, RenderBounds.fBottom), |
| }; |
| SkColor colors[] = { |
| SK_ColorGREEN, |
| SK_ColorYELLOW, |
| SK_ColorBLUE, |
| }; |
| float stops[] = { |
| 0.0, |
| 0.5, |
| 1.0, |
| }; |
| sk_sp<SkShader> shader = SkGradientShader::MakeLinear( |
| end_points, colors, stops, 3, SkTileMode::kMirror, 0, nullptr); |
| { |
| RenderWith([=](SkCanvas*, SkPaint& p) { p.setShader(shader); }, |
| [=](DisplayListBuilder& b) { b.setShader(shader); }, |
| cv_renderer, dl_renderer, "LinearGradient GYB"); |
| } |
| ASSERT_TRUE(shader->unique()) << "Shader Cleanup"; |
| } |
| } |
| |
| static void RenderWithStrokes(CvRenderer& cv_renderer, |
| DlRenderer& dl_renderer) { |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { p.setStyle(SkPaint::kFill_Style); }, |
| [=](DisplayListBuilder& b) { b.setDrawStyle(SkPaint::kFill_Style); }, |
| cv_renderer, dl_renderer, "Fill"); |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { p.setStyle(SkPaint::kStroke_Style); }, |
| [=](DisplayListBuilder& b) { b.setDrawStyle(SkPaint::kStroke_Style); }, |
| cv_renderer, dl_renderer, "Stroke + defaults"); |
| |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStyle(SkPaint::kFill_Style); |
| p.setStrokeWidth(10.0); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setDrawStyle(SkPaint::kFill_Style); |
| b.setStrokeWidth(10.0); |
| }, |
| cv_renderer, dl_renderer, "Fill + unnecessary StrokeWidth 10"); |
| |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStyle(SkPaint::kStroke_Style); |
| p.setStrokeWidth(10.0); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setDrawStyle(SkPaint::kStroke_Style); |
| b.setStrokeWidth(10.0); |
| }, |
| cv_renderer, dl_renderer, "Stroke Width 10"); |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStyle(SkPaint::kStroke_Style); |
| p.setStrokeWidth(5.0); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setDrawStyle(SkPaint::kStroke_Style); |
| b.setStrokeWidth(5.0); |
| }, |
| cv_renderer, dl_renderer, "Stroke Width 5"); |
| |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStyle(SkPaint::kStroke_Style); |
| p.setStrokeWidth(5.0); |
| p.setStrokeCap(SkPaint::kButt_Cap); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setDrawStyle(SkPaint::kStroke_Style); |
| b.setStrokeWidth(5.0); |
| b.setCaps(SkPaint::kButt_Cap); |
| }, |
| cv_renderer, dl_renderer, "Stroke Width 5, Butt Cap"); |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStyle(SkPaint::kStroke_Style); |
| p.setStrokeWidth(5.0); |
| p.setStrokeCap(SkPaint::kRound_Cap); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setDrawStyle(SkPaint::kStroke_Style); |
| b.setStrokeWidth(5.0); |
| b.setCaps(SkPaint::kRound_Cap); |
| }, |
| cv_renderer, dl_renderer, "Stroke Width 5, Round Cap"); |
| |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStyle(SkPaint::kStroke_Style); |
| p.setStrokeWidth(5.0); |
| p.setStrokeJoin(SkPaint::kBevel_Join); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setDrawStyle(SkPaint::kStroke_Style); |
| b.setStrokeWidth(5.0); |
| b.setJoins(SkPaint::kBevel_Join); |
| }, |
| cv_renderer, dl_renderer, "Stroke Width 5, Bevel Join"); |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStyle(SkPaint::kStroke_Style); |
| p.setStrokeWidth(5.0); |
| p.setStrokeJoin(SkPaint::kRound_Join); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setDrawStyle(SkPaint::kStroke_Style); |
| b.setStrokeWidth(5.0); |
| b.setJoins(SkPaint::kRound_Join); |
| }, |
| cv_renderer, dl_renderer, "Stroke Width 5, Round Join"); |
| |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStyle(SkPaint::kStroke_Style); |
| p.setStrokeWidth(5.0); |
| p.setStrokeMiter(100.0); |
| p.setStrokeJoin(SkPaint::kMiter_Join); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setDrawStyle(SkPaint::kStroke_Style); |
| b.setStrokeWidth(5.0); |
| b.setMiterLimit(100.0); |
| b.setJoins(SkPaint::kMiter_Join); |
| }, |
| cv_renderer, dl_renderer, "Stroke Width 5, Miter 100"); |
| |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStyle(SkPaint::kStroke_Style); |
| p.setStrokeWidth(5.0); |
| p.setStrokeMiter(0.0); |
| p.setStrokeJoin(SkPaint::kMiter_Join); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setDrawStyle(SkPaint::kStroke_Style); |
| b.setStrokeWidth(5.0); |
| b.setMiterLimit(0.0); |
| b.setJoins(SkPaint::kMiter_Join); |
| }, |
| cv_renderer, dl_renderer, "Stroke Width 5, Miter 0"); |
| |
| { |
| const SkScalar TestDashes1[] = {4.0, 2.0}; |
| const SkScalar TestDashes2[] = {1.0, 1.5}; |
| sk_sp<SkPathEffect> effect = SkDashPathEffect::Make(TestDashes1, 2, 0.0f); |
| { |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStyle(SkPaint::kStroke_Style); |
| p.setStrokeWidth(5.0); |
| p.setPathEffect(effect); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setDrawStyle(SkPaint::kStroke_Style); |
| b.setStrokeWidth(5.0); |
| b.setPathEffect(effect); |
| }, |
| cv_renderer, dl_renderer, "PathEffect == Dash-4-2"); |
| } |
| ASSERT_TRUE(effect->unique()) << "PathEffect Cleanup"; |
| effect = SkDashPathEffect::Make(TestDashes2, 2, 0.0f); |
| { |
| RenderWith( |
| [=](SkCanvas*, SkPaint& p) { |
| p.setStyle(SkPaint::kStroke_Style); |
| p.setStrokeWidth(5.0); |
| p.setPathEffect(effect); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.setDrawStyle(SkPaint::kStroke_Style); |
| b.setStrokeWidth(5.0); |
| b.setPathEffect(effect); |
| }, |
| cv_renderer, dl_renderer, "PathEffect == Dash-1-1.5"); |
| } |
| ASSERT_TRUE(effect->unique()) << "PathEffect Cleanup"; |
| } |
| } |
| |
| static void RenderWithTransforms(CvRenderer& cv_renderer, |
| DlRenderer& dl_renderer) { |
| RenderWith([=](SkCanvas* c, SkPaint&) { c->translate(5, 10); }, // |
| [=](DisplayListBuilder& b) { b.translate(5, 10); }, // |
| cv_renderer, dl_renderer, "Translate 5, 10"); |
| RenderWith([=](SkCanvas* c, SkPaint&) { c->scale(1.05, 1.05); }, // |
| [=](DisplayListBuilder& b) { b.scale(1.05, 1.05); }, // |
| cv_renderer, dl_renderer, "Scale +5%"); |
| RenderWith([=](SkCanvas* c, SkPaint&) { c->rotate(5); }, // |
| [=](DisplayListBuilder& b) { b.rotate(5); }, // |
| cv_renderer, dl_renderer, "Rotate 5 degrees"); |
| RenderWith([=](SkCanvas* c, SkPaint&) { c->skew(0.05, 0.05); }, // |
| [=](DisplayListBuilder& b) { b.skew(0.05, 0.05); }, // |
| cv_renderer, dl_renderer, "Skew 5%"); |
| { |
| SkMatrix tx = SkMatrix::MakeAll(1.1, 0.1, 1.05, 0.05, 1, 1, 0, 0, 1); |
| RenderWith([=](SkCanvas* c, SkPaint&) { c->concat(tx); }, // |
| [=](DisplayListBuilder& b) { |
| b.transform2x3(tx[0], tx[1], tx[2], // |
| tx[3], tx[4], tx[5]); |
| }, // |
| cv_renderer, dl_renderer, "Transform 2x3"); |
| } |
| { |
| SkMatrix tx = SkMatrix::MakeAll(1.1, 0.1, 1.05, 0.05, 1, 1, 0, 0, 1.01); |
| RenderWith([=](SkCanvas* c, SkPaint&) { c->concat(tx); }, // |
| [=](DisplayListBuilder& b) { |
| b.transform3x3(tx[0], tx[1], tx[2], // |
| tx[3], tx[4], tx[5], // |
| tx[6], tx[7], tx[8]); |
| }, // |
| cv_renderer, dl_renderer, "Transform 3x3"); |
| } |
| } |
| |
| static void RenderWithClips(CvRenderer& cv_renderer, |
| DlRenderer& dl_renderer) { |
| SkRect r_clip = RenderBounds.makeInset(15.5, 15.5); |
| RenderWith( |
| [=](SkCanvas* c, SkPaint&) { |
| c->clipRect(r_clip, SkClipOp::kIntersect, false); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.clipRect(r_clip, false, SkClipOp::kIntersect); |
| }, |
| cv_renderer, dl_renderer, "Hard ClipRect inset by 15.5"); |
| RenderWith( |
| [=](SkCanvas* c, SkPaint&) { |
| c->clipRect(r_clip, SkClipOp::kIntersect, true); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.clipRect(r_clip, true, SkClipOp::kIntersect); |
| }, |
| cv_renderer, dl_renderer, "AA ClipRect inset by 15.5"); |
| RenderWith( |
| [=](SkCanvas* c, SkPaint&) { |
| c->clipRect(r_clip, SkClipOp::kDifference, false); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.clipRect(r_clip, false, SkClipOp::kDifference); |
| }, |
| cv_renderer, dl_renderer, "Hard ClipRect Diff, inset by 15.5"); |
| SkRRect rr_clip = SkRRect::MakeRectXY(r_clip, 1.8, 2.7); |
| RenderWith( |
| [=](SkCanvas* c, SkPaint&) { |
| c->clipRRect(rr_clip, SkClipOp::kIntersect, false); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.clipRRect(rr_clip, false, SkClipOp::kIntersect); |
| }, |
| cv_renderer, dl_renderer, "Hard ClipRRect inset by 15.5"); |
| RenderWith( |
| [=](SkCanvas* c, SkPaint&) { |
| c->clipRRect(rr_clip, SkClipOp::kIntersect, true); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.clipRRect(rr_clip, true, SkClipOp::kIntersect); |
| }, |
| cv_renderer, dl_renderer, "AA ClipRRect inset by 15.5"); |
| RenderWith( |
| [=](SkCanvas* c, SkPaint&) { |
| c->clipRRect(rr_clip, SkClipOp::kDifference, false); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.clipRRect(rr_clip, false, SkClipOp::kDifference); |
| }, |
| cv_renderer, dl_renderer, "Hard ClipRRect Diff, inset by 15.5"); |
| SkPath path_clip = SkPath(); |
| path_clip.setFillType(SkPathFillType::kEvenOdd); |
| path_clip.addRect(r_clip); |
| path_clip.addCircle(RenderCenterX, RenderCenterY, 1.0); |
| RenderWith( |
| [=](SkCanvas* c, SkPaint&) { |
| c->clipPath(path_clip, SkClipOp::kIntersect, false); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.clipPath(path_clip, false, SkClipOp::kIntersect); |
| }, |
| cv_renderer, dl_renderer, "Hard ClipPath inset by 15.5"); |
| RenderWith( |
| [=](SkCanvas* c, SkPaint&) { |
| c->clipPath(path_clip, SkClipOp::kIntersect, true); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.clipPath(path_clip, true, SkClipOp::kIntersect); |
| }, |
| cv_renderer, dl_renderer, "AA ClipPath inset by 15.5"); |
| RenderWith( |
| [=](SkCanvas* c, SkPaint&) { |
| c->clipPath(path_clip, SkClipOp::kDifference, false); |
| }, |
| [=](DisplayListBuilder& b) { |
| b.clipPath(path_clip, false, SkClipOp::kDifference); |
| }, |
| cv_renderer, dl_renderer, "Hard ClipPath Diff, inset by 15.5"); |
| } |
| |
| static SkRect getSkBounds(CvRenderer& cv_setup, CvRenderer& cv_render) { |
| SkPictureRecorder recorder; |
| SkRTreeFactory rtree_factory; |
| SkCanvas* cv = recorder.beginRecording(TestBounds, &rtree_factory); |
| SkPaint p; |
| cv_setup(cv, p); |
| cv_render(cv, p); |
| return recorder.finishRecordingAsPicture()->cullRect(); |
| } |
| |
| static void RenderWith(CvRenderer& cv_setup, |
| DlRenderer& dl_setup, |
| CvRenderer& cv_render, |
| DlRenderer& dl_render, |
| const std::string info, |
| const SkColor* bg = nullptr) { |
| // surface1 is direct rendering via SkCanvas to SkSurface |
| // DisplayList mechanisms are not involved in this operation |
| sk_sp<SkSurface> ref_surface = makeSurface(bg); |
| SkPaint paint1; |
| cv_setup(ref_surface->getCanvas(), paint1); |
| cv_render(ref_surface->getCanvas(), paint1); |
| SkRect ref_bounds = getSkBounds(cv_setup, cv_render); |
| SkPixmap ref_pixels; |
| ASSERT_TRUE(ref_surface->peekPixels(&ref_pixels)) << info; |
| ASSERT_EQ(ref_pixels.width(), TestWidth) << info; |
| ASSERT_EQ(ref_pixels.height(), TestHeight) << info; |
| ASSERT_EQ(ref_pixels.info().bytesPerPixel(), 4) << info; |
| checkPixels(&ref_pixels, ref_bounds, info, bg); |
| |
| { |
| // This sequence plays the provided equivalently constructed |
| // DisplayList onto the SkCanvas of the surface |
| // DisplayList => direct rendering |
| sk_sp<SkSurface> test_surface = makeSurface(bg); |
| DisplayListBuilder builder(TestBounds); |
| dl_setup(builder); |
| dl_render(builder); |
| sk_sp<DisplayList> display_list = builder.Build(); |
| SkRect dl_bounds = display_list->bounds(); |
| #ifdef DISPLAY_LIST_BOUNDS_ACCURACY_CHECKING |
| if (dl_bounds != ref_bounds) { |
| FML_LOG(ERROR) << "For " << info; |
| FML_LOG(ERROR) << "ref: " << ref_bounds.fLeft << ", " << ref_bounds.fTop |
| << " => " << ref_bounds.fRight << ", " |
| << ref_bounds.fBottom; |
| FML_LOG(ERROR) << "dl: " << dl_bounds.fLeft << ", " << dl_bounds.fTop |
| << " => " << dl_bounds.fRight << ", " |
| << dl_bounds.fBottom; |
| if (!dl_bounds.contains(ref_bounds)) { |
| FML_LOG(ERROR) << "DisplayList bounds are too small!"; |
| } |
| } |
| #endif // DISPLAY_LIST_BOUNDS_ACCURACY_CHECKING |
| // This sometimes triggers, but when it triggers and I examine |
| // the ref_bounds, they are always unnecessarily large and |
| // since the pixel OOB tests in the compare method do not |
| // trigger, we will trust the DL bounds. |
| // EXPECT_TRUE(dl_bounds.contains(ref_bounds)) << info; |
| display_list->RenderTo(test_surface->getCanvas()); |
| compareToReference(test_surface.get(), &ref_pixels, info + " (DL render)", |
| &dl_bounds, bg); |
| } |
| |
| // This test cannot work if the rendering is using shadows until |
| // we can access the Skia ShadowRec via public headers. |
| if (!TestingDrawShadows) { |
| // This sequence renders SkCanvas calls to a DisplayList and then |
| // plays them back on SkCanvas to SkSurface |
| // SkCanvas calls => DisplayList => rendering |
| sk_sp<SkSurface> test_surface = makeSurface(bg); |
| DisplayListCanvasRecorder dl_recorder(TestBounds); |
| SkPaint test_paint; |
| cv_setup(&dl_recorder, test_paint); |
| cv_render(&dl_recorder, test_paint); |
| dl_recorder.builder()->Build()->RenderTo(test_surface->getCanvas()); |
| compareToReference(test_surface.get(), &ref_pixels, |
| info + " (Sk->DL render)", nullptr, nullptr); |
| } |
| |
| { |
| // This sequence renders the SkCanvas calls to an SkPictureRecorder and |
| // renders the DisplayList calls to a DisplayListBuilder and then |
| // renders both back under a transform (scale(2x)) to see if their |
| // rendering is affected differently by a change of matrix between |
| // recording time and rendering time. |
| const int TestWidth2 = TestWidth * 2; |
| const int TestHeight2 = TestHeight * 2; |
| const SkScalar TestScale = 2.0; |
| |
| SkPictureRecorder sk_recorder; |
| SkCanvas* ref_canvas = sk_recorder.beginRecording(TestBounds); |
| SkPaint ref_paint; |
| cv_setup(ref_canvas, ref_paint); |
| cv_render(ref_canvas, ref_paint); |
| sk_sp<SkPicture> ref_picture = sk_recorder.finishRecordingAsPicture(); |
| sk_sp<SkSurface> ref_surface2 = makeSurface(bg, TestWidth2, TestHeight2); |
| SkCanvas* ref_canvas2 = ref_surface2->getCanvas(); |
| ref_canvas2->scale(TestScale, TestScale); |
| ref_picture->playback(ref_canvas2); |
| SkPixmap ref_pixels2; |
| ASSERT_TRUE(ref_surface2->peekPixels(&ref_pixels2)) << info; |
| ASSERT_EQ(ref_pixels2.width(), TestWidth2) << info; |
| ASSERT_EQ(ref_pixels2.height(), TestHeight2) << info; |
| ASSERT_EQ(ref_pixels2.info().bytesPerPixel(), 4) << info; |
| |
| DisplayListBuilder builder(TestBounds); |
| dl_setup(builder); |
| dl_render(builder); |
| sk_sp<DisplayList> display_list = builder.Build(); |
| sk_sp<SkSurface> test_surface = makeSurface(bg, TestWidth2, TestHeight2); |
| SkCanvas* test_canvas = test_surface->getCanvas(); |
| test_canvas->scale(TestScale, TestScale); |
| display_list->RenderTo(test_canvas); |
| compareToReference(test_surface.get(), &ref_pixels2, |
| info + " (SKP/DL render scaled 2x)", nullptr, nullptr, |
| TestWidth2, TestHeight2, false); |
| } |
| } |
| |
| static void checkPixels(SkPixmap* ref_pixels, |
| SkRect ref_bounds, |
| const std::string info, |
| const SkColor* bg) { |
| SkPMColor untouched = (bg) ? SkPreMultiplyColor(*bg) : 0; |
| int pixels_touched = 0; |
| int pixels_oob = 0; |
| for (int y = 0; y < TestHeight; y++) { |
| const uint32_t* ref_row = ref_pixels->addr32(0, y); |
| for (int x = 0; x < TestWidth; x++) { |
| if (ref_row[x] != untouched) { |
| pixels_touched++; |
| if (!ref_bounds.intersects(SkRect::MakeXYWH(x, y, 1, 1))) { |
| pixels_oob++; |
| } |
| } |
| } |
| } |
| ASSERT_EQ(pixels_oob, 0) << info; |
| ASSERT_GT(pixels_touched, 0) << info; |
| } |
| |
| static void compareToReference(SkSurface* test_surface, |
| SkPixmap* reference, |
| const std::string info, |
| SkRect* bounds, |
| const SkColor* bg, |
| int width = TestWidth, |
| int height = TestHeight, |
| bool printMismatches = false) { |
| SkPMColor untouched = (bg) ? SkPreMultiplyColor(*bg) : 0; |
| SkPixmap test_pixels; |
| ASSERT_TRUE(test_surface->peekPixels(&test_pixels)) << info; |
| ASSERT_EQ(test_pixels.width(), width) << info; |
| ASSERT_EQ(test_pixels.height(), height) << info; |
| ASSERT_EQ(test_pixels.info().bytesPerPixel(), 4) << info; |
| |
| int pixels_different = 0; |
| int pixels_oob = 0; |
| int minX = width; |
| int minY = height; |
| int maxX = 0; |
| int maxY = 0; |
| for (int y = 0; y < height; y++) { |
| const uint32_t* ref_row = reference->addr32(0, y); |
| const uint32_t* test_row = test_pixels.addr32(0, y); |
| for (int x = 0; x < width; x++) { |
| if (bounds && test_row[x] != untouched) { |
| if (minX > x) |
| minX = x; |
| if (minY > y) |
| minY = y; |
| if (maxX < x) |
| maxX = x; |
| if (maxY < y) |
| maxY = y; |
| if (!bounds->intersects(SkRect::MakeXYWH(x, y, 1, 1))) { |
| pixels_oob++; |
| } |
| } |
| if (test_row[x] != ref_row[x]) { |
| if (printMismatches) { |
| FML_LOG(ERROR) << "pix[" << x << ", " << y |
| << "] mismatch: " << std::hex << test_row[x] |
| << "(test) != (ref)" << ref_row[x] << std::dec; |
| } |
| pixels_different++; |
| } |
| } |
| } |
| #ifdef DISPLAY_LIST_BOUNDS_ACCURACY_CHECKING |
| if (bounds && *bounds != SkRect::MakeLTRB(minX, minY, maxX + 1, maxY + 1)) { |
| FML_LOG(ERROR) << "inaccurate bounds for " << info; |
| FML_LOG(ERROR) << "dl: " << bounds->fLeft << ", " << bounds->fTop |
| << " => " << bounds->fRight << ", " << bounds->fBottom; |
| FML_LOG(ERROR) << "pixels: " << minX << ", " << minY << " => " |
| << (maxX + 1) << ", " << (maxY + 1); |
| } |
| #endif // DISPLAY_LIST_BOUNDS_ACCURACY_CHECKING |
| ASSERT_EQ(pixels_oob, 0) << info; |
| ASSERT_EQ(pixels_different, 0) << info; |
| } |
| |
| static sk_sp<SkSurface> makeSurface(const SkColor* bg, |
| int width = TestWidth, |
| int height = TestHeight) { |
| sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(width, height); |
| if (bg) { |
| surface->getCanvas()->drawColor(*bg); |
| } |
| return surface; |
| } |
| |
| static const sk_sp<SkImage> testImage; |
| static const sk_sp<SkImage> makeTestImage() { |
| sk_sp<SkSurface> surface = |
| SkSurface::MakeRasterN32Premul(RenderWidth, RenderHeight); |
| SkCanvas* canvas = surface->getCanvas(); |
| SkPaint p0, p1; |
| p0.setStyle(SkPaint::kFill_Style); |
| p0.setColor(SK_ColorGREEN); |
| p1.setStyle(SkPaint::kFill_Style); |
| p1.setColor(SK_ColorBLUE); |
| // Some pixels need some transparency for DstIn testing |
| p1.setAlpha(128); |
| int cbdim = 5; |
| for (int y = 0; y < RenderHeight; y += cbdim) { |
| for (int x = 0; x < RenderWidth; x += cbdim) { |
| SkPaint& cellp = ((x + y) & 1) == 0 ? p0 : p1; |
| canvas->drawRect(SkRect::MakeXYWH(x, y, cbdim, cbdim), cellp); |
| } |
| } |
| return surface->makeImageSnapshot(); |
| } |
| |
| static sk_sp<SkTextBlob> MakeTextBlob(std::string string, |
| SkScalar height = RenderHeight) { |
| SkFont font(SkTypeface::MakeDefault(), height); |
| return SkTextBlob::MakeFromText(string.c_str(), string.size(), font, |
| SkTextEncoding::kUTF8); |
| } |
| }; |
| |
| bool CanvasCompareTester::TestingDrawShadows = false; |
| bool CanvasCompareTester::TestingDrawVertices = false; |
| bool CanvasCompareTester::TestingDrawAtlas = false; |
| |
| const sk_sp<SkImage> CanvasCompareTester::testImage = |
| CanvasCompareTester::makeTestImage(); |
| |
| TEST(DisplayListCanvas, DrawPaint) { |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawPaint(paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawPaint(); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawColor) { |
| CanvasCompareTester::RenderNoAttributes( // |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawColor(SK_ColorMAGENTA); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawColor(SK_ColorMAGENTA, SkBlendMode::kSrcOver); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawLine) { |
| SkRect rect = RenderBounds; |
| SkPoint p1 = SkPoint::Make(rect.fLeft, rect.fTop); |
| SkPoint p2 = SkPoint::Make(rect.fRight, rect.fBottom); |
| |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawLine(p1, p2, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawLine(p1, p2); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawRect) { |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawRect(RenderBounds, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawRect(RenderBounds); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawOval) { |
| SkRect rect = RenderBounds.makeInset(0, 10); |
| |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawOval(rect, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawOval(rect); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawCircle) { |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawCircle(TestCenter, RenderRadius, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawCircle(TestCenter, RenderRadius); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawRRect) { |
| SkRRect rrect = |
| SkRRect::MakeRectXY(RenderBounds, RenderCornerRadius, RenderCornerRadius); |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawRRect(rrect, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawRRect(rrect); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawDRRect) { |
| SkRRect outer = |
| SkRRect::MakeRectXY(RenderBounds, RenderCornerRadius, RenderCornerRadius); |
| SkRect innerBounds = RenderBounds.makeInset(30.0, 30.0); |
| SkRRect inner = |
| SkRRect::MakeRectXY(innerBounds, RenderCornerRadius, RenderCornerRadius); |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawDRRect(outer, inner, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawDRRect(outer, inner); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawPath) { |
| SkPath path; |
| path.moveTo(RenderCenterX, RenderTop); |
| path.lineTo(RenderRight, RenderBottom); |
| path.lineTo(RenderLeft, RenderCenterY); |
| path.lineTo(RenderRight, RenderCenterY); |
| path.lineTo(RenderLeft, RenderBottom); |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawPath(path, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawPath(path); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawArc) { |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawArc(RenderBounds, 30, 270, false, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawArc(RenderBounds, 30, 270, false); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawArcCenter) { |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawArc(RenderBounds, 30, 270, true, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawArc(RenderBounds, 30, 270, true); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawPointsAsPoints) { |
| const SkScalar x0 = RenderLeft; |
| const SkScalar x1 = (RenderLeft + RenderCenterX) * 0.5; |
| const SkScalar x2 = RenderCenterX; |
| const SkScalar x3 = (RenderRight + RenderCenterX) * 0.5; |
| const SkScalar x4 = RenderRight; |
| |
| const SkScalar y0 = RenderTop; |
| const SkScalar y1 = (RenderTop + RenderCenterY) * 0.5; |
| const SkScalar y2 = RenderCenterY; |
| const SkScalar y3 = (RenderBottom + RenderCenterY) * 0.5; |
| const SkScalar y4 = RenderBottom; |
| |
| // clang-format off |
| const SkPoint points[] = { |
| {x0, y0}, {x1, y0}, {x2, y0}, {x3, y0}, {x4, y0}, |
| {x0, y1}, {x1, y1}, {x2, y1}, {x3, y1}, {x4, y1}, |
| {x0, y2}, {x1, y2}, {x2, y2}, {x3, y2}, {x4, y2}, |
| {x0, y3}, {x1, y3}, {x2, y3}, {x3, y3}, {x4, y3}, |
| {x0, y4}, {x1, y4}, {x2, y4}, {x3, y4}, {x4, y4}, |
| }; |
| // clang-format on |
| |
| const int count = sizeof(points) / sizeof(points[0]); |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| SkPaint p = paint; |
| p.setStyle(SkPaint::kStroke_Style); |
| canvas->drawPoints(SkCanvas::kPoints_PointMode, count, points, p); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawPoints(SkCanvas::kPoints_PointMode, count, points); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawPointsAsLines) { |
| const SkScalar x0 = RenderLeft; |
| const SkScalar x1 = (RenderLeft + RenderCenterX) * 0.5; |
| const SkScalar x2 = RenderCenterX; |
| const SkScalar x3 = (RenderRight + RenderCenterX) * 0.5; |
| const SkScalar x4 = RenderRight; |
| |
| const SkScalar y0 = RenderTop; |
| const SkScalar y1 = (RenderTop + RenderCenterY) * 0.5; |
| const SkScalar y2 = RenderCenterY; |
| const SkScalar y3 = (RenderBottom + RenderCenterY) * 0.5; |
| const SkScalar y4 = RenderBottom; |
| |
| // clang-format off |
| const SkPoint points[] = { |
| // Diagonals |
| {x0, y0}, {x4, y4}, {x4, y0}, {x0, y4}, |
| // Inner box |
| {x1, y1}, {x3, y1}, |
| {x3, y1}, {x3, y3}, |
| {x3, y3}, {x1, y3}, |
| {x1, y3}, {x1, y1}, |
| // Middle crosshair |
| {x2, y1}, {x2, y3}, |
| {x1, y2}, {x3, y3}, |
| }; |
| // clang-format on |
| |
| const int count = sizeof(points) / sizeof(points[0]); |
| ASSERT_TRUE((count & 1) == 0); |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| SkPaint p = paint; |
| p.setStyle(SkPaint::kStroke_Style); |
| canvas->drawPoints(SkCanvas::kLines_PointMode, count, points, p); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawPoints(SkCanvas::kLines_PointMode, count, points); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawPointsAsPolygon) { |
| const SkPoint points[] = { |
| SkPoint::Make(RenderLeft, RenderTop), |
| SkPoint::Make(RenderRight, RenderBottom), |
| SkPoint::Make(RenderRight, RenderTop), |
| SkPoint::Make(RenderLeft, RenderBottom), |
| SkPoint::Make(RenderLeft, RenderTop), |
| }; |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| SkPaint p = paint; |
| p.setStyle(SkPaint::kStroke_Style); |
| canvas->drawPoints(SkCanvas::kPolygon_PointMode, 4, points, p); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawPoints(SkCanvas::kPolygon_PointMode, 4, points); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawVerticesWithColors) { |
| const SkPoint pts[3] = { |
| SkPoint::Make(RenderCenterX, RenderTop), |
| SkPoint::Make(RenderLeft, RenderBottom), |
| SkPoint::Make(RenderRight, RenderBottom), |
| }; |
| const SkColor colors[3] = {SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN}; |
| const sk_sp<SkVertices> vertices = SkVertices::MakeCopy( |
| SkVertices::kTriangles_VertexMode, 3, pts, nullptr, colors); |
| CanvasCompareTester::RenderVertices( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawVertices(vertices.get(), SkBlendMode::kSrcOver, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawVertices(vertices, SkBlendMode::kSrcOver); |
| }); |
| ASSERT_TRUE(vertices->unique()); |
| } |
| |
| TEST(DisplayListCanvas, DrawVerticesWithImage) { |
| const SkPoint pts[3] = { |
| SkPoint::Make(RenderCenterX, RenderTop), |
| SkPoint::Make(RenderLeft, RenderBottom), |
| SkPoint::Make(RenderRight, RenderBottom), |
| }; |
| const SkPoint tex[3] = { |
| SkPoint::Make(RenderWidth / 2.0, 0), |
| SkPoint::Make(0, RenderHeight), |
| SkPoint::Make(RenderWidth, RenderHeight), |
| }; |
| const sk_sp<SkVertices> vertices = SkVertices::MakeCopy( |
| SkVertices::kTriangles_VertexMode, 3, pts, tex, nullptr); |
| const sk_sp<SkShader> shader = CanvasCompareTester::testImage->makeShader( |
| SkTileMode::kRepeat, SkTileMode::kRepeat, SkSamplingOptions()); |
| CanvasCompareTester::RenderVertices( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| paint.setShader(shader); |
| canvas->drawVertices(vertices.get(), SkBlendMode::kSrcOver, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.setShader(shader); |
| builder.drawVertices(vertices, SkBlendMode::kSrcOver); |
| }); |
| ASSERT_TRUE(vertices->unique()); |
| ASSERT_TRUE(shader->unique()); |
| } |
| |
| TEST(DisplayListCanvas, DrawImageNearest) { |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawImage(CanvasCompareTester::testImage, RenderLeft, RenderTop, |
| DisplayList::NearestSampling, &paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawImage(CanvasCompareTester::testImage, |
| SkPoint::Make(RenderLeft, RenderTop), |
| DisplayList::NearestSampling); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawImageLinear) { |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawImage(CanvasCompareTester::testImage, RenderLeft, RenderTop, |
| DisplayList::LinearSampling, &paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawImage(CanvasCompareTester::testImage, |
| SkPoint::Make(RenderLeft, RenderTop), |
| DisplayList::LinearSampling); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawImageRectNearest) { |
| SkRect src = SkRect::MakeIWH(RenderWidth, RenderHeight).makeInset(5, 5); |
| SkRect dst = RenderBounds.makeInset(15.5, 10.5); |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawImageRect(CanvasCompareTester::testImage, src, dst, |
| DisplayList::NearestSampling, &paint, |
| SkCanvas::kFast_SrcRectConstraint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawImageRect(CanvasCompareTester::testImage, src, dst, |
| DisplayList::NearestSampling); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawImageRectLinear) { |
| SkRect src = SkRect::MakeIWH(RenderWidth, RenderHeight).makeInset(5, 5); |
| SkRect dst = RenderBounds.makeInset(15.5, 10.5); |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawImageRect(CanvasCompareTester::testImage, src, dst, |
| DisplayList::LinearSampling, &paint, |
| SkCanvas::kFast_SrcRectConstraint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawImageRect(CanvasCompareTester::testImage, src, dst, |
| DisplayList::LinearSampling); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawImageNineNearest) { |
| SkIRect src = SkIRect::MakeWH(RenderWidth, RenderHeight).makeInset(5, 5); |
| SkRect dst = RenderBounds.makeInset(15.5, 10.5); |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawImageNine(CanvasCompareTester::testImage.get(), src, dst, |
| SkFilterMode::kNearest, &paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawImageNine(CanvasCompareTester::testImage, src, dst, |
| SkFilterMode::kNearest); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawImageNineLinear) { |
| SkIRect src = SkIRect::MakeWH(RenderWidth, RenderHeight).makeInset(5, 5); |
| SkRect dst = RenderBounds.makeInset(15.5, 10.5); |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawImageNine(CanvasCompareTester::testImage.get(), src, dst, |
| SkFilterMode::kLinear, &paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawImageNine(CanvasCompareTester::testImage, src, dst, |
| SkFilterMode::kLinear); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawImageLatticeNearest) { |
| const SkRect dst = RenderBounds.makeInset(15.5, 10.5); |
| const int divX[] = { |
| (RenderLeft + RenderCenterX) / 2, |
| RenderCenterX, |
| (RenderRight + RenderCenterX) / 2, |
| }; |
| const int divY[] = { |
| (RenderTop + RenderCenterY) / 2, |
| RenderCenterY, |
| (RenderBottom + RenderCenterY) / 2, |
| }; |
| SkCanvas::Lattice lattice = { |
| divX, divY, nullptr, 3, 3, nullptr, nullptr, |
| }; |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawImageLattice(CanvasCompareTester::testImage.get(), lattice, |
| dst, SkFilterMode::kNearest, &paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawImageLattice(CanvasCompareTester::testImage, lattice, // |
| dst, SkFilterMode::kNearest, true); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawImageLatticeLinear) { |
| const SkRect dst = RenderBounds.makeInset(15.5, 10.5); |
| const int divX[] = { |
| (RenderLeft + RenderCenterX) / 2, |
| RenderCenterX, |
| (RenderRight + RenderCenterX) / 2, |
| }; |
| const int divY[] = { |
| (RenderTop + RenderCenterY) / 2, |
| RenderCenterY, |
| (RenderBottom + RenderCenterY) / 2, |
| }; |
| SkCanvas::Lattice lattice = { |
| divX, divY, nullptr, 3, 3, nullptr, nullptr, |
| }; |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawImageLattice(CanvasCompareTester::testImage.get(), lattice, |
| dst, SkFilterMode::kLinear, &paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawImageLattice(CanvasCompareTester::testImage, lattice, // |
| dst, SkFilterMode::kLinear, true); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawAtlasNearest) { |
| const SkRSXform xform[] = { |
| {0.5, 0, RenderLeft, RenderRight}, |
| {0, 0.5, RenderCenterX, RenderCenterY}, |
| }; |
| const SkRect tex[] = { |
| {0, 0, RenderWidth * 0.5, RenderHeight * 0.5}, |
| {RenderWidth * 0.5, RenderHeight * 0.5, RenderWidth, RenderHeight}, |
| }; |
| const SkColor colors[] = { |
| SK_ColorBLUE, |
| SK_ColorGREEN, |
| }; |
| const sk_sp<SkImage> image = CanvasCompareTester::testImage; |
| CanvasCompareTester::RenderAtlas( |
| [=](SkCanvas* canvas, SkPaint& paint) { |
| canvas->drawAtlas(image.get(), xform, tex, colors, 2, |
| SkBlendMode::kSrcOver, DisplayList::NearestSampling, |
| nullptr, &paint); |
| }, |
| [=](DisplayListBuilder& builder) { |
| builder.drawAtlas(image, xform, tex, colors, 2, // |
| SkBlendMode::kSrcOver, DisplayList::NearestSampling, |
| nullptr); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawAtlasLinear) { |
| const SkRSXform xform[] = { |
| {0.5, 0, RenderLeft, RenderRight}, |
| {0, 0.5, RenderCenterX, RenderCenterY}, |
| }; |
| const SkRect tex[] = { |
| {0, 0, RenderWidth * 0.5, RenderHeight * 0.5}, |
| {RenderWidth * 0.5, RenderHeight * 0.5, RenderWidth, RenderHeight}, |
| }; |
| const SkColor colors[] = { |
| SK_ColorBLUE, |
| SK_ColorGREEN, |
| }; |
| const sk_sp<SkImage> image = CanvasCompareTester::testImage; |
| CanvasCompareTester::RenderAtlas( |
| [=](SkCanvas* canvas, SkPaint& paint) { |
| canvas->drawAtlas(image.get(), xform, tex, colors, 2, // |
| SkBlendMode::kSrcOver, DisplayList::LinearSampling, |
| nullptr, &paint); |
| }, |
| [=](DisplayListBuilder& builder) { |
| builder.drawAtlas(image, xform, tex, colors, 2, // |
| SkBlendMode::kSrcOver, DisplayList::LinearSampling, |
| nullptr); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawPicture) { |
| SkPictureRecorder recorder; |
| SkCanvas* cv = recorder.beginRecording(RenderBounds); |
| SkPaint p; |
| p.setStyle(SkPaint::kFill_Style); |
| p.setColor(SK_ColorBLUE); |
| cv->drawOval(RenderBounds, p); |
| sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture(); |
| CanvasCompareTester::RenderNoAttributes( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawPicture(picture, nullptr, nullptr); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawPicture(picture, nullptr, false); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawPictureWithMatrix) { |
| SkPictureRecorder recorder; |
| SkCanvas* cv = recorder.beginRecording(RenderBounds); |
| SkPaint p; |
| p.setStyle(SkPaint::kFill_Style); |
| p.setColor(SK_ColorBLUE); |
| cv->drawOval(RenderBounds, p); |
| sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture(); |
| SkMatrix matrix = SkMatrix::Scale(0.95, 0.95); |
| CanvasCompareTester::RenderNoAttributes( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawPicture(picture, &matrix, nullptr); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawPicture(picture, &matrix, false); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawPictureWithPaint) { |
| SkPictureRecorder recorder; |
| SkCanvas* cv = recorder.beginRecording(RenderBounds); |
| SkPaint p; |
| p.setStyle(SkPaint::kFill_Style); |
| p.setColor(SK_ColorBLUE); |
| cv->drawOval(RenderBounds, p); |
| sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture(); |
| CanvasCompareTester::RenderAll( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawPicture(picture, nullptr, &paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawPicture(picture, nullptr, true); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawDisplayList) { |
| DisplayListBuilder builder; |
| builder.setDrawStyle(SkPaint::kFill_Style); |
| builder.setColor(SK_ColorBLUE); |
| builder.drawOval(RenderBounds); |
| sk_sp<DisplayList> display_list = builder.Build(); |
| CanvasCompareTester::RenderNoAttributes( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| display_list->RenderTo(canvas); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawDisplayList(display_list); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawTextBlob) { |
| // TODO(https://github.com/flutter/flutter/issues/82202): Remove once the |
| // performance overlay can use Fuchsia's font manager instead of the empty |
| // default. |
| #if defined(OS_FUCHSIA) |
| GTEST_SKIP() << "Rendering comparisons require a valid default font manager"; |
| #endif // OS_FUCHSIA |
| sk_sp<SkTextBlob> blob = CanvasCompareTester::MakeTextBlob("Test Blob"); |
| CanvasCompareTester::RenderNoAttributes( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| canvas->drawTextBlob(blob, RenderLeft, RenderBottom, paint); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawTextBlob(blob, RenderLeft, RenderBottom); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawShadow) { |
| SkPath path; |
| path.moveTo(RenderCenterX, RenderTop); |
| path.lineTo(RenderRight, RenderBottom); |
| path.lineTo(RenderLeft, RenderCenterY); |
| path.lineTo(RenderRight, RenderCenterY); |
| path.lineTo(RenderLeft, RenderBottom); |
| path.close(); |
| const SkColor color = SK_ColorDKGRAY; |
| const SkScalar elevation = 10; |
| |
| CanvasCompareTester::RenderShadows( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| PhysicalShapeLayer::DrawShadow(canvas, path, color, elevation, false, |
| 1.0); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawShadow(path, color, elevation, false, 1.0); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawOccludingShadow) { |
| SkPath path; |
| path.moveTo(RenderCenterX, RenderTop); |
| path.lineTo(RenderRight, RenderBottom); |
| path.lineTo(RenderLeft, RenderCenterY); |
| path.lineTo(RenderRight, RenderCenterY); |
| path.lineTo(RenderLeft, RenderBottom); |
| path.close(); |
| const SkColor color = SK_ColorDKGRAY; |
| const SkScalar elevation = 10; |
| |
| CanvasCompareTester::RenderShadows( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| PhysicalShapeLayer::DrawShadow(canvas, path, color, elevation, true, |
| 1.0); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawShadow(path, color, elevation, true, 1.0); |
| }); |
| } |
| |
| TEST(DisplayListCanvas, DrawShadowDpr) { |
| SkPath path; |
| path.moveTo(RenderCenterX, RenderTop); |
| path.lineTo(RenderRight, RenderBottom); |
| path.lineTo(RenderLeft, RenderCenterY); |
| path.lineTo(RenderRight, RenderCenterY); |
| path.lineTo(RenderLeft, RenderBottom); |
| path.close(); |
| const SkColor color = SK_ColorDKGRAY; |
| const SkScalar elevation = 10; |
| |
| CanvasCompareTester::RenderShadows( |
| [=](SkCanvas* canvas, SkPaint& paint) { // |
| PhysicalShapeLayer::DrawShadow(canvas, path, color, elevation, false, |
| 2.5); |
| }, |
| [=](DisplayListBuilder& builder) { // |
| builder.drawShadow(path, color, elevation, false, 2.5); |
| }); |
| } |
| |
| } // namespace testing |
| } // namespace flutter |
