static void test_layerDrawLooper(skiatest::Reporter* reporter, SkMaskFilter* mf, SkScalar sigma,
SkBlurStyle style, SkBlurQuality quality, bool expectSuccess) {
SkLayerDrawLooper::LayerInfo info;
SkLayerDrawLooper::Builder builder;
// 1 layer is too few
make_noop_layer(&builder);
test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, false);
// 2 layers is good, but need blur
make_noop_layer(&builder);
make_noop_layer(&builder);
test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, false);
// 2 layers is just right
make_noop_layer(&builder);
make_blur_layer(&builder, mf);
test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, expectSuccess);
// 3 layers is too many
make_noop_layer(&builder);
make_blur_layer(&builder, mf);
make_noop_layer(&builder);
test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, false);
}
void onDraw(SkCanvas* canvas) 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_tool_utils::color_to_565(SK_ColorLTGRAY),
SkXfermode::kSrcIn_Mode);
paint->setColorFilter(colorFilter)->unref();
paint->setColor(sk_tool_utils::color_to_565(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);
}
SkLayerDrawLooper* createLooper(SkScalar xOff, SkScalar sigma) {
SkLayerDrawLooper::Builder looperBuilder;
//-----------------------------------------------
SkLayerDrawLooper::LayerInfo info;
// TODO: add a color filter to better match what is seen in the wild
info.fPaintBits = /* SkLayerDrawLooper::kColorFilter_Bit |*/
SkLayerDrawLooper::kMaskFilter_Bit;
info.fColorMode = SkXfermode::kDst_Mode;
info.fOffset.set(xOff, 0);
info.fPostTranslate = false;
SkPaint* paint = looperBuilder.addLayer(info);
SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
sigma,
SkBlurMaskFilter::kHighQuality_BlurFlag);
paint->setMaskFilter(mf)->unref();
//-----------------------------------------------
info.fPaintBits = 0;
info.fOffset.set(0, 0);
paint = looperBuilder.addLayer(info);
return looperBuilder.detachLooper();
}
DEF_TEST(Paint_copy, reporter) {
SkPaint paint;
// set a few member variables
paint.setStyle(SkPaint::kStrokeAndFill_Style);
paint.setTextAlign(SkPaint::kLeft_Align);
paint.setStrokeWidth(SkIntToScalar(2));
// set a few pointers
SkLayerDrawLooper::Builder looperBuilder;
SkLayerDrawLooper* looper = looperBuilder.detachLooper();
paint.setLooper(looper)->unref();
SkMaskFilter* mask = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(1)));
paint.setMaskFilter(mask)->unref();
// copy the paint using the copy constructor and check they are the same
SkPaint copiedPaint = paint;
REPORTER_ASSERT(reporter, paint == copiedPaint);
#ifdef SK_BUILD_FOR_ANDROID
// the copy constructor should preserve the Generation ID
uint32_t paintGenID = paint.getGenerationID();
uint32_t copiedPaintGenID = copiedPaint.getGenerationID();
REPORTER_ASSERT(reporter, paintGenID == copiedPaintGenID);
REPORTER_ASSERT(reporter, paint == copiedPaint);
#endif
// copy the paint using the equal operator and check they are the same
copiedPaint = paint;
REPORTER_ASSERT(reporter, paint == copiedPaint);
#ifdef SK_BUILD_FOR_ANDROID
// the equals operator should increment the Generation ID
REPORTER_ASSERT(reporter, paint.getGenerationID() == paintGenID);
REPORTER_ASSERT(reporter, copiedPaint.getGenerationID() != copiedPaintGenID);
copiedPaintGenID = copiedPaint.getGenerationID(); // reset to the new value
REPORTER_ASSERT(reporter, paint == copiedPaint); // operator== ignores fGenerationID
#endif
// clean the paint and check they are back to their initial states
SkPaint cleanPaint;
paint.reset();
copiedPaint.reset();
REPORTER_ASSERT(reporter, cleanPaint == paint);
REPORTER_ASSERT(reporter, cleanPaint == copiedPaint);
#ifdef SK_BUILD_FOR_ANDROID
// the reset function should increment the Generation ID
REPORTER_ASSERT(reporter, paint.getGenerationID() != paintGenID);
REPORTER_ASSERT(reporter, copiedPaint.getGenerationID() != copiedPaintGenID);
// operator== ignores fGenerationID
REPORTER_ASSERT(reporter, cleanPaint == paint);
REPORTER_ASSERT(reporter, cleanPaint == copiedPaint);
#endif
}
void init() {
if (fLooper) return;
static const struct {
SkColor fColor;
SkPaint::Style fStyle;
SkScalar fWidth;
SkScalar fOffset;
SkScalar fBlur;
} gParams[] = {
{ SK_ColorWHITE, SkPaint::kStroke_Style, SkIntToScalar(1)*3/4, 0, 0 },
{ SK_ColorRED, SkPaint::kStroke_Style, SkIntToScalar(4), 0, 0 },
{ SK_ColorBLUE, SkPaint::kFill_Style, 0, 0, 0 },
{ 0x88000000, SkPaint::kFill_Style, 0, SkIntToScalar(10), SkIntToScalar(3) }
};
SkLayerDrawLooper::Builder looperBuilder;
SkLayerDrawLooper::LayerInfo info;
info.fPaintBits = SkLayerDrawLooper::kStyle_Bit | SkLayerDrawLooper::kMaskFilter_Bit;
info.fColorMode = SkXfermode::kSrc_Mode;
for (size_t i = 0; i < SK_ARRAY_COUNT(gParams); i++) {
info.fOffset.set(gParams[i].fOffset, gParams[i].fOffset);
SkPaint* paint = looperBuilder.addLayer(info);
paint->setColor(gParams[i].fColor);
paint->setStyle(gParams[i].fStyle);
paint->setStrokeWidth(gParams[i].fWidth);
if (gParams[i].fBlur > 0) {
SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
SkBlurMask::ConvertRadiusToSigma(gParams[i].fBlur));
paint->setMaskFilter(mf)->unref();
}
}
fLooper = looperBuilder.detachLooper();
}
static SkLayerDrawLooper* setupLooper(SkLayerDrawLooper::BitFlags bits,
LooperProc proc,
const LooperSettings settings[],
size_t size) {
SkLayerDrawLooper::Builder looperBuilder;
SkLayerDrawLooper::LayerInfo info;
info.fPaintBits = bits;
info.fColorMode = SkXfermode::kSrc_Mode;
for (size_t i = 0; i < size; i++) {
info.fOffset.set(settings[i].fOffset, settings[i].fOffset);
SkPaint* paint = looperBuilder.addLayer(info);
paint->setXfermodeMode(settings[i].fMode);
paint->setColor(settings[i].fColor);
paint->setStyle(settings[i].fStyle);
paint->setStrokeWidth(settings[i].fWidth);
if (settings[i].fEffect) {
(*proc)(paint);
}
}
return looperBuilder.detachLooper();
}