1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/*
* 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 "SkColorFilter.h"
#include "SkLayerDrawLooper.h"
#include "SkPaint.h"
#include "SkPath.h"
#include "SkPoint.h"
#include "SkRect.h"
#include "SkRRect.h"
#include "SkString.h"
#include "SkXfermode.h"
// This GM mimics a blurred RR seen in the wild.
class BlurRoundRectGM : public skiagm::GM {
public:
BlurRoundRectGM(int width, int height, int radius)
: fName("blurroundrect")
{
SkRect r = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
fRRect.setRectXY(r, SkIntToScalar(radius), SkIntToScalar(radius));
fName.appendf("-WH-%ix%i-corner-%i", width, height, radius);
}
BlurRoundRectGM(int width, int height)
: fName("blurroundrect") {
fName.appendf("-WH-%ix%i-unevenCorners", width, height);
SkVector radii[4];
radii[0].set(SkIntToScalar(30), SkIntToScalar(30));
radii[1].set(SkIntToScalar(10), SkIntToScalar(10));
radii[2].set(SkIntToScalar(30), SkIntToScalar(30));
radii[3].set(SkIntToScalar(10), SkIntToScalar(10));
SkRect r = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
fRRect.setRectRadii(r, radii);
}
virtual uint32_t onGetFlags() const SK_OVERRIDE {
return kSkipTiled_Flag;
}
virtual SkString onShortName() SK_OVERRIDE {
return fName;
}
virtual SkISize onISize() SK_OVERRIDE {
return SkISize::Make(SkScalarCeilToInt(fRRect.rect().width()),
SkScalarCeilToInt(fRRect.rect().height()));
}
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
SkLayerDrawLooper::Builder looperBuilder;
{
SkLayerDrawLooper::LayerInfo info;
info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit
| SkLayerDrawLooper::kColorFilter_Bit;
info.fColorMode = SkXfermode::kSrc_Mode;
info.fOffset = SkPoint::Make(SkIntToScalar(-1), SkIntToScalar(0));
info.fPostTranslate = false;
SkPaint* paint = looperBuilder.addLayerOnTop(info);
SkMaskFilter* maskFilter = SkBlurMaskFilter::Create(
kNormal_SkBlurStyle,
SkBlurMask::ConvertRadiusToSigma(SK_ScalarHalf),
SkBlurMaskFilter::kHighQuality_BlurFlag);
paint->setMaskFilter(maskFilter)->unref();
SkColorFilter* colorFilter = SkColorFilter::CreateModeFilter(SK_ColorLTGRAY,
SkXfermode::kSrcIn_Mode);
paint->setColorFilter(colorFilter)->unref();
paint->setColor(SK_ColorGRAY);
}
{
SkLayerDrawLooper::LayerInfo info;
looperBuilder.addLayerOnTop(info);
}
SkPaint paint;
canvas->drawRect(fRRect.rect(), paint);
paint.setLooper(looperBuilder.detachLooper())->unref();
paint.setColor(SK_ColorCYAN);
paint.setAntiAlias(true);
canvas->drawRRect(fRRect, paint);
}
private:
SkString fName;
SkRRect fRRect;
typedef skiagm::GM INHERITED;
};
// Simpler blurred RR test cases where all the radii are the same.
class SimpleBlurRoundRectGM : public skiagm::GM {
public:
SimpleBlurRoundRectGM()
: fName("simpleblurroundrect") {
}
protected:
virtual uint32_t onGetFlags() const SK_OVERRIDE {
return kSkipTiled_Flag;
}
virtual SkString onShortName() SK_OVERRIDE {
return fName;
}
virtual SkISize onISize() SK_OVERRIDE {
return SkISize::Make(950, 950);
}
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
canvas->scale(1.5f, 1.5f);
canvas->translate(50,50);
const float blurRadii[] = { 1,5,10,20 };
const int cornerRadii[] = { 1,5,10,20 };
const SkRect r = SkRect::MakeWH(SkIntToScalar(100), SkIntToScalar(100));
for (size_t i = 0; i < SK_ARRAY_COUNT(blurRadii); ++i) {
SkAutoCanvasRestore autoRestore(canvas, true);
canvas->translate(0, (r.height() + SkIntToScalar(50)) * i);
for (size_t j = 0; j < SK_ARRAY_COUNT(cornerRadii); ++j) {
SkMaskFilter* filter = SkBlurMaskFilter::Create(
kNormal_SkBlurStyle,
SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(blurRadii[i])),
SkBlurMaskFilter::kHighQuality_BlurFlag);
SkPaint paint;
paint.setColor(SK_ColorBLACK);
paint.setMaskFilter(filter)->unref();
SkRRect rrect;
rrect.setRectXY(r, SkIntToScalar(cornerRadii[j]), SkIntToScalar(cornerRadii[j]));
canvas->drawRRect(rrect, paint);
canvas->translate(r.width() + SkIntToScalar(50), 0);
}
}
}
private:
const SkString fName;
typedef skiagm::GM INHERITED;
};
// Create one with dimensions/rounded corners based on the skp
//
// TODO(scroggo): Disabled in an attempt to rememdy
// https://code.google.com/p/skia/issues/detail?id=1801 ('Win7 Test bots all failing GenerateGMs:
// ran wrong number of tests')
//DEF_GM(return new BlurRoundRectGM(600, 5514, 6);)
// Rounded rect with two opposite corners with large radii, the other two
// small.
DEF_GM(return new BlurRoundRectGM(100, 100);)
DEF_GM(return new SimpleBlurRoundRectGM();)
|
