Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(12)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: gm/bleed.cpp

Issue 1424473006: Rewrite bleed GM bmp/img generators and change oversized texture case (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: update Created 5 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « no previous file | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: gm/bleed.cpp
diff --git a/gm/bleed.cpp b/gm/bleed.cpp
index 37a38442fdd7c3b923f4ffbd65f13b70bb320af3..6690f0afe02bb15d601c0d492e147df8181cca5c 100644
--- a/gm/bleed.cpp
+++ b/gm/bleed.cpp
@@ -1,510 +1,605 @@
-/*
- * Copyright 2013 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "gm.h"
-#include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
-#include "SkCanvas.h"
-#include "SkGradientShader.h"
-#include "SkImage.h"
-#include "SkUtils.h"
-
-#if SK_SUPPORT_GPU
-#include "GrContext.h"
-#include "GrContextOptions.h"
-#include "SkGr.h"
-#endif
-
-static void draw_bitmap_rect(SkCanvas* canvas, const SkBitmap& bitmap, const SkImage*,
- const SkRect& src, const SkRect& dst,
- const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
- canvas->drawBitmapRect(bitmap, src, dst, paint, constraint);
-}
-
-static void draw_image_rect(SkCanvas* canvas, const SkBitmap&, const SkImage* image,
- const SkRect& src, const SkRect& dst,
- const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
- canvas->drawImageRect(image, src, dst, paint, constraint);
-}
-
-// Upload the tight-fitting sw-backed bitmap to a loose-fitting gpu-backed texture before drawing
-static void draw_texture_bitmap_rect(SkCanvas* canvas, const SkBitmap& bitmap, const SkImage*,
- const SkRect& src, const SkRect& dst,
- const SkPaint* paint,
- SkCanvas::SrcRectConstraint constraint) {
- GrContext* context = canvas->getGrContext();
- if (!context) {
- // For non-GPU canvases fallback to drawing the bitmap directly.
- canvas->drawBitmapRect(bitmap, src, dst, paint, constraint);
- return;
- }
-#if SK_SUPPORT_GPU
- GrSurfaceDesc desc;
- desc.fConfig = kAlpha_8_SkColorType == bitmap.colorType() ? kAlpha_8_GrPixelConfig :
- kSkia8888_GrPixelConfig;
- // Add some padding to the right and beneath the bitmap contents to exercise the case where
- // the texture is larger than the bitmap. Outsets chosen to be small and different.
- desc.fWidth = bitmap.width() + 16;
- desc.fHeight = bitmap.height() + 23;
- SkAutoTUnref<GrTexture> texture(context->textureProvider()->createTexture(desc, true));
- if (!texture) {
- return;
- }
- // Init the whole texture to 0 in the alpha case or solid green in the 32bit rgba case.
- SkAutoLockPixels al(bitmap);
- if (kAlpha_8_GrPixelConfig == texture->config()) {
- SkAutoMalloc pixels(texture->width() * texture->height());
- memset(pixels.get(), 0, texture->width() * texture->height());
- texture->writePixels(0, 0, texture->width(), texture->height(), desc.fConfig, pixels.get(),
- 0);
- } else {
- SkAutoMalloc pixels(texture->width() * texture->height() * sizeof(uint32_t));
- SkOpts::memset32((uint32_t*)pixels.get(), 0xFF00FF00, texture->width()*texture->height());
- texture->writePixels(0, 0, texture->width(), texture->height(), desc.fConfig, pixels.get(),
- 0);
- }
-
- // Upload the bitmap contents to the upper left.
- texture->writePixels(0, 0, bitmap.width(), bitmap.height(), desc.fConfig, bitmap.getPixels(),
- bitmap.rowBytes());
-
- // Wrap the texture in a bitmap and draw it.
- SkBitmap textureBmp;
- GrWrapTextureInBitmap(texture, bitmap.width(), bitmap.height(), true, &textureBmp);
- canvas->drawBitmapRect(textureBmp, src, dst, paint, constraint);
-#endif
-}
-
-// Create a black&white checked texture with 2 1-pixel rings
-// around the outside edge. The inner ring is red and the outer ring is blue.
-static void make_ringed_color_bitmap(SkBitmap* result, int width, int height) {
- SkASSERT(0 == width % 2 && 0 == height % 2);
-
- static const SkPMColor kRed = SkPreMultiplyColor(SK_ColorRED);
- static const SkPMColor kBlue = SkPreMultiplyColor(SK_ColorBLUE);
- static const SkPMColor kBlack = SkPreMultiplyColor(SK_ColorBLACK);
- static const SkPMColor kWhite = SkPreMultiplyColor(SK_ColorWHITE);
-
- result->allocN32Pixels(width, height, true);
-
- SkPMColor* scanline = result->getAddr32(0, 0);
- for (int x = 0; x < width; ++x) {
- scanline[x] = kBlue;
- }
- scanline = result->getAddr32(0, 1);
- scanline[0] = kBlue;
- for (int x = 1; x < width - 1; ++x) {
- scanline[x] = kRed;
- }
- scanline[width-1] = kBlue;
-
- for (int y = 2; y < height/2; ++y) {
- scanline = result->getAddr32(0, y);
- scanline[0] = kBlue;
- scanline[1] = kRed;
- for (int x = 2; x < width/2; ++x) {
- scanline[x] = kBlack;
- }
- for (int x = width/2; x < width-2; ++x) {
- scanline[x] = kWhite;
- }
- scanline[width-2] = kRed;
- scanline[width-1] = kBlue;
- }
-
- for (int y = height/2; y < height-2; ++y) {
- scanline = result->getAddr32(0, y);
- scanline[0] = kBlue;
- scanline[1] = kRed;
- for (int x = 2; x < width/2; ++x) {
- scanline[x] = kWhite;
- }
- for (int x = width/2; x < width-2; ++x) {
- scanline[x] = kBlack;
- }
- scanline[width-2] = kRed;
- scanline[width-1] = kBlue;
- }
-
- scanline = result->getAddr32(0, height-2);
- scanline[0] = kBlue;
- for (int x = 1; x < width - 1; ++x) {
- scanline[x] = kRed;
- }
- scanline[width-1] = kBlue;
-
- scanline = result->getAddr32(0, height-1);
- for (int x = 0; x < width; ++x) {
- scanline[x] = kBlue;
- }
- result->setImmutable();
-}
-
-/** Makes a alpha bitmap with 1 wide rect/ring of 0s, an inset of 1s, and the interior is a 2x2
- checker board of 3/4 and 1/2. The inner checkers are large enough to fill the interior with
- the 2x2 checker grid. */
-static void make_ringed_alpha_bitmap(SkBitmap* result, int width, int height) {
- SkASSERT(0 == width % 2 && 0 == height % 2);
-
- static const SkPMColor kZero = 0x00;
- static const SkPMColor kHalf = 0x80;
- static const SkPMColor k3Q = 0xC0;
- static const SkPMColor kOne = 0xFF;
- SkImageInfo info = SkImageInfo::MakeA8(width, height);
- // The 4 byte alignment seems to be necessary to allow this bmp to be converted
- // to an image.
- result->allocPixels(info, SkAlign4(width));
-
- uint8_t* scanline = result->getAddr8(0, 0);
- for (int x = 0; x < width; ++x) {
- scanline[x] = kOne;
- }
- scanline = result->getAddr8(0, 1);
- scanline[0] = kOne;
- for (int x = 1; x < width - 1; ++x) {
- scanline[x] = kOne;
- }
- scanline[width - 1] = kZero;
-
- for (int y = 2; y < height / 2; ++y) {
- scanline = result->getAddr8(0, y);
- scanline[0] = kZero;
- scanline[1] = kOne;
- for (int x = 2; x < width / 2; ++x) {
- scanline[x] = k3Q;
- }
- for (int x = width / 2; x < width - 2; ++x) {
- scanline[x] = kHalf;
- }
- scanline[width - 2] = kOne;
- scanline[width - 1] = kZero;
- }
-
- for (int y = height / 2; y < height - 2; ++y) {
- scanline = result->getAddr8(0, y);
- scanline[0] = kZero;
- scanline[1] = kOne;
- for (int x = 2; x < width / 2; ++x) {
- scanline[x] = kHalf;
- }
- for (int x = width / 2; x < width - 2; ++x) {
- scanline[x] = k3Q;
- }
- scanline[width - 2] = kOne;
- scanline[width - 1] = kZero;
- }
-
- scanline = result->getAddr8(0, height - 2);
- scanline[0] = kZero;
- for (int x = 1; x < width - 1; ++x) {
- scanline[x] = kOne;
- }
- scanline[width - 1] = kZero;
-
- scanline = result->getAddr8(0, height - 1);
- for (int x = 0; x < width; ++x) {
- scanline[x] = kZero;
- }
- result->setImmutable();
-}
-
-static SkShader* make_shader() {
- static const SkPoint pts[] = { {0, 0}, {20, 20} };
- static const SkColor colors[] = { SK_ColorGREEN, SK_ColorYELLOW };
- return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kMirror_TileMode);
-}
-
-static SkShader* make_null_shader() { return nullptr; }
-
-enum BleedTest {
- kUseBitmap_BleedTest,
- kUseTextureBitmap_BleedTest,
- kUseImage_BleedTest,
- kUseAlphaBitmap_BleedTest,
- kUseAlphaTextureBitmap_BleedTest,
- kUseAlphaImage_BleedTest,
- kUseAlphaBitmapShader_BleedTest,
- kUseAlphaTextureBitmapShader_BleedTest,
- kUseAlphaImageShader_BleedTest,
-};
-
-const struct {
- const char* fName;
- void(*fBmpMaker)(SkBitmap* result, int width, int height);
- SkShader*(*fShaderMaker)();
- void(*fDraw)(SkCanvas*, const SkBitmap&, const SkImage*, const SkRect&, const SkRect&,
- const SkPaint*, SkCanvas::SrcRectConstraint);
-} gBleedRec[] = {
- { "bleed", make_ringed_color_bitmap, make_null_shader, draw_bitmap_rect },
- { "bleed_texture_bmp", make_ringed_color_bitmap, make_null_shader, draw_texture_bitmap_rect },
- { "bleed_image", make_ringed_color_bitmap, make_null_shader, draw_image_rect },
- { "bleed_alpha_bmp", make_ringed_alpha_bitmap, make_null_shader, draw_bitmap_rect },
- { "bleed_alpha_texture_bmp", make_ringed_alpha_bitmap, make_null_shader, draw_texture_bitmap_rect },
- { "bleed_alpha_image", make_ringed_alpha_bitmap, make_null_shader, draw_image_rect },
- { "bleed_alpha_bmp_shader", make_ringed_alpha_bitmap, make_shader, draw_bitmap_rect },
- { "bleed_alpha_texture_bmp_shader", make_ringed_alpha_bitmap, make_shader, draw_texture_bitmap_rect },
- { "bleed_alpha_image_shader", make_ringed_alpha_bitmap, make_shader, draw_image_rect },
-};
-
-// This GM exercises the drawBitmapRect constraints
-class BleedGM : public skiagm::GM {
-public:
- BleedGM(BleedTest bt) : fBT(bt) {}
-
-protected:
-
- SkString onShortName() override {
- return SkString(gBleedRec[fBT].fName);
- }
-
- SkISize onISize() override {
- return SkISize::Make(1200, 1080);
- }
-
- void onOnceBeforeDraw() override {
- gBleedRec[fBT].fBmpMaker(&fBitmapSmall, kSmallTextureSize, kSmallTextureSize);
- fImageSmall.reset(SkImage::NewFromBitmap(fBitmapSmall));
-
- // To exercise the GPU's tiling path we need a texture
- // too big for the GPU to handle in one go
- gBleedRec[fBT].fBmpMaker(&fBitmapBig, 2*kMaxTileSize, 2*kMaxTileSize);
- fImageBig.reset(SkImage::NewFromBitmap(fBitmapBig));
-
- fShader.reset(gBleedRec[fBT].fShaderMaker());
- }
-
- // Draw only the center of the small bitmap
- void drawCase1(SkCanvas* canvas, int transX, int transY, bool aa,
- SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
- SkRect src = SkRect::MakeXYWH(2, 2,
- SkIntToScalar(kSmallTextureSize-4),
- SkIntToScalar(kSmallTextureSize-4));
- SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
- SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
-
- SkPaint paint;
- paint.setFilterQuality(filter);
- paint.setShader(fShader);
- paint.setColor(SK_ColorBLUE);
- paint.setAntiAlias(aa);
-
- gBleedRec[fBT].fDraw(canvas, fBitmapSmall, fImageSmall, src, dst, &paint, constraint);
- }
-
- // Draw almost all of the large bitmap
- void drawCase2(SkCanvas* canvas, int transX, int transY, bool aa,
- SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
- SkRect src = SkRect::MakeXYWH(2, 2,
- SkIntToScalar(fBitmapBig.width()-4),
- SkIntToScalar(fBitmapBig.height()-4));
- SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
- SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
-
- SkPaint paint;
- paint.setFilterQuality(filter);
- paint.setShader(fShader);
- paint.setColor(SK_ColorBLUE);
- paint.setAntiAlias(aa);
-
- gBleedRec[fBT].fDraw(canvas, fBitmapBig, fImageBig, src, dst, &paint, constraint);
- }
-
- // Draw ~1/4 of the large bitmap
- void drawCase3(SkCanvas* canvas, int transX, int transY, bool aa,
- SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
- SkRect src = SkRect::MakeXYWH(2, 2,
- SkIntToScalar(fBitmapBig.width()/2-2),
- SkIntToScalar(fBitmapBig.height()/2-2));
- SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
- SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
-
- SkPaint paint;
- paint.setFilterQuality(filter);
- paint.setShader(fShader);
- paint.setColor(SK_ColorBLUE);
- paint.setAntiAlias(aa);
-
- gBleedRec[fBT].fDraw(canvas, fBitmapBig, fImageBig, src, dst, &paint, constraint);
- }
-
- // Draw the center of the small bitmap with a normal blur
- void drawCase4(SkCanvas* canvas, int transX, int transY, bool aa,
- SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
- SkRect src = SkRect::MakeXYWH(2, 2,
- SkIntToScalar(kSmallTextureSize-4),
- SkIntToScalar(kSmallTextureSize-4));
- SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
- SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
-
- SkPaint paint;
- paint.setFilterQuality(filter);
- SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
- SkBlurMask::ConvertRadiusToSigma(3));
- paint.setMaskFilter(mf)->unref();
- paint.setShader(fShader);
- paint.setColor(SK_ColorBLUE);
- paint.setAntiAlias(aa);
-
- gBleedRec[fBT].fDraw(canvas, fBitmapSmall, fImageSmall, src, dst, &paint, constraint);
- }
-
- // Draw the center of the small bitmap with a outer blur
- void drawCase5(SkCanvas* canvas, int transX, int transY, bool aa,
- SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
- SkRect src = SkRect::MakeXYWH(2, 2,
- SkIntToScalar(kSmallTextureSize - 4),
- SkIntToScalar(kSmallTextureSize - 4));
- SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
- SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
-
- SkPaint paint;
- paint.setFilterQuality(filter);
- SkMaskFilter* mf = SkBlurMaskFilter::Create(kOuter_SkBlurStyle,
- SkBlurMask::ConvertRadiusToSigma(7));
- paint.setMaskFilter(mf)->unref();
- paint.setShader(fShader);
- paint.setColor(SK_ColorBLUE);
- paint.setAntiAlias(aa);
-
- gBleedRec[fBT].fDraw(canvas, fBitmapSmall, fImageSmall, src, dst, &paint, constraint);
- }
-
- void onDraw(SkCanvas* canvas) override {
- canvas->clear(SK_ColorGRAY);
- SkTDArray<SkMatrix> matrices;
- // Draw with identity
- *matrices.append() = SkMatrix::I();
-
- // Draw with rotation and scale down in x, up in y.
- SkMatrix m;
- static const SkScalar kBottom = SkIntToScalar(kRow4Y + kBlockSize + kBlockSpacing);
- m.setTranslate(0, kBottom);
- m.preRotate(15.f, 0, kBottom + kBlockSpacing);
- m.preScale(0.71f, 1.22f);
- *matrices.append() = m;
-
- // Align the next set with the middle of the previous in y, translated to the right in x.
- SkPoint corners[] = {{0, 0}, { 0, kBottom }, { kWidth, kBottom }, {kWidth, 0} };
- matrices[matrices.count()-1].mapPoints(corners, 4);
- SkScalar y = (corners[0].fY + corners[1].fY + corners[2].fY + corners[3].fY) / 4;
- SkScalar x = SkTMax(SkTMax(corners[0].fX, corners[1].fX),
- SkTMax(corners[2].fX, corners[3].fX));
- m.setTranslate(x, y);
- m.preScale(0.2f, 0.2f);
- *matrices.append() = m;
-
- SkScalar maxX = 0;
- for (int antiAlias = 0; antiAlias < 2; ++antiAlias) {
- canvas->save();
- canvas->translate(maxX, 0);
- for (int m = 0; m < matrices.count(); ++m) {
- canvas->save();
- canvas->concat(matrices[m]);
- bool aa = SkToBool(antiAlias);
-
- // First draw a column with no bleeding and no filtering
- this->drawCase1(canvas, kCol0X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
- this->drawCase2(canvas, kCol0X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
- this->drawCase3(canvas, kCol0X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
- this->drawCase4(canvas, kCol0X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
- this->drawCase5(canvas, kCol0X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
-
- // Then draw a column with no bleeding and low filtering
- this->drawCase1(canvas, kCol1X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
- this->drawCase2(canvas, kCol1X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
- this->drawCase3(canvas, kCol1X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
- this->drawCase4(canvas, kCol1X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
- this->drawCase5(canvas, kCol1X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
-
- // Then draw a column with no bleeding and high filtering
- this->drawCase1(canvas, kCol2X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
- this->drawCase2(canvas, kCol2X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
- this->drawCase3(canvas, kCol2X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
- this->drawCase4(canvas, kCol2X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
- this->drawCase5(canvas, kCol2X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
-
- // Then draw a column with bleeding and no filtering (bleed should have no effect w/out blur)
- this->drawCase1(canvas, kCol3X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
- this->drawCase2(canvas, kCol3X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
- this->drawCase3(canvas, kCol3X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
- this->drawCase4(canvas, kCol3X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
- this->drawCase5(canvas, kCol3X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
-
- // Then draw a column with bleeding and low filtering
- this->drawCase1(canvas, kCol4X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
- this->drawCase2(canvas, kCol4X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
- this->drawCase3(canvas, kCol4X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
- this->drawCase4(canvas, kCol4X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
- this->drawCase5(canvas, kCol4X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
-
- // Finally draw a column with bleeding and high filtering
- this->drawCase1(canvas, kCol5X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
- this->drawCase2(canvas, kCol5X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
- this->drawCase3(canvas, kCol5X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
- this->drawCase4(canvas, kCol5X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
- this->drawCase5(canvas, kCol5X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
-
- SkPoint corners[] = { { 0, 0 },{ 0, kBottom },{ kWidth, kBottom },{ kWidth, 0 } };
- matrices[m].mapPoints(corners, 4);
- SkScalar x = kBlockSize + SkTMax(SkTMax(corners[0].fX, corners[1].fX),
- SkTMax(corners[2].fX, corners[3].fX));
- maxX = SkTMax(maxX, x);
- canvas->restore();
- }
- canvas->restore();
- }
- }
-
-#if SK_SUPPORT_GPU
- void modifyGrContextOptions(GrContextOptions* options) override {
- options->fMaxTileSizeOverride = kMaxTileSize;
- }
-#endif
-
-private:
- static const int kBlockSize = 70;
- static const int kBlockSpacing = 12;
-
- static const int kCol0X = kBlockSpacing;
- static const int kCol1X = 2*kBlockSpacing + kBlockSize;
- static const int kCol2X = 3*kBlockSpacing + 2*kBlockSize;
- static const int kCol3X = 4*kBlockSpacing + 3*kBlockSize;
- static const int kCol4X = 5*kBlockSpacing + 4*kBlockSize;
- static const int kCol5X = 6*kBlockSpacing + 5*kBlockSize;
- static const int kWidth = 7*kBlockSpacing + 6*kBlockSize;
-
- static const int kRow0Y = kBlockSpacing;
- static const int kRow1Y = 2*kBlockSpacing + kBlockSize;
- static const int kRow2Y = 3*kBlockSpacing + 2*kBlockSize;
- static const int kRow3Y = 4*kBlockSpacing + 3*kBlockSize;
- static const int kRow4Y = 5*kBlockSpacing + 4*kBlockSize;
-
- static const int kSmallTextureSize = 6;
- static const int kMaxTileSize = 32;
-
- SkBitmap fBitmapSmall;
- SkBitmap fBitmapBig;
- SkAutoTUnref<SkImage> fImageSmall;
- SkAutoTUnref<SkImage> fImageBig;
-
- SkAutoTUnref<SkShader> fShader;
-
- const BleedTest fBT;
-
- typedef GM INHERITED;
-};
-
-
-DEF_GM( return new BleedGM(kUseBitmap_BleedTest); )
-DEF_GM( return new BleedGM(kUseTextureBitmap_BleedTest); )
-DEF_GM( return new BleedGM(kUseImage_BleedTest); )
-DEF_GM( return new BleedGM(kUseAlphaBitmap_BleedTest); )
-DEF_GM( return new BleedGM(kUseAlphaTextureBitmap_BleedTest); )
-DEF_GM( return new BleedGM(kUseAlphaImage_BleedTest); )
-DEF_GM( return new BleedGM(kUseAlphaBitmapShader_BleedTest); )
-DEF_GM( return new BleedGM(kUseAlphaTextureBitmapShader_BleedTest); )
-DEF_GM( return new BleedGM(kUseAlphaImageShader_BleedTest); )
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "gm.h"
+#include "SkBlurMask.h"
+#include "SkBlurMaskFilter.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkImage.h"
+#include "SkUtils.h"
+
+#if SK_SUPPORT_GPU
+#include "GrContext.h"
+#include "GrContextOptions.h"
+#include "SkGr.h"
+#endif
+
+/** Holds either a bitmap or image to be rendered and a rect that indicates what part of the bitmap
+ or image should be tested by the GM. The area outside of the rect is present to check
+ for bleed due to filtering/blurring. */
+struct TestPixels {
+ enum Type {
+ kBitmap,
+ kImage
+ };
+ Type fType;
+ SkBitmap fBitmap;
+ SkAutoTUnref<SkImage> fImage;
+ SkIRect fRect; // The region of the bitmap/image that should be rendered.
+};
+
+/** Creates a bitmap with two one-pixel rings around a checkerboard. The checkerboard is 2x2
+ logically where each check has as many pixels as is necessary to fill the interior. The rect
+ to draw is set to the checkerboard portion. */
+template<typename PIXEL_TYPE>
+bool make_ringed_bitmap(GrContext*, TestPixels* result, int width, int height,
+ SkColorType ct, SkAlphaType at,
+ PIXEL_TYPE outerRingColor, PIXEL_TYPE innerRingColor,
+ PIXEL_TYPE checkColor1, PIXEL_TYPE checkColor2) {
+ SkASSERT(0 == width % 2 && 0 == height % 2);
+ SkASSERT(width >= 6 && height >= 6);
+
+ result->fType = TestPixels::kBitmap;
+ SkImageInfo info = SkImageInfo::Make(width, height, ct, at);
+ size_t rowBytes = SkAlign4(info.minRowBytes());
+ result->fBitmap.allocPixels(info, rowBytes);
+
+ PIXEL_TYPE* scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, 0);
+ for (int x = 0; x < width; ++x) {
+ scanline[x] = outerRingColor;
+ }
+ scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, 1);
+ scanline[0] = outerRingColor;
+ for (int x = 1; x < width - 1; ++x) {
+ scanline[x] = innerRingColor;
+ }
+ scanline[width - 1] = outerRingColor;
+
+ for (int y = 2; y < height / 2; ++y) {
+ scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, y);
+ scanline[0] = outerRingColor;
+ scanline[1] = innerRingColor;
+ for (int x = 2; x < width / 2; ++x) {
+ scanline[x] = checkColor1;
+ }
+ for (int x = width / 2; x < width - 2; ++x) {
+ scanline[x] = checkColor2;
+ }
+ scanline[width - 2] = innerRingColor;
+ scanline[width - 1] = outerRingColor;
+ }
+
+ for (int y = height / 2; y < height - 2; ++y) {
+ scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, y);
+ scanline[0] = outerRingColor;
+ scanline[1] = innerRingColor;
+ for (int x = 2; x < width / 2; ++x) {
+ scanline[x] = checkColor2;
+ }
+ for (int x = width / 2; x < width - 2; ++x) {
+ scanline[x] = checkColor1;
+ }
+ scanline[width - 2] = innerRingColor;
+ scanline[width - 1] = outerRingColor;
+ }
+
+ scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, height - 2);
+ scanline[0] = outerRingColor;
+ for (int x = 1; x < width - 1; ++x) {
+ scanline[x] = innerRingColor;
+ }
+ scanline[width - 1] = outerRingColor;
+
+ scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, height - 1);
+ for (int x = 0; x < width; ++x) {
+ scanline[x] = outerRingColor;
+ }
+ result->fBitmap.setImmutable();
+ result->fRect.set(2, 2, width - 2, height - 2);
+ return true;
+}
+
+/** Create a black and white checked texture with 2 1-pixel rings around the outside edge.
+ The inner ring is red and the outer ring is blue. */
+static bool make_ringed_color_bitmap(GrContext* ctx, TestPixels* result, int width, int height) {
+ static const SkPMColor kBlue = SkPreMultiplyColor(SK_ColorBLUE);
+ static const SkPMColor kRed = SkPreMultiplyColor(SK_ColorRED);
+ static const SkPMColor kBlack = SkPreMultiplyColor(SK_ColorBLACK);
+ static const SkPMColor kWhite = SkPreMultiplyColor(SK_ColorWHITE);
+ return make_ringed_bitmap<SkPMColor>(ctx, result, width, height, kBGRA_8888_SkColorType,
+ kPremul_SkAlphaType, kBlue, kRed, kBlack, kWhite);
+}
+
+/** Makes a alpha bitmap with 1 wide rect/ring of 0s, an inset of 1s, and the interior is a 2x2
+ checker board of 3/4 and 1/2. The inner checkers are large enough to fill the interior with
+ the 2x2 checker grid. */
+static bool make_ringed_alpha_bitmap(GrContext* ctx, TestPixels* result, int width, int height) {
+ static const uint8_t kZero = 0x00;
+ static const uint8_t kHalf = 0x80;
+ static const uint8_t k3Q = 0xC0;
+ static const uint8_t kOne = 0xFF;
+ return make_ringed_bitmap<uint8_t>(ctx, result, width, height, kAlpha_8_SkColorType,
+ kPremul_SkAlphaType, kZero, kOne, k3Q, kHalf);
+}
+
+/** Helper to reuse above functions to produce images rather than bmps */
+static void bmp_to_image(TestPixels* result) {
+ SkASSERT(TestPixels::kBitmap == result->fType);
+ result->fImage.reset(SkImage::NewFromBitmap(result->fBitmap));
+ SkASSERT(result->fImage);
+ result->fType = TestPixels::kImage;
+ result->fBitmap.reset();
+}
+
+/** Color image case. */
+bool make_ringed_color_image(GrContext* ctx, TestPixels* result, int width, int height) {
+ if (make_ringed_color_bitmap(ctx, result, width, height)) {
+ bmp_to_image(result);
+ return true;
+ }
+ return false;
+}
+
+/** Alpha image case. */
+bool make_ringed_alpha_image(GrContext* ctx, TestPixels* result, int width, int height) {
+ if (make_ringed_alpha_bitmap(ctx, result, width, height)) {
+ bmp_to_image(result);
+ return true;
+ }
+ return false;
+}
+
+/** Similar to make_ringed_bitmap with these modifications:
+ - The backing store is a texture.
+ - The texture is larger than the bitmap dimensions (it is surrounded by non-content
+ padding on the right/bottom of the contents.)
+ - The right/bottom sides of the rings are omitted so that the rect to draw is adjacent to
+ the texture padding.
+ */
+template <typename PIXEL_TYPE>
+bool make_oversized_texture_bitmap(GrContext* ctx, TestPixels* result, int width, int height,
+ GrPixelConfig config, PIXEL_TYPE outerRingColor,
+ PIXEL_TYPE innerRingColor, PIXEL_TYPE checkColor1,
+ PIXEL_TYPE checkColor2, PIXEL_TYPE padColor) {
+ SkASSERT(0 == width % 2 && 0 == height % 2);
+ SkASSERT(width >= 6 && height >= 6);
+#if SK_SUPPORT_GPU
+ if (!ctx) {
+ return false;
+ }
+ /** Put arbitrary pad to the right and below the bitmap content. */
+ static const int kXPad = 10;
+ static const int kYPad = 17;
+ size_t rowBytes = (width + kXPad) * sizeof(PIXEL_TYPE);
+ SkAutoTMalloc<PIXEL_TYPE> pixels(rowBytes*(height + kYPad));
+
+ PIXEL_TYPE* scanline = pixels.get();
+ for (int x = 0; x < width; ++x) {
+ scanline[x] = outerRingColor;
+ }
+ for (int x = width; x < width + kXPad; ++x) {
+ scanline[x] = padColor;
+ }
+
+ scanline = (PIXEL_TYPE*)((char*)scanline + rowBytes);
+ scanline[0] = outerRingColor;
+ for (int x = 1; x < width; ++x) {
+ scanline[x] = innerRingColor;
+ }
+ for (int x = width; x < width + kXPad; ++x) {
+ scanline[x] = padColor;
+ }
+
+ for (int y = 2; y < height / 2 + 1; ++y) {
+ scanline = (PIXEL_TYPE*)((char*)scanline + rowBytes);
+ scanline[0] = outerRingColor;
+ scanline[1] = innerRingColor;
+ for (int x = 2; x < width / 2 + 1; ++x) {
+ scanline[x] = checkColor1;
+ }
+ for (int x = width / 2 + 1; x < width; ++x) {
+ scanline[x] = checkColor2;
+ }
+ for (int x = width; x < width + kXPad; ++x) {
+ scanline[x] = padColor;
+ }
+ }
+
+ for (int y = height / 2 + 1; y < height; ++y) {
+ scanline = (PIXEL_TYPE*)((char*)scanline + rowBytes);
+ scanline[0] = outerRingColor;
+ scanline[1] = innerRingColor;
+ for (int x = 2; x < width / 2 + 1; ++x) {
+ scanline[x] = checkColor2;
+ }
+ for (int x = width / 2 + 1; x < width; ++x) {
+ scanline[x] = checkColor1;
+ }
+ for (int x = width; x < width + kXPad; ++x) {
+ scanline[x] = padColor;
+ }
+ }
+
+ for (int y = height; y < height + kYPad; ++y) {
+ scanline = (PIXEL_TYPE*)((char*)scanline + rowBytes);
+ for (int x = 0; x < width + kXPad; ++x) {
+ scanline[x] = padColor;
+ }
+ }
+
+ GrSurfaceDesc desc;
+ desc.fConfig = config;
+ desc.fWidth = width + kXPad;
+ desc.fHeight = height + kYPad;
+ SkAutoTUnref<GrTexture> texture(ctx->textureProvider()->createTexture(desc, true, pixels.get(),
+ rowBytes));
+
+ if (!texture) {
+ return false;
+ }
+
+ GrWrapTextureInBitmap(texture, width, height, true, &result->fBitmap);
+ result->fType = TestPixels::kBitmap;
+ result->fBitmap.setImmutable();
+ result->fRect.set(2, 2, width, height);
+ return true;
+#else
+ return false;
+#endif
+}
+
+/** Make the color version of the oversized texture-backed bitmap */
+static bool make_ringed_oversized_color_texture_bitmap(GrContext* ctx, TestPixels* result,
+ int width, int height) {
+ static const SkPMColor kBlue = SkPreMultiplyColor(SK_ColorBLUE);
+ static const SkPMColor kRed = SkPreMultiplyColor(SK_ColorRED);
+ static const SkPMColor kBlack = SkPreMultiplyColor(SK_ColorBLACK);
+ static const SkPMColor kWhite = SkPreMultiplyColor(SK_ColorWHITE);
+ static const SkPMColor kGreen = SkPreMultiplyColor(SK_ColorGREEN);
+ return make_oversized_texture_bitmap<SkPMColor>(
+ ctx, result, width, height, kSkia8888_GrPixelConfig, kBlue, kRed, kBlack, kWhite, kGreen);
+}
+
+/** Make the alpha version of the oversized texture-backed bitmap */
+static bool make_ringed_oversized_alpha_texture_bitmap(GrContext* ctx, TestPixels* result,
+ int width, int height) {
+ static const uint8_t kZero = 0x00;
+ static const uint8_t kHalf = 0x80;
+ static const uint8_t k3Q = 0xC0;
+ static const uint8_t kOne = 0xFF;
+ static const uint8_t k1Q = 0x40;
+ return make_oversized_texture_bitmap<uint8_t>(
+ ctx, result, width, height, kAlpha_8_GrPixelConfig, kZero, kOne, k3Q, kHalf, k1Q);
+}
+
+static SkShader* make_shader() {
+ static const SkPoint pts[] = { {0, 0}, {20, 20} };
+ static const SkColor colors[] = { SK_ColorGREEN, SK_ColorYELLOW };
+ return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kMirror_TileMode);
+}
+
+static SkShader* make_null_shader() { return nullptr; }
+
+enum BleedTest {
+ kUseBitmap_BleedTest,
+ kUseTextureBitmap_BleedTest,
+ kUseImage_BleedTest,
+ kUseAlphaBitmap_BleedTest,
+ kUseAlphaTextureBitmap_BleedTest,
+ kUseAlphaImage_BleedTest,
+ kUseAlphaBitmapShader_BleedTest,
+ kUseAlphaTextureBitmapShader_BleedTest,
+ kUseAlphaImageShader_BleedTest,
+};
+
+const struct {
+ const char* fName;
+ bool (*fPixelMaker)(GrContext*, TestPixels* result, int width, int height);
+ SkShader* (*fShaderMaker)();
+} gBleedRec[] = {
+ { "bleed", make_ringed_color_bitmap, make_null_shader },
+ { "bleed_texture_bmp", make_ringed_oversized_color_texture_bitmap, make_null_shader },
+ { "bleed_image", make_ringed_color_image, make_null_shader },
+ { "bleed_alpha_bmp", make_ringed_alpha_bitmap, make_null_shader },
+ { "bleed_alpha_texture_bmp", make_ringed_oversized_alpha_texture_bitmap, make_null_shader },
+ { "bleed_alpha_image", make_ringed_alpha_image, make_null_shader },
+ { "bleed_alpha_bmp_shader", make_ringed_alpha_bitmap, make_shader },
+ { "bleed_alpha_texture_bmp_shader", make_ringed_oversized_alpha_texture_bitmap, make_shader },
+ { "bleed_alpha_image_shader", make_ringed_alpha_image, make_shader },
+};
+
+/** This GM exercises the behavior of the drawBitmapRect & drawImageRect calls. Specifically their
+ handling of :
+ - SrcRectConstraint(bleed vs.no - bleed)
+ - handling of the sub - region feature(area - of - interest) of drawBitmap*
+ - handling of 8888 vs. A8 (including presence of a shader in the A8 case).
+ - (gpu - only) handling of tiled vs.non - tiled drawing)
+ - (gpu - only) texture's backing a bmp where the texture is larger than the bmp.
+ In particular, we should never see the padding outside of an SkBitmap's sub - region (green for
+ 8888, 1/4 for alpha). In some instances we can see the two outer rings outside of the area o
+ interest (i.e., the inner four checks) due to AA or filtering if allowed by the
+ SrcRectConstraint.
+*/
+class BleedGM : public skiagm::GM {
+public:
+ BleedGM(BleedTest bt) : fCreatedPixels(false), fBT(bt){}
+
+protected:
+
+ SkString onShortName() override {
+ return SkString(gBleedRec[fBT].fName);
+ }
+
+ SkISize onISize() override {
+ return SkISize::Make(1200, 1080);
+ }
+
+ void drawPixels(SkCanvas* canvas, const TestPixels& pixels, const SkRect& src,
+ const SkRect& dst, const SkPaint* paint,
+ SkCanvas::SrcRectConstraint constraint) {
+ if (TestPixels::kBitmap == pixels.fType) {
+ canvas->drawBitmapRect(pixels.fBitmap, src, dst, paint, constraint);
+ } else {
+ canvas->drawImageRect(pixels.fImage, src, dst, paint, constraint);
+ }
+ }
+
+ // Draw the area of interest of the small image
+ void drawCase1(SkCanvas* canvas, int transX, int transY, bool aa,
+ SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
+
+ SkRect src = SkRect::Make(fSmallTestPixels.fRect);
+ SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
+ SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
+
+ SkPaint paint;
+ paint.setFilterQuality(filter);
+ paint.setShader(fShader);
+ paint.setColor(SK_ColorBLUE);
+ paint.setAntiAlias(aa);
+
+ this->drawPixels(canvas, fSmallTestPixels, src, dst, &paint, constraint);
+ }
+
+ // Draw the area of interest of the large image
+ void drawCase2(SkCanvas* canvas, int transX, int transY, bool aa,
+ SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
+ SkRect src = SkRect::Make(fBigTestPixels.fRect);
+ SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
+ SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
+
+ SkPaint paint;
+ paint.setFilterQuality(filter);
+ paint.setShader(fShader);
+ paint.setColor(SK_ColorBLUE);
+ paint.setAntiAlias(aa);
+
+ this->drawPixels(canvas, fBigTestPixels, src, dst, &paint, constraint);
+ }
+
+ // Draw upper-left 1/4 of the area of interest of the large image
+ void drawCase3(SkCanvas* canvas, int transX, int transY, bool aa,
+ SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
+ SkRect src = SkRect::MakeXYWH(SkIntToScalar(fBigTestPixels.fRect.fLeft),
+ SkIntToScalar(fBigTestPixels.fRect.fTop),
+ fBigTestPixels.fRect.width()/2.f,
+ fBigTestPixels.fRect.height()/2.f);
+ SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
+ SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
+
+ SkPaint paint;
+ paint.setFilterQuality(filter);
+ paint.setShader(fShader);
+ paint.setColor(SK_ColorBLUE);
+ paint.setAntiAlias(aa);
+
+ this->drawPixels(canvas, fBigTestPixels, src, dst, &paint, constraint);
+ }
+
+ // Draw the area of interest of the small image with a normal blur
+ void drawCase4(SkCanvas* canvas, int transX, int transY, bool aa,
+ SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
+ SkRect src = SkRect::Make(fSmallTestPixels.fRect);
+ SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
+ SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
+
+ SkPaint paint;
+ paint.setFilterQuality(filter);
+ SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
+ SkBlurMask::ConvertRadiusToSigma(3));
+ paint.setMaskFilter(mf)->unref();
+ paint.setShader(fShader);
+ paint.setColor(SK_ColorBLUE);
+ paint.setAntiAlias(aa);
+
+ this->drawPixels(canvas, fSmallTestPixels, src, dst, &paint, constraint);
+ }
+
+ // Draw the area of interest of the small image with a outer blur
+ void drawCase5(SkCanvas* canvas, int transX, int transY, bool aa,
+ SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
+ SkRect src = SkRect::Make(fSmallTestPixels.fRect);
+ SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
+ SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
+
+ SkPaint paint;
+ paint.setFilterQuality(filter);
+ SkMaskFilter* mf = SkBlurMaskFilter::Create(kOuter_SkBlurStyle,
+ SkBlurMask::ConvertRadiusToSigma(7));
+ paint.setMaskFilter(mf)->unref();
+ paint.setShader(fShader);
+ paint.setColor(SK_ColorBLUE);
+ paint.setAntiAlias(aa);
+
+ this->drawPixels(canvas, fSmallTestPixels, src, dst, &paint, constraint);
+ }
+
+ void onDraw(SkCanvas* canvas) override {
+ // We don't create pixels in an onOnceBeforeDraw() override because we want access to
+ // GrContext.
+ GrContext* context = canvas->getGrContext();
+#if SK_SUPPORT_GPU
+ // Workaround for SampleApp.
+ if (GrTexture* tex = fBigTestPixels.fBitmap.getTexture()) {
+ if (tex->wasDestroyed()) {
+ fCreatedPixels = false;
+ }
+ }
+#endif
+ bool madePixels = fCreatedPixels;
+
+ if (!madePixels) {
+ madePixels = gBleedRec[fBT].fPixelMaker(context, &fSmallTestPixels, kSmallTextureSize,
+ kSmallTextureSize);
+ madePixels &= gBleedRec[fBT].fPixelMaker(context, &fBigTestPixels, 2 * kMaxTileSize,
+ 2 * kMaxTileSize);
+ fCreatedPixels = madePixels;
+ }
+
+ // Assume that if we coulnd't make the bitmap/image it's because it's a GPU test on a
+ // non-GPU backend.
+ if (!madePixels) {
+ skiagm::GM::DrawGpuOnlyMessage(canvas);
+ return;
+ }
+
+ fShader.reset(gBleedRec[fBT].fShaderMaker());
+
+ canvas->clear(SK_ColorGRAY);
+ SkTDArray<SkMatrix> matrices;
+ // Draw with identity
+ *matrices.append() = SkMatrix::I();
+
+ // Draw with rotation and scale down in x, up in y.
+ SkMatrix m;
+ static const SkScalar kBottom = SkIntToScalar(kRow4Y + kBlockSize + kBlockSpacing);
+ m.setTranslate(0, kBottom);
+ m.preRotate(15.f, 0, kBottom + kBlockSpacing);
+ m.preScale(0.71f, 1.22f);
+ *matrices.append() = m;
+
+ // Align the next set with the middle of the previous in y, translated to the right in x.
+ SkPoint corners[] = {{0, 0}, { 0, kBottom }, { kWidth, kBottom }, {kWidth, 0} };
+ matrices[matrices.count()-1].mapPoints(corners, 4);
+ SkScalar y = (corners[0].fY + corners[1].fY + corners[2].fY + corners[3].fY) / 4;
+ SkScalar x = SkTMax(SkTMax(corners[0].fX, corners[1].fX),
+ SkTMax(corners[2].fX, corners[3].fX));
+ m.setTranslate(x, y);
+ m.preScale(0.2f, 0.2f);
+ *matrices.append() = m;
+
+ SkScalar maxX = 0;
+ for (int antiAlias = 0; antiAlias < 2; ++antiAlias) {
+ canvas->save();
+ canvas->translate(maxX, 0);
+ for (int m = 0; m < matrices.count(); ++m) {
+ canvas->save();
+ canvas->concat(matrices[m]);
+ bool aa = SkToBool(antiAlias);
+
+ // First draw a column with no bleeding and no filtering
+ this->drawCase1(canvas, kCol0X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
+ this->drawCase2(canvas, kCol0X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
+ this->drawCase3(canvas, kCol0X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
+ this->drawCase4(canvas, kCol0X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
+ this->drawCase5(canvas, kCol0X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
+
+ // Then draw a column with no bleeding and low filtering
+ this->drawCase1(canvas, kCol1X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
+ this->drawCase2(canvas, kCol1X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
+ this->drawCase3(canvas, kCol1X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
+ this->drawCase4(canvas, kCol1X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
+ this->drawCase5(canvas, kCol1X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
+
+ // Then draw a column with no bleeding and high filtering
+ this->drawCase1(canvas, kCol2X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
+ this->drawCase2(canvas, kCol2X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
+ this->drawCase3(canvas, kCol2X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
+ this->drawCase4(canvas, kCol2X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
+ this->drawCase5(canvas, kCol2X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
+
+ // Then draw a column with bleeding and no filtering (bleed should have no effect w/out blur)
+ this->drawCase1(canvas, kCol3X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
+ this->drawCase2(canvas, kCol3X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
+ this->drawCase3(canvas, kCol3X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
+ this->drawCase4(canvas, kCol3X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
+ this->drawCase5(canvas, kCol3X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
+
+ // Then draw a column with bleeding and low filtering
+ this->drawCase1(canvas, kCol4X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
+ this->drawCase2(canvas, kCol4X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
+ this->drawCase3(canvas, kCol4X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
+ this->drawCase4(canvas, kCol4X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
+ this->drawCase5(canvas, kCol4X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
+
+ // Finally draw a column with bleeding and high filtering
+ this->drawCase1(canvas, kCol5X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
+ this->drawCase2(canvas, kCol5X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
+ this->drawCase3(canvas, kCol5X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
+ this->drawCase4(canvas, kCol5X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
+ this->drawCase5(canvas, kCol5X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
+
+ SkPoint corners[] = { { 0, 0 },{ 0, kBottom },{ kWidth, kBottom },{ kWidth, 0 } };
+ matrices[m].mapPoints(corners, 4);
+ SkScalar x = kBlockSize + SkTMax(SkTMax(corners[0].fX, corners[1].fX),
+ SkTMax(corners[2].fX, corners[3].fX));
+ maxX = SkTMax(maxX, x);
+ canvas->restore();
+ }
+ canvas->restore();
+ }
+ }
+
+#if SK_SUPPORT_GPU
+ void modifyGrContextOptions(GrContextOptions* options) override {
+ options->fMaxTileSizeOverride = kMaxTileSize;
+ }
+#endif
+
+private:
+ static const int kBlockSize = 70;
+ static const int kBlockSpacing = 12;
+
+ static const int kCol0X = kBlockSpacing;
+ static const int kCol1X = 2*kBlockSpacing + kBlockSize;
+ static const int kCol2X = 3*kBlockSpacing + 2*kBlockSize;
+ static const int kCol3X = 4*kBlockSpacing + 3*kBlockSize;
+ static const int kCol4X = 5*kBlockSpacing + 4*kBlockSize;
+ static const int kCol5X = 6*kBlockSpacing + 5*kBlockSize;
+ static const int kWidth = 7*kBlockSpacing + 6*kBlockSize;
+
+ static const int kRow0Y = kBlockSpacing;
+ static const int kRow1Y = 2*kBlockSpacing + kBlockSize;
+ static const int kRow2Y = 3*kBlockSpacing + 2*kBlockSize;
+ static const int kRow3Y = 4*kBlockSpacing + 3*kBlockSize;
+ static const int kRow4Y = 5*kBlockSpacing + 4*kBlockSize;
+
+ static const int kSmallTextureSize = 6;
+ static const int kMaxTileSize = 32;
+
+ bool fCreatedPixels;
+ TestPixels fBigTestPixels;
+ TestPixels fSmallTestPixels;
+
+ SkAutoTUnref<SkShader> fShader;
+
+ const BleedTest fBT;
+
+ typedef GM INHERITED;
+};
+
+
+DEF_GM( return new BleedGM(kUseBitmap_BleedTest); )
+DEF_GM( return new BleedGM(kUseTextureBitmap_BleedTest); )
+DEF_GM( return new BleedGM(kUseImage_BleedTest); )
+DEF_GM( return new BleedGM(kUseAlphaBitmap_BleedTest); )
+DEF_GM( return new BleedGM(kUseAlphaTextureBitmap_BleedTest); )
+DEF_GM( return new BleedGM(kUseAlphaImage_BleedTest); )
+DEF_GM( return new BleedGM(kUseAlphaBitmapShader_BleedTest); )
+DEF_GM( return new BleedGM(kUseAlphaTextureBitmapShader_BleedTest); )
+DEF_GM( return new BleedGM(kUseAlphaImageShader_BleedTest); )
« no previous file with comments | « no previous file | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698