OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "gm.h" | 8 #include "gm.h" |
9 #include "SkBlurMask.h" | 9 #include "SkBlurMask.h" |
10 #include "SkBlurMaskFilter.h" | 10 #include "SkBlurMaskFilter.h" |
11 #include "SkCanvas.h" | 11 #include "SkCanvas.h" |
| 12 #include "SkGradientShader.h" |
12 #include "SkImage.h" | 13 #include "SkImage.h" |
13 | 14 |
14 #if SK_SUPPORT_GPU | 15 #if SK_SUPPORT_GPU |
15 #include "GrContext.h" | 16 #include "GrContext.h" |
16 #include "GrContextOptions.h" | 17 #include "GrContextOptions.h" |
17 #endif | 18 #endif |
18 | 19 |
19 static void draw_bitmap_rect(SkCanvas* canvas, const SkBitmap& bitmap, const SkI
mage*, | 20 static void draw_bitmap_rect(SkCanvas* canvas, const SkBitmap& bitmap, const SkI
mage*, |
20 const SkRect& src, const SkRect& dst, | 21 const SkRect& src, const SkRect& dst, |
21 const SkPaint* paint, SkCanvas::SrcRectConstraint c
onstraint) { | 22 const SkPaint* paint, SkCanvas::SrcRectConstraint c
onstraint) { |
22 canvas->drawBitmapRect(bitmap, src, dst, paint, constraint); | 23 canvas->drawBitmapRect(bitmap, src, dst, paint, constraint); |
23 } | 24 } |
24 | 25 |
25 static void draw_image_rect(SkCanvas* canvas, const SkBitmap&, const SkImage* im
age, | 26 static void draw_image_rect(SkCanvas* canvas, const SkBitmap&, const SkImage* im
age, |
26 const SkRect& src, const SkRect& dst, | 27 const SkRect& src, const SkRect& dst, |
27 const SkPaint* paint, SkCanvas::SrcRectConstraint co
nstraint) { | 28 const SkPaint* paint, SkCanvas::SrcRectConstraint co
nstraint) { |
28 canvas->drawImageRect(image, src, dst, paint, constraint); | 29 canvas->drawImageRect(image, src, dst, paint, constraint); |
29 } | 30 } |
30 | 31 |
31 enum BleedTest { | |
32 kUseBitmap_BleedTest, | |
33 kUseImage_BleedTest, | |
34 }; | |
35 | |
36 const struct { | |
37 const char* fName; | |
38 void (*fDraw)(SkCanvas*, const SkBitmap&, const SkImage*, const SkRect&, con
st SkRect&, | |
39 const SkPaint*, SkCanvas::SrcRectConstraint); | |
40 } gBleedRec[] = { | |
41 { "bleed", draw_bitmap_rect }, | |
42 { "bleed_image", draw_image_rect }, | |
43 }; | |
44 | |
45 // Create a black&white checked texture with 2 1-pixel rings | 32 // Create a black&white checked texture with 2 1-pixel rings |
46 // around the outside edge. The inner ring is red and the outer ring is blue. | 33 // around the outside edge. The inner ring is red and the outer ring is blue. |
47 static void make_ringed_bitmap(SkBitmap* result, int width, int height) { | 34 static void make_ringed_color_bitmap(SkBitmap* result, int width, int height) { |
48 SkASSERT(0 == width % 2 && 0 == height % 2); | 35 SkASSERT(0 == width % 2 && 0 == height % 2); |
49 | 36 |
50 static const SkPMColor kRed = SkPreMultiplyColor(SK_ColorRED); | 37 static const SkPMColor kRed = SkPreMultiplyColor(SK_ColorRED); |
51 static const SkPMColor kBlue = SkPreMultiplyColor(SK_ColorBLUE); | 38 static const SkPMColor kBlue = SkPreMultiplyColor(SK_ColorBLUE); |
52 static const SkPMColor kBlack = SkPreMultiplyColor(SK_ColorBLACK); | 39 static const SkPMColor kBlack = SkPreMultiplyColor(SK_ColorBLACK); |
53 static const SkPMColor kWhite = SkPreMultiplyColor(SK_ColorWHITE); | 40 static const SkPMColor kWhite = SkPreMultiplyColor(SK_ColorWHITE); |
54 | 41 |
55 result->allocN32Pixels(width, height, true); | 42 result->allocN32Pixels(width, height, true); |
56 | 43 |
57 SkPMColor* scanline = result->getAddr32(0, 0); | 44 SkPMColor* scanline = result->getAddr32(0, 0); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
100 } | 87 } |
101 scanline[width-1] = kBlue; | 88 scanline[width-1] = kBlue; |
102 | 89 |
103 scanline = result->getAddr32(0, height-1); | 90 scanline = result->getAddr32(0, height-1); |
104 for (int x = 0; x < width; ++x) { | 91 for (int x = 0; x < width; ++x) { |
105 scanline[x] = kBlue; | 92 scanline[x] = kBlue; |
106 } | 93 } |
107 result->setImmutable(); | 94 result->setImmutable(); |
108 } | 95 } |
109 | 96 |
| 97 /** Makes a alpha bitmap with 1 wide rect/ring of 1s, an inset of 0s, and the in
terior is a 2x2 |
| 98 checker board of 3/4 and 1/2. The inner checkers are large enough to fill th
e interior with |
| 99 the 2x2 checker grid. */ |
| 100 static void make_ringed_alpha_bitmap(SkBitmap* result, int width, int height) { |
| 101 SkASSERT(0 == width % 2 && 0 == height % 2); |
| 102 |
| 103 static const SkPMColor kZero = 0x00; |
| 104 static const SkPMColor kHalf = 0x80; |
| 105 static const SkPMColor k3Q = 0xC0; |
| 106 static const SkPMColor kOne = 0xFF; |
| 107 SkImageInfo info = SkImageInfo::MakeA8(width, height); |
| 108 // The 4 byte alignment seems to be necessary to allow this bmp to be conver
ted |
| 109 // to an image. |
| 110 result->allocPixels(info, SkAlign4(width)); |
| 111 |
| 112 uint8_t* scanline = result->getAddr8(0, 0); |
| 113 for (int x = 0; x < width; ++x) { |
| 114 scanline[x] = kOne; |
| 115 } |
| 116 scanline = result->getAddr8(0, 1); |
| 117 scanline[0] = kOne; |
| 118 for (int x = 1; x < width - 1; ++x) { |
| 119 scanline[x] = kZero; |
| 120 } |
| 121 scanline[width - 1] = kOne; |
| 122 |
| 123 for (int y = 2; y < height / 2; ++y) { |
| 124 scanline = result->getAddr8(0, y); |
| 125 scanline[0] = kOne; |
| 126 scanline[1] = kZero; |
| 127 for (int x = 2; x < width / 2; ++x) { |
| 128 scanline[x] = k3Q; |
| 129 } |
| 130 for (int x = width / 2; x < width - 2; ++x) { |
| 131 scanline[x] = kHalf; |
| 132 } |
| 133 scanline[width - 2] = kZero; |
| 134 scanline[width - 1] = kOne; |
| 135 } |
| 136 |
| 137 for (int y = height / 2; y < height - 2; ++y) { |
| 138 scanline = result->getAddr8(0, y); |
| 139 scanline[0] = kOne; |
| 140 scanline[1] = kZero; |
| 141 for (int x = 2; x < width / 2; ++x) { |
| 142 scanline[x] = kHalf; |
| 143 } |
| 144 for (int x = width / 2; x < width - 2; ++x) { |
| 145 scanline[x] = k3Q; |
| 146 } |
| 147 scanline[width - 2] = kZero; |
| 148 scanline[width - 1] = kOne; |
| 149 } |
| 150 |
| 151 scanline = result->getAddr8(0, height - 2); |
| 152 scanline[0] = kOne; |
| 153 for (int x = 1; x < width - 1; ++x) { |
| 154 scanline[x] = kZero; |
| 155 } |
| 156 scanline[width - 1] = kOne; |
| 157 |
| 158 scanline = result->getAddr8(0, height - 1); |
| 159 for (int x = 0; x < width; ++x) { |
| 160 scanline[x] = kOne; |
| 161 } |
| 162 result->setImmutable(); |
| 163 } |
| 164 |
| 165 static SkShader* make_shader() { |
| 166 static const SkPoint pts[] = { {0, 0}, {20, 20} }; |
| 167 static const SkColor colors[] = { SK_ColorGREEN, SK_ColorYELLOW }; |
| 168 return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kMi
rror_TileMode); |
| 169 } |
| 170 |
| 171 static SkShader* make_null_shader() { return nullptr; } |
| 172 |
| 173 enum BleedTest { |
| 174 kUseBitmap_BleedTest, |
| 175 kUseImage_BleedTest, |
| 176 kUseAlphaBitmap_BleedTest, |
| 177 kUseAlphaImage_BleedTest, |
| 178 kUseAlphaBitmapShader_BleedTest, |
| 179 kUseAlphaImageShader_BleedTest, |
| 180 }; |
| 181 |
| 182 const struct { |
| 183 const char* fName; |
| 184 void(*fBmpMaker)(SkBitmap* result, int width, int height); |
| 185 SkShader*(*fShaderMaker)(); |
| 186 void(*fDraw)(SkCanvas*, const SkBitmap&, const SkImage*, const SkRect&, cons
t SkRect&, |
| 187 const SkPaint*, SkCanvas::SrcRectConstraint); |
| 188 } gBleedRec[] = { |
| 189 { "bleed", make_ringed_color_bitmap, make_null_shader,
draw_bitmap_rect }, |
| 190 { "bleed_image", make_ringed_color_bitmap, make_null_shader,
draw_image_rect }, |
| 191 { "bleed_alpha_bmp", make_ringed_alpha_bitmap, make_null_shader,
draw_bitmap_rect }, |
| 192 { "bleed_alpha_image", make_ringed_alpha_bitmap, make_null_shader,
draw_image_rect }, |
| 193 { "bleed_alpha_bmp_shader", make_ringed_alpha_bitmap, make_shader,
draw_bitmap_rect }, |
| 194 { "bleed_alpha_image_shader", make_ringed_alpha_bitmap, make_shader,
draw_image_rect }, |
| 195 }; |
| 196 |
110 // This GM exercises the drawBitmapRect constraints | 197 // This GM exercises the drawBitmapRect constraints |
111 class BleedGM : public skiagm::GM { | 198 class BleedGM : public skiagm::GM { |
112 public: | 199 public: |
113 BleedGM(BleedTest bt) : fBT(bt) {} | 200 BleedGM(BleedTest bt) : fBT(bt) {} |
114 | 201 |
115 protected: | 202 protected: |
116 | 203 |
117 SkString onShortName() override { | 204 SkString onShortName() override { |
118 return SkString(gBleedRec[fBT].fName); | 205 return SkString(gBleedRec[fBT].fName); |
119 } | 206 } |
120 | 207 |
121 SkISize onISize() override { | 208 SkISize onISize() override { |
122 return SkISize::Make(kWidth, 780); | 209 return SkISize::Make(1050, 780); |
123 } | 210 } |
124 | 211 |
125 void onOnceBeforeDraw() override { | 212 void onOnceBeforeDraw() override { |
126 make_ringed_bitmap(&fBitmapSmall, kSmallTextureSize, kSmallTextureSize); | 213 gBleedRec[fBT].fBmpMaker(&fBitmapSmall, kSmallTextureSize, kSmallTexture
Size); |
127 fImageSmall.reset(SkImage::NewFromBitmap(fBitmapSmall)); | 214 fImageSmall.reset(SkImage::NewFromBitmap(fBitmapSmall)); |
128 | 215 |
129 // To exercise the GPU's tiling path we need a texture | 216 // To exercise the GPU's tiling path we need a texture |
130 // too big for the GPU to handle in one go | 217 // too big for the GPU to handle in one go |
131 make_ringed_bitmap(&fBitmapBig, 2*kMaxTextureSize, 2*kMaxTextureSize); | 218 gBleedRec[fBT].fBmpMaker(&fBitmapBig, 2*kMaxTextureSize, 2*kMaxTextureSi
ze); |
132 fImageBig.reset(SkImage::NewFromBitmap(fBitmapBig)); | 219 fImageBig.reset(SkImage::NewFromBitmap(fBitmapBig)); |
| 220 |
| 221 fShader.reset(gBleedRec[fBT].fShaderMaker()); |
133 } | 222 } |
134 | 223 |
135 // Draw only the center of the small bitmap | 224 // Draw only the center of the small bitmap |
136 void drawCase1(SkCanvas* canvas, int transX, int transY, | 225 void drawCase1(SkCanvas* canvas, int transX, int transY, bool aa, |
137 SkCanvas::SrcRectConstraint constraint, SkFilterQuality filte
r) { | 226 SkCanvas::SrcRectConstraint constraint, SkFilterQuality filte
r) { |
138 SkRect src = SkRect::MakeXYWH(2, 2, | 227 SkRect src = SkRect::MakeXYWH(2, 2, |
139 SkIntToScalar(kSmallTextureSize-4), | 228 SkIntToScalar(kSmallTextureSize-4), |
140 SkIntToScalar(kSmallTextureSize-4)); | 229 SkIntToScalar(kSmallTextureSize-4)); |
141 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(trans
Y), | 230 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(trans
Y), |
142 SkIntToScalar(kBlockSize), SkIntToScalar(k
BlockSize)); | 231 SkIntToScalar(kBlockSize), SkIntToScalar(k
BlockSize)); |
143 | 232 |
144 SkPaint paint; | 233 SkPaint paint; |
145 paint.setFilterQuality(filter); | 234 paint.setFilterQuality(filter); |
| 235 paint.setShader(fShader); |
| 236 paint.setColor(SK_ColorBLUE); |
| 237 paint.setAntiAlias(aa); |
146 | 238 |
147 gBleedRec[fBT].fDraw(canvas, fBitmapSmall, fImageSmall, src, dst, &paint
, constraint); | 239 gBleedRec[fBT].fDraw(canvas, fBitmapSmall, fImageSmall, src, dst, &paint
, constraint); |
148 } | 240 } |
149 | 241 |
150 // Draw almost all of the large bitmap | 242 // Draw almost all of the large bitmap |
151 void drawCase2(SkCanvas* canvas, int transX, int transY, | 243 void drawCase2(SkCanvas* canvas, int transX, int transY, bool aa, |
152 SkCanvas::SrcRectConstraint constraint, SkFilterQuality filte
r) { | 244 SkCanvas::SrcRectConstraint constraint, SkFilterQuality filte
r) { |
153 SkRect src = SkRect::MakeXYWH(2, 2, | 245 SkRect src = SkRect::MakeXYWH(2, 2, |
154 SkIntToScalar(fBitmapBig.width()-4), | 246 SkIntToScalar(fBitmapBig.width()-4), |
155 SkIntToScalar(fBitmapBig.height()-4)); | 247 SkIntToScalar(fBitmapBig.height()-4)); |
156 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(trans
Y), | 248 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(trans
Y), |
157 SkIntToScalar(kBlockSize), SkIntToScalar(k
BlockSize)); | 249 SkIntToScalar(kBlockSize), SkIntToScalar(k
BlockSize)); |
158 | 250 |
159 SkPaint paint; | 251 SkPaint paint; |
160 paint.setFilterQuality(filter); | 252 paint.setFilterQuality(filter); |
| 253 paint.setShader(fShader); |
| 254 paint.setColor(SK_ColorBLUE); |
| 255 paint.setAntiAlias(aa); |
161 | 256 |
162 gBleedRec[fBT].fDraw(canvas, fBitmapBig, fImageBig, src, dst, &paint, co
nstraint); | 257 gBleedRec[fBT].fDraw(canvas, fBitmapBig, fImageBig, src, dst, &paint, co
nstraint); |
163 } | 258 } |
164 | 259 |
165 // Draw ~1/4 of the large bitmap | 260 // Draw ~1/4 of the large bitmap |
166 void drawCase3(SkCanvas* canvas, int transX, int transY, | 261 void drawCase3(SkCanvas* canvas, int transX, int transY, bool aa, |
167 SkCanvas::SrcRectConstraint constraint, SkFilterQuality filte
r) { | 262 SkCanvas::SrcRectConstraint constraint, SkFilterQuality filte
r) { |
168 SkRect src = SkRect::MakeXYWH(2, 2, | 263 SkRect src = SkRect::MakeXYWH(2, 2, |
169 SkIntToScalar(fBitmapBig.width()/2-2), | 264 SkIntToScalar(fBitmapBig.width()/2-2), |
170 SkIntToScalar(fBitmapBig.height()/2-2)); | 265 SkIntToScalar(fBitmapBig.height()/2-2)); |
171 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(trans
Y), | 266 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(trans
Y), |
172 SkIntToScalar(kBlockSize), SkIntToScalar(k
BlockSize)); | 267 SkIntToScalar(kBlockSize), SkIntToScalar(k
BlockSize)); |
173 | 268 |
174 SkPaint paint; | 269 SkPaint paint; |
175 paint.setFilterQuality(filter); | 270 paint.setFilterQuality(filter); |
| 271 paint.setShader(fShader); |
| 272 paint.setColor(SK_ColorBLUE); |
| 273 paint.setAntiAlias(aa); |
176 | 274 |
177 gBleedRec[fBT].fDraw(canvas, fBitmapBig, fImageBig, src, dst, &paint, co
nstraint); | 275 gBleedRec[fBT].fDraw(canvas, fBitmapBig, fImageBig, src, dst, &paint, co
nstraint); |
178 } | 276 } |
179 | 277 |
180 // Draw the center of the small bitmap with a mask filter | 278 // Draw the center of the small bitmap with a mask filter |
181 void drawCase4(SkCanvas* canvas, int transX, int transY, | 279 void drawCase4(SkCanvas* canvas, int transX, int transY, bool aa, |
182 SkCanvas::SrcRectConstraint constraint, SkFilterQuality filte
r) { | 280 SkCanvas::SrcRectConstraint constraint, SkFilterQuality filte
r) { |
183 SkRect src = SkRect::MakeXYWH(2, 2, | 281 SkRect src = SkRect::MakeXYWH(2, 2, |
184 SkIntToScalar(kSmallTextureSize-4), | 282 SkIntToScalar(kSmallTextureSize-4), |
185 SkIntToScalar(kSmallTextureSize-4)); | 283 SkIntToScalar(kSmallTextureSize-4)); |
186 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(trans
Y), | 284 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(trans
Y), |
187 SkIntToScalar(kBlockSize), SkIntToScalar(k
BlockSize)); | 285 SkIntToScalar(kBlockSize), SkIntToScalar(k
BlockSize)); |
188 | 286 |
189 SkPaint paint; | 287 SkPaint paint; |
190 paint.setFilterQuality(filter); | 288 paint.setFilterQuality(filter); |
191 SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle, | 289 SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle, |
192 SkBlurMask::ConvertRadiusToSigma(3)); | 290 SkBlurMask::ConvertRadiusToSigma(3)); |
193 paint.setMaskFilter(mf)->unref(); | 291 paint.setMaskFilter(mf)->unref(); |
| 292 paint.setShader(fShader); |
| 293 paint.setColor(SK_ColorBLUE); |
| 294 paint.setAntiAlias(aa); |
194 | 295 |
195 gBleedRec[fBT].fDraw(canvas, fBitmapSmall, fImageSmall, src, dst, &paint
, constraint); | 296 gBleedRec[fBT].fDraw(canvas, fBitmapSmall, fImageSmall, src, dst, &paint
, constraint); |
196 } | 297 } |
197 | 298 |
198 void onDraw(SkCanvas* canvas) override { | 299 void onDraw(SkCanvas* canvas) override { |
| 300 canvas->clear(SK_ColorGRAY); |
| 301 SkTDArray<SkMatrix> matrices; |
| 302 // Draw with identity |
| 303 *matrices.append() = SkMatrix::I(); |
199 | 304 |
200 canvas->clear(SK_ColorGRAY); | 305 // Draw with rotation and scale down in x, up in y. |
| 306 SkMatrix m; |
| 307 static const SkScalar kBottom = SkIntToScalar(kRow3Y + kBlockSize + kBlo
ckSpacing); |
| 308 m.setTranslate(0, kBottom); |
| 309 m.preRotate(15.f, 0, kBottom + kBlockSpacing); |
| 310 m.preScale(0.71f, 1.22f); |
| 311 *matrices.append() = m; |
201 | 312 |
202 for (int m = 0; m < 2; ++m) { | 313 // Align the next set with the middle of the previous in y, translated t
o the right in x. |
| 314 SkPoint corners[] = {{0, 0}, { 0, kBottom }, { kWidth, kBottom }, {kWidt
h, 0} }; |
| 315 matrices[matrices.count()-1].mapPoints(corners, 4); |
| 316 SkScalar y = (corners[0].fY + corners[1].fY + corners[2].fY + corners[3]
.fY) / 4; |
| 317 SkScalar x = SkTMax(SkTMax(corners[0].fX, corners[1].fX), |
| 318 SkTMax(corners[2].fX, corners[3].fX)); |
| 319 m.setTranslate(x, y); |
| 320 m.preScale(0.2f, 0.2f); |
| 321 *matrices.append() = m; |
| 322 |
| 323 SkScalar maxX = 0; |
| 324 for (int antiAlias = 0; antiAlias < 2; ++antiAlias) { |
203 canvas->save(); | 325 canvas->save(); |
204 if (m) { | 326 canvas->translate(maxX, 0); |
205 static const SkScalar kBottom = SkIntToScalar(kRow3Y + kBlockSiz
e + kBlockSpacing); | 327 for (int m = 0; m < matrices.count(); ++m) { |
206 canvas->translate(0, kBottom); | 328 canvas->save(); |
207 SkMatrix rotate; | 329 canvas->concat(matrices[m]); |
208 rotate.setRotate(15.f, 0, kBottom + kBlockSpacing); | 330 bool aa = SkToBool(antiAlias); |
209 canvas->concat(rotate); | 331 |
210 canvas->scale(0.71f, 1.22f); | 332 // First draw a column with no bleeding and no filtering |
| 333 this->drawCase1(canvas, kCol0X, kRow0Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kNone_SkFilterQuality); |
| 334 this->drawCase2(canvas, kCol0X, kRow1Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kNone_SkFilterQuality); |
| 335 this->drawCase3(canvas, kCol0X, kRow2Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kNone_SkFilterQuality); |
| 336 this->drawCase4(canvas, kCol0X, kRow3Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kNone_SkFilterQuality); |
| 337 |
| 338 // Then draw a column with no bleeding and low filtering |
| 339 this->drawCase1(canvas, kCol1X, kRow0Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kLow_SkFilterQuality); |
| 340 this->drawCase2(canvas, kCol1X, kRow1Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kLow_SkFilterQuality); |
| 341 this->drawCase3(canvas, kCol1X, kRow2Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kLow_SkFilterQuality); |
| 342 this->drawCase4(canvas, kCol1X, kRow3Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kLow_SkFilterQuality); |
| 343 |
| 344 // Then draw a column with no bleeding and high filtering |
| 345 this->drawCase1(canvas, kCol2X, kRow0Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kHigh_SkFilterQuality); |
| 346 this->drawCase2(canvas, kCol2X, kRow1Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kHigh_SkFilterQuality); |
| 347 this->drawCase3(canvas, kCol2X, kRow2Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kHigh_SkFilterQuality); |
| 348 this->drawCase4(canvas, kCol2X, kRow3Y, aa, SkCanvas::kStrict_Sr
cRectConstraint, kHigh_SkFilterQuality); |
| 349 |
| 350 // Then draw a column with bleeding and no filtering (bleed shou
ld have no effect w/out blur) |
| 351 this->drawCase1(canvas, kCol3X, kRow0Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kNone_SkFilterQuality); |
| 352 this->drawCase2(canvas, kCol3X, kRow1Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kNone_SkFilterQuality); |
| 353 this->drawCase3(canvas, kCol3X, kRow2Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kNone_SkFilterQuality); |
| 354 this->drawCase4(canvas, kCol3X, kRow3Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kNone_SkFilterQuality); |
| 355 |
| 356 // Then draw a column with bleeding and low filtering |
| 357 this->drawCase1(canvas, kCol4X, kRow0Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kLow_SkFilterQuality); |
| 358 this->drawCase2(canvas, kCol4X, kRow1Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kLow_SkFilterQuality); |
| 359 this->drawCase3(canvas, kCol4X, kRow2Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kLow_SkFilterQuality); |
| 360 this->drawCase4(canvas, kCol4X, kRow3Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kLow_SkFilterQuality); |
| 361 |
| 362 // Finally draw a column with bleeding and high filtering |
| 363 this->drawCase1(canvas, kCol5X, kRow0Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kHigh_SkFilterQuality); |
| 364 this->drawCase2(canvas, kCol5X, kRow1Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kHigh_SkFilterQuality); |
| 365 this->drawCase3(canvas, kCol5X, kRow2Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kHigh_SkFilterQuality); |
| 366 this->drawCase4(canvas, kCol5X, kRow3Y, aa, SkCanvas::kFast_SrcR
ectConstraint, kHigh_SkFilterQuality); |
| 367 |
| 368 SkPoint corners[] = { { 0, 0 },{ 0, kBottom },{ kWidth, kBottom
},{ kWidth, 0 } }; |
| 369 matrices[m].mapPoints(corners, 4); |
| 370 SkScalar x = kBlockSize + SkTMax(SkTMax(corners[0].fX, corners[1
].fX), |
| 371 SkTMax(corners[2].fX, corners[3
].fX)); |
| 372 maxX = SkTMax(maxX, x); |
| 373 canvas->restore(); |
211 } | 374 } |
212 | |
213 // First draw a column with no bleeding and no filtering | |
214 this->drawCase1(canvas, kCol0X, kRow0Y, SkCanvas::kStrict_SrcRectCon
straint, kNone_SkFilterQuality); | |
215 this->drawCase2(canvas, kCol0X, kRow1Y, SkCanvas::kStrict_SrcRectCon
straint, kNone_SkFilterQuality); | |
216 this->drawCase3(canvas, kCol0X, kRow2Y, SkCanvas::kStrict_SrcRectCon
straint, kNone_SkFilterQuality); | |
217 this->drawCase4(canvas, kCol0X, kRow3Y, SkCanvas::kStrict_SrcRectCon
straint, kNone_SkFilterQuality); | |
218 | |
219 // Then draw a column with no bleeding and low filtering | |
220 this->drawCase1(canvas, kCol1X, kRow0Y, SkCanvas::kStrict_SrcRectCon
straint, kLow_SkFilterQuality); | |
221 this->drawCase2(canvas, kCol1X, kRow1Y, SkCanvas::kStrict_SrcRectCon
straint, kLow_SkFilterQuality); | |
222 this->drawCase3(canvas, kCol1X, kRow2Y, SkCanvas::kStrict_SrcRectCon
straint, kLow_SkFilterQuality); | |
223 this->drawCase4(canvas, kCol1X, kRow3Y, SkCanvas::kStrict_SrcRectCon
straint, kLow_SkFilterQuality); | |
224 | |
225 // Then draw a column with no bleeding and high filtering | |
226 this->drawCase1(canvas, kCol2X, kRow0Y, SkCanvas::kStrict_SrcRectCon
straint, kHigh_SkFilterQuality); | |
227 this->drawCase2(canvas, kCol2X, kRow1Y, SkCanvas::kStrict_SrcRectCon
straint, kHigh_SkFilterQuality); | |
228 this->drawCase3(canvas, kCol2X, kRow2Y, SkCanvas::kStrict_SrcRectCon
straint, kHigh_SkFilterQuality); | |
229 this->drawCase4(canvas, kCol2X, kRow3Y, SkCanvas::kStrict_SrcRectCon
straint, kHigh_SkFilterQuality); | |
230 | |
231 // Then draw a column with bleeding and no filtering (bleed should h
ave no effect w/out blur) | |
232 this->drawCase1(canvas, kCol3X, kRow0Y, SkCanvas::kFast_SrcRectConst
raint, kNone_SkFilterQuality); | |
233 this->drawCase2(canvas, kCol3X, kRow1Y, SkCanvas::kFast_SrcRectConst
raint, kNone_SkFilterQuality); | |
234 this->drawCase3(canvas, kCol3X, kRow2Y, SkCanvas::kFast_SrcRectConst
raint, kNone_SkFilterQuality); | |
235 this->drawCase4(canvas, kCol3X, kRow3Y, SkCanvas::kFast_SrcRectConst
raint, kNone_SkFilterQuality); | |
236 | |
237 // Then draw a column with bleeding and low filtering | |
238 this->drawCase1(canvas, kCol4X, kRow0Y, SkCanvas::kFast_SrcRectConst
raint, kLow_SkFilterQuality); | |
239 this->drawCase2(canvas, kCol4X, kRow1Y, SkCanvas::kFast_SrcRectConst
raint, kLow_SkFilterQuality); | |
240 this->drawCase3(canvas, kCol4X, kRow2Y, SkCanvas::kFast_SrcRectConst
raint, kLow_SkFilterQuality); | |
241 this->drawCase4(canvas, kCol4X, kRow3Y, SkCanvas::kFast_SrcRectConst
raint, kLow_SkFilterQuality); | |
242 | |
243 // Finally draw a column with bleeding and high filtering | |
244 this->drawCase1(canvas, kCol5X, kRow0Y, SkCanvas::kFast_SrcRectConst
raint, kHigh_SkFilterQuality); | |
245 this->drawCase2(canvas, kCol5X, kRow1Y, SkCanvas::kFast_SrcRectConst
raint, kHigh_SkFilterQuality); | |
246 this->drawCase3(canvas, kCol5X, kRow2Y, SkCanvas::kFast_SrcRectConst
raint, kHigh_SkFilterQuality); | |
247 this->drawCase4(canvas, kCol5X, kRow3Y, SkCanvas::kFast_SrcRectConst
raint, kHigh_SkFilterQuality); | |
248 | |
249 canvas->restore(); | 375 canvas->restore(); |
250 } | 376 } |
251 } | 377 } |
252 | 378 |
253 #if SK_SUPPORT_GPU | 379 #if SK_SUPPORT_GPU |
254 void modifyGrContextOptions(GrContextOptions* options) override { | 380 void modifyGrContextOptions(GrContextOptions* options) override { |
255 options->fMaxTextureSizeOverride = kMaxTextureSize; | 381 options->fMaxTextureSizeOverride = kMaxTextureSize; |
256 } | 382 } |
257 #endif | 383 #endif |
258 | 384 |
(...skipping 14 matching lines...) Expand all Loading... |
273 static const int kRow2Y = 3*kBlockSpacing + 2*kBlockSize; | 399 static const int kRow2Y = 3*kBlockSpacing + 2*kBlockSize; |
274 static const int kRow3Y = 4*kBlockSpacing + 3*kBlockSize; | 400 static const int kRow3Y = 4*kBlockSpacing + 3*kBlockSize; |
275 | 401 |
276 static const int kSmallTextureSize = 6; | 402 static const int kSmallTextureSize = 6; |
277 static const int kMaxTextureSize = 32; | 403 static const int kMaxTextureSize = 32; |
278 | 404 |
279 SkBitmap fBitmapSmall; | 405 SkBitmap fBitmapSmall; |
280 SkBitmap fBitmapBig; | 406 SkBitmap fBitmapBig; |
281 SkAutoTUnref<SkImage> fImageSmall; | 407 SkAutoTUnref<SkImage> fImageSmall; |
282 SkAutoTUnref<SkImage> fImageBig; | 408 SkAutoTUnref<SkImage> fImageBig; |
| 409 |
| 410 SkAutoTUnref<SkShader> fShader; |
| 411 |
283 const BleedTest fBT; | 412 const BleedTest fBT; |
284 | 413 |
285 typedef GM INHERITED; | 414 typedef GM INHERITED; |
286 }; | 415 }; |
287 | 416 |
288 DEF_GM( return new BleedGM(kUseBitmap_BleedTest); ) | 417 DEF_GM( return new BleedGM(kUseBitmap_BleedTest); ) |
289 DEF_GM( return new BleedGM(kUseImage_BleedTest); ) | 418 DEF_GM( return new BleedGM(kUseImage_BleedTest); ) |
| 419 DEF_GM( return new BleedGM(kUseAlphaBitmap_BleedTest); ) |
| 420 DEF_GM( return new BleedGM(kUseAlphaImage_BleedTest); ) |
| 421 #if 0 // Currently crashes GPU backend |
| 422 DEF_GM(return new BleedGM(kUseAlphaBitmapShader_BleedTest); ) |
| 423 DEF_GM(return new BleedGM(kUseAlphaImageShader_BleedTest); ) |
| 424 #endif |
OLD | NEW |