a90c680386
- Rename TileGrid -> Quilt to avoid the name overload. - Tag all failing GMs with kSkipTiled_Flag. You may be wondering, do any GMs pass? Yes, some do! And that trends towards all of them as we increase --quiltTile. Two GMs only fail in --quilt mode in 565. Otherwise all GMs which fail are skipped, and those which don't fail aren't. (The 8888 variants of those two GMs are skipped even though they pass.) BUG=skia:2477 R=reed@google.com, mtklein@google.com Author: mtklein@chromium.org Review URL: https://codereview.chromium.org/256373002 git-svn-id: http://skia.googlecode.com/svn/trunk@14457 2bbb7eff-a529-9590-31e7-b0007b416f81
283 lines
12 KiB
C++
283 lines
12 KiB
C++
/*
|
|
* 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"
|
|
|
|
#if SK_SUPPORT_GPU
|
|
#include "GrContext.h"
|
|
#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_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();
|
|
}
|
|
|
|
// This GM exercises the drawBitmapRectToRect "bleed" flag
|
|
class BleedGM : public skiagm::GM {
|
|
public:
|
|
BleedGM() {}
|
|
|
|
protected:
|
|
virtual uint32_t onGetFlags() const SK_OVERRIDE {
|
|
return kSkipTiled_Flag;
|
|
}
|
|
|
|
virtual SkString onShortName() SK_OVERRIDE {
|
|
return SkString("bleed");
|
|
}
|
|
|
|
virtual SkISize onISize() SK_OVERRIDE {
|
|
return SkISize::Make(kWidth, 780);
|
|
}
|
|
|
|
virtual void onOnceBeforeDraw() SK_OVERRIDE {
|
|
make_ringed_bitmap(&fBitmapSmall, kSmallTextureSize, kSmallTextureSize);
|
|
|
|
// To exercise the GPU's tiling path we need a texture
|
|
// too big for the GPU to handle in one go
|
|
make_ringed_bitmap(&fBitmapBig, 2*kMaxTextureSize, 2*kMaxTextureSize);
|
|
}
|
|
|
|
// Draw only the center of the small bitmap
|
|
void drawCase1(SkCanvas* canvas, int transX, int transY,
|
|
SkCanvas::DrawBitmapRectFlags flags, SkPaint::FilterLevel filter) {
|
|
SkRect src = SkRect::MakeXYWH(2, 2,
|
|
SkIntToScalar(kSmallTextureSize-4),
|
|
SkIntToScalar(kSmallTextureSize-4));
|
|
SkRect dst = SkRect::MakeXYWH(0, 0, SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
|
|
|
|
SkPaint paint;
|
|
paint.setFilterLevel(filter);
|
|
|
|
canvas->save();
|
|
canvas->translate(SkIntToScalar(transX), SkIntToScalar(transY));
|
|
canvas->drawBitmapRectToRect(fBitmapSmall, &src, dst, &paint, flags);
|
|
canvas->restore();
|
|
}
|
|
|
|
// Draw almost all of the large bitmap
|
|
void drawCase2(SkCanvas* canvas, int transX, int transY,
|
|
SkCanvas::DrawBitmapRectFlags flags, SkPaint::FilterLevel filter) {
|
|
SkRect src = SkRect::MakeXYWH(2, 2,
|
|
SkIntToScalar(fBitmapBig.width()-4),
|
|
SkIntToScalar(fBitmapBig.height()-4));
|
|
SkRect dst = SkRect::MakeXYWH(0, 0, SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
|
|
|
|
SkPaint paint;
|
|
paint.setFilterLevel(filter);
|
|
|
|
canvas->save();
|
|
canvas->translate(SkIntToScalar(transX), SkIntToScalar(transY));
|
|
canvas->drawBitmapRectToRect(fBitmapBig, &src, dst, &paint, flags);
|
|
canvas->restore();
|
|
}
|
|
|
|
// Draw ~1/4 of the large bitmap
|
|
void drawCase3(SkCanvas* canvas, int transX, int transY,
|
|
SkCanvas::DrawBitmapRectFlags flags, SkPaint::FilterLevel filter) {
|
|
SkRect src = SkRect::MakeXYWH(2, 2,
|
|
SkIntToScalar(fBitmapBig.width()/2-2),
|
|
SkIntToScalar(fBitmapBig.height()/2-2));
|
|
SkRect dst = SkRect::MakeXYWH(0, 0, SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
|
|
|
|
SkPaint paint;
|
|
paint.setFilterLevel(filter);
|
|
|
|
canvas->save();
|
|
canvas->translate(SkIntToScalar(transX), SkIntToScalar(transY));
|
|
canvas->drawBitmapRectToRect(fBitmapBig, &src, dst, &paint, flags);
|
|
canvas->restore();
|
|
}
|
|
|
|
// Draw the center of the small bitmap with a mask filter
|
|
void drawCase4(SkCanvas* canvas, int transX, int transY,
|
|
SkCanvas::DrawBitmapRectFlags flags, SkPaint::FilterLevel filter) {
|
|
SkRect src = SkRect::MakeXYWH(2, 2,
|
|
SkIntToScalar(kSmallTextureSize-4),
|
|
SkIntToScalar(kSmallTextureSize-4));
|
|
SkRect dst = SkRect::MakeXYWH(0, 0, SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
|
|
|
|
SkPaint paint;
|
|
paint.setFilterLevel(filter);
|
|
SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
|
|
SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(3)));
|
|
paint.setMaskFilter(mf)->unref();
|
|
|
|
canvas->save();
|
|
canvas->translate(SkIntToScalar(transX), SkIntToScalar(transY));
|
|
canvas->drawBitmapRectToRect(fBitmapSmall, &src, dst, &paint, flags);
|
|
canvas->restore();
|
|
}
|
|
|
|
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
|
|
|
|
canvas->clear(SK_ColorGRAY);
|
|
|
|
for (int m = 0; m < 2; ++m) {
|
|
canvas->save();
|
|
if (m) {
|
|
static const SkScalar kBottom = SkIntToScalar(kRow3Y + kBlockSize + kBlockSpacing);
|
|
canvas->translate(0, kBottom);
|
|
SkMatrix rotate;
|
|
rotate.setRotate(15.f, 0, kBottom + kBlockSpacing);
|
|
canvas->concat(rotate);
|
|
canvas->scale(0.71f, 1.22f);
|
|
}
|
|
|
|
// First draw a column with no bleeding, tiling, or filtering
|
|
this->drawCase1(canvas, kCol0X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kNone_FilterLevel);
|
|
this->drawCase2(canvas, kCol0X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kNone_FilterLevel);
|
|
this->drawCase3(canvas, kCol0X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kNone_FilterLevel);
|
|
this->drawCase4(canvas, kCol0X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kNone_FilterLevel);
|
|
|
|
// Then draw a column with no bleeding or tiling but with low filtering
|
|
this->drawCase1(canvas, kCol1X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
this->drawCase2(canvas, kCol1X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
this->drawCase3(canvas, kCol1X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
this->drawCase4(canvas, kCol1X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
|
|
// Then draw a column with no bleeding or tiling but with high filtering
|
|
this->drawCase1(canvas, kCol2X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
this->drawCase2(canvas, kCol2X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
this->drawCase3(canvas, kCol2X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
this->drawCase4(canvas, kCol2X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
|
|
#if SK_SUPPORT_GPU
|
|
GrContext* ctx = canvas->getGrContext();
|
|
int oldMaxTextureSize = 0;
|
|
if (NULL != ctx) {
|
|
// shrink the max texture size so all our textures can be reasonably sized
|
|
oldMaxTextureSize = ctx->getMaxTextureSize();
|
|
ctx->setMaxTextureSizeOverride(kMaxTextureSize);
|
|
}
|
|
#endif
|
|
|
|
// Then draw a column with no bleeding but with tiling and low filtering
|
|
this->drawCase1(canvas, kCol3X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
this->drawCase2(canvas, kCol3X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
this->drawCase3(canvas, kCol3X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
this->drawCase4(canvas, kCol3X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
|
|
// Then draw a column with no bleeding but with tiling and high filtering
|
|
this->drawCase1(canvas, kCol4X, kRow0Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
this->drawCase2(canvas, kCol4X, kRow1Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
this->drawCase3(canvas, kCol4X, kRow2Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
this->drawCase4(canvas, kCol4X, kRow3Y, SkCanvas::kNone_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
|
|
// Then draw a column with bleeding, tiling, and low filtering
|
|
this->drawCase1(canvas, kCol5X, kRow0Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
this->drawCase2(canvas, kCol5X, kRow1Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
this->drawCase3(canvas, kCol5X, kRow2Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
this->drawCase4(canvas, kCol5X, kRow3Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kLow_FilterLevel);
|
|
|
|
// Finally draw a column with bleeding, tiling, and high filtering
|
|
this->drawCase1(canvas, kCol6X, kRow0Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
this->drawCase2(canvas, kCol6X, kRow1Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
this->drawCase3(canvas, kCol6X, kRow2Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
this->drawCase4(canvas, kCol6X, kRow3Y, SkCanvas::kBleed_DrawBitmapRectFlag, SkPaint::kHigh_FilterLevel);
|
|
|
|
#if SK_SUPPORT_GPU
|
|
if (NULL != ctx) {
|
|
ctx->setMaxTextureSizeOverride(oldMaxTextureSize);
|
|
}
|
|
#endif
|
|
canvas->restore();
|
|
}
|
|
}
|
|
|
|
private:
|
|
static const int kBlockSize = 70;
|
|
static const int kBlockSpacing = 5;
|
|
|
|
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 kCol6X = 7*kBlockSpacing + 6*kBlockSize;
|
|
static const int kWidth = 8*kBlockSpacing + 7*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 kSmallTextureSize = 6;
|
|
static const int kMaxTextureSize = 32;
|
|
|
|
SkBitmap fBitmapSmall;
|
|
SkBitmap fBitmapBig;
|
|
|
|
typedef GM INHERITED;
|
|
};
|
|
|
|
DEF_GM( return new BleedGM(); )
|