robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2013 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
robertphillips@google.com | b706117 | 2013-09-06 14:16:12 +0000 | [diff] [blame] | 8 | #include "SkBlurMask.h" |
robertphillips@google.com | b706117 | 2013-09-06 14:16:12 +0000 | [diff] [blame] | 9 | #include "SkCanvas.h" |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 10 | #include "SkGradientShader.h" |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 11 | #include "SkImage.h" |
Mike Reed | 1be1f8d | 2018-03-14 13:01:17 -0400 | [diff] [blame] | 12 | #include "SkMaskFilter.h" |
Mike Klein | 33d2055 | 2017-03-22 13:47:51 -0400 | [diff] [blame] | 13 | #include "SkTDArray.h" |
Hal Canary | ea60b95 | 2018-08-21 11:45:46 -0400 | [diff] [blame] | 14 | #include "SkUTF.h" |
Mike Klein | ea3f014 | 2019-03-20 11:12:10 -0500 | [diff] [blame] | 15 | #include "ToolUtils.h" |
| 16 | #include "gm.h" |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 17 | |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 18 | #include "GrContext.h" |
bsalomon | 4ee6bd8 | 2015-05-27 13:23:23 -0700 | [diff] [blame] | 19 | #include "GrContextOptions.h" |
bsalomon | 9c58654 | 2015-11-02 12:33:21 -0800 | [diff] [blame] | 20 | #include "SkGr.h" |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 21 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 22 | /** Holds either a bitmap or image to be rendered and a rect that indicates what part of the bitmap |
| 23 | or image should be tested by the GM. The area outside of the rect is present to check |
| 24 | for bleed due to filtering/blurring. */ |
| 25 | struct TestPixels { |
| 26 | enum Type { |
| 27 | kBitmap, |
| 28 | kImage |
| 29 | }; |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 30 | Type fType; |
| 31 | SkBitmap fBitmap; |
| 32 | sk_sp<SkImage> fImage; |
| 33 | SkIRect fRect; // The region of the bitmap/image that should be rendered. |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 34 | }; |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 35 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 36 | /** Creates a bitmap with two one-pixel rings around a checkerboard. The checkerboard is 2x2 |
| 37 | logically where each check has as many pixels as is necessary to fill the interior. The rect |
| 38 | to draw is set to the checkerboard portion. */ |
| 39 | template<typename PIXEL_TYPE> |
bsalomon | a2e0837 | 2016-07-13 14:50:17 -0700 | [diff] [blame] | 40 | bool make_ringed_bitmap(TestPixels* result, int width, int height, |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 41 | SkColorType ct, SkAlphaType at, |
| 42 | PIXEL_TYPE outerRingColor, PIXEL_TYPE innerRingColor, |
| 43 | PIXEL_TYPE checkColor1, PIXEL_TYPE checkColor2) { |
commit-bot@chromium.org | ec39b50 | 2013-11-08 15:09:22 +0000 | [diff] [blame] | 44 | SkASSERT(0 == width % 2 && 0 == height % 2); |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 45 | SkASSERT(width >= 6 && height >= 6); |
skia.committer@gmail.com | ed00084 | 2013-11-09 07:02:23 +0000 | [diff] [blame] | 46 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 47 | result->fType = TestPixels::kBitmap; |
| 48 | SkImageInfo info = SkImageInfo::Make(width, height, ct, at); |
| 49 | size_t rowBytes = SkAlign4(info.minRowBytes()); |
| 50 | result->fBitmap.allocPixels(info, rowBytes); |
| 51 | |
| 52 | PIXEL_TYPE* scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, 0); |
| 53 | for (int x = 0; x < width; ++x) { |
| 54 | scanline[x] = outerRingColor; |
| 55 | } |
| 56 | scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, 1); |
| 57 | scanline[0] = outerRingColor; |
| 58 | for (int x = 1; x < width - 1; ++x) { |
| 59 | scanline[x] = innerRingColor; |
| 60 | } |
| 61 | scanline[width - 1] = outerRingColor; |
| 62 | |
| 63 | for (int y = 2; y < height / 2; ++y) { |
| 64 | scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, y); |
| 65 | scanline[0] = outerRingColor; |
| 66 | scanline[1] = innerRingColor; |
| 67 | for (int x = 2; x < width / 2; ++x) { |
| 68 | scanline[x] = checkColor1; |
| 69 | } |
| 70 | for (int x = width / 2; x < width - 2; ++x) { |
| 71 | scanline[x] = checkColor2; |
| 72 | } |
| 73 | scanline[width - 2] = innerRingColor; |
| 74 | scanline[width - 1] = outerRingColor; |
| 75 | } |
| 76 | |
| 77 | for (int y = height / 2; y < height - 2; ++y) { |
| 78 | scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, y); |
| 79 | scanline[0] = outerRingColor; |
| 80 | scanline[1] = innerRingColor; |
| 81 | for (int x = 2; x < width / 2; ++x) { |
| 82 | scanline[x] = checkColor2; |
| 83 | } |
| 84 | for (int x = width / 2; x < width - 2; ++x) { |
| 85 | scanline[x] = checkColor1; |
| 86 | } |
| 87 | scanline[width - 2] = innerRingColor; |
| 88 | scanline[width - 1] = outerRingColor; |
| 89 | } |
| 90 | |
| 91 | scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, height - 2); |
| 92 | scanline[0] = outerRingColor; |
| 93 | for (int x = 1; x < width - 1; ++x) { |
| 94 | scanline[x] = innerRingColor; |
| 95 | } |
| 96 | scanline[width - 1] = outerRingColor; |
| 97 | |
| 98 | scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, height - 1); |
| 99 | for (int x = 0; x < width; ++x) { |
| 100 | scanline[x] = outerRingColor; |
| 101 | } |
| 102 | result->fBitmap.setImmutable(); |
| 103 | result->fRect.set(2, 2, width - 2, height - 2); |
| 104 | return true; |
| 105 | } |
| 106 | |
bsalomon | a2e0837 | 2016-07-13 14:50:17 -0700 | [diff] [blame] | 107 | /** Create a black and white checked bitmap with 2 1-pixel rings around the outside edge. |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 108 | The inner ring is red and the outer ring is blue. */ |
bsalomon | a2e0837 | 2016-07-13 14:50:17 -0700 | [diff] [blame] | 109 | static bool make_ringed_color_bitmap(TestPixels* result, int width, int height) { |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame] | 110 | const SkPMColor kBlue = SkPreMultiplyColor(SK_ColorBLUE); |
| 111 | const SkPMColor kRed = SkPreMultiplyColor(SK_ColorRED); |
| 112 | const SkPMColor kBlack = SkPreMultiplyColor(SK_ColorBLACK); |
| 113 | const SkPMColor kWhite = SkPreMultiplyColor(SK_ColorWHITE); |
bsalomon | 48b2461 | 2016-08-25 06:45:29 -0700 | [diff] [blame] | 114 | return make_ringed_bitmap<SkPMColor>(result, width, height, kN32_SkColorType, |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 115 | kPremul_SkAlphaType, kBlue, kRed, kBlack, kWhite); |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 116 | } |
| 117 | |
bsalomon | df85a72 | 2015-11-04 04:23:45 -0800 | [diff] [blame] | 118 | /** Makes a alpha bitmap with 1 wide rect/ring of 0s, an inset of 1s, and the interior is a 2x2 |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 119 | checker board of 3/4 and 1/2. The inner checkers are large enough to fill the interior with |
| 120 | the 2x2 checker grid. */ |
bsalomon | a2e0837 | 2016-07-13 14:50:17 -0700 | [diff] [blame] | 121 | static bool make_ringed_alpha_bitmap(TestPixels* result, int width, int height) { |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame] | 122 | constexpr uint8_t kZero = 0x00; |
| 123 | constexpr uint8_t kHalf = 0x80; |
| 124 | constexpr uint8_t k3Q = 0xC0; |
| 125 | constexpr uint8_t kOne = 0xFF; |
bsalomon | a2e0837 | 2016-07-13 14:50:17 -0700 | [diff] [blame] | 126 | return make_ringed_bitmap<uint8_t>(result, width, height, kAlpha_8_SkColorType, |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 127 | kPremul_SkAlphaType, kZero, kOne, k3Q, kHalf); |
| 128 | } |
| 129 | |
| 130 | /** Helper to reuse above functions to produce images rather than bmps */ |
| 131 | static void bmp_to_image(TestPixels* result) { |
| 132 | SkASSERT(TestPixels::kBitmap == result->fType); |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 133 | result->fImage = SkImage::MakeFromBitmap(result->fBitmap); |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 134 | SkASSERT(result->fImage); |
| 135 | result->fType = TestPixels::kImage; |
| 136 | result->fBitmap.reset(); |
| 137 | } |
| 138 | |
| 139 | /** Color image case. */ |
bsalomon | a2e0837 | 2016-07-13 14:50:17 -0700 | [diff] [blame] | 140 | bool make_ringed_color_image(TestPixels* result, int width, int height) { |
| 141 | if (make_ringed_color_bitmap(result, width, height)) { |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 142 | bmp_to_image(result); |
| 143 | return true; |
| 144 | } |
| 145 | return false; |
| 146 | } |
| 147 | |
| 148 | /** Alpha image case. */ |
bsalomon | a2e0837 | 2016-07-13 14:50:17 -0700 | [diff] [blame] | 149 | bool make_ringed_alpha_image(TestPixels* result, int width, int height) { |
| 150 | if (make_ringed_alpha_bitmap(result, width, height)) { |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 151 | bmp_to_image(result); |
| 152 | return true; |
| 153 | } |
| 154 | return false; |
| 155 | } |
| 156 | |
reed | 2ad1aa6 | 2016-03-09 09:50:50 -0800 | [diff] [blame] | 157 | static sk_sp<SkShader> make_shader() { |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame] | 158 | constexpr SkPoint pts[] = { {0, 0}, {20, 20} }; |
| 159 | constexpr SkColor colors[] = { SK_ColorGREEN, SK_ColorYELLOW }; |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 160 | return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kMirror); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 161 | } |
| 162 | |
reed | 2ad1aa6 | 2016-03-09 09:50:50 -0800 | [diff] [blame] | 163 | static sk_sp<SkShader> make_null_shader() { return nullptr; } |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 164 | |
| 165 | enum BleedTest { |
| 166 | kUseBitmap_BleedTest, |
| 167 | kUseImage_BleedTest, |
| 168 | kUseAlphaBitmap_BleedTest, |
| 169 | kUseAlphaImage_BleedTest, |
| 170 | kUseAlphaBitmapShader_BleedTest, |
| 171 | kUseAlphaImageShader_BleedTest, |
| 172 | }; |
| 173 | |
| 174 | const struct { |
| 175 | const char* fName; |
bsalomon | a2e0837 | 2016-07-13 14:50:17 -0700 | [diff] [blame] | 176 | bool (*fPixelMaker)(TestPixels* result, int width, int height); |
reed | 2ad1aa6 | 2016-03-09 09:50:50 -0800 | [diff] [blame] | 177 | sk_sp<SkShader> (*fShaderMaker)(); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 178 | } gBleedRec[] = { |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 179 | { "bleed", make_ringed_color_bitmap, make_null_shader }, |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 180 | { "bleed_image", make_ringed_color_image, make_null_shader }, |
| 181 | { "bleed_alpha_bmp", make_ringed_alpha_bitmap, make_null_shader }, |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 182 | { "bleed_alpha_image", make_ringed_alpha_image, make_null_shader }, |
| 183 | { "bleed_alpha_bmp_shader", make_ringed_alpha_bitmap, make_shader }, |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 184 | { "bleed_alpha_image_shader", make_ringed_alpha_image, make_shader }, |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 185 | }; |
| 186 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 187 | /** This GM exercises the behavior of the drawBitmapRect & drawImageRect calls. Specifically their |
| 188 | handling of : |
| 189 | - SrcRectConstraint(bleed vs.no - bleed) |
| 190 | - handling of the sub - region feature(area - of - interest) of drawBitmap* |
| 191 | - handling of 8888 vs. A8 (including presence of a shader in the A8 case). |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 192 | In particular, we should never see the padding outside of an SkBitmap's sub - region (green for |
| 193 | 8888, 1/4 for alpha). In some instances we can see the two outer rings outside of the area o |
| 194 | interest (i.e., the inner four checks) due to AA or filtering if allowed by the |
| 195 | SrcRectConstraint. |
| 196 | */ |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 197 | class BleedGM : public skiagm::GM { |
| 198 | public: |
bsalomon | a2e0837 | 2016-07-13 14:50:17 -0700 | [diff] [blame] | 199 | BleedGM(BleedTest bt) : fBT(bt){} |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 200 | |
| 201 | protected: |
commit-bot@chromium.org | a90c680 | 2014-04-30 13:20:45 +0000 | [diff] [blame] | 202 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 203 | SkString onShortName() override { |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 204 | return SkString(gBleedRec[fBT].fName); |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 205 | } |
| 206 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 207 | SkISize onISize() override { |
bsalomon | f57ef1c | 2015-11-04 04:36:12 -0800 | [diff] [blame] | 208 | return SkISize::Make(1200, 1080); |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 209 | } |
| 210 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 211 | void drawPixels(SkCanvas* canvas, const TestPixels& pixels, const SkRect& src, |
| 212 | const SkRect& dst, const SkPaint* paint, |
| 213 | SkCanvas::SrcRectConstraint constraint) { |
| 214 | if (TestPixels::kBitmap == pixels.fType) { |
| 215 | canvas->drawBitmapRect(pixels.fBitmap, src, dst, paint, constraint); |
| 216 | } else { |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 217 | canvas->drawImageRect(pixels.fImage.get(), src, dst, paint, constraint); |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 218 | } |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 219 | } |
| 220 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 221 | // Draw the area of interest of the small image |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 222 | void drawCase1(SkCanvas* canvas, int transX, int transY, bool aa, |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 223 | SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) { |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 224 | |
| 225 | SkRect src = SkRect::Make(fSmallTestPixels.fRect); |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 226 | SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY), |
| 227 | SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize)); |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 228 | |
| 229 | SkPaint paint; |
reed | 93a1215 | 2015-03-16 10:08:34 -0700 | [diff] [blame] | 230 | paint.setFilterQuality(filter); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 231 | paint.setShader(fShader); |
| 232 | paint.setColor(SK_ColorBLUE); |
| 233 | paint.setAntiAlias(aa); |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 234 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 235 | this->drawPixels(canvas, fSmallTestPixels, src, dst, &paint, constraint); |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 236 | } |
| 237 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 238 | // Draw the area of interest of the large image |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 239 | void drawCase2(SkCanvas* canvas, int transX, int transY, bool aa, |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 240 | SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) { |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 241 | SkRect src = SkRect::Make(fBigTestPixels.fRect); |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 242 | SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY), |
| 243 | SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize)); |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 244 | |
| 245 | SkPaint paint; |
reed | 93a1215 | 2015-03-16 10:08:34 -0700 | [diff] [blame] | 246 | paint.setFilterQuality(filter); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 247 | paint.setShader(fShader); |
| 248 | paint.setColor(SK_ColorBLUE); |
| 249 | paint.setAntiAlias(aa); |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 250 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 251 | this->drawPixels(canvas, fBigTestPixels, src, dst, &paint, constraint); |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 252 | } |
| 253 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 254 | // Draw upper-left 1/4 of the area of interest of the large image |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 255 | void drawCase3(SkCanvas* canvas, int transX, int transY, bool aa, |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 256 | SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) { |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 257 | SkRect src = SkRect::MakeXYWH(SkIntToScalar(fBigTestPixels.fRect.fLeft), |
| 258 | SkIntToScalar(fBigTestPixels.fRect.fTop), |
| 259 | fBigTestPixels.fRect.width()/2.f, |
| 260 | fBigTestPixels.fRect.height()/2.f); |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 261 | SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY), |
| 262 | SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize)); |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 263 | |
| 264 | SkPaint paint; |
reed | 93a1215 | 2015-03-16 10:08:34 -0700 | [diff] [blame] | 265 | paint.setFilterQuality(filter); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 266 | paint.setShader(fShader); |
| 267 | paint.setColor(SK_ColorBLUE); |
| 268 | paint.setAntiAlias(aa); |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 269 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 270 | this->drawPixels(canvas, fBigTestPixels, src, dst, &paint, constraint); |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 271 | } |
| 272 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 273 | // Draw the area of interest of the small image with a normal blur |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 274 | void drawCase4(SkCanvas* canvas, int transX, int transY, bool aa, |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 275 | SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) { |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 276 | SkRect src = SkRect::Make(fSmallTestPixels.fRect); |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 277 | SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY), |
| 278 | SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize)); |
robertphillips@google.com | 2cc0b47 | 2013-08-20 16:51:20 +0000 | [diff] [blame] | 279 | |
| 280 | SkPaint paint; |
reed | 93a1215 | 2015-03-16 10:08:34 -0700 | [diff] [blame] | 281 | paint.setFilterQuality(filter); |
Mike Reed | 1be1f8d | 2018-03-14 13:01:17 -0400 | [diff] [blame] | 282 | paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, |
reed | efdfd51 | 2016-04-04 10:02:58 -0700 | [diff] [blame] | 283 | SkBlurMask::ConvertRadiusToSigma(3))); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 284 | paint.setShader(fShader); |
| 285 | paint.setColor(SK_ColorBLUE); |
| 286 | paint.setAntiAlias(aa); |
robertphillips@google.com | 2cc0b47 | 2013-08-20 16:51:20 +0000 | [diff] [blame] | 287 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 288 | this->drawPixels(canvas, fSmallTestPixels, src, dst, &paint, constraint); |
robertphillips@google.com | 2cc0b47 | 2013-08-20 16:51:20 +0000 | [diff] [blame] | 289 | } |
| 290 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 291 | // Draw the area of interest of the small image with a outer blur |
bsalomon | f57ef1c | 2015-11-04 04:36:12 -0800 | [diff] [blame] | 292 | void drawCase5(SkCanvas* canvas, int transX, int transY, bool aa, |
| 293 | SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) { |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 294 | SkRect src = SkRect::Make(fSmallTestPixels.fRect); |
bsalomon | f57ef1c | 2015-11-04 04:36:12 -0800 | [diff] [blame] | 295 | SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY), |
| 296 | SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize)); |
| 297 | |
| 298 | SkPaint paint; |
| 299 | paint.setFilterQuality(filter); |
Mike Reed | 1be1f8d | 2018-03-14 13:01:17 -0400 | [diff] [blame] | 300 | paint.setMaskFilter(SkMaskFilter::MakeBlur(kOuter_SkBlurStyle, |
reed | efdfd51 | 2016-04-04 10:02:58 -0700 | [diff] [blame] | 301 | SkBlurMask::ConvertRadiusToSigma(7))); |
bsalomon | f57ef1c | 2015-11-04 04:36:12 -0800 | [diff] [blame] | 302 | paint.setShader(fShader); |
| 303 | paint.setColor(SK_ColorBLUE); |
| 304 | paint.setAntiAlias(aa); |
| 305 | |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 306 | this->drawPixels(canvas, fSmallTestPixels, src, dst, &paint, constraint); |
bsalomon | f57ef1c | 2015-11-04 04:36:12 -0800 | [diff] [blame] | 307 | } |
| 308 | |
bsalomon | a2e0837 | 2016-07-13 14:50:17 -0700 | [diff] [blame] | 309 | void onOnceBeforeDraw() override { |
| 310 | SkAssertResult(gBleedRec[fBT].fPixelMaker(&fSmallTestPixels, kSmallSize, kSmallSize)); |
| 311 | SkAssertResult(gBleedRec[fBT].fPixelMaker(&fBigTestPixels, 2 * kMaxTileSize, |
| 312 | 2 * kMaxTileSize)); |
| 313 | } |
| 314 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 315 | void onDraw(SkCanvas* canvas) override { |
reed | 2ad1aa6 | 2016-03-09 09:50:50 -0800 | [diff] [blame] | 316 | fShader = gBleedRec[fBT].fShaderMaker(); |
bsalomon | 5c1262d | 2015-11-09 10:06:06 -0800 | [diff] [blame] | 317 | |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 318 | canvas->clear(SK_ColorGRAY); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 319 | SkTDArray<SkMatrix> matrices; |
| 320 | // Draw with identity |
| 321 | *matrices.append() = SkMatrix::I(); |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 322 | |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 323 | // Draw with rotation and scale down in x, up in y. |
| 324 | SkMatrix m; |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame] | 325 | constexpr SkScalar kBottom = SkIntToScalar(kRow4Y + kBlockSize + kBlockSpacing); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 326 | m.setTranslate(0, kBottom); |
| 327 | m.preRotate(15.f, 0, kBottom + kBlockSpacing); |
| 328 | m.preScale(0.71f, 1.22f); |
| 329 | *matrices.append() = m; |
| 330 | |
| 331 | // Align the next set with the middle of the previous in y, translated to the right in x. |
| 332 | SkPoint corners[] = {{0, 0}, { 0, kBottom }, { kWidth, kBottom }, {kWidth, 0} }; |
| 333 | matrices[matrices.count()-1].mapPoints(corners, 4); |
| 334 | SkScalar y = (corners[0].fY + corners[1].fY + corners[2].fY + corners[3].fY) / 4; |
| 335 | SkScalar x = SkTMax(SkTMax(corners[0].fX, corners[1].fX), |
| 336 | SkTMax(corners[2].fX, corners[3].fX)); |
| 337 | m.setTranslate(x, y); |
| 338 | m.preScale(0.2f, 0.2f); |
| 339 | *matrices.append() = m; |
| 340 | |
| 341 | SkScalar maxX = 0; |
| 342 | for (int antiAlias = 0; antiAlias < 2; ++antiAlias) { |
commit-bot@chromium.org | d6ca4ac | 2013-11-22 20:34:59 +0000 | [diff] [blame] | 343 | canvas->save(); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 344 | canvas->translate(maxX, 0); |
| 345 | for (int m = 0; m < matrices.count(); ++m) { |
| 346 | canvas->save(); |
| 347 | canvas->concat(matrices[m]); |
| 348 | bool aa = SkToBool(antiAlias); |
| 349 | |
| 350 | // First draw a column with no bleeding and no filtering |
| 351 | this->drawCase1(canvas, kCol0X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality); |
| 352 | this->drawCase2(canvas, kCol0X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality); |
| 353 | this->drawCase3(canvas, kCol0X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality); |
| 354 | this->drawCase4(canvas, kCol0X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality); |
bsalomon | f57ef1c | 2015-11-04 04:36:12 -0800 | [diff] [blame] | 355 | this->drawCase5(canvas, kCol0X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 356 | |
| 357 | // Then draw a column with no bleeding and low filtering |
| 358 | this->drawCase1(canvas, kCol1X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality); |
| 359 | this->drawCase2(canvas, kCol1X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality); |
| 360 | this->drawCase3(canvas, kCol1X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality); |
| 361 | this->drawCase4(canvas, kCol1X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality); |
bsalomon | f57ef1c | 2015-11-04 04:36:12 -0800 | [diff] [blame] | 362 | this->drawCase5(canvas, kCol1X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 363 | |
| 364 | // Then draw a column with no bleeding and high filtering |
| 365 | this->drawCase1(canvas, kCol2X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality); |
| 366 | this->drawCase2(canvas, kCol2X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality); |
| 367 | this->drawCase3(canvas, kCol2X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality); |
| 368 | this->drawCase4(canvas, kCol2X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality); |
bsalomon | f57ef1c | 2015-11-04 04:36:12 -0800 | [diff] [blame] | 369 | this->drawCase5(canvas, kCol2X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 370 | |
| 371 | // Then draw a column with bleeding and no filtering (bleed should have no effect w/out blur) |
| 372 | this->drawCase1(canvas, kCol3X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality); |
| 373 | this->drawCase2(canvas, kCol3X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality); |
| 374 | this->drawCase3(canvas, kCol3X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality); |
| 375 | this->drawCase4(canvas, kCol3X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality); |
bsalomon | f57ef1c | 2015-11-04 04:36:12 -0800 | [diff] [blame] | 376 | this->drawCase5(canvas, kCol3X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 377 | |
| 378 | // Then draw a column with bleeding and low filtering |
| 379 | this->drawCase1(canvas, kCol4X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality); |
| 380 | this->drawCase2(canvas, kCol4X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality); |
| 381 | this->drawCase3(canvas, kCol4X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality); |
| 382 | this->drawCase4(canvas, kCol4X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality); |
bsalomon | f57ef1c | 2015-11-04 04:36:12 -0800 | [diff] [blame] | 383 | this->drawCase5(canvas, kCol4X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 384 | |
| 385 | // Finally draw a column with bleeding and high filtering |
| 386 | this->drawCase1(canvas, kCol5X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality); |
| 387 | this->drawCase2(canvas, kCol5X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality); |
| 388 | this->drawCase3(canvas, kCol5X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality); |
| 389 | this->drawCase4(canvas, kCol5X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality); |
bsalomon | f57ef1c | 2015-11-04 04:36:12 -0800 | [diff] [blame] | 390 | this->drawCase5(canvas, kCol5X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality); |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 391 | |
| 392 | SkPoint corners[] = { { 0, 0 },{ 0, kBottom },{ kWidth, kBottom },{ kWidth, 0 } }; |
| 393 | matrices[m].mapPoints(corners, 4); |
| 394 | SkScalar x = kBlockSize + SkTMax(SkTMax(corners[0].fX, corners[1].fX), |
| 395 | SkTMax(corners[2].fX, corners[3].fX)); |
| 396 | maxX = SkTMax(maxX, x); |
| 397 | canvas->restore(); |
commit-bot@chromium.org | d6ca4ac | 2013-11-22 20:34:59 +0000 | [diff] [blame] | 398 | } |
commit-bot@chromium.org | d6ca4ac | 2013-11-22 20:34:59 +0000 | [diff] [blame] | 399 | canvas->restore(); |
| 400 | } |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 401 | } |
| 402 | |
bsalomon | 4ee6bd8 | 2015-05-27 13:23:23 -0700 | [diff] [blame] | 403 | void modifyGrContextOptions(GrContextOptions* options) override { |
bsalomon | 8c07b7a | 2015-11-02 11:36:52 -0800 | [diff] [blame] | 404 | options->fMaxTileSizeOverride = kMaxTileSize; |
bsalomon | 4ee6bd8 | 2015-05-27 13:23:23 -0700 | [diff] [blame] | 405 | } |
bsalomon | 4ee6bd8 | 2015-05-27 13:23:23 -0700 | [diff] [blame] | 406 | |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 407 | private: |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame] | 408 | static constexpr int kBlockSize = 70; |
| 409 | static constexpr int kBlockSpacing = 12; |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 410 | |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame] | 411 | static constexpr int kCol0X = kBlockSpacing; |
| 412 | static constexpr int kCol1X = 2*kBlockSpacing + kBlockSize; |
| 413 | static constexpr int kCol2X = 3*kBlockSpacing + 2*kBlockSize; |
| 414 | static constexpr int kCol3X = 4*kBlockSpacing + 3*kBlockSize; |
| 415 | static constexpr int kCol4X = 5*kBlockSpacing + 4*kBlockSize; |
| 416 | static constexpr int kCol5X = 6*kBlockSpacing + 5*kBlockSize; |
| 417 | static constexpr int kWidth = 7*kBlockSpacing + 6*kBlockSize; |
robertphillips@google.com | d7ca661 | 2013-08-20 12:09:32 +0000 | [diff] [blame] | 418 | |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame] | 419 | static constexpr int kRow0Y = kBlockSpacing; |
| 420 | static constexpr int kRow1Y = 2*kBlockSpacing + kBlockSize; |
| 421 | static constexpr int kRow2Y = 3*kBlockSpacing + 2*kBlockSize; |
| 422 | static constexpr int kRow3Y = 4*kBlockSpacing + 3*kBlockSize; |
| 423 | static constexpr int kRow4Y = 5*kBlockSpacing + 4*kBlockSize; |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 424 | |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame] | 425 | static constexpr int kSmallSize = 6; |
| 426 | static constexpr int kMaxTileSize = 32; |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 427 | |
reed | 2ad1aa6 | 2016-03-09 09:50:50 -0800 | [diff] [blame] | 428 | TestPixels fBigTestPixels; |
| 429 | TestPixels fSmallTestPixels; |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 430 | |
reed | 2ad1aa6 | 2016-03-09 09:50:50 -0800 | [diff] [blame] | 431 | sk_sp<SkShader> fShader; |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 432 | |
reed | 2ad1aa6 | 2016-03-09 09:50:50 -0800 | [diff] [blame] | 433 | const BleedTest fBT; |
robertphillips@google.com | aaa9b29 | 2013-07-25 21:34:00 +0000 | [diff] [blame] | 434 | |
| 435 | typedef GM INHERITED; |
| 436 | }; |
| 437 | |
bsalomon | 9c58654 | 2015-11-02 12:33:21 -0800 | [diff] [blame] | 438 | |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 439 | DEF_GM( return new BleedGM(kUseBitmap_BleedTest); ) |
| 440 | DEF_GM( return new BleedGM(kUseImage_BleedTest); ) |
bsalomon | 9003d1e | 2015-10-23 11:13:01 -0700 | [diff] [blame] | 441 | DEF_GM( return new BleedGM(kUseAlphaBitmap_BleedTest); ) |
| 442 | DEF_GM( return new BleedGM(kUseAlphaImage_BleedTest); ) |
bsalomon | 9c58654 | 2015-11-02 12:33:21 -0800 | [diff] [blame] | 443 | DEF_GM( return new BleedGM(kUseAlphaBitmapShader_BleedTest); ) |
bsalomon | 9c58654 | 2015-11-02 12:33:21 -0800 | [diff] [blame] | 444 | DEF_GM( return new BleedGM(kUseAlphaImageShader_BleedTest); ) |
reed | 2adecda | 2016-07-25 08:11:58 -0700 | [diff] [blame] | 445 | |
| 446 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 447 | #include "SkSurface.h" |
| 448 | |
reed | 2adecda | 2016-07-25 08:11:58 -0700 | [diff] [blame] | 449 | // Construct an image and return the inner "src" rect. Build the image such that the interior is |
| 450 | // blue, with a margin of blue (2px) but then an outer margin of red. |
| 451 | // |
| 452 | // Show that kFast_SrcRectConstraint sees even the red margin (due to mipmapping) when the image |
| 453 | // is scaled down far enough. |
| 454 | // |
| 455 | static sk_sp<SkImage> make_image(SkCanvas* canvas, SkRect* srcR) { |
egdaniel | 26318c9 | 2016-07-26 08:26:46 -0700 | [diff] [blame] | 456 | // Intentially making the size a power of 2 to avoid the noise from how different GPUs will |
| 457 | // produce different mipmap filtering when we have an odd sized texture. |
| 458 | const int N = 10 + 2 + 8 + 2 + 10; |
reed | 2adecda | 2016-07-25 08:11:58 -0700 | [diff] [blame] | 459 | SkImageInfo info = SkImageInfo::MakeN32Premul(N, N); |
Mike Klein | ea3f014 | 2019-03-20 11:12:10 -0500 | [diff] [blame] | 460 | auto surface = ToolUtils::makeSurface(canvas, info); |
reed | 2adecda | 2016-07-25 08:11:58 -0700 | [diff] [blame] | 461 | SkCanvas* c = surface->getCanvas(); |
| 462 | SkRect r = SkRect::MakeIWH(info.width(), info.height()); |
| 463 | SkPaint paint; |
| 464 | |
| 465 | paint.setColor(SK_ColorRED); |
| 466 | c->drawRect(r, paint); |
egdaniel | 26318c9 | 2016-07-26 08:26:46 -0700 | [diff] [blame] | 467 | r.inset(10, 10); |
reed | 2adecda | 2016-07-25 08:11:58 -0700 | [diff] [blame] | 468 | paint.setColor(SK_ColorBLUE); |
| 469 | c->drawRect(r, paint); |
| 470 | |
| 471 | *srcR = r.makeInset(2, 2); |
| 472 | return surface->makeImageSnapshot(); |
| 473 | } |
| 474 | |
| 475 | DEF_SIMPLE_GM(bleed_downscale, canvas, 360, 240) { |
| 476 | SkRect src; |
| 477 | sk_sp<SkImage> img = make_image(canvas, &src); |
| 478 | SkPaint paint; |
| 479 | |
| 480 | canvas->translate(10, 10); |
| 481 | |
| 482 | const SkCanvas::SrcRectConstraint constraints[] = { |
| 483 | SkCanvas::kStrict_SrcRectConstraint, SkCanvas::kFast_SrcRectConstraint |
| 484 | }; |
| 485 | const SkFilterQuality qualities[] = { |
| 486 | kNone_SkFilterQuality, kLow_SkFilterQuality, kMedium_SkFilterQuality |
| 487 | }; |
| 488 | for (auto constraint : constraints) { |
| 489 | canvas->save(); |
| 490 | for (auto quality : qualities) { |
| 491 | paint.setFilterQuality(quality); |
Mike Klein | ea3f014 | 2019-03-20 11:12:10 -0500 | [diff] [blame] | 492 | auto surf = ToolUtils::makeSurface(canvas, SkImageInfo::MakeN32Premul(1, 1)); |
reed | 2adecda | 2016-07-25 08:11:58 -0700 | [diff] [blame] | 493 | surf->getCanvas()->drawImageRect(img, src, SkRect::MakeWH(1, 1), &paint, constraint); |
| 494 | // now blow up the 1 pixel result |
| 495 | canvas->drawImageRect(surf->makeImageSnapshot(), SkRect::MakeWH(100, 100), nullptr); |
| 496 | canvas->translate(120, 0); |
| 497 | } |
| 498 | canvas->restore(); |
| 499 | canvas->translate(0, 120); |
| 500 | } |
| 501 | } |
| 502 | |
| 503 | |