void make_bitmaps() {
make_bitmap();
make_checkerboard(&fCheckerboard, 80, 80);
make_checkerboard(&fSmall, 64, 64);
make_checkerboard(&fLarge, 96, 96);
make_checkerboard(&fLargeW, 96, 64);
make_checkerboard(&fLargeH, 64, 96);
}
virtual void onDraw(SkCanvas* canvas) {
canvas->clear(SK_ColorBLACK);
SkMatrix matrix;
SkScalar margin = SkIntToScalar(10);
matrix.setSkew(SkDoubleToScalar(0.5), SkDoubleToScalar(0.2));
SkBitmap checkerboard;
make_checkerboard(&checkerboard);
SkRect srcRect = SkRect::MakeWH(96, 96);
canvas->translate(margin, margin);
draw(canvas, srcRect, checkerboard, matrix, kNone_SkFilterQuality);
canvas->translate(srcRect.width() + margin, 0);
draw(canvas, srcRect, checkerboard, matrix, kLow_SkFilterQuality);
#if 0
// This may be causing Mac 10.6 to barf.
canvas->translate(srcRect.width() + margin, 0);
draw(canvas, srcRect, checkerboard, matrix, kMedium_SkFilterQuality);
canvas->translate(srcRect.width() + margin, 0);
draw(canvas, srcRect, checkerboard, matrix, kHigh_SkFilterQuality);
#endif
}
void onPreDraw() override {
if (!fInitialized) {
make_bitmap();
make_checkerboard();
fInitialized = true;
}
}
virtual void onDraw(SkCanvas* canvas) {
if (!fInitialized) {
make_bitmap();
make_checkerboard();
fInitialized = true;
}
canvas->clear(0x00000000);
SkPaint paint;
int x = 0, y = 0;
for (size_t i = 0; i < 4; i++) {
SkBitmap* bitmap = (i & 0x01) ? &fCheckerboard : &fBitmap;
SkRect srcRect = SkRect::MakeXYWH(SkIntToScalar(bitmap->width()/4),
SkIntToScalar(bitmap->height()/4),
SkIntToScalar(bitmap->width()/(i+1)),
SkIntToScalar(bitmap->height()/(i+1)));
SkRect dstRect = SkRect::MakeXYWH(SkIntToScalar(i * 8),
SkIntToScalar(i * 4),
SkIntToScalar(bitmap->width() - i * 12),
SkIntToScalar(bitmap->height()) - i * 12);
SkAutoTUnref<SkImageFilter> tileInput(SkBitmapSource::Create(*bitmap));
SkAutoTUnref<SkImageFilter> filter(
SkTileImageFilter::Create(srcRect, dstRect, tileInput));
canvas->save();
canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
paint.setImageFilter(filter);
canvas->drawBitmap(fBitmap, 0, 0, &paint);
canvas->restore();
x += bitmap->width() + MARGIN;
if (x + bitmap->width() > WIDTH) {
x = 0;
y += bitmap->height() + MARGIN;
}
}
}
virtual void onDraw(SkCanvas* canvas) {
if (!fInitialized) {
make_bitmap();
make_checkerboard();
fInitialized = true;
}
canvas->clear(0x00000000);
SkPaint paint;
int x = 0, y = 0;
for (size_t i = 0; i < 4; i++) {
SkBitmap* bitmap = (i & 0x01) ? &fCheckerboard : &fBitmap;
SkIRect cropRect = SkIRect::MakeXYWH(x + i * 12,
y + i * 8,
bitmap->width() - i * 8,
bitmap->height() - i * 12);
SkImageFilter::CropRect rect(SkRect::Make(cropRect));
SkAutoTUnref<SkImageFilter> tileInput(SkNEW_ARGS(SkBitmapSource, (*bitmap)));
SkScalar dx = SkIntToScalar(i*5);
SkScalar dy = SkIntToScalar(i*10);
SkAutoTUnref<SkImageFilter> filter(SkNEW_ARGS(
SkOffsetImageFilter, (dx, dy, tileInput, &rect)));
paint.setImageFilter(filter);
drawClippedBitmap(canvas, *bitmap, paint, SkIntToScalar(x), SkIntToScalar(y));
x += bitmap->width() + MARGIN;
if (x + bitmap->width() > WIDTH) {
x = 0;
y += bitmap->height() + MARGIN;
}
}
}
virtual void onDraw(SkCanvas* canvas) {
if (!fInitialized) {
make_bitmap();
make_checkerboard();
fInitialized = true;
}
canvas->clear(0x00000000);
SkPaint paint;
for (int i = 0; i < 4; i++) {
SkBitmap* bitmap = (i & 0x01) ? &fCheckerboard : &fBitmap;
SkIRect cropRect = SkIRect::MakeXYWH(i * 12,
i * 8,
bitmap->width() - i * 8,
bitmap->height() - i * 12);
SkImageFilter::CropRect rect(SkRect::Make(cropRect));
SkAutoTUnref<SkImageFilter> tileInput(SkBitmapSource::Create(*bitmap));
SkScalar dx = SkIntToScalar(i*5);
SkScalar dy = SkIntToScalar(i*10);
SkAutoTUnref<SkImageFilter> filter(
SkOffsetImageFilter::Create(dx, dy, tileInput, &rect));
paint.setImageFilter(filter);
drawClippedBitmap(canvas, *bitmap, paint, SK_Scalar1, cropRect);
canvas->translate(SkIntToScalar(bitmap->width() + MARGIN), 0);
}
SkIRect cropRect = SkIRect::MakeXYWH(0, 0, 100, 100);
SkImageFilter::CropRect rect(SkRect::Make(cropRect));
SkAutoTUnref<SkImageFilter> filter(
SkOffsetImageFilter::Create(SkIntToScalar(-5), SkIntToScalar(-10), NULL, &rect));
paint.setImageFilter(filter);
drawClippedBitmap(canvas, fBitmap, paint, SkIntToScalar(2), cropRect);
}
void onDelayedSetup() override {
if (!fInitialized) {
make_bitmap();
make_checkerboard();
fInitialized = true;
}
}
virtual void onDraw(SkCanvas* canvas) {
if (!fInitialized) {
make_checkerboard(4, 4);
fInitialized = true;
}
SkScalar sk32 = SkIntToScalar(32);
canvas->clear(0x00000000);
SkPaint bilinearPaint, bicubicPaint;
SkSize scale = SkSize::Make(sk32, sk32);
canvas->save();
canvas->scale(sk32, sk32);
bilinearPaint.setFilterLevel(SkPaint::kLow_FilterLevel);
canvas->drawBitmap(fCheckerboard, 0, 0, &bilinearPaint);
canvas->restore();
SkAutoTUnref<SkImageFilter> bicubic(SkBicubicImageFilter::CreateMitchell(scale));
bicubicPaint.setImageFilter(bicubic);
SkRect srcBounds;
fCheckerboard.getBounds(&srcBounds);
canvas->translate(SkIntToScalar(140), 0);
canvas->saveLayer(&srcBounds, &bicubicPaint);
canvas->drawBitmap(fCheckerboard, 0, 0);
canvas->restore();
}
void onOnceBeforeDraw() override{
make_checkerboard();
}
virtual void onDraw(SkCanvas* canvas) {
if (!fInitialized) {
make_bitmap();
make_checkerboard();
fInitialized = true;
}
canvas->clear(0x00000000);
SkPaint paint;
const struct {
SkXfermode::Mode fMode;
const char* fLabel;
} gModes[] = {
{ SkXfermode::kClear_Mode, "Clear" },
{ SkXfermode::kSrc_Mode, "Src" },
{ SkXfermode::kDst_Mode, "Dst" },
{ SkXfermode::kSrcOver_Mode, "SrcOver" },
{ SkXfermode::kDstOver_Mode, "DstOver" },
{ SkXfermode::kSrcIn_Mode, "SrcIn" },
{ SkXfermode::kDstIn_Mode, "DstIn" },
{ SkXfermode::kSrcOut_Mode, "SrcOut" },
{ SkXfermode::kDstOut_Mode, "DstOut" },
{ SkXfermode::kSrcATop_Mode, "SrcATop" },
{ SkXfermode::kDstATop_Mode, "DstATop" },
{ SkXfermode::kXor_Mode, "Xor" },
{ SkXfermode::kPlus_Mode, "Plus" },
{ SkXfermode::kModulate_Mode, "Modulate" },
{ SkXfermode::kScreen_Mode, "Screen" },
{ SkXfermode::kOverlay_Mode, "Overlay" },
{ SkXfermode::kDarken_Mode, "Darken" },
{ SkXfermode::kLighten_Mode, "Lighten" },
{ SkXfermode::kColorDodge_Mode, "ColorDodge" },
{ SkXfermode::kColorBurn_Mode, "ColorBurn" },
{ SkXfermode::kHardLight_Mode, "HardLight" },
{ SkXfermode::kSoftLight_Mode, "SoftLight" },
{ SkXfermode::kDifference_Mode, "Difference" },
{ SkXfermode::kExclusion_Mode, "Exclusion" },
{ SkXfermode::kMultiply_Mode, "Multiply" },
{ SkXfermode::kHue_Mode, "Hue" },
{ SkXfermode::kSaturation_Mode, "Saturation" },
{ SkXfermode::kColor_Mode, "Color" },
{ SkXfermode::kLuminosity_Mode, "Luminosity" },
};
int x = 0, y = 0;
SkAutoTUnref<SkImageFilter> background(SkNEW_ARGS(SkBitmapSource, (fCheckerboard)));
for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(gModes[i].fMode));
SkAutoTUnref<SkImageFilter> filter(SkNEW_ARGS(
SkXfermodeImageFilter, (mode, background)));
paint.setImageFilter(filter);
drawClippedBitmap(canvas, fBitmap, paint, SkIntToScalar(x), SkIntToScalar(y));
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
x = 0;
y += fBitmap.height() + MARGIN;
}
}
// Test arithmetic mode as image filter
SkAutoTUnref<SkXfermode> mode(SkArithmeticMode::Create(0, SK_Scalar1, SK_Scalar1, 0));
SkAutoTUnref<SkImageFilter> filter(SkNEW_ARGS(SkXfermodeImageFilter, (mode, background)));
paint.setImageFilter(filter);
drawClippedBitmap(canvas, fBitmap, paint, SkIntToScalar(x), SkIntToScalar(y));
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
x = 0;
y += fBitmap.height() + MARGIN;
}
// Test NULL mode
filter.reset(SkNEW_ARGS(SkXfermodeImageFilter, (NULL, background)));
paint.setImageFilter(filter);
drawClippedBitmap(canvas, fBitmap, paint, SkIntToScalar(x), SkIntToScalar(y));
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
x = 0;
y += fBitmap.height() + MARGIN;
}
// Test offsets on SrcMode (uses fixed-function blend)
SkAutoTUnref<SkImageFilter> foreground(SkNEW_ARGS(SkBitmapSource, (fBitmap)));
SkAutoTUnref<SkImageFilter> offsetForeground(SkNEW_ARGS(SkOffsetImageFilter,
(SkIntToScalar(4), SkIntToScalar(-4), foreground)));
SkAutoTUnref<SkImageFilter> offsetBackground(SkNEW_ARGS(SkOffsetImageFilter,
(SkIntToScalar(4), SkIntToScalar(4), background)));
mode.reset(SkXfermode::Create(SkXfermode::kSrcOver_Mode));
filter.reset(SkNEW_ARGS(SkXfermodeImageFilter,
(mode, offsetBackground, offsetForeground)));
paint.setImageFilter(filter);
canvas->save();
canvas->clipRect(SkRect::MakeXYWH(SkIntToScalar(x),
SkIntToScalar(y),
SkIntToScalar(fBitmap.width() + 4),
SkIntToScalar(fBitmap.height() + 4)));
canvas->drawPaint(paint);
canvas->restore();
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
x = 0;
y += fBitmap.height() + MARGIN;
}
// Test offsets on Darken (uses shader blend)
mode.reset(SkXfermode::Create(SkXfermode::kDarken_Mode));
filter.reset(SkNEW_ARGS(SkXfermodeImageFilter, (mode, offsetBackground, offsetForeground)));
paint.setImageFilter(filter);
canvas->save();
canvas->clipRect(SkRect::MakeXYWH(SkIntToScalar(x),
SkIntToScalar(y),
SkIntToScalar(fBitmap.width() + 4),
SkIntToScalar(fBitmap.height() + 4)));
canvas->drawPaint(paint);
canvas->restore();
}
virtual void onDraw(SkCanvas* canvas) {
SkAutoTUnref<SkColorFilter> cf(
SkColorFilter::CreateModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode));
SkImageFilter::CropRect crop_rect(
SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)),
SkImageFilter::CropRect::kHasAll_CropEdge);
SkBitmap gradient_circle, checkerboard;
make_gradient_circle(64, 64, &gradient_circle);
make_checkerboard(&checkerboard);
SkAutoTUnref<SkImageFilter> gradient_circle_source(
SkBitmapSource::Create(gradient_circle));
SkAutoTUnref<SkImageFilter> noop_cropped(
SkOffsetImageFilter::Create(0, 0, NULL, &crop_rect));
SkScalar sk255 = SkIntToScalar(255);
SkScalar matrix[20] = { 1, 0, 0, 0, 0,
0, 1, 0, 0, sk255,
0, 0, 1, 0, 0,
0, 0, 0, 0, sk255 };
SkAutoTUnref<SkColorFilter> cf_alpha_trans(SkColorMatrixFilter::Create(matrix));
SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
SkScalar MARGIN = SkIntToScalar(12);
SkIRect bounds;
r.roundOut(&bounds);
SkPaint paint;
canvas->translate(MARGIN, MARGIN);
for (int outset = -15; outset <= 20; outset += 5) {
canvas->save();
SkRect rect = crop_rect.rect();
rect.outset(SkIntToScalar(outset),
SkIntToScalar(outset));
SkImageFilter::CropRect big_rect(rect, SkImageFilter::CropRect::kHasAll_CropEdge);
draw(canvas, checkerboard, rect, SkColorFilterImageFilter::Create(
cf_alpha_trans, noop_cropped.get(), &big_rect));
draw(canvas, checkerboard, rect, SkBlurImageFilter::Create(
8.0f, 8.0f, noop_cropped.get(), &big_rect));
draw(canvas, checkerboard, rect, SkDilateImageFilter::Create(
2, 2, noop_cropped.get(), &big_rect));
draw(canvas, checkerboard, rect, SkErodeImageFilter::Create(
2, 2, noop_cropped.get(), &big_rect));
draw(canvas, checkerboard, rect, SkDropShadowImageFilter::Create(
SkIntToScalar(10), SkIntToScalar(10), SkIntToScalar(3), SkIntToScalar(3),
SK_ColorBLUE, noop_cropped.get(), &big_rect));
draw(canvas, checkerboard, rect, SkDisplacementMapEffect::Create(
SkDisplacementMapEffect::kR_ChannelSelectorType,
SkDisplacementMapEffect::kR_ChannelSelectorType,
SkIntToScalar(12),
gradient_circle_source.get(),
noop_cropped.get(),
&big_rect));
draw(canvas, checkerboard, rect, SkOffsetImageFilter::Create(
SkIntToScalar(-8), SkIntToScalar(16), noop_cropped.get(), &big_rect));
canvas->restore();
canvas->translate(0, SkIntToScalar(80));
}
}
