Update gms to use new image filter factories
Bug: skia:9280
Change-Id: Ic7ca3a9c86025128bc45b89ea90aa4553287b8c9
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/230879
Commit-Queue: Michael Ludwig <michaelludwig@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
diff --git a/gm/animatedimageblurs.cpp b/gm/animatedimageblurs.cpp
index 420eaaf..90eb1d4 100644
--- a/gm/animatedimageblurs.cpp
+++ b/gm/animatedimageblurs.cpp
@@ -16,7 +16,7 @@
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/utils/SkRandom.h"
#include "tools/timer/TimeUtils.h"
@@ -52,9 +52,8 @@
for (int i = 0; i < kNumNodes; ++i) {
SkPaint layerPaint;
- layerPaint.setImageFilter(SkBlurImageFilter::Make(fNodes[i].sigma(),
- fNodes[i].sigma(),
- nullptr));
+ layerPaint.setImageFilter(SkImageFilters::Blur(fNodes[i].sigma(), fNodes[i].sigma(),
+ nullptr));
canvas->saveLayer(nullptr, &layerPaint);
// The rect is outset to block the circle case
diff --git a/gm/arithmode.cpp b/gm/arithmode.cpp
index ea5e7b7..f835eb7 100644
--- a/gm/arithmode.cpp
+++ b/gm/arithmode.cpp
@@ -24,9 +24,8 @@
#include "include/core/SkTileMode.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkArithmeticImageFilter.h"
#include "include/effects/SkGradientShader.h"
-#include "include/effects/SkImageSource.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include <utility>
@@ -88,8 +87,8 @@
void onDraw(SkCanvas* canvas) override {
sk_sp<SkImage> src = make_src();
sk_sp<SkImage> dst = make_dst();
- sk_sp<SkImageFilter> srcFilter = SkImageSource::Make(src);
- sk_sp<SkImageFilter> dstFilter = SkImageSource::Make(dst);
+ sk_sp<SkImageFilter> srcFilter = SkImageFilters::Image(src);
+ sk_sp<SkImageFilter> dstFilter = SkImageFilters::Image(dst);
constexpr SkScalar one = SK_Scalar1;
constexpr SkScalar K[] = {
@@ -118,8 +117,8 @@
canvas->drawImage(dst, 0, 0);
canvas->translate(gap, 0);
SkPaint paint;
- paint.setImageFilter(SkArithmeticImageFilter::Make(k[0], k[1], k[2], k[3], true,
- dstFilter, srcFilter, nullptr));
+ paint.setImageFilter(SkImageFilters::Arithmetic(k[0], k[1], k[2], k[3], true,
+ dstFilter, srcFilter, nullptr));
canvas->saveLayer(&rect, &paint);
canvas->restore();
@@ -146,11 +145,11 @@
canvas->translate(gap, 0);
sk_sp<SkImageFilter> bg =
- SkArithmeticImageFilter::Make(0, 0, -one / 2, 1, enforcePMColor, dstFilter,
- nullptr, nullptr);
+ SkImageFilters::Arithmetic(0, 0, -one / 2, 1, enforcePMColor, dstFilter,
+ nullptr, nullptr);
SkPaint p;
- p.setImageFilter(SkArithmeticImageFilter::Make(0, one / 2, -one, 1, true,
- std::move(bg), dstFilter, nullptr));
+ p.setImageFilter(SkImageFilters::Arithmetic(0, one / 2, -one, 1, true,
+ std::move(bg), dstFilter, nullptr));
canvas->saveLayer(&rect, &p);
canvas->restore();
canvas->translate(gap, 0);
diff --git a/gm/backdrop.cpp b/gm/backdrop.cpp
index 4d01782..8aba7dd 100644
--- a/gm/backdrop.cpp
+++ b/gm/backdrop.cpp
@@ -16,8 +16,8 @@
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
#include "include/effects/SkGradientShader.h"
+#include "include/effects/SkImageFilters.h"
#include <initializer_list>
@@ -54,7 +54,7 @@
if (useClip) {
canvas->clipRect(r);
}
- auto blur = SkBlurImageFilter::Make(sigma, sigma, nullptr);
+ auto blur = SkImageFilters::Blur(sigma, sigma, nullptr);
auto rec = SkCanvas::SaveLayerRec(drawrptr, nullptr, blur.get(), 0);
canvas->saveLayer(rec);
// draw something inside, just to demonstrate that we don't blur the new contents,
diff --git a/gm/backdrop_imagefilter_croprect.cpp b/gm/backdrop_imagefilter_croprect.cpp
index 7cc437c..a3f442b 100644
--- a/gm/backdrop_imagefilter_croprect.cpp
+++ b/gm/backdrop_imagefilter_croprect.cpp
@@ -7,11 +7,11 @@
#include "gm/gm.h"
#include "include/core/SkCanvas.h"
+#include "include/core/SkColorFilter.h"
#include "include/core/SkPaint.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkColorFilterImageFilter.h"
+#include "include/effects/SkImageFilters.h"
-typedef sk_sp<SkImageFilter> (*FilterFactory)(const SkImageFilter::CropRect* crop);
+typedef sk_sp<SkImageFilter> (*FilterFactory)(const SkIRect* crop);
static void draw_backdrop_filter_gm(SkCanvas* canvas, float outsetX, float outsetY,
FilterFactory factory) {
@@ -25,7 +25,7 @@
// the layer's image space.
SkRect cropInLocal = SkRect::MakeLTRB(50.f, 10.f, 250.f, 40.f);
- SkImageFilter::CropRect cropRect(cropInLocal.makeOutset(outsetX, outsetY));
+ SkIRect cropRect = cropInLocal.makeOutset(outsetX, outsetY).roundOut();
sk_sp<SkImageFilter> imageFilter = factory(&cropRect);
SkPaint p;
@@ -68,17 +68,17 @@
}
}
-static sk_sp<SkImageFilter> make_invert_filter(const SkImageFilter::CropRect* crop) {
+static sk_sp<SkImageFilter> make_invert_filter(const SkIRect* crop) {
static const float matrix[20] = {-1.f, 0.f, 0.f, 0.f, 1.f,
0.f, -1.f, 0.f, 0.f, 1.f,
0.f, 0.f, -1.f, 0.f, 1.f,
0.f, 0.f, 0.f, 1.f, 0.f};
- return SkColorFilterImageFilter::Make(SkColorFilters::Matrix(matrix), nullptr, crop);
+ return SkImageFilters::ColorFilter(SkColorFilters::Matrix(matrix), nullptr, crop);
}
-static sk_sp<SkImageFilter> make_blur_filter(const SkImageFilter::CropRect* crop) {
+static sk_sp<SkImageFilter> make_blur_filter(const SkIRect* crop) {
// Use different sigmas for x and y so rotated CTM is apparent
- return SkBlurImageFilter::Make(16.f, 4.f, nullptr, crop);
+ return SkImageFilters::Blur(16.f, 4.f, nullptr, crop);
}
// This draws correctly if there's a small cyan rectangle above a much larger magenta rectangle.
diff --git a/gm/bigtileimagefilter.cpp b/gm/bigtileimagefilter.cpp
index 12e18fc..67f9762 100644
--- a/gm/bigtileimagefilter.cpp
+++ b/gm/bigtileimagefilter.cpp
@@ -18,8 +18,7 @@
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkTileImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include <utility>
@@ -68,12 +67,11 @@
SkPaint p;
const SkRect bound = SkRect::MakeIWH(kWidth, kHeight);
- sk_sp<SkImageFilter> imageSource(SkImageSource::Make(fRedImage));
+ sk_sp<SkImageFilter> imageSource(SkImageFilters::Image(fRedImage));
- sk_sp<SkImageFilter> tif(SkTileImageFilter::Make(
- SkRect::MakeIWH(kBitmapSize, kBitmapSize),
- SkRect::MakeIWH(kWidth, kHeight),
- std::move(imageSource)));
+ sk_sp<SkImageFilter> tif(SkImageFilters::Tile(
+ SkRect::MakeIWH(kBitmapSize, kBitmapSize), SkRect::MakeIWH(kWidth, kHeight),
+ std::move(imageSource)));
p.setImageFilter(std::move(tif));
@@ -86,10 +84,10 @@
const SkRect bound2 = SkRect::MakeIWH(kBitmapSize, kBitmapSize);
- sk_sp<SkImageFilter> tif(SkTileImageFilter::Make(
- SkRect::MakeIWH(kBitmapSize, kBitmapSize),
- SkRect::MakeIWH(kBitmapSize, kBitmapSize),
- nullptr));
+ sk_sp<SkImageFilter> tif(SkImageFilters::Tile(
+ SkRect::MakeIWH(kBitmapSize, kBitmapSize),
+ SkRect::MakeIWH(kBitmapSize, kBitmapSize),
+ nullptr));
p2.setImageFilter(std::move(tif));
diff --git a/gm/blurimagevmask.cpp b/gm/blurimagevmask.cpp
index 161c629..6dc1a6a 100644
--- a/gm/blurimagevmask.cpp
+++ b/gm/blurimagevmask.cpp
@@ -18,7 +18,7 @@
#include "include/core/SkRefCnt.h"
#include "include/core/SkString.h"
#include "include/core/SkTypeface.h"
-#include "include/effects/SkBlurImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/Resources.h"
#include "tools/ToolUtils.h"
@@ -54,7 +54,7 @@
SkPaint imageBlurPaint;
r.offset(250, 0);
- imageBlurPaint.setImageFilter(SkBlurImageFilter::Make(sigma, sigma, nullptr));
+ imageBlurPaint.setImageFilter(SkImageFilters::Blur(sigma, sigma, nullptr));
canvas->saveLayer(nullptr, &imageBlurPaint);
canvas->drawRect(r, paint);
diff --git a/gm/blurpositioning.cpp b/gm/blurpositioning.cpp
index dde3590..deb7753 100644
--- a/gm/blurpositioning.cpp
+++ b/gm/blurpositioning.cpp
@@ -12,7 +12,7 @@
#include "include/core/SkPaint.h"
#include "include/core/SkRect.h"
#include "include/core/SkScalar.h"
-#include "include/effects/SkBlurImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include <initializer_list>
@@ -36,7 +36,7 @@
p.reset();
p.setColor(SK_ColorBLACK);
- p.setImageFilter(SkBlurImageFilter::Make(sigma, sigma, nullptr));
+ p.setImageFilter(SkImageFilters::Blur(sigma, sigma, nullptr));
canvas->drawRect(r, p);
canvas->translate(0, 100);
diff --git a/gm/coloremoji.cpp b/gm/coloremoji.cpp
index ef93000..f94d0af 100644
--- a/gm/coloremoji.cpp
+++ b/gm/coloremoji.cpp
@@ -24,10 +24,9 @@
#include "include/core/SkTileMode.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkColorFilterImageFilter.h"
#include "include/effects/SkColorMatrixFilter.h"
#include "include/effects/SkGradientShader.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include <string.h>
@@ -53,11 +52,11 @@
matrix[2] = matrix[7] = matrix[12] = 0.0722f;
matrix[18] = 1.0f;
sk_sp<SkColorFilter> filter(SkColorFilters::Matrix(matrix));
- return SkColorFilterImageFilter::Make(std::move(filter), std::move(input));
+ return SkImageFilters::ColorFilter(std::move(filter), std::move(input));
}
static sk_sp<SkImageFilter> make_blur(float amount, sk_sp<SkImageFilter> input) {
- return SkBlurImageFilter::Make(amount, amount, std::move(input));
+ return SkImageFilters::Blur(amount, amount, std::move(input));
}
static sk_sp<SkColorFilter> make_color_filter() {
diff --git a/gm/colorfilterimagefilter.cpp b/gm/colorfilterimagefilter.cpp
index cfce7a4..9373388 100644
--- a/gm/colorfilterimagefilter.cpp
+++ b/gm/colorfilterimagefilter.cpp
@@ -19,10 +19,9 @@
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkTileMode.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkColorFilterImageFilter.h"
#include "include/effects/SkColorMatrix.h"
#include "include/effects/SkGradientShader.h"
+#include "include/effects/SkImageFilters.h"
#include "include/private/SkTArray.h"
#include "include/private/SkTDArray.h"
#include "tools/Resources.h"
@@ -100,19 +99,19 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
static sk_sp<SkImageFilter> make_blur(float amount, sk_sp<SkImageFilter> input) {
- return SkBlurImageFilter::Make(amount, amount, std::move(input));
+ return SkImageFilters::Blur(amount, amount, std::move(input));
}
static sk_sp<SkImageFilter> make_brightness(float amount, sk_sp<SkImageFilter> input) {
- return SkColorFilterImageFilter::Make(cf_make_brightness(amount), std::move(input));
+ return SkImageFilters::ColorFilter(cf_make_brightness(amount), std::move(input));
}
static sk_sp<SkImageFilter> make_grayscale(sk_sp<SkImageFilter> input) {
- return SkColorFilterImageFilter::Make(cf_make_grayscale(), std::move(input));
+ return SkImageFilters::ColorFilter(cf_make_grayscale(), std::move(input));
}
static sk_sp<SkImageFilter> make_mode_blue(sk_sp<SkImageFilter> input) {
- return SkColorFilterImageFilter::Make(cf_make_colorize(SK_ColorBLUE), std::move(input));
+ return SkImageFilters::ColorFilter(cf_make_colorize(SK_ColorBLUE), std::move(input));
}
static void draw_clipped_rect(SkCanvas* canvas,
@@ -190,7 +189,7 @@
cm.setSaturation(0.0f);
sk_sp<SkColorFilter> cf(SkColorFilters::Matrix(cm));
SkPaint p;
- p.setImageFilter(SkColorFilterImageFilter::Make(std::move(cf), nullptr));
+ p.setImageFilter(SkImageFilters::ColorFilter(std::move(cf), nullptr));
canvas->saveLayer(nullptr, &p);
canvas->clear(SK_ColorRED);
}
diff --git a/gm/complexclip_blur_tiled.cpp b/gm/complexclip_blur_tiled.cpp
index 5b684af..4d32081 100644
--- a/gm/complexclip_blur_tiled.cpp
+++ b/gm/complexclip_blur_tiled.cpp
@@ -17,7 +17,7 @@
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
-#include "include/effects/SkBlurImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "src/core/SkClipOpPriv.h"
#include "tools/ToolUtils.h"
@@ -42,7 +42,7 @@
void onDraw(SkCanvas* canvas) override {
SkPaint blurPaint;
- blurPaint.setImageFilter(SkBlurImageFilter::Make(5.0f, 5.0f, nullptr));
+ blurPaint.setImageFilter(SkImageFilters::Blur(5.0f, 5.0f, nullptr));
const SkScalar tileSize = SkIntToScalar(128);
SkRect bounds = canvas->getLocalClipBounds();
int ts = SkScalarCeilToInt(tileSize);
diff --git a/gm/compositor_quads.cpp b/gm/compositor_quads.cpp
index 8a24df2..236d360 100644
--- a/gm/compositor_quads.cpp
+++ b/gm/compositor_quads.cpp
@@ -34,7 +34,7 @@
#include "include/core/SkTypes.h"
#include "include/effects/SkColorMatrix.h"
#include "include/effects/SkGradientShader.h"
-#include "include/effects/SkMorphologyImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/effects/SkShaderMaskFilter.h"
#include "include/private/SkTArray.h"
#include "src/core/SkLineClipper.h"
@@ -1031,7 +1031,7 @@
SkColorMatrix cm;
cm.setSaturation(10);
sk_sp<SkColorFilter> colorFilter = SkColorFilters::Matrix(cm);
- sk_sp<SkImageFilter> imageFilter = SkDilateImageFilter::Make(8, 8, nullptr);
+ sk_sp<SkImageFilter> imageFilter = SkImageFilters::Dilate(8, 8, nullptr);
static constexpr SkColor kAlphas[] = { SK_ColorTRANSPARENT, SK_ColorBLACK };
auto alphaGradient = SkGradientShader::MakeRadial(
diff --git a/gm/crbug_905548.cpp b/gm/crbug_905548.cpp
index 2b086b0..2406e8f 100644
--- a/gm/crbug_905548.cpp
+++ b/gm/crbug_905548.cpp
@@ -15,11 +15,7 @@
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSurface.h"
-#include "include/effects/SkArithmeticImageFilter.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkMorphologyImageFilter.h"
-#include "include/effects/SkXfermodeImageFilter.h"
+#include "include/effects/SkImageFilters.h"
DEF_SIMPLE_GM(crbug_905548, canvas, 100, 200) {
auto surface = canvas->makeSurface(SkImageInfo::MakeN32Premul(100, 100));
@@ -28,17 +24,17 @@
}
surface->getCanvas()->clear(0);
surface->getCanvas()->drawCircle(50, 50, 45, SkPaint());
- auto imageSource = SkImageSource::Make(surface->makeImageSnapshot());
+ auto imageSource = SkImageFilters::Image(surface->makeImageSnapshot());
- auto blurred = SkBlurImageFilter::Make(15, 15, imageSource);
- auto eroded = SkErodeImageFilter::Make(0, 0, blurred);
- auto blended = SkXfermodeImageFilter::Make(SkBlendMode::kDstOut, eroded, imageSource, nullptr);
+ auto blurred = SkImageFilters::Blur(15, 15, imageSource);
+ auto eroded = SkImageFilters::Erode(0, 0, blurred);
+ auto blended = SkImageFilters::Xfermode(SkBlendMode::kDstOut, eroded, imageSource, nullptr);
SkPaint paint;
paint.setImageFilter(blended);
canvas->drawRect(SkRect::MakeWH(100, 100), paint);
- auto mult = SkArithmeticImageFilter::Make(1, 0, 0, 0, false, eroded, imageSource, nullptr);
+ auto mult = SkImageFilters::Arithmetic(1, 0, 0, 0, false, eroded, imageSource, nullptr);
paint.setImageFilter(mult);
canvas->translate(0, 100);
canvas->drawRect(SkRect::MakeWH(100, 100), paint);
diff --git a/gm/displacement.cpp b/gm/displacement.cpp
index b788d6f..0261199 100644
--- a/gm/displacement.cpp
+++ b/gm/displacement.cpp
@@ -17,8 +17,7 @@
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
-#include "include/effects/SkDisplacementMapEffect.h"
-#include "include/effects/SkImageSource.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include <utility>
@@ -65,142 +64,100 @@
void onDraw(SkCanvas* canvas) override {
canvas->clear(SK_ColorBLACK);
SkPaint paint;
- sk_sp<SkImageFilter> displ(SkImageSource::Make(fCheckerboard));
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType, 0.0f, displ, nullptr));
+ sk_sp<SkImageFilter> displ(SkImageFilters::Image(fCheckerboard));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kG, 0.0f, displ, nullptr));
this->drawClippedBitmap(canvas, 0, 0, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 16.0f, displ, nullptr));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kB, SkColorChannel::kA, 16.0f, displ, nullptr));
this->drawClippedBitmap(canvas, 100, 0, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType, 32.0f, displ, nullptr));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kB, 32.0f, displ, nullptr));
this->drawClippedBitmap(canvas, 200, 0, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 48.0f, displ, nullptr));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kG, SkColorChannel::kA, 48.0f, displ, nullptr));
this->drawClippedBitmap(canvas, 300, 0, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 64.0f, displ, nullptr));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kA, 64.0f, displ, nullptr));
this->drawClippedBitmap(canvas, 400, 0, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType, 40.0f, displ, nullptr));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kG, 40.0f, displ, nullptr));
this->drawClippedBitmap(canvas, 0, 100, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 40.0f, displ, nullptr));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kB, SkColorChannel::kA, 40.0f, displ, nullptr));
this->drawClippedBitmap(canvas, 100, 100, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType, 40.0f, displ, nullptr));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kB, 40.0f, displ, nullptr));
this->drawClippedBitmap(canvas, 200, 100, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 40.0f, displ, nullptr));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kG, SkColorChannel::kA, 40.0f, displ, nullptr));
this->drawClippedBitmap(canvas, 300, 100, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 40.0f, displ, nullptr));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kA, 40.0f, displ, nullptr));
this->drawClippedBitmap(canvas, 400, 100, paint);
- SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(30, 30, 40, 40));
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- 0.0f, displ, nullptr, &cropRect));
+ SkIRect cropRect = SkIRect::MakeXYWH(30, 30, 40, 40);
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kG, 0.0f, displ, nullptr, &cropRect));
this->drawClippedBitmap(canvas, 0, 200, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 16.0f, displ, nullptr, &cropRect));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kB, SkColorChannel::kA, 16.0f, displ, nullptr, &cropRect));
this->drawClippedBitmap(canvas, 100, 200, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- 32.0f, displ, nullptr, &cropRect));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kB, 32.0f, displ, nullptr, &cropRect));
this->drawClippedBitmap(canvas, 200, 200, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 48.0f, displ, nullptr, &cropRect));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kG, SkColorChannel::kA, 48.0f, displ, nullptr, &cropRect));
this->drawClippedBitmap(canvas, 300, 200, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 64.0f, displ, nullptr, &cropRect));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kA, 64.0f, displ, nullptr, &cropRect));
this->drawClippedBitmap(canvas, 400, 200, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- 40.0f, displ, nullptr, &cropRect));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kG, 40.0f, displ, nullptr, &cropRect));
this->drawClippedBitmap(canvas, 0, 300, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, displ, nullptr, &cropRect));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kB, SkColorChannel::kA, 40.0f, displ, nullptr, &cropRect));
this->drawClippedBitmap(canvas, 100, 300, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- 40.0f, displ, nullptr, &cropRect));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kB, 40.0f, displ, nullptr, &cropRect));
this->drawClippedBitmap(canvas, 200, 300, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, displ, nullptr, &cropRect));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kG, SkColorChannel::kA, 40.0f, displ, nullptr, &cropRect));
this->drawClippedBitmap(canvas, 300, 300, paint);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, displ, nullptr, &cropRect));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kA, 40.0f, displ, nullptr, &cropRect));
this->drawClippedBitmap(canvas, 400, 300, paint);
// Test for negative scale.
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- -40.0f, displ, nullptr));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kG, SkColorChannel::kA, -40.0f, displ, nullptr));
this->drawClippedBitmap(canvas, 500, 0, paint);
// Tests for images of different sizes
- displ = SkImageSource::Make(fSmall);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- 40.0f, std::move(displ), nullptr));
+ displ = SkImageFilters::Image(fSmall);
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kG, 40.0f, std::move(displ), nullptr));
this->drawClippedBitmap(canvas, 0, 400, paint);
- displ = SkImageSource::Make(fLarge);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, std::move(displ), nullptr));
+ displ = SkImageFilters::Image(fLarge);
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kB, SkColorChannel::kA, 40.0f, std::move(displ), nullptr));
this->drawClippedBitmap(canvas, 100, 400, paint);
- displ = SkImageSource::Make(fLargeW);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- 40.0f, std::move(displ), nullptr));
+ displ = SkImageFilters::Image(fLargeW);
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kR, SkColorChannel::kB, 40.0f, std::move(displ), nullptr));
this->drawClippedBitmap(canvas, 200, 400, paint);
- displ = SkImageSource::Make(fLargeH);
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, std::move(displ), nullptr));
+ displ = SkImageFilters::Image(fLargeH);
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kG, SkColorChannel::kA, 40.0f, std::move(displ), nullptr));
this->drawClippedBitmap(canvas, 300, 400, paint);
// Test for no given displacement input. In this case, both displacement
// and color should use the same bitmap, given to SkCanvas::drawBitmap()
// as an input argument.
- paint.setImageFilter(SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, nullptr, nullptr));
+ paint.setImageFilter(SkImageFilters::DisplacementMap(
+ SkColorChannel::kG, SkColorChannel::kA, 40.0f, nullptr, nullptr));
this->drawClippedBitmap(canvas, 400, 400, paint);
}
diff --git a/gm/drawregionmodes.cpp b/gm/drawregionmodes.cpp
index bb0c4ae..b069e74 100644
--- a/gm/drawregionmodes.cpp
+++ b/gm/drawregionmodes.cpp
@@ -19,9 +19,9 @@
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTileMode.h"
-#include "include/effects/SkBlurImageFilter.h"
#include "include/effects/SkDashPathEffect.h"
#include "include/effects/SkGradientShader.h"
+#include "include/effects/SkImageFilters.h"
class DrawRegionModesGM : public skiagm::GM {
public:
@@ -55,7 +55,7 @@
canvas->drawRegion(fRegion, paint);
canvas->translate(125.0f, 125.0f);
- paint.setImageFilter(SkBlurImageFilter::Make(5.0f, 5.0f, nullptr, nullptr));
+ paint.setImageFilter(SkImageFilters::Blur(5.0f, 5.0f, nullptr, nullptr));
canvas->drawRegion(fRegion, paint);
canvas->translate(-125.0f, 125.0f);
diff --git a/gm/dropshadowimagefilter.cpp b/gm/dropshadowimagefilter.cpp
index f4244b6..7d78094 100644
--- a/gm/dropshadowimagefilter.cpp
+++ b/gm/dropshadowimagefilter.cpp
@@ -19,8 +19,7 @@
#include "include/core/SkScalar.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkColorFilterImageFilter.h"
-#include "include/effects/SkDropShadowImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/utils/SkTextUtils.h"
#include "tools/ToolUtils.h"
@@ -89,28 +88,19 @@
};
sk_sp<SkColorFilter> cf(SkColorFilters::Blend(SK_ColorMAGENTA, SkBlendMode::kSrcIn));
- sk_sp<SkImageFilter> cfif(SkColorFilterImageFilter::Make(std::move(cf), nullptr));
- SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)),
- SkImageFilter::CropRect::kHasAll_CropEdge);
- SkImageFilter::CropRect bogusRect(SkRect::Make(SkIRect::MakeXYWH(-100, -100, 10, 10)),
- SkImageFilter::CropRect::kHasAll_CropEdge);
+ sk_sp<SkImageFilter> cfif(SkImageFilters::ColorFilter(std::move(cf), nullptr));
+ SkIRect cropRect = SkIRect::MakeXYWH(10, 10, 44, 44);
+ SkIRect bogusRect = SkIRect::MakeXYWH(-100, -100, 10, 10);
sk_sp<SkImageFilter> filters[] = {
nullptr,
- SkDropShadowImageFilter::Make(7.0f, 0.0f, 0.0f, 3.0f, SK_ColorBLUE,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr),
- SkDropShadowImageFilter::Make(0.0f, 7.0f, 3.0f, 0.0f, SK_ColorBLUE,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr),
- SkDropShadowImageFilter::Make(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr),
- SkDropShadowImageFilter::Make(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, std::move(cfif)),
- SkDropShadowImageFilter::Make(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr, &cropRect),
- SkDropShadowImageFilter::Make(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr, &bogusRect),
- SkDropShadowImageFilter::Make(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
- SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode, nullptr),
+ SkImageFilters::DropShadow(7.0f, 0.0f, 0.0f, 3.0f, SK_ColorBLUE, nullptr),
+ SkImageFilters::DropShadow(0.0f, 7.0f, 3.0f, 0.0f, SK_ColorBLUE, nullptr),
+ SkImageFilters::DropShadow(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, nullptr),
+ SkImageFilters::DropShadow(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, std::move(cfif)),
+ SkImageFilters::DropShadow(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, nullptr, &cropRect),
+ SkImageFilters::DropShadow(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, nullptr, &bogusRect),
+ SkImageFilters::DropShadowOnly(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, nullptr),
};
SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
diff --git a/gm/fadefilter.cpp b/gm/fadefilter.cpp
index 9681d66..0cac81a 100644
--- a/gm/fadefilter.cpp
+++ b/gm/fadefilter.cpp
@@ -12,7 +12,7 @@
#include "include/core/SkPaint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
-#include "include/effects/SkColorFilterImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include <utility>
@@ -24,6 +24,6 @@
0, 0, 0, 1, 0 };
sk_sp<SkColorFilter> colorFilter(SkColorFilters::Matrix(matrix));
SkPaint layerPaint;
- layerPaint.setImageFilter(SkColorFilterImageFilter::Make(std::move(colorFilter), nullptr));
+ layerPaint.setImageFilter(SkImageFilters::ColorFilter(std::move(colorFilter), nullptr));
canvas->drawRect(SkRect::MakeLTRB(64, 64, 192, 192), layerPaint);
}
diff --git a/gm/filterfastbounds.cpp b/gm/filterfastbounds.cpp
index 033e102..7da526c 100644
--- a/gm/filterfastbounds.cpp
+++ b/gm/filterfastbounds.cpp
@@ -26,12 +26,7 @@
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkDropShadowImageFilter.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkOffsetImageFilter.h"
-#include "include/effects/SkPictureImageFilter.h"
-#include "include/effects/SkTileImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/private/SkTArray.h"
#include <utility>
@@ -115,7 +110,7 @@
scale.setScale(2.0f, 2.0f);
sk_sp<SkImageFilter> scaleMIF(
- SkImageFilter::MakeMatrixFilter(scale, kLow_SkFilterQuality, source));
+ SkImageFilters::MatrixTransform(scale, kLow_SkFilterQuality, source));
add_paint(paints, std::move(scaleMIF));
}
@@ -125,7 +120,7 @@
rot.setRotate(-33.3f);
sk_sp<SkImageFilter> rotMIF(
- SkImageFilter::MakeMatrixFilter(rot, kLow_SkFilterQuality, source));
+ SkImageFilters::MatrixTransform(rot, kLow_SkFilterQuality, source));
add_paint(paints, std::move(rotMIF));
}
@@ -133,36 +128,27 @@
{
SkRect src = SkRect::MakeXYWH(20, 20, 10, 10);
SkRect dst = SkRect::MakeXYWH(30, 30, 30, 30);
- sk_sp<SkImageFilter> tileIF(SkTileImageFilter::Make(src, dst, nullptr));
+ sk_sp<SkImageFilter> tileIF(SkImageFilters::Tile(src, dst, nullptr));
add_paint(paints, std::move(tileIF));
}
{
- constexpr SkDropShadowImageFilter::ShadowMode kBoth =
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode;
-
- sk_sp<SkImageFilter> dsif(SkDropShadowImageFilter::Make(10.0f, 10.0f,
- 3.0f, 3.0f,
- SK_ColorRED, kBoth,
- source));
+ sk_sp<SkImageFilter> dsif =
+ SkImageFilters::DropShadow(10.0f, 10.0f, 3.0f, 3.0f, SK_ColorRED, source);
add_paint(paints, std::move(dsif));
}
{
- sk_sp<SkImageFilter> dsif(
- SkDropShadowImageFilter::Make(27.0f, 27.0f,
- 3.0f, 3.0f,
- SK_ColorRED,
- SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode,
- source));
+ sk_sp<SkImageFilter> dsif =
+ SkImageFilters::DropShadowOnly(27.0f, 27.0f, 3.0f, 3.0f, SK_ColorRED, source);
add_paint(paints, std::move(dsif));
}
- add_paint(paints, SkBlurImageFilter::Make(3, 3, source));
- add_paint(paints, SkOffsetImageFilter::Make(15, 15, source));
+ add_paint(paints, SkImageFilters::Blur(3, 3, source));
+ add_paint(paints, SkImageFilters::Offset(15, 15, source));
}
// This GM visualizes the fast bounds for various combinations of geometry
@@ -266,7 +252,7 @@
}
SkTArray<SkPaint> pifPaints;
- create_paints(&pifPaints, SkPictureImageFilter::Make(pic));
+ create_paints(&pifPaints, SkImageFilters::Picture(pic));
//-----------
// Paints with a SkImageSource as a source
@@ -283,7 +269,7 @@
}
sk_sp<SkImage> image(surface->makeImageSnapshot());
- sk_sp<SkImageFilter> imageSource(SkImageSource::Make(std::move(image)));
+ sk_sp<SkImageFilter> imageSource(SkImageFilters::Image(std::move(image)));
SkTArray<SkPaint> bmsPaints;
create_paints(&bmsPaints, std::move(imageSource));
diff --git a/gm/imagealphathreshold.cpp b/gm/imagealphathreshold.cpp
index e785762..c9a5a3f 100644
--- a/gm/imagealphathreshold.cpp
+++ b/gm/imagealphathreshold.cpp
@@ -21,9 +21,7 @@
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
-#include "include/effects/SkAlphaThresholdFilter.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkOffsetImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/utils/SkRandom.h"
#include "tools/ToolUtils.h"
@@ -44,7 +42,7 @@
canvas->drawRect(SkRect::MakeXYWH(WIDTH / 2, HEIGHT / 2, WIDTH / 2, HEIGHT / 2), rectPaint);
}
-static SkPaint create_filter_paint(SkImageFilter::CropRect* cropRect = nullptr) {
+static SkPaint create_filter_paint(SkIRect* cropRect = nullptr) {
SkIRect rects[2];
rects[0] = SkIRect::MakeXYWH(0, 150, WIDTH, HEIGHT - 300);
rects[1] = SkIRect::MakeXYWH(150, 0, WIDTH - 300, HEIGHT);
@@ -52,8 +50,9 @@
region.setRects(rects, 2);
SkPaint paint;
- sk_sp<SkImageFilter> offset(SkOffsetImageFilter::Make(25, 25, nullptr));
- paint.setImageFilter(SkAlphaThresholdFilter::Make(region, 0.2f, 0.7f, std::move(offset), cropRect));
+ sk_sp<SkImageFilter> offset(SkImageFilters::Offset(25, 25, nullptr));
+ paint.setImageFilter(
+ SkImageFilters::AlphaThreshold(region, 0.2f, 0.7f, std::move(offset), cropRect));
return paint;
}
@@ -85,8 +84,7 @@
canvas->concat(matrix);
- SkRect r = SkRect::MakeLTRB(100, 100, WIDTH - 100, HEIGHT - 100);
- SkImageFilter::CropRect cropRect(r);
+ SkIRect cropRect = SkIRect::MakeLTRB(100, 100, WIDTH - 100, HEIGHT - 100);
SkPaint paint = create_filter_paint(fUseCropRect ? &cropRect : nullptr);
canvas->saveLayer(nullptr, &paint);
@@ -201,9 +199,9 @@
region.setRects(rects, 2);
SkPaint filterPaint;
- sk_sp<SkImageFilter> imageSource(SkImageSource::Make(image));
- filterPaint.setImageFilter(SkAlphaThresholdFilter::Make(region, 0.2f, 0.7f,
- std::move(imageSource)));
+ sk_sp<SkImageFilter> imageSource(SkImageFilters::Image(image));
+ filterPaint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.2f, 0.7f,
+ std::move(imageSource)));
canvas->saveLayer(nullptr, &filterPaint);
canvas->restore();
diff --git a/gm/imageblur.cpp b/gm/imageblur.cpp
index 9485fe0..cb8808c 100644
--- a/gm/imageblur.cpp
+++ b/gm/imageblur.cpp
@@ -13,7 +13,7 @@
#include "include/core/SkPaint.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypeface.h"
-#include "include/effects/SkBlurImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/utils/SkRandom.h"
#include "tools/ToolUtils.h"
@@ -22,7 +22,7 @@
void imageblurgm_draw(SkScalar fSigmaX, SkScalar fSigmaY, SkCanvas* canvas) {
SkPaint paint;
- paint.setImageFilter(SkBlurImageFilter::Make(fSigmaX, fSigmaY, nullptr));
+ paint.setImageFilter(SkImageFilters::Blur(fSigmaX, fSigmaY, nullptr));
canvas->saveLayer(nullptr, &paint);
const char* str = "The quick brown fox jumped over the lazy dog.";
diff --git a/gm/imageblur2.cpp b/gm/imageblur2.cpp
index d849c85..eba756c 100644
--- a/gm/imageblur2.cpp
+++ b/gm/imageblur2.cpp
@@ -13,7 +13,7 @@
#include "include/core/SkScalar.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/utils/SkRandom.h"
#include "tools/ToolUtils.h"
@@ -47,7 +47,7 @@
SkScalar sigmaY = kBlurSigmas[y];
SkPaint paint;
- paint.setImageFilter(SkBlurImageFilter::Make(sigmaX, sigmaY, nullptr));
+ paint.setImageFilter(SkImageFilters::Blur(sigmaX, sigmaY, nullptr));
canvas->saveLayer(nullptr, &paint);
SkRandom rand;
diff --git a/gm/imageblurclampmode.cpp b/gm/imageblurclampmode.cpp
index 34b4259..06ce313 100644
--- a/gm/imageblurclampmode.cpp
+++ b/gm/imageblurclampmode.cpp
@@ -18,7 +18,7 @@
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
-#include "include/effects/SkBlurImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include <initializer_list>
@@ -84,20 +84,17 @@
canvas->save();
// x-only blur
- filter = SkBlurImageFilter::Make(sigma, 0.0f, nullptr, nullptr,
- SkBlurImageFilter::kClamp_TileMode);
+ filter = SkImageFilters::Blur(sigma, 0.0f, SkTileMode::kClamp, nullptr);
draw_image(canvas, image, std::move(filter));
canvas->translate(image->width() + 20, 0);
// y-only blur
- filter = SkBlurImageFilter::Make(0.0f, sigma, nullptr, nullptr,
- SkBlurImageFilter::kClamp_TileMode);
+ filter = SkImageFilters::Blur(0.0f, sigma, SkTileMode::kClamp, nullptr);
draw_image(canvas, image, std::move(filter));
canvas->translate(image->width() + 20, 0);
// both directions
- filter = SkBlurImageFilter::Make(sigma, sigma, nullptr, nullptr,
- SkBlurImageFilter::kClamp_TileMode);
+ filter = SkImageFilters::Blur(sigma, sigma, SkTileMode::kClamp, nullptr);
draw_image(canvas, image, std::move(filter));
canvas->translate(image->width() + 20, 0);
diff --git a/gm/imageblurrepeatmode.cpp b/gm/imageblurrepeatmode.cpp
index ac4aa2d..ce500a2 100644
--- a/gm/imageblurrepeatmode.cpp
+++ b/gm/imageblurrepeatmode.cpp
@@ -18,7 +18,7 @@
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
-#include "include/effects/SkBlurImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include <initializer_list>
@@ -101,18 +101,15 @@
for (auto sigma: { 0.6f, 3.0f, 8.0f, 20.0f }) {
canvas->save();
sk_sp<SkImageFilter> filter(
- SkBlurImageFilter::Make(sigma, 0.0f, nullptr, nullptr,
- SkBlurImageFilter::kRepeat_TileMode));
+ SkImageFilters::Blur(sigma, 0.0f, SkTileMode::kRepeat, nullptr));
draw_image(canvas, image[0], std::move(filter));
canvas->translate(image[0]->width() + 20, 0);
- filter = SkBlurImageFilter::Make(0.0f, sigma, nullptr, nullptr,
- SkBlurImageFilter::kRepeat_TileMode);
+ filter = SkImageFilters::Blur(0.0f, sigma, SkTileMode::kRepeat, nullptr);
draw_image(canvas, image[1], std::move(filter));
canvas->translate(image[1]->width() + 20, 0);
- filter = SkBlurImageFilter::Make(sigma, sigma, nullptr, nullptr,
- SkBlurImageFilter::kRepeat_TileMode);
+ filter = SkImageFilters::Blur(sigma, sigma, SkTileMode::kRepeat, nullptr);
draw_image(canvas, image[2], std::move(filter));
canvas->translate(image[2]->width() + 20, 0);
diff --git a/gm/imageblurtiled.cpp b/gm/imageblurtiled.cpp
index deadee4..565d137 100644
--- a/gm/imageblurtiled.cpp
+++ b/gm/imageblurtiled.cpp
@@ -16,7 +16,7 @@
#include "include/core/SkString.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#define WIDTH 640
@@ -41,7 +41,7 @@
void onDraw(SkCanvas* canvas) override {
SkPaint paint;
- paint.setImageFilter(SkBlurImageFilter::Make(fSigmaX, fSigmaY, nullptr));
+ paint.setImageFilter(SkImageFilters::Blur(fSigmaX, fSigmaY, nullptr));
const SkScalar tileSize = SkIntToScalar(128);
SkRect bounds = canvas->getLocalClipBounds();
for (SkScalar y = bounds.top(); y < bounds.bottom(); y += tileSize) {
diff --git a/gm/imagefilters.cpp b/gm/imagefilters.cpp
index 91bcbc5..958eae3 100644
--- a/gm/imagefilters.cpp
+++ b/gm/imagefilters.cpp
@@ -22,11 +22,8 @@
#include "include/core/SkScalar.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkColorFilterImageFilter.h"
#include "include/effects/SkColorMatrix.h"
-#include "include/effects/SkMatrixConvolutionImageFilter.h"
-#include "include/effects/SkMorphologyImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/Resources.h"
#include "tools/ToolUtils.h"
@@ -68,7 +65,7 @@
canvas->translate(10, 10);
// just need an imagefilter to trigger the code-path (which creates a tmp layer)
- sk_sp<SkImageFilter> imf(SkImageFilter::MakeMatrixFilter(SkMatrix::I(),
+ sk_sp<SkImageFilter> imf(SkImageFilters::MatrixTransform(SkMatrix::I(),
kNone_SkFilterQuality,
nullptr));
@@ -105,7 +102,7 @@
canvas->translate(10, 10);
for (SkScalar sigma = 8; sigma <= 128; sigma *= 2) {
SkPaint paint;
- paint.setImageFilter(SkBlurImageFilter::Make(sigma, sigma, nullptr));
+ paint.setImageFilter(SkImageFilters::Blur(sigma, sigma, nullptr));
canvas->save();
// we outset the clip by 1, to fall out of the fast-case in drawImage
@@ -153,13 +150,11 @@
sk_sp<SkColorFilter> cf(SkColorFilters::Matrix(cm));
const SkScalar kernel[] = { 4, 0, 4, 0, -15, 0, 4, 0, 4 };
sk_sp<SkImageFilter> filters[] = {
- SkBlurImageFilter::Make(10, 10, nullptr),
- SkDilateImageFilter::Make(8, 8, nullptr),
- SkMatrixConvolutionImageFilter::Make(
- { 3, 3 }, kernel, 1, 0, { 0, 0 },
- SkMatrixConvolutionImageFilter::kClampToBlack_TileMode,
- true, nullptr),
- SkColorFilterImageFilter::Make(std::move(cf), nullptr),
+ SkImageFilters::Blur(10, 10, nullptr),
+ SkImageFilters::Dilate(8, 8, nullptr),
+ SkImageFilters::MatrixConvolution({ 3, 3 }, kernel, 1, 0, { 0, 0 },
+ SkTileMode::kDecal, true, nullptr),
+ SkImageFilters::ColorFilter(std::move(cf), nullptr),
};
const struct {
diff --git a/gm/imagefiltersbase.cpp b/gm/imagefiltersbase.cpp
index 80f28cb..3003de3 100644
--- a/gm/imagefiltersbase.cpp
+++ b/gm/imagefiltersbase.cpp
@@ -23,9 +23,7 @@
#include "include/core/SkString.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkColorFilterImageFilter.h"
-#include "include/effects/SkDropShadowImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/utils/SkTextUtils.h"
#include "src/core/SkImageFilter_Base.h"
#include "src/core/SkSpecialImage.h"
@@ -190,15 +188,12 @@
nullptr,
IdentityImageFilter::Make(nullptr),
FailImageFilter::Make(),
- SkColorFilterImageFilter::Make(std::move(cf), nullptr),
- // The strage 0.29 value tickles an edge case where crop rect calculates
- // a small border, but the blur really needs no border. This tickels
+ SkImageFilters::ColorFilter(std::move(cf), nullptr),
+ // The strange 0.29 value tickles an edge case where crop rect calculates
+ // a small border, but the blur really needs no border. This tickles
// an msan uninitialized value bug.
- SkBlurImageFilter::Make(12.0f, 0.29f, nullptr),
- SkDropShadowImageFilter::Make(
- 10.0f, 5.0f, 3.0f, 3.0f, SK_ColorBLUE,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
- nullptr),
+ SkImageFilters::Blur(12.0f, 0.29f, nullptr),
+ SkImageFilters::DropShadow(10.0f, 5.0f, 3.0f, 3.0f, SK_ColorBLUE, nullptr),
};
SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
@@ -300,7 +295,7 @@
ImageFiltersText_IF() : ImageFiltersTextBaseGM("image") {}
void installFilter(SkPaint* paint) override {
- paint->setImageFilter(SkBlurImageFilter::Make(1.5f, 1.5f, nullptr));
+ paint->setImageFilter(SkImageFilters::Blur(1.5f, 1.5f, nullptr));
}
};
DEF_GM( return new ImageFiltersText_IF; )
diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp
index c145e19..6a3101a 100644
--- a/gm/imagefiltersclipped.cpp
+++ b/gm/imagefiltersclipped.cpp
@@ -25,15 +25,8 @@
#include "include/core/SkSurface.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkDisplacementMapEffect.h"
-#include "include/effects/SkDropShadowImageFilter.h"
#include "include/effects/SkGradientShader.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkLightingImageFilter.h"
-#include "include/effects/SkMorphologyImageFilter.h"
-#include "include/effects/SkOffsetImageFilter.h"
-#include "include/effects/SkPaintImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/effects/SkPerlinNoiseShader.h"
#include "tools/ToolUtils.h"
@@ -103,30 +96,24 @@
void onDraw(SkCanvas* canvas) override {
canvas->clear(SK_ColorBLACK);
- sk_sp<SkImageFilter> gradient(SkImageSource::Make(fGradientCircle));
- sk_sp<SkImageFilter> checkerboard(SkImageSource::Make(fCheckerboard));
+ sk_sp<SkImageFilter> gradient(SkImageFilters::Image(fGradientCircle));
+ sk_sp<SkImageFilter> checkerboard(SkImageFilters::Image(fCheckerboard));
SkMatrix resizeMatrix;
resizeMatrix.setScale(RESIZE_FACTOR_X, RESIZE_FACTOR_Y);
SkPoint3 pointLocation = SkPoint3::Make(32, 32, SkIntToScalar(10));
sk_sp<SkImageFilter> filters[] = {
- SkBlurImageFilter::Make(SkIntToScalar(12), SkIntToScalar(12), nullptr),
- SkDropShadowImageFilter::Make(
- SkIntToScalar(10), SkIntToScalar(10),
- SkIntToScalar(3), SkIntToScalar(3), SK_ColorGREEN,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
- nullptr),
- SkDisplacementMapEffect::Make(SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkIntToScalar(12),
- std::move(gradient),
- checkerboard),
- SkDilateImageFilter::Make(2, 2, checkerboard),
- SkErodeImageFilter::Make(2, 2, checkerboard),
- SkOffsetImageFilter::Make(SkIntToScalar(-16), SkIntToScalar(32), nullptr),
- SkImageFilter::MakeMatrixFilter(resizeMatrix, kNone_SkFilterQuality, nullptr),
- SkLightingImageFilter::MakePointLitDiffuse(pointLocation, SK_ColorWHITE, SK_Scalar1,
- SkIntToScalar(2), checkerboard),
+ SkImageFilters::Blur(SkIntToScalar(12), SkIntToScalar(12), nullptr),
+ SkImageFilters::DropShadow(SkIntToScalar(10), SkIntToScalar(10),
+ SkIntToScalar(3), SkIntToScalar(3), SK_ColorGREEN, nullptr),
+ SkImageFilters::DisplacementMap(SkColorChannel::kR, SkColorChannel::kR,
+ SkIntToScalar(12), std::move(gradient), checkerboard),
+ SkImageFilters::Dilate(2, 2, checkerboard),
+ SkImageFilters::Erode(2, 2, checkerboard),
+ SkImageFilters::Offset(SkIntToScalar(-16), SkIntToScalar(32), nullptr),
+ SkImageFilters::MatrixTransform(resizeMatrix, kNone_SkFilterQuality, nullptr),
+ SkImageFilters::PointLitDiffuse(pointLocation, SK_ColorWHITE, SK_Scalar1,
+ SkIntToScalar(2), checkerboard),
};
@@ -151,7 +138,7 @@
SkPaint noisePaint;
noisePaint.setShader(SkPerlinNoiseShader::MakeFractalNoise(0.1f, 0.05f, 1, 0));
- sk_sp<SkImageFilter> rectFilter(SkPaintImageFilter::Make(noisePaint));
+ sk_sp<SkImageFilter> rectFilter(SkImageFilters::Paint(noisePaint));
canvas->translate(SK_ARRAY_COUNT(filters)*(r.width() + margin), 0);
for (int xOffset = 0; xOffset < 80; xOffset += 16) {
bounds.fLeft = SkIntToScalar(xOffset);
diff --git a/gm/imagefilterscropexpand.cpp b/gm/imagefilterscropexpand.cpp
index b7792bc..b6e7fae 100644
--- a/gm/imagefilterscropexpand.cpp
+++ b/gm/imagefilterscropexpand.cpp
@@ -21,15 +21,8 @@
#include "include/core/SkShader.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTileMode.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkColorFilterImageFilter.h"
-#include "include/effects/SkDisplacementMapEffect.h"
-#include "include/effects/SkDropShadowImageFilter.h"
#include "include/effects/SkGradientShader.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkLightingImageFilter.h"
-#include "include/effects/SkMorphologyImageFilter.h"
-#include "include/effects/SkOffsetImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include <utility>
@@ -45,16 +38,14 @@
///////////////////////////////////////////////////////////////////////////////
DEF_SIMPLE_GM(imagefilterscropexpand, canvas, 730, 650) {
- SkImageFilter::CropRect cropRect(
- SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)),
- SkImageFilter::CropRect::kHasAll_CropEdge);
+ SkIRect cropRect = SkIRect::MakeXYWH(10, 10, 44, 44);
sk_sp<SkImage> gradientCircle(make_gradient_circle(64, 64));
SkBitmap checkerboard;
make_checkerboard(&checkerboard);
- sk_sp<SkImageFilter> gradientCircleSource(SkImageSource::Make(std::move(gradientCircle)));
- sk_sp<SkImageFilter> noopCropped(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
+ sk_sp<SkImageFilter> gradientCircleSource(SkImageFilters::Image(std::move(gradientCircle)));
+ sk_sp<SkImageFilter> noopCropped(SkImageFilters::Offset(0, 0, nullptr, &cropRect));
// This color matrix saturates the green component but only partly increases the opacity.
// For the opaque checkerboard, the opacity boost doesn't matter but it does impact the
// area outside the checkerboard.
@@ -77,62 +68,38 @@
canvas->translate(MARGIN, MARGIN);
for (int outset = -15; outset <= 20; outset += 5) {
canvas->save();
- SkRect rect = cropRect.rect();
- rect.outset(SkIntToScalar(outset),
- SkIntToScalar(outset));
- SkImageFilter::CropRect bigRect(rect, SkImageFilter::CropRect::kHasAll_CropEdge);
+ SkRect rect = SkRect::Make(cropRect);
+ SkIRect bigRect = cropRect;
+ bigRect.outset(outset, outset);
- draw(canvas, checkerboard, rect, SkColorFilterImageFilter::Make(cfAlphaTrans,
- noopCropped,
- &bigRect));
+ draw(canvas, checkerboard, rect, SkImageFilters::ColorFilter(
+ cfAlphaTrans, noopCropped, &bigRect));
- draw(canvas, checkerboard, rect, SkBlurImageFilter::Make(0.3f, 0.3f,
- noopCropped,
- &bigRect));
+ draw(canvas, checkerboard, rect, SkImageFilters::Blur(
+ 0.3f, 0.3f, noopCropped, &bigRect));
- draw(canvas, checkerboard, rect, SkBlurImageFilter::Make(8.0f, 8.0f,
- noopCropped,
- &bigRect));
+ draw(canvas, checkerboard, rect, SkImageFilters::Blur(
+ 8.0f, 8.0f, noopCropped, &bigRect));
- draw(canvas, checkerboard, rect, SkDilateImageFilter::Make(2, 2,
- noopCropped,
- &bigRect));
+ draw(canvas, checkerboard, rect, SkImageFilters::Dilate(
+ 2, 2, noopCropped, &bigRect));
- draw(canvas, checkerboard, rect, SkErodeImageFilter::Make(2, 2,
- noopCropped,
- &bigRect));
+ draw(canvas, checkerboard, rect, SkImageFilters::Erode(
+ 2, 2, noopCropped, &bigRect));
draw(canvas, checkerboard, rect,
- SkDropShadowImageFilter::Make(
- SkIntToScalar(10),
- SkIntToScalar(10),
- SkIntToScalar(3),
- SkIntToScalar(3),
- SK_ColorBLUE,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
- noopCropped,
- &bigRect));
+ SkImageFilters::DropShadow(10, 10, 3, 3, SK_ColorBLUE, noopCropped, &bigRect));
draw(canvas, checkerboard, rect,
- SkDisplacementMapEffect::Make(SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkIntToScalar(12),
- gradientCircleSource,
- noopCropped,
- &bigRect));
+ SkImageFilters::DisplacementMap(SkColorChannel::kR, SkColorChannel::kR, 12,
+ gradientCircleSource, noopCropped, &bigRect));
draw(canvas, checkerboard, rect,
- SkOffsetImageFilter::Make(SkIntToScalar(-8), SkIntToScalar(16),
- noopCropped,
- &bigRect));
+ SkImageFilters::Offset(SkIntToScalar(-8), SkIntToScalar(16), noopCropped, &bigRect));
draw(canvas, checkerboard, rect,
- SkLightingImageFilter::MakePointLitDiffuse(pointLocation,
- SK_ColorWHITE,
- surfaceScale,
- kd,
- noopCropped,
- &bigRect));
+ SkImageFilters::PointLitDiffuse(pointLocation, SK_ColorWHITE, surfaceScale, kd,
+ noopCropped, &bigRect));
canvas->restore();
canvas->translate(0, SkIntToScalar(80));
diff --git a/gm/imagefilterscropped.cpp b/gm/imagefilterscropped.cpp
index 8e47cdf..21f3981 100644
--- a/gm/imagefilterscropped.cpp
+++ b/gm/imagefilterscropped.cpp
@@ -21,11 +21,7 @@
#include "include/core/SkString.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkColorFilterImageFilter.h"
-#include "include/effects/SkMergeImageFilter.h"
-#include "include/effects/SkMorphologyImageFilter.h"
-#include "include/effects/SkOffsetImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/utils/SkTextUtils.h"
#include "tools/ToolUtils.h"
@@ -128,37 +124,31 @@
sk_sp<SkColorFilter> cf(SkColorFilters::Blend(SK_ColorBLUE,
SkBlendMode::kSrcIn));
- SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)),
- SkImageFilter::CropRect::kHasAll_CropEdge);
- SkImageFilter::CropRect bogusRect(SkRect::Make(SkIRect::MakeXYWH(-100, -100, 10, 10)),
- SkImageFilter::CropRect::kHasAll_CropEdge);
+ SkIRect cropRect = SkIRect::MakeXYWH(10, 10, 44, 44);
+ SkIRect bogusRect = SkIRect::MakeXYWH(-100, -100, 10, 10);
- sk_sp<SkImageFilter> offset(SkOffsetImageFilter::Make(SkIntToScalar(-10),
- SkIntToScalar(-10),
- nullptr));
+ sk_sp<SkImageFilter> offset(SkImageFilters::Offset(-10, -10, nullptr));
- sk_sp<SkImageFilter> cfOffset(SkColorFilterImageFilter::Make(cf, std::move(offset)));
+ sk_sp<SkImageFilter> cfOffset(SkImageFilters::ColorFilter(cf, std::move(offset)));
- sk_sp<SkImageFilter> erodeX(SkErodeImageFilter::Make(8, 0, nullptr, &cropRect));
- sk_sp<SkImageFilter> erodeY(SkErodeImageFilter::Make(0, 8, nullptr, &cropRect));
+ sk_sp<SkImageFilter> erodeX(SkImageFilters::Erode(8, 0, nullptr, &cropRect));
+ sk_sp<SkImageFilter> erodeY(SkImageFilters::Erode(0, 8, nullptr, &cropRect));
sk_sp<SkImageFilter> filters[] = {
nullptr,
- SkColorFilterImageFilter::Make(cf, nullptr, &cropRect),
- SkBlurImageFilter::Make(0.0f, 0.0f, nullptr, &cropRect),
- SkBlurImageFilter::Make(1.0f, 1.0f, nullptr, &cropRect),
- SkBlurImageFilter::Make(8.0f, 0.0f, nullptr, &cropRect),
- SkBlurImageFilter::Make(0.0f, 8.0f, nullptr, &cropRect),
- SkBlurImageFilter::Make(8.0f, 8.0f, nullptr, &cropRect),
- SkErodeImageFilter::Make(1, 1, nullptr, &cropRect),
- SkErodeImageFilter::Make(8, 0, std::move(erodeY), &cropRect),
- SkErodeImageFilter::Make(0, 8, std::move(erodeX), &cropRect),
- SkErodeImageFilter::Make(8, 8, nullptr, &cropRect),
- SkMergeImageFilter::Make(nullptr,
- std::move(cfOffset),
- &cropRect),
- SkBlurImageFilter::Make(8.0f, 8.0f, nullptr, &bogusRect),
- SkColorFilterImageFilter::Make(cf, nullptr, &bogusRect),
+ SkImageFilters::ColorFilter(cf, nullptr, &cropRect),
+ SkImageFilters::Blur(0.0f, 0.0f, nullptr, &cropRect),
+ SkImageFilters::Blur(1.0f, 1.0f, nullptr, &cropRect),
+ SkImageFilters::Blur(8.0f, 0.0f, nullptr, &cropRect),
+ SkImageFilters::Blur(0.0f, 8.0f, nullptr, &cropRect),
+ SkImageFilters::Blur(8.0f, 8.0f, nullptr, &cropRect),
+ SkImageFilters::Erode(1, 1, nullptr, &cropRect),
+ SkImageFilters::Erode(8, 0, std::move(erodeY), &cropRect),
+ SkImageFilters::Erode(0, 8, std::move(erodeX), &cropRect),
+ SkImageFilters::Erode(8, 8, nullptr, &cropRect),
+ SkImageFilters::Merge(nullptr, std::move(cfOffset), &cropRect),
+ SkImageFilters::Blur(8.0f, 8.0f, nullptr, &bogusRect),
+ SkImageFilters::ColorFilter(cf, nullptr, &bogusRect),
};
SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
diff --git a/gm/imagefiltersgraph.cpp b/gm/imagefiltersgraph.cpp
index ecc4dd8..25e4de9 100644
--- a/gm/imagefiltersgraph.cpp
+++ b/gm/imagefiltersgraph.cpp
@@ -20,15 +20,7 @@
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
-#include "include/effects/SkArithmeticImageFilter.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkColorFilterImageFilter.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkMatrixConvolutionImageFilter.h"
-#include "include/effects/SkMergeImageFilter.h"
-#include "include/effects/SkMorphologyImageFilter.h"
-#include "include/effects/SkOffsetImageFilter.h"
-#include "include/effects/SkXfermodeImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include <utility>
@@ -53,14 +45,14 @@
void onDraw(SkCanvas* canvas) override {
canvas->clear(SK_ColorBLACK);
{
- sk_sp<SkImageFilter> bitmapSource(SkImageSource::Make(fImage));
+ sk_sp<SkImageFilter> bitmapSource(SkImageFilters::Image(fImage));
sk_sp<SkColorFilter> cf(SkColorFilters::Blend(SK_ColorRED,
SkBlendMode::kSrcIn));
- sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(4.0f, 4.0f, std::move(bitmapSource)));
- sk_sp<SkImageFilter> erode(SkErodeImageFilter::Make(4, 4, blur));
- sk_sp<SkImageFilter> color(SkColorFilterImageFilter::Make(std::move(cf),
+ sk_sp<SkImageFilter> blur(SkImageFilters::Blur(4.0f, 4.0f, std::move(bitmapSource)));
+ sk_sp<SkImageFilter> erode(SkImageFilters::Erode(4, 4, blur));
+ sk_sp<SkImageFilter> color(SkImageFilters::ColorFilter(std::move(cf),
std::move(erode)));
- sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(blur, color));
+ sk_sp<SkImageFilter> merge(SkImageFilters::Merge(blur, color));
SkPaint paint;
paint.setImageFilter(std::move(merge));
@@ -68,7 +60,7 @@
canvas->translate(SkIntToScalar(100), 0);
}
{
- sk_sp<SkImageFilter> morph(SkDilateImageFilter::Make(5, 5, nullptr));
+ sk_sp<SkImageFilter> morph(SkImageFilters::Dilate(5, 5, nullptr));
float matrix[20] = { 1, 0, 0, 0, 0,
0, 1, 0, 0, 0,
@@ -76,11 +68,11 @@
0, 0, 0, 0.5f, 0 };
sk_sp<SkColorFilter> matrixFilter(SkColorFilters::Matrix(matrix));
- sk_sp<SkImageFilter> colorMorph(SkColorFilterImageFilter::Make(std::move(matrixFilter),
+ sk_sp<SkImageFilter> colorMorph(SkImageFilters::ColorFilter(std::move(matrixFilter),
std::move(morph)));
SkPaint paint;
- paint.setImageFilter(SkXfermodeImageFilter::Make(SkBlendMode::kSrcOver,
- std::move(colorMorph)));
+ paint.setImageFilter(SkImageFilters::Xfermode(SkBlendMode::kSrcOver,
+ std::move(colorMorph)));
DrawClippedImage(canvas, fImage.get(), paint);
canvas->translate(SkIntToScalar(100), 0);
@@ -91,28 +83,24 @@
0, 0, 1, 0, 0,
0, 0, 0, 0.5f, 0 };
sk_sp<SkColorFilter> matrixCF(SkColorFilters::Matrix(matrix));
- sk_sp<SkImageFilter> matrixFilter(SkColorFilterImageFilter::Make(std::move(matrixCF),
+ sk_sp<SkImageFilter> matrixFilter(SkImageFilters::ColorFilter(std::move(matrixCF),
nullptr));
- sk_sp<SkImageFilter> offsetFilter(SkOffsetImageFilter::Make(10.0f, 10.f,
- matrixFilter));
+ sk_sp<SkImageFilter> offsetFilter(SkImageFilters::Offset(10.0f, 10.f, matrixFilter));
SkPaint paint;
- paint.setImageFilter(SkArithmeticImageFilter::Make(
+ paint.setImageFilter(SkImageFilters::Arithmetic(
0, 1, 1, 0, true, std::move(matrixFilter), std::move(offsetFilter), nullptr));
DrawClippedImage(canvas, fImage.get(), paint);
canvas->translate(SkIntToScalar(100), 0);
}
{
- sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(SkIntToScalar(10),
- SkIntToScalar(10),
- nullptr));
+ sk_sp<SkImageFilter> blur(SkImageFilters::Blur(10, 10, nullptr));
- SkImageFilter::CropRect cropRect(SkRect::MakeWH(SkIntToScalar(95), SkIntToScalar(100)));
+ SkIRect cropRect = SkIRect::MakeWH(95, 100);
SkPaint paint;
paint.setImageFilter(
- SkXfermodeImageFilter::Make(SkBlendMode::kSrcIn, std::move(blur), nullptr,
- &cropRect));
+ SkImageFilters::Xfermode(SkBlendMode::kSrcIn, std::move(blur), nullptr, &cropRect));
DrawClippedImage(canvas, fImage.get(), paint);
canvas->translate(SkIntToScalar(100), 0);
}
@@ -121,26 +109,18 @@
// This tests that a filter using asFragmentProcessor (matrix
// convolution) correctly handles a non-zero source offset
// (supplied by the dilate).
- sk_sp<SkImageFilter> dilate(SkDilateImageFilter::Make(5, 5, nullptr));
+ sk_sp<SkImageFilter> dilate(SkImageFilters::Dilate(5, 5, nullptr));
- SkScalar kernel[9] = {
- SkIntToScalar(-1), SkIntToScalar( -1 ), SkIntToScalar(-1),
- SkIntToScalar(-1), SkIntToScalar( 7 ), SkIntToScalar(-1),
- SkIntToScalar(-1), SkIntToScalar( -1 ), SkIntToScalar(-1),
- };
+ SkScalar kernel[9] = { -1, -1, -1,
+ -1, 7, -1,
+ -1, -1, -1 };
SkISize kernelSize = SkISize::Make(3, 3);
- SkScalar gain = 1.0f, bias = SkIntToScalar(0);
+ SkScalar gain = 1.0f, bias = 0;
SkIPoint kernelOffset = SkIPoint::Make(1, 1);
- auto tileMode = SkMatrixConvolutionImageFilter::kClamp_TileMode;
bool convolveAlpha = false;
- sk_sp<SkImageFilter> convolve(SkMatrixConvolutionImageFilter::Make(kernelSize,
- kernel,
- gain,
- bias,
- kernelOffset,
- tileMode,
- convolveAlpha,
- std::move(dilate)));
+ sk_sp<SkImageFilter> convolve(SkImageFilters::MatrixConvolution(
+ kernelSize, kernel, gain, bias, kernelOffset, SkTileMode::kClamp, convolveAlpha,
+ std::move(dilate)));
SkPaint paint;
paint.setImageFilter(std::move(convolve));
@@ -151,16 +131,12 @@
// Test that crop offsets are absolute, not relative to the parent's crop rect.
sk_sp<SkColorFilter> cf1(SkColorFilters::Blend(SK_ColorBLUE, SkBlendMode::kSrcIn));
sk_sp<SkColorFilter> cf2(SkColorFilters::Blend(SK_ColorGREEN, SkBlendMode::kSrcIn));
- SkImageFilter::CropRect outerRect(SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(10),
- SkIntToScalar(80), SkIntToScalar(80)));
- SkImageFilter::CropRect innerRect(SkRect::MakeXYWH(SkIntToScalar(20), SkIntToScalar(20),
- SkIntToScalar(60), SkIntToScalar(60)));
- sk_sp<SkImageFilter> color1(SkColorFilterImageFilter::Make(std::move(cf1),
- nullptr,
- &outerRect));
- sk_sp<SkImageFilter> color2(SkColorFilterImageFilter::Make(std::move(cf2),
- std::move(color1),
- &innerRect));
+ SkIRect outerRect = SkIRect::MakeXYWH(10, 10, 80, 80);
+ SkIRect innerRect= SkIRect::MakeXYWH(20, 20, 60, 60);
+ sk_sp<SkImageFilter> color1(SkImageFilters::ColorFilter(
+ std::move(cf1), nullptr, &outerRect));
+ sk_sp<SkImageFilter> color2(SkImageFilters::ColorFilter(
+ std::move(cf2), std::move(color1), &innerRect));
SkPaint paint;
paint.setImageFilter(std::move(color2));
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index 471d9ae..10da56b 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -25,15 +25,8 @@
#include "include/core/SkSurface.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkDisplacementMapEffect.h"
-#include "include/effects/SkDropShadowImageFilter.h"
#include "include/effects/SkGradientShader.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkLightingImageFilter.h"
-#include "include/effects/SkMorphologyImageFilter.h"
-#include "include/effects/SkOffsetImageFilter.h"
-#include "include/effects/SkPaintImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/effects/SkPerlinNoiseShader.h"
#include "tools/ToolUtils.h"
@@ -87,8 +80,8 @@
void onDraw(SkCanvas* canvas) override {
canvas->clear(SK_ColorBLACK);
- sk_sp<SkImageFilter> gradient(SkImageSource::Make(fGradientCircle));
- sk_sp<SkImageFilter> checkerboard(SkImageSource::Make(fCheckerboard));
+ sk_sp<SkImageFilter> gradient(SkImageFilters::Image(fGradientCircle));
+ sk_sp<SkImageFilter> checkerboard(SkImageFilters::Image(fCheckerboard));
SkPaint noisePaint;
noisePaint.setShader(SkPerlinNoiseShader::MakeFractalNoise(SkDoubleToScalar(0.1),
@@ -108,27 +101,18 @@
resizeMatrix.setScale(RESIZE_FACTOR, RESIZE_FACTOR);
sk_sp<SkImageFilter> filters[] = {
- SkBlurImageFilter::Make(SkIntToScalar(4), SkIntToScalar(4), nullptr),
- SkDropShadowImageFilter::Make(
- SkIntToScalar(5), SkIntToScalar(10),
- SkIntToScalar(3), SkIntToScalar(3), SK_ColorYELLOW,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
- nullptr),
- SkDisplacementMapEffect::Make(SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkIntToScalar(12),
- std::move(gradient),
- checkerboard),
- SkDilateImageFilter::Make(1, 1, checkerboard),
- SkErodeImageFilter::Make(1, 1, checkerboard),
- SkOffsetImageFilter::Make(SkIntToScalar(32), 0, nullptr),
- SkImageFilter::MakeMatrixFilter(resizeMatrix, kNone_SkFilterQuality, nullptr),
- SkPaintImageFilter::Make(noisePaint),
- SkLightingImageFilter::MakePointLitDiffuse(pointLocation, white, surfaceScale, kd,
- nullptr),
- SkLightingImageFilter::MakeSpotLitDiffuse(spotLocation, spotTarget, spotExponent,
- cutoffAngle, white, surfaceScale, kd,
- nullptr),
+ SkImageFilters::Blur(SkIntToScalar(4), SkIntToScalar(4), nullptr),
+ SkImageFilters::DropShadow(5, 10, 3, 3, SK_ColorYELLOW, nullptr),
+ SkImageFilters::DisplacementMap(SkColorChannel::kR, SkColorChannel::kR, 12,
+ std::move(gradient), checkerboard),
+ SkImageFilters::Dilate(1, 1, checkerboard),
+ SkImageFilters::Erode(1, 1, checkerboard),
+ SkImageFilters::Offset(SkIntToScalar(32), 0, nullptr),
+ SkImageFilters::MatrixTransform(resizeMatrix, kNone_SkFilterQuality, nullptr),
+ SkImageFilters::Paint(noisePaint),
+ SkImageFilters::PointLitDiffuse(pointLocation, white, surfaceScale, kd, nullptr),
+ SkImageFilters::SpotLitDiffuse(spotLocation, spotTarget, spotExponent,
+ cutoffAngle, white, surfaceScale, kd, nullptr),
};
SkVector scales[] = {
diff --git a/gm/imagefiltersstroked.cpp b/gm/imagefiltersstroked.cpp
index 186cc29..fc08a70 100644
--- a/gm/imagefiltersstroked.cpp
+++ b/gm/imagefiltersstroked.cpp
@@ -18,9 +18,7 @@
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkDropShadowImageFilter.h"
-#include "include/effects/SkOffsetImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#define RESIZE_FACTOR_X SkIntToScalar(2)
#define RESIZE_FACTOR_Y SkIntToScalar(5)
@@ -67,12 +65,10 @@
resizeMatrix.setScale(RESIZE_FACTOR_X, RESIZE_FACTOR_Y);
sk_sp<SkImageFilter> filters[] = {
- SkBlurImageFilter::Make(5, 5, nullptr),
- SkDropShadowImageFilter::Make(10, 10, 3, 3, SK_ColorGREEN,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
- nullptr),
- SkOffsetImageFilter::Make(-16, 32, nullptr),
- SkImageFilter::MakeMatrixFilter(resizeMatrix, kNone_SkFilterQuality, nullptr),
+ SkImageFilters::Blur(5, 5, nullptr),
+ SkImageFilters::DropShadow(10, 10, 3, 3, SK_ColorGREEN, nullptr),
+ SkImageFilters::Offset(-16, 32, nullptr),
+ SkImageFilters::MatrixTransform(resizeMatrix, kNone_SkFilterQuality, nullptr),
};
SkRect r = SkRect::MakeWH(64, 64);
diff --git a/gm/imagefilterstransformed.cpp b/gm/imagefilterstransformed.cpp
index 22926fc..5f36da2 100644
--- a/gm/imagefilterstransformed.cpp
+++ b/gm/imagefilterstransformed.cpp
@@ -23,13 +23,8 @@
#include "include/core/SkSurface.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkDisplacementMapEffect.h"
-#include "include/effects/SkDropShadowImageFilter.h"
#include "include/effects/SkGradientShader.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkMorphologyImageFilter.h"
-#include "include/effects/SkXfermodeImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include <utility>
@@ -79,19 +74,15 @@
}
void onDraw(SkCanvas* canvas) override {
- sk_sp<SkImageFilter> gradient(SkImageSource::Make(fGradientCircle));
- sk_sp<SkImageFilter> checkerboard(SkImageSource::Make(fCheckerboard));
+ sk_sp<SkImageFilter> gradient(SkImageFilters::Image(fGradientCircle));
+ sk_sp<SkImageFilter> checkerboard(SkImageFilters::Image(fCheckerboard));
sk_sp<SkImageFilter> filters[] = {
- SkBlurImageFilter::Make(12, 0, nullptr),
- SkDropShadowImageFilter::Make(0, 15, 8, 0, SK_ColorGREEN,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr),
- SkDisplacementMapEffect::Make(SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- 12,
- std::move(gradient),
- checkerboard),
- SkDilateImageFilter::Make(2, 2, checkerboard),
- SkErodeImageFilter::Make(2, 2, checkerboard),
+ SkImageFilters::Blur(12, 0, nullptr),
+ SkImageFilters::DropShadow(0, 15, 8, 0, SK_ColorGREEN, nullptr),
+ SkImageFilters::DisplacementMap(SkColorChannel::kR, SkColorChannel::kR, 12,
+ std::move(gradient), checkerboard),
+ SkImageFilters::Dilate(2, 2, checkerboard),
+ SkImageFilters::Erode(2, 2, checkerboard),
};
const SkScalar margin = SkIntToScalar(20);
@@ -141,8 +132,8 @@
sk_sp<SkImageFilter> filters[] = {
nullptr,
- SkBlurImageFilter::Make(6, 0, nullptr),
- SkXfermodeImageFilter::Make(SkBlendMode::kSrcOver, nullptr),
+ SkImageFilters::Blur(6, 0, nullptr),
+ SkImageFilters::Xfermode(SkBlendMode::kSrcOver, nullptr),
};
for (auto& filter : filters) {
diff --git a/gm/imagemagnifier.cpp b/gm/imagemagnifier.cpp
index 1c7fad1..b61519b 100644
--- a/gm/imagemagnifier.cpp
+++ b/gm/imagemagnifier.cpp
@@ -19,8 +19,7 @@
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypeface.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkMagnifierImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/utils/SkRandom.h"
#include "tools/ToolUtils.h"
@@ -32,7 +31,7 @@
DEF_SIMPLE_GM_BG(imagemagnifier, canvas, WIDTH, HEIGHT, SK_ColorBLACK) {
SkPaint filterPaint;
filterPaint.setImageFilter(
- SkMagnifierImageFilter::Make(
+ SkImageFilters::Magnifier(
SkRect::MakeXYWH(SkIntToScalar(100), SkIntToScalar(100),
SkIntToScalar(WIDTH / 2),
SkIntToScalar(HEIGHT / 2)),
@@ -81,7 +80,7 @@
sk_sp<SkImage> image(make_img());
- sk_sp<SkImageFilter> imageSource(SkImageSource::Make(std::move(image)));
+ sk_sp<SkImageFilter> imageSource(SkImageFilters::Image(std::move(image)));
SkRect srcRect = SkRect::MakeWH(SkIntToScalar(WIDTH_HEIGHT-32),
SkIntToScalar(WIDTH_HEIGHT-32));
@@ -90,13 +89,11 @@
constexpr SkScalar kInset = 64.0f;
// Crop out a 16 pixel ring around the result
- const SkRect rect = SkRect::MakeXYWH(16, 16, WIDTH_HEIGHT-32, WIDTH_HEIGHT-32);
- SkImageFilter::CropRect cropRect(rect);
+ const SkIRect cropRect = SkIRect::MakeXYWH(16, 16, WIDTH_HEIGHT-32, WIDTH_HEIGHT-32);
SkPaint filterPaint;
- filterPaint.setImageFilter(SkMagnifierImageFilter::Make(srcRect, kInset,
- std::move(imageSource),
- &cropRect));
+ filterPaint.setImageFilter(SkImageFilters::Magnifier(
+ srcRect, kInset, std::move(imageSource), &cropRect));
canvas->saveLayer(nullptr, &filterPaint);
canvas->restore();
diff --git a/gm/imagemakewithfilter.cpp b/gm/imagemakewithfilter.cpp
index 88c11e1..62d9c26 100644
--- a/gm/imagemakewithfilter.cpp
+++ b/gm/imagemakewithfilter.cpp
@@ -26,20 +26,7 @@
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkAlphaThresholdFilter.h"
-#include "include/effects/SkArithmeticImageFilter.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkColorFilterImageFilter.h"
-#include "include/effects/SkDisplacementMapEffect.h"
-#include "include/effects/SkDropShadowImageFilter.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkLightingImageFilter.h"
-#include "include/effects/SkMatrixConvolutionImageFilter.h"
-#include "include/effects/SkMergeImageFilter.h"
-#include "include/effects/SkMorphologyImageFilter.h"
-#include "include/effects/SkOffsetImageFilter.h"
-#include "include/effects/SkTileImageFilter.h"
-#include "include/effects/SkXfermodeImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/gpu/GrContext.h"
@@ -72,88 +59,60 @@
// less generally useful).
typedef sk_sp<SkImageFilter> (*FilterFactory)(sk_sp<SkImage> auxImage, const SkIRect* cropRect);
-SkImageFilter::CropRect make_crop(const SkIRect* cropRect) {
- if (cropRect) {
- return SkImageFilter::CropRect(SkRect::Make(*cropRect));
- } else {
- return SkImageFilter::CropRect(SkRect(), 0x0 /* no edge flags */);
- }
-}
-
static sk_sp<SkImageFilter> color_filter_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
// The color filter uses kSrcIn so that it respects the transparency introduced by clamping;
// using kSrc would just turn the entire out rect to green regardless.
auto cf = SkColorFilters::Blend(SK_ColorGREEN, SkBlendMode::kSrcIn);
- auto crop = make_crop(cropRect);
- return SkColorFilterImageFilter::Make(std::move(cf), nullptr, &crop);
+ return SkImageFilters::ColorFilter(std::move(cf), nullptr, cropRect);
}
static sk_sp<SkImageFilter> blur_filter_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
- auto crop = make_crop(cropRect);
- return SkBlurImageFilter::Make(2.0f, 2.0f, nullptr, &crop);
+ return SkImageFilters::Blur(2.0f, 2.0f, nullptr, cropRect);
}
static sk_sp<SkImageFilter> drop_shadow_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
- auto crop = make_crop(cropRect);
- return SkDropShadowImageFilter::Make(
- 10.0f, 5.0f, 3.0f, 3.0f, SK_ColorBLUE,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
- nullptr, &crop);
+ return SkImageFilters::DropShadow(10.0f, 5.0f, 3.0f, 3.0f, SK_ColorBLUE, nullptr, cropRect);
}
static sk_sp<SkImageFilter> offset_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
- auto crop = make_crop(cropRect);
- return SkOffsetImageFilter::Make(10.f, 5.f, nullptr, &crop);
+ return SkImageFilters::Offset(10.f, 5.f, nullptr, cropRect);
}
static sk_sp<SkImageFilter> dilate_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
- auto crop = make_crop(cropRect);
- return SkDilateImageFilter::Make(10.f, 5.f, nullptr, &crop);
+ return SkImageFilters::Dilate(10.f, 5.f, nullptr, cropRect);
}
static sk_sp<SkImageFilter> erode_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
- auto crop = make_crop(cropRect);
- return SkErodeImageFilter::Make(10.f, 5.f, nullptr, &crop);
+ return SkImageFilters::Erode(10.f, 5.f, nullptr, cropRect);
}
static sk_sp<SkImageFilter> displacement_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
- auto crop = make_crop(cropRect);
-
- sk_sp<SkImageFilter> displacement = SkImageSource::Make(std::move(auxImage));
- return SkDisplacementMapEffect::Make(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- 40.f, std::move(displacement), nullptr, &crop);
+ sk_sp<SkImageFilter> displacement = SkImageFilters::Image(std::move(auxImage));
+ return SkImageFilters::DisplacementMap(SkColorChannel::kR, SkColorChannel::kG, 40.f,
+ std::move(displacement), nullptr, cropRect);
}
static sk_sp<SkImageFilter> arithmetic_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
- auto crop = make_crop(cropRect);
-
- sk_sp<SkImageFilter> background = SkImageSource::Make(std::move(auxImage));
- return SkArithmeticImageFilter::Make(0.0f, .6f, 1.f, 0.f, false, std::move(background),
- nullptr, &crop);
+ sk_sp<SkImageFilter> background = SkImageFilters::Image(std::move(auxImage));
+ return SkImageFilters::Arithmetic(0.0f, .6f, 1.f, 0.f, false, std::move(background),
+ nullptr, cropRect);
}
static sk_sp<SkImageFilter> xfermode_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
- auto crop = make_crop(cropRect);
-
- sk_sp<SkImageFilter> background = SkImageSource::Make(std::move(auxImage));
- return SkXfermodeImageFilter::Make(
- SkBlendMode::kModulate, std::move(background), nullptr, &crop);
+ sk_sp<SkImageFilter> background = SkImageFilters::Image(std::move(auxImage));
+ return SkImageFilters::Xfermode(
+ SkBlendMode::kModulate, std::move(background), nullptr, cropRect);
}
static sk_sp<SkImageFilter> convolution_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
- auto crop = make_crop(cropRect);
-
SkISize kernelSize = SkISize::Make(3, 3);
SkIPoint kernelOffset = SkIPoint::Make(1, 1);
// A Laplacian edge detector, ee https://en.wikipedia.org/wiki/Kernel_(image_processing)
SkScalar kernel[9] = {-1.f, -1.f, -1.f,
-1.f, 8.f, -1.f,
-1.f, -1.f, -1.f};
- return SkMatrixConvolutionImageFilter::Make(
- kernelSize, kernel, 1.f, 0.f, kernelOffset,
- SkMatrixConvolutionImageFilter::kClamp_TileMode, false, nullptr, &crop);
+ return SkImageFilters::MatrixConvolution(kernelSize, kernel, 1.f, 0.f, kernelOffset,
+ SkTileMode::kClamp, false, nullptr, cropRect);
}
static sk_sp<SkImageFilter> matrix_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
@@ -161,23 +120,19 @@
matrix.setRotate(45.f, 50.f, 50.f);
// This doesn't support a cropRect
- return SkImageFilter::MakeMatrixFilter(matrix, kLow_SkFilterQuality, nullptr);
+ return SkImageFilters::MatrixTransform(matrix, kLow_SkFilterQuality, nullptr);
}
static sk_sp<SkImageFilter> alpha_threshold_factory(sk_sp<SkImage> auxImage,
const SkIRect* cropRect) {
- auto crop = make_crop(cropRect);
-
// Centered cross with higher opacity
SkRegion region(SkIRect::MakeLTRB(30, 45, 70, 55));
region.op(SkIRect::MakeLTRB(45, 30, 55, 70), SkRegion::kUnion_Op);
- return SkAlphaThresholdFilter::Make(region, 1.f, .2f, nullptr, &crop);
+ return SkImageFilters::AlphaThreshold(region, 1.f, .2f, nullptr, cropRect);
}
static sk_sp<SkImageFilter> lighting_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
- auto crop = make_crop(cropRect);
-
// Must convert the RGB values of the source to alpha, since that is what the lighting filters
// use to estimate their normals. This color matrix changes the color to white and the alpha
// to be equal to the approx. luminance of the original color.
@@ -187,7 +142,7 @@
0.f, 0.f, 0.f, 0.f, 1.f,
0.2126f, 0.7152f, 0.0722f, 0.f, 0.f
};
- sk_sp<SkImageFilter> srcToAlpha = SkColorFilterImageFilter::Make(
+ sk_sp<SkImageFilter> srcToAlpha = SkImageFilters::ColorFilter(
SkColorFilters::Matrix(kMatrix), nullptr);
// Combine both specular and diffuse into a single DAG since they use separate internal filter
@@ -202,18 +157,18 @@
SkPoint3 specLocation = SkPoint3::Make(spotTarget.fX - 50 * sinAzimuth,
spotTarget.fY + 50 * cosAzimuth,
SkIntToScalar(10));
- sk_sp<SkImageFilter> diffuse = SkLightingImageFilter::MakePointLitDiffuse(
- diffLocation, SK_ColorWHITE, /* scale */ 1.f, /* kd */ 2.f, srcToAlpha, &crop);
- sk_sp<SkImageFilter> specular = SkLightingImageFilter::MakePointLitSpecular(
+ sk_sp<SkImageFilter> diffuse = SkImageFilters::PointLitDiffuse(
+ diffLocation, SK_ColorWHITE, /* scale */ 1.f, /* kd */ 2.f, srcToAlpha, cropRect);
+ sk_sp<SkImageFilter> specular = SkImageFilters::PointLitSpecular(
specLocation, SK_ColorRED, /* scale */ 1.f, /* ks */ 1.f, /* shine */ 8.f,
- srcToAlpha, &crop);
- return SkMergeImageFilter::Make(std::move(diffuse), std::move(specular), &crop);
+ srcToAlpha, cropRect);
+ return SkImageFilters::Merge(std::move(diffuse), std::move(specular), cropRect);
}
static sk_sp<SkImageFilter> tile_factory(sk_sp<SkImage> auxImage, const SkIRect* cropRect) {
// Tile the subset over a large region
- return SkTileImageFilter::Make(SkRect::MakeLTRB(25, 25, 75, 75), SkRect::MakeWH(100, 100),
- nullptr);
+ return SkImageFilters::Tile(SkRect::MakeLTRB(25, 25, 75, 75), SkRect::MakeWH(100, 100),
+ nullptr);
}
namespace {
diff --git a/gm/imageresizetiled.cpp b/gm/imageresizetiled.cpp
index 042df53..23c949b 100644
--- a/gm/imageresizetiled.cpp
+++ b/gm/imageresizetiled.cpp
@@ -16,6 +16,7 @@
#include "include/core/SkScalar.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#define WIDTH 640
@@ -27,7 +28,7 @@
SkPaint paint;
SkMatrix matrix;
matrix.setScale(RESIZE_FACTOR, RESIZE_FACTOR);
- paint.setImageFilter(SkImageFilter::MakeMatrixFilter(matrix,
+ paint.setImageFilter(SkImageFilters::MatrixTransform(matrix,
kNone_SkFilterQuality,
nullptr));
diff --git a/gm/imagesource.cpp b/gm/imagesource.cpp
index 64f9cfe..897012e 100644
--- a/gm/imagesource.cpp
+++ b/gm/imagesource.cpp
@@ -18,7 +18,7 @@
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
-#include "include/effects/SkImageSource.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include <utility>
@@ -62,28 +62,28 @@
{
// Draw an unscaled bitmap.
- sk_sp<SkImageFilter> imageSource(SkImageSource::Make(fImage));
+ sk_sp<SkImageFilter> imageSource(SkImageFilters::Image(fImage));
fill_rect_filtered(canvas, clipRect, std::move(imageSource));
canvas->translate(SkIntToScalar(100), 0);
}
{
// Draw an unscaled subset of the source bitmap (srcRect -> srcRect).
sk_sp<SkImageFilter> imageSourceSrcRect(
- SkImageSource::Make(fImage, srcRect, srcRect, kHigh_SkFilterQuality));
+ SkImageFilters::Image(fImage, srcRect, srcRect, kHigh_SkFilterQuality));
fill_rect_filtered(canvas, clipRect, std::move(imageSourceSrcRect));
canvas->translate(SkIntToScalar(100), 0);
}
{
// Draw a subset of the bitmap scaled to a destination rect (srcRect -> dstRect).
sk_sp<SkImageFilter> imageSourceSrcRectDstRect(
- SkImageSource::Make(fImage, srcRect, dstRect, kHigh_SkFilterQuality));
+ SkImageFilters::Image(fImage, srcRect, dstRect, kHigh_SkFilterQuality));
fill_rect_filtered(canvas, clipRect, std::move(imageSourceSrcRectDstRect));
canvas->translate(SkIntToScalar(100), 0);
}
{
// Draw the entire bitmap scaled to a destination rect (bounds -> dstRect).
sk_sp<SkImageFilter> imageSourceDstRectOnly(
- SkImageSource::Make(fImage, bounds, dstRect, kHigh_SkFilterQuality));
+ SkImageFilters::Image(fImage, bounds, dstRect, kHigh_SkFilterQuality));
fill_rect_filtered(canvas, clipRect, std::move(imageSourceDstRectOnly));
canvas->translate(SkIntToScalar(100), 0);
}
diff --git a/gm/imagesource2.cpp b/gm/imagesource2.cpp
index b0f31ea..4949ce7 100644
--- a/gm/imagesource2.cpp
+++ b/gm/imagesource2.cpp
@@ -19,7 +19,7 @@
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkImageSource.h"
+#include "include/effects/SkImageFilters.h"
namespace skiagm {
@@ -77,7 +77,7 @@
const SkRect dstRect = SkRect::MakeLTRB(0.75f, 0.75f, 225.75f, 225.75f);
SkPaint p;
- p.setImageFilter(SkImageSource::Make(fImage, srcRect, dstRect, fFilter));
+ p.setImageFilter(SkImageFilters::Image(fImage, srcRect, dstRect, fFilter));
canvas->saveLayer(nullptr, &p);
canvas->restore();
diff --git a/gm/lighting.cpp b/gm/lighting.cpp
index 8d9f5ed..cc85181 100644
--- a/gm/lighting.cpp
+++ b/gm/lighting.cpp
@@ -17,8 +17,7 @@
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
-#include "include/effects/SkLightingImageFilter.h"
-#include "include/effects/SkOffsetImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include "tools/timer/TimeUtils.h"
@@ -95,71 +94,40 @@
SkColor white(0xFFFFFFFF);
SkPaint paint;
- SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(20, 10, 60, 65));
- SkImageFilter::CropRect fullSizeCropRect(SkRect::MakeXYWH(0, 0, 100, 100));
- sk_sp<SkImageFilter> noopCropped(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
+ SkIRect cropRect = SkIRect::MakeXYWH(20, 10, 60, 65);
+ SkIRect fullSizeCropRect = SkIRect::MakeXYWH(0, 0, 100, 100);
+ sk_sp<SkImageFilter> noopCropped(SkImageFilters::Offset(0, 0, nullptr, &cropRect));
int y = 0;
for (int i = 0; i < 3; i++) {
- const SkImageFilter::CropRect* cr = (i == 1) ? &cropRect : (i == 2) ? &fullSizeCropRect : nullptr;
+ const SkIRect* cr = (i == 1) ? &cropRect : (i == 2) ? &fullSizeCropRect : nullptr;
sk_sp<SkImageFilter> input = (i == 2) ? noopCropped : nullptr;
- paint.setImageFilter(SkLightingImageFilter::MakePointLitDiffuse(pointLocation,
- white,
- surfaceScale,
- kd,
- input,
- cr));
+ paint.setImageFilter(SkImageFilters::PointLitDiffuse(
+ pointLocation, white, surfaceScale, kd, input, cr));
drawClippedBitmap(canvas, paint, 0, y);
- paint.setImageFilter(SkLightingImageFilter::MakeDistantLitDiffuse(distantDirection,
- white,
- surfaceScale,
- kd,
- input,
- cr));
+ paint.setImageFilter(SkImageFilters::DistantLitDiffuse(
+ distantDirection, white, surfaceScale, kd, input, cr));
drawClippedBitmap(canvas, paint, 110, y);
- paint.setImageFilter(SkLightingImageFilter::MakeSpotLitDiffuse(spotLocation,
- spotTarget,
- spotExponent,
- cutoffAngle,
- white,
- surfaceScale,
- kd,
- input,
- cr));
+ paint.setImageFilter(SkImageFilters::SpotLitDiffuse(
+ spotLocation, spotTarget, spotExponent, cutoffAngle, white, surfaceScale, kd,
+ input, cr));
drawClippedBitmap(canvas, paint, 220, y);
y += 110;
- paint.setImageFilter(SkLightingImageFilter::MakePointLitSpecular(pointLocation,
- white,
- surfaceScale,
- ks,
- shininess,
- input,
- cr));
+ paint.setImageFilter(SkImageFilters::PointLitSpecular(
+ pointLocation, white, surfaceScale, ks, shininess, input, cr));
drawClippedBitmap(canvas, paint, 0, y);
- paint.setImageFilter(SkLightingImageFilter::MakeDistantLitSpecular(distantDirection,
- white,
- surfaceScale,
- ks,
- shininess,
- input,
- cr));
+ paint.setImageFilter(SkImageFilters::DistantLitSpecular(
+ distantDirection, white, surfaceScale, ks, shininess, input, cr));
drawClippedBitmap(canvas, paint, 110, y);
- paint.setImageFilter(SkLightingImageFilter::MakeSpotLitSpecular(spotLocation,
- spotTarget,
- spotExponent,
- cutoffAngle,
- white,
- surfaceScale,
- ks,
- shininess,
- input,
- cr));
+ paint.setImageFilter(SkImageFilters::SpotLitSpecular(
+ spotLocation, spotTarget, spotExponent, cutoffAngle, white, surfaceScale, ks,
+ shininess, input, cr));
drawClippedBitmap(canvas, paint, 220, y);
y += 110;
diff --git a/gm/localmatriximagefilter.cpp b/gm/localmatriximagefilter.cpp
index 19dee85..9a9902d 100644
--- a/gm/localmatriximagefilter.cpp
+++ b/gm/localmatriximagefilter.cpp
@@ -17,9 +17,7 @@
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkSurface.h"
-#include "include/effects/SkBlurImageFilter.h"
-#include "include/effects/SkMorphologyImageFilter.h"
-#include "include/effects/SkOffsetImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include <utility>
@@ -49,20 +47,15 @@
typedef sk_sp<SkImageFilter> (*ImageFilterFactory)();
-// +[]{...} did not work on windows (VS)
-// (ImageFilterFactory)[]{...} did not work on linux (gcc)
-// hence this cast function
-template <typename T> ImageFilterFactory IFCCast(T arg) { return arg; }
-
// Show the effect of localmatriximagefilter with various matrices, on various filters
DEF_SIMPLE_GM(localmatriximagefilter, canvas, 640, 640) {
sk_sp<SkImage> image0(make_image(canvas));
const ImageFilterFactory factories[] = {
- IFCCast([]{ return SkBlurImageFilter::Make(8, 8, nullptr); }),
- IFCCast([]{ return SkDilateImageFilter::Make(8, 8, nullptr); }),
- IFCCast([]{ return SkErodeImageFilter::Make(8, 8, nullptr); }),
- IFCCast([]{ return SkOffsetImageFilter::Make(8, 8, nullptr); }),
+ []{ return SkImageFilters::Blur(8, 8, nullptr); },
+ []{ return SkImageFilters::Dilate(8, 8, nullptr); },
+ []{ return SkImageFilters::Erode(8, 8, nullptr); },
+ []{ return SkImageFilters::Offset(8, 8, nullptr); },
};
const SkMatrix matrices[] = {
diff --git a/gm/matrixconvolution.cpp b/gm/matrixconvolution.cpp
index a848b00..bedb3df 100644
--- a/gm/matrixconvolution.cpp
+++ b/gm/matrixconvolution.cpp
@@ -21,7 +21,7 @@
#include "include/core/SkTileMode.h"
#include "include/core/SkTypeface.h"
#include "include/effects/SkGradientShader.h"
-#include "include/effects/SkMatrixConvolutionImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
namespace skiagm {
@@ -62,8 +62,8 @@
}
void draw(SkCanvas* canvas, int x, int y, const SkIPoint& kernelOffset,
- SkMatrixConvolutionImageFilter::TileMode tileMode, bool convolveAlpha,
- const SkImageFilter::CropRect* cropRect = nullptr) {
+ SkTileMode tileMode, bool convolveAlpha,
+ const SkIRect* cropRect = nullptr) {
SkScalar kernel[9] = {
SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
@@ -72,15 +72,9 @@
SkISize kernelSize = SkISize::Make(3, 3);
SkScalar gain = 0.3f, bias = SkIntToScalar(100);
SkPaint paint;
- paint.setImageFilter(SkMatrixConvolutionImageFilter::Make(kernelSize,
- kernel,
- gain,
- bias,
- kernelOffset,
- tileMode,
- convolveAlpha,
- nullptr,
- cropRect));
+ paint.setImageFilter(SkImageFilters::MatrixConvolution(kernelSize, kernel, gain, bias,
+ kernelOffset, tileMode,
+ convolveAlpha, nullptr, cropRect));
canvas->save();
canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
const SkRect layerBounds = SkRect::MakeIWH(fBitmap.width(), fBitmap.height());
@@ -94,8 +88,6 @@
canvas->restore();
}
- typedef SkMatrixConvolutionImageFilter MCIF;
-
void onOnceBeforeDraw() override {
this->makeBitmap();
}
@@ -103,22 +95,22 @@
void onDraw(SkCanvas* canvas) override {
canvas->clear(SK_ColorBLACK);
SkIPoint kernelOffset = SkIPoint::Make(1, 0);
- SkImageFilter::CropRect rect(SkRect::Make(fBitmap.bounds()));
+ SkIRect rect = fBitmap.bounds();
for (int x = 10; x < 310; x += 100) {
- this->draw(canvas, x, 10, kernelOffset, MCIF::kClamp_TileMode, true, &rect);
- this->draw(canvas, x, 110, kernelOffset, MCIF::kClampToBlack_TileMode, true, &rect);
- this->draw(canvas, x, 210, kernelOffset, MCIF::kRepeat_TileMode, true, &rect);
+ this->draw(canvas, x, 10, kernelOffset, SkTileMode::kClamp, true, &rect);
+ this->draw(canvas, x, 110, kernelOffset, SkTileMode::kDecal, true, &rect);
+ this->draw(canvas, x, 210, kernelOffset, SkTileMode::kRepeat, true, &rect);
kernelOffset.fY++;
}
kernelOffset.fY = 1;
- SkImageFilter::CropRect smallRect(SkRect::MakeXYWH(10, 5, 60, 60));
- this->draw(canvas, 310, 10, kernelOffset, MCIF::kClamp_TileMode, true, &smallRect);
- this->draw(canvas, 310, 110, kernelOffset, MCIF::kClampToBlack_TileMode, true, &smallRect);
- this->draw(canvas, 310, 210, kernelOffset, MCIF::kRepeat_TileMode, true, &smallRect);
+ SkIRect smallRect = SkIRect::MakeXYWH(10, 5, 60, 60);
+ this->draw(canvas, 310, 10, kernelOffset, SkTileMode::kClamp, true, &smallRect);
+ this->draw(canvas, 310, 110, kernelOffset, SkTileMode::kDecal, true, &smallRect);
+ this->draw(canvas, 310, 210, kernelOffset, SkTileMode::kRepeat, true, &smallRect);
- this->draw(canvas, 410, 10, kernelOffset, MCIF::kClamp_TileMode, false, &rect);
- this->draw(canvas, 410, 110, kernelOffset, MCIF::kClampToBlack_TileMode, false, &rect);
- this->draw(canvas, 410, 210, kernelOffset, MCIF::kRepeat_TileMode, false, &rect);
+ this->draw(canvas, 410, 10, kernelOffset, SkTileMode::kClamp, false, &rect);
+ this->draw(canvas, 410, 110, kernelOffset, SkTileMode::kDecal, false, &rect);
+ this->draw(canvas, 410, 210, kernelOffset, SkTileMode::kRepeat, false, &rect);
}
private:
diff --git a/gm/morphology.cpp b/gm/morphology.cpp
index ef2174e..eb937b6 100644
--- a/gm/morphology.cpp
+++ b/gm/morphology.cpp
@@ -17,7 +17,7 @@
#include "include/core/SkString.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkMorphologyImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#define WIDTH 700
@@ -73,21 +73,17 @@
{ 24, 24, 25, 25 },
};
SkPaint paint;
- SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(25, 20, 100, 80));
+ SkIRect cropRect = SkIRect::MakeXYWH(25, 20, 100, 80);
for (unsigned j = 0; j < 4; ++j) {
for (unsigned i = 0; i < SK_ARRAY_COUNT(samples); ++i) {
- const SkImageFilter::CropRect* cr = j & 0x02 ? &cropRect : nullptr;
+ const SkIRect* cr = j & 0x02 ? &cropRect : nullptr;
if (j & 0x01) {
- paint.setImageFilter(SkErodeImageFilter::Make(samples[i].fRadiusX,
- samples[i].fRadiusY,
- nullptr,
- cr));
+ paint.setImageFilter(SkImageFilters::Erode(
+ samples[i].fRadiusX, samples[i].fRadiusY, nullptr, cr));
} else {
- paint.setImageFilter(SkDilateImageFilter::Make(samples[i].fRadiusX,
- samples[i].fRadiusY,
- nullptr,
- cr));
+ paint.setImageFilter(SkImageFilters::Erode(
+ samples[i].fRadiusX, samples[i].fRadiusY, nullptr, cr));
}
this->drawClippedBitmap(canvas, paint, i * 140, j * 140);
}
diff --git a/gm/offsetimagefilter.cpp b/gm/offsetimagefilter.cpp
index 38ae539..7a006cc 100644
--- a/gm/offsetimagefilter.cpp
+++ b/gm/offsetimagefilter.cpp
@@ -18,8 +18,7 @@
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkOffsetImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "src/core/SkImageFilter_Base.h"
#include "tools/ToolUtils.h"
@@ -62,18 +61,16 @@
i * 8,
image->width() - i * 8,
image->height() - i * 12);
- SkImageFilter::CropRect rect(SkRect::Make(cropRect));
- sk_sp<SkImageFilter> tileInput(SkImageSource::Make(image));
+ sk_sp<SkImageFilter> tileInput(SkImageFilters::Image(image));
SkScalar dx = SkIntToScalar(i*5);
SkScalar dy = SkIntToScalar(i*10);
- paint.setImageFilter(SkOffsetImageFilter::Make(dx, dy, std::move(tileInput), &rect));
+ paint.setImageFilter(SkImageFilters::Offset(dx, dy, std::move(tileInput), &cropRect));
DrawClippedImage(canvas, image.get(), paint, 1, cropRect);
canvas->translate(SkIntToScalar(image->width() + MARGIN), 0);
}
SkIRect cropRect = SkIRect::MakeXYWH(0, 0, 100, 100);
- SkImageFilter::CropRect rect(SkRect::Make(cropRect));
- paint.setImageFilter(SkOffsetImageFilter::Make(-5, -10, nullptr, &rect));
+ paint.setImageFilter(SkImageFilters::Offset(-5, -10, nullptr, &cropRect));
DrawClippedImage(canvas, fBitmap.get(), paint, 2, cropRect);
}
private:
@@ -158,11 +155,11 @@
}
void onDraw(SkCanvas* canvas) override {
- const SkRect r = SkRect::MakeWH(40, 40);
- SkImageFilter::CropRect cr0(r);
- SkImageFilter::CropRect cr1(SkRect::MakeWH(20, 20));
- const SkRect r2 = SkRect::MakeXYWH(40, 0, 40, 40);
- SkImageFilter::CropRect cr2(r2);
+ SkIRect cr0 = SkIRect::MakeWH(40, 40);
+ SkIRect cr1 = SkIRect::MakeWH(20, 20);
+ SkIRect cr2 = SkIRect::MakeXYWH(40, 0, 40, 40);
+ const SkRect r = SkRect::Make(cr0);
+ const SkRect r2 = SkRect::Make(cr2);
canvas->translate(40, 40);
@@ -170,20 +167,20 @@
this->doDraw(canvas, r, nullptr);
canvas->translate(100, 0);
- this->doDraw(canvas, r, SkOffsetImageFilter::Make(20, 20, nullptr));
+ this->doDraw(canvas, r, SkImageFilters::Offset(20, 20, nullptr));
canvas->translate(100, 0);
- this->doDraw(canvas, r, SkOffsetImageFilter::Make(20, 20, nullptr, &cr0));
+ this->doDraw(canvas, r, SkImageFilters::Offset(20, 20, nullptr, &cr0));
canvas->translate(100, 0);
- this->doDraw(canvas, r, SkOffsetImageFilter::Make(20, 20, nullptr), &r);
+ this->doDraw(canvas, r, SkImageFilters::Offset(20, 20, nullptr), &r);
canvas->translate(100, 0);
- this->doDraw(canvas, r, SkOffsetImageFilter::Make(20, 20, nullptr, &cr1));
+ this->doDraw(canvas, r, SkImageFilters::Offset(20, 20, nullptr, &cr1));
SkRect clipR = SkRect::MakeXYWH(40, 40, 40, 40);
canvas->translate(100, 0);
- this->doDraw(canvas, r, SkOffsetImageFilter::Make(20, 20, nullptr, nullptr), &clipR);
+ this->doDraw(canvas, r, SkImageFilters::Offset(20, 20, nullptr, nullptr), &clipR);
canvas->restore();
// 2nd row
@@ -194,19 +191,19 @@
*/
// crop==clip==src
- this->doDraw(canvas, r, SkOffsetImageFilter::Make(40, 0, nullptr, &cr0), &r);
+ this->doDraw(canvas, r, SkImageFilters::Offset(40, 0, nullptr, &cr0), &r);
// crop==src, clip==dst
canvas->translate(100, 0);
- this->doDraw(canvas, r, SkOffsetImageFilter::Make(40, 0, nullptr, &cr0), &r2);
+ this->doDraw(canvas, r, SkImageFilters::Offset(40, 0, nullptr, &cr0), &r2);
// crop==dst, clip==src
canvas->translate(100, 0);
- this->doDraw(canvas, r, SkOffsetImageFilter::Make(40, 0, nullptr, &cr2), &r);
+ this->doDraw(canvas, r, SkImageFilters::Offset(40, 0, nullptr, &cr2), &r);
// crop==clip==dst
canvas->translate(100, 0);
- this->doDraw(canvas, r, SkOffsetImageFilter::Make(40, 0, nullptr, &cr2), &r2);
+ this->doDraw(canvas, r, SkImageFilters::Offset(40, 0, nullptr, &cr2), &r2);
}
private:
diff --git a/gm/pictureimagefilter.cpp b/gm/pictureimagefilter.cpp
index 38b5893..b7be53e 100644
--- a/gm/pictureimagefilter.cpp
+++ b/gm/pictureimagefilter.cpp
@@ -22,8 +22,7 @@
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTypeface.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkPictureImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
// This GM exercises the SkPictureImageFilter ImageFilter class.
@@ -83,7 +82,7 @@
SkISize dim = { SkScalarRoundToInt(r.width()), SkScalarRoundToInt(r.height()) };
auto img = SkImage::MakeFromPicture(pic, dim, nullptr, nullptr,
SkImage::BitDepth::kU8, SkColorSpace::MakeSRGB());
- return SkImageSource::Make(img, r, r, fq);
+ return SkImageFilters::Image(img, r, r, fq);
}
sk_sp<SkImageFilter> make(SkFilterQuality fq) {
return make(fPicture, fPicture->cullRect(), fq);
@@ -95,11 +94,10 @@
SkRect srcRect = SkRect::MakeXYWH(20, 20, 30, 30);
SkRect emptyRect = SkRect::MakeXYWH(20, 20, 0, 0);
SkRect bounds = SkRect::MakeXYWH(0, 0, 100, 100);
- sk_sp<SkImageFilter> pictureSource(SkPictureImageFilter::Make(fPicture));
- sk_sp<SkImageFilter> pictureSourceSrcRect(SkPictureImageFilter::Make(fPicture,
- srcRect));
- sk_sp<SkImageFilter> pictureSourceEmptyRect(SkPictureImageFilter::Make(fPicture,
- emptyRect));
+ sk_sp<SkImageFilter> pictureSource(SkImageFilters::Picture(fPicture));
+ sk_sp<SkImageFilter> pictureSourceSrcRect(SkImageFilters::Picture(fPicture, srcRect));
+ sk_sp<SkImageFilter> pictureSourceEmptyRect(SkImageFilters::Picture(fPicture,
+ emptyRect));
sk_sp<SkImageFilter> pictureSourceResampled = make(kLow_SkFilterQuality);
sk_sp<SkImageFilter> pictureSourcePixelated = make(kNone_SkFilterQuality);
diff --git a/gm/recordopts.cpp b/gm/recordopts.cpp
index 83e30cf..3d0bd16 100644
--- a/gm/recordopts.cpp
+++ b/gm/recordopts.cpp
@@ -18,8 +18,7 @@
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkColorFilterImageFilter.h"
-#include "include/effects/SkPictureImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/effects/SkTableColorFilter.h"
#include "include/gpu/GrContext.h"
@@ -49,8 +48,8 @@
// This detector detects that image filter phase of the pixel pipeline receives the correct value.
static void install_detector_image_filter(SkPaint* drawPaint) {
- drawPaint->setImageFilter(SkColorFilterImageFilter::Make(make_detector_color_filter(),
- drawPaint->refImageFilter()));
+ drawPaint->setImageFilter(SkImageFilters::ColorFilter(
+ make_detector_color_filter(), drawPaint->refImageFilter()));
}
static void no_detector_install(SkPaint*) {
@@ -124,7 +123,7 @@
canvas->save();
canvas->clipRect(targetRect);
SkPaint drawPaint;
- drawPaint.setImageFilter(SkPictureImageFilter::Make(shape));
+ drawPaint.setImageFilter(SkImageFilters::Picture(shape));
installDetector(&drawPaint);
canvas->saveLayer(&targetRect, &drawPaint);
canvas->restore();
diff --git a/gm/resizeimagefilter.cpp b/gm/resizeimagefilter.cpp
index db40866..af278b0 100644
--- a/gm/resizeimagefilter.cpp
+++ b/gm/resizeimagefilter.cpp
@@ -19,7 +19,7 @@
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
-#include "include/effects/SkImageSource.h"
+#include "include/effects/SkImageFilters.h"
#include <utility>
@@ -51,7 +51,7 @@
canvas->translate(-rect.x(), -rect.y());
SkMatrix matrix;
matrix.setScale(SkScalarInvert(deviceScaleX), SkScalarInvert(deviceScaleY));
- sk_sp<SkImageFilter> filter(SkImageFilter::MakeMatrixFilter(matrix,
+ sk_sp<SkImageFilter> filter(SkImageFilters::MatrixTransform(matrix,
filterQuality,
std::move(input)));
SkPaint filteredPaint;
@@ -102,7 +102,7 @@
SkRect inRect = SkRect::MakeXYWH(-4, -4, 20, 20);
SkRect outRect = SkRect::MakeXYWH(-24, -24, 120, 120);
sk_sp<SkImageFilter> source(
- SkImageSource::Make(std::move(image), inRect, outRect, kHigh_SkFilterQuality));
+ SkImageFilters::Image(std::move(image), inRect, outRect, kHigh_SkFilterQuality));
canvas->translate(srcRect.width() + SkIntToScalar(10), 0);
this->draw(canvas, srcRect, deviceSize, kHigh_SkFilterQuality, std::move(source));
}
diff --git a/gm/savelayer.cpp b/gm/savelayer.cpp
index c948ca9..a0f966c 100644
--- a/gm/savelayer.cpp
+++ b/gm/savelayer.cpp
@@ -31,8 +31,8 @@
#include "include/core/SkTileMode.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
#include "include/effects/SkGradientShader.h"
+#include "include/effects/SkImageFilters.h"
#include "include/effects/SkShaderMaskFilter.h"
#include "include/utils/SkRandom.h"
#include "src/core/SkCanvasPriv.h"
@@ -219,7 +219,7 @@
static const PaintMakerFunc kPaintMakers[] = {
[]() -> SkPaint { return SkPaint(); },
[]() -> SkPaint {
- SkPaint p; p.setImageFilter(SkBlurImageFilter::Make(2, 2, nullptr)); return p;
+ SkPaint p; p.setImageFilter(SkImageFilters::Blur(2, 2, nullptr)); return p;
},
[]() -> SkPaint { SkPaint p; p.setBlendMode(SkBlendMode::kSrcOut); return p; },
};
diff --git a/gm/shadermaskfilter.cpp b/gm/shadermaskfilter.cpp
index 7ef23a4..a4e54c6 100644
--- a/gm/shadermaskfilter.cpp
+++ b/gm/shadermaskfilter.cpp
@@ -30,8 +30,8 @@
#include "include/core/SkSurface.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkBlurImageFilter.h"
#include "include/effects/SkGradientShader.h"
+#include "include/effects/SkImageFilters.h"
#include "include/effects/SkShaderMaskFilter.h"
#include "include/utils/SkTextUtils.h"
#include "src/core/SkBlendModePriv.h"
@@ -222,7 +222,7 @@
// Important that we test with and without an imagefilter attached to the layer,
// as cpu and gpu backends treat these differently (w/ or w/o a SkSpecialImage)
- const sk_sp<SkImageFilter> imfs[] = {nullptr, SkBlurImageFilter::Make(3.5f, 3.5f, nullptr)};
+ const sk_sp<SkImageFilter> imfs[] = {nullptr, SkImageFilters::Blur(3.5f, 3.5f, nullptr)};
for (auto& mf : mfs) {
SkPaint layerPaint;
diff --git a/gm/simple_magnification.cpp b/gm/simple_magnification.cpp
index 3c0a636..45f9b57 100644
--- a/gm/simple_magnification.cpp
+++ b/gm/simple_magnification.cpp
@@ -21,8 +21,7 @@
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkMagnifierImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "include/gpu/GrTypes.h"
#include <utility>
@@ -98,10 +97,10 @@
}
void draw(SkCanvas* canvas, sk_sp<SkImage> image, const SkIPoint& offset, int inset) {
- sk_sp<SkImageFilter> imgSrc(SkImageSource::Make(std::move(image)));
+ sk_sp<SkImageFilter> imgSrc(SkImageFilters::Image(std::move(image)));
SkRect srcRect = SkRect::MakeXYWH(1.0f, 1.0f, 2.0f, 2.0f);
- sk_sp<SkImageFilter> magFilter(SkMagnifierImageFilter::Make(srcRect, inset, imgSrc));
+ sk_sp<SkImageFilter> magFilter(SkImageFilters::Magnifier(srcRect, inset, imgSrc));
SkPaint paint;
paint.setImageFilter(std::move(magFilter));
diff --git a/gm/spritebitmap.cpp b/gm/spritebitmap.cpp
index 1a137c0..8d76843 100644
--- a/gm/spritebitmap.cpp
+++ b/gm/spritebitmap.cpp
@@ -16,7 +16,7 @@
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
-#include "include/effects/SkBlurImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include <utility>
@@ -81,7 +81,7 @@
int dy = 10;
SkScalar sigma = 8;
- sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(sigma, sigma, nullptr));
+ sk_sp<SkImageFilter> filter(SkImageFilters::Blur(sigma, sigma, nullptr));
draw_1_bitmap(canvas, bm, false, dx, dy, nullptr);
dy += bm.height() + 20;
diff --git a/gm/tablecolorfilter.cpp b/gm/tablecolorfilter.cpp
index 4e23a61..b4bbd12 100644
--- a/gm/tablecolorfilter.cpp
+++ b/gm/tablecolorfilter.cpp
@@ -22,8 +22,8 @@
#include "include/core/SkString.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkColorFilterImageFilter.h"
#include "include/effects/SkGradientShader.h"
+#include "include/effects/SkImageFilters.h"
#include "include/effects/SkTableColorFilter.h"
#include <math.h>
@@ -182,8 +182,8 @@
for (unsigned i = 0; i < SK_ARRAY_COUNT(gColorFilterMakers); ++i) {
sk_sp<SkColorFilter> colorFilter1(gColorFilterMakers[i]());
- sk_sp<SkImageFilter> imageFilter1(SkColorFilterImageFilter::Make(
- std::move(colorFilter1), nullptr));
+ sk_sp<SkImageFilter> imageFilter1(SkImageFilters::ColorFilter(
+ std::move(colorFilter1), nullptr));
// Move down to the next line and draw it
// each draw being at xOffset of the previous one
@@ -191,8 +191,8 @@
x = 0;
for (unsigned j = 1; j < SK_ARRAY_COUNT(gColorFilterMakers); ++j) {
sk_sp<SkColorFilter> colorFilter2(gColorFilterMakers[j]());
- sk_sp<SkImageFilter> imageFilter2(SkColorFilterImageFilter::Make(
- std::move(colorFilter2), imageFilter1, nullptr));
+ sk_sp<SkImageFilter> imageFilter2(SkImageFilters::ColorFilter(
+ std::move(colorFilter2), imageFilter1, nullptr));
paint.setImageFilter(std::move(imageFilter2));
canvas->drawBitmap(bm, x, y, &paint);
x += xOffset;
diff --git a/gm/tileimagefilter.cpp b/gm/tileimagefilter.cpp
index bde34e0..f598b8a 100644
--- a/gm/tileimagefilter.cpp
+++ b/gm/tileimagefilter.cpp
@@ -19,9 +19,7 @@
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
-#include "include/effects/SkColorFilterImageFilter.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkTileImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include <stddef.h>
@@ -78,10 +76,9 @@
SkIntToScalar(i * 4),
SkIntToScalar(image->width() - i * 12),
SkIntToScalar(image->height()) - i * 12);
- sk_sp<SkImageFilter> tileInput(SkImageSource::Make(image));
- sk_sp<SkImageFilter> filter(SkTileImageFilter::Make(srcRect,
- dstRect,
- std::move(tileInput)));
+ sk_sp<SkImageFilter> tileInput(SkImageFilters::Image(image));
+ sk_sp<SkImageFilter> filter(SkImageFilters::Tile(srcRect, dstRect,
+ std::move(tileInput)));
canvas->save();
canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
SkPaint paint;
@@ -108,11 +105,11 @@
SkIntToScalar(fBitmap->height()));
SkRect dstRect = SkRect::MakeWH(SkIntToScalar(fBitmap->width() * 2),
SkIntToScalar(fBitmap->height() * 2));
- sk_sp<SkImageFilter> tile(SkTileImageFilter::Make(srcRect, dstRect, nullptr));
+ sk_sp<SkImageFilter> tile(SkImageFilters::Tile(srcRect, dstRect, nullptr));
sk_sp<SkColorFilter> cf(SkColorFilters::Matrix(matrix));
SkPaint paint;
- paint.setImageFilter(SkColorFilterImageFilter::Make(std::move(cf), std::move(tile)));
+ paint.setImageFilter(SkImageFilters::ColorFilter(std::move(cf), std::move(tile)));
canvas->save();
canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
canvas->clipRect(dstRect);
@@ -130,14 +127,14 @@
SkRect srcRect = SkRect::MakeXYWH(0, 0, 50, 50);
SkRect dstRect = SkRect::MakeXYWH(0, 0, 100, 100);
- SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(5, 5, 40, 40));
+ SkIRect cropRect = SkIRect::MakeXYWH(5, 5, 40, 40);
sk_sp<SkColorFilter> greenCF = SkColorFilters::Blend(SK_ColorGREEN, SkBlendMode::kSrc);
- sk_sp<SkImageFilter> green(SkColorFilterImageFilter::Make(std::move(greenCF),
+ sk_sp<SkImageFilter> green(SkImageFilters::ColorFilter(std::move(greenCF),
nullptr,
&cropRect));
SkPaint paint;
paint.setColor(SK_ColorRED);
- paint.setImageFilter(SkTileImageFilter::Make(srcRect, dstRect, std::move(green)));
+ paint.setImageFilter(SkImageFilters::Tile(srcRect, dstRect, std::move(green)));
canvas->drawRect(dstRect, paint);
}
}
diff --git a/gm/xfermodeimagefilter.cpp b/gm/xfermodeimagefilter.cpp
index c2292d6..155d6a6 100644
--- a/gm/xfermodeimagefilter.cpp
+++ b/gm/xfermodeimagefilter.cpp
@@ -19,10 +19,7 @@
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
-#include "include/effects/SkArithmeticImageFilter.h"
-#include "include/effects/SkImageSource.h"
-#include "include/effects/SkOffsetImageFilter.h"
-#include "include/effects/SkXfermodeImageFilter.h"
+#include "include/effects/SkImageFilters.h"
#include "tools/ToolUtils.h"
#include <utility>
@@ -93,9 +90,9 @@
};
int x = 0, y = 0;
- sk_sp<SkImageFilter> background(SkImageSource::Make(fCheckerboard));
+ sk_sp<SkImageFilter> background(SkImageFilters::Image(fCheckerboard));
for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
- paint.setImageFilter(SkXfermodeImageFilter::Make(gModes[i], background));
+ paint.setImageFilter(SkImageFilters::Xfermode(gModes[i], background));
DrawClippedBitmap(canvas, fBitmap, paint, x, y);
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
@@ -104,8 +101,7 @@
}
}
// Test arithmetic mode as image filter
- paint.setImageFilter(SkArithmeticImageFilter::Make(0, 1, 1, 0, true, background,
- nullptr, nullptr));
+ paint.setImageFilter(SkImageFilters::Arithmetic(0, 1, 1, 0, true, background, nullptr));
DrawClippedBitmap(canvas, fBitmap, paint, x, y);
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
@@ -113,7 +109,7 @@
y += fBitmap.height() + MARGIN;
}
// Test nullptr mode
- paint.setImageFilter(SkXfermodeImageFilter::Make(SkBlendMode::kSrcOver, background));
+ paint.setImageFilter(SkImageFilters::Xfermode(SkBlendMode::kSrcOver, background));
DrawClippedBitmap(canvas, fBitmap, paint, x, y);
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
@@ -124,17 +120,11 @@
SkIntToScalar(fBitmap.height() + 4));
// Test offsets on SrcMode (uses fixed-function blend)
sk_sp<SkImage> bitmapImage(SkImage::MakeFromBitmap(fBitmap));
- sk_sp<SkImageFilter> foreground(SkImageSource::Make(std::move(bitmapImage)));
- sk_sp<SkImageFilter> offsetForeground(SkOffsetImageFilter::Make(SkIntToScalar(4),
- SkIntToScalar(-4),
- foreground));
- sk_sp<SkImageFilter> offsetBackground(SkOffsetImageFilter::Make(SkIntToScalar(4),
- SkIntToScalar(4),
- background));
- paint.setImageFilter(SkXfermodeImageFilter::Make(SkBlendMode::kSrcOver,
- offsetBackground,
- offsetForeground,
- nullptr));
+ sk_sp<SkImageFilter> foreground(SkImageFilters::Image(std::move(bitmapImage)));
+ sk_sp<SkImageFilter> offsetForeground(SkImageFilters::Offset(4, -4, foreground));
+ sk_sp<SkImageFilter> offsetBackground(SkImageFilters::Offset(4, 4, background));
+ paint.setImageFilter(SkImageFilters::Xfermode(
+ SkBlendMode::kSrcOver, offsetBackground, offsetForeground));
DrawClippedPaint(canvas, clipRect, paint, x, y);
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
@@ -142,10 +132,8 @@
y += fBitmap.height() + MARGIN;
}
// Test offsets on Darken (uses shader blend)
- paint.setImageFilter(SkXfermodeImageFilter::Make(SkBlendMode::kDarken,
- offsetBackground,
- offsetForeground,
- nullptr));
+ paint.setImageFilter(SkImageFilters::Xfermode(
+ SkBlendMode::kDarken, offsetBackground, offsetForeground));
DrawClippedPaint(canvas, clipRect, paint, x, y);
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
@@ -165,11 +153,8 @@
offsets[i][1],
fBitmap.width() + offsets[i][2],
fBitmap.height() + offsets[i][3]);
- SkImageFilter::CropRect rect(SkRect::Make(cropRect));
- paint.setImageFilter(SkXfermodeImageFilter::Make(sampledModes[i],
- offsetBackground,
- offsetForeground,
- &rect));
+ paint.setImageFilter(SkImageFilters::Xfermode(sampledModes[i], offsetBackground,
+ offsetForeground, &cropRect));
DrawClippedPaint(canvas, clipRect, paint, x, y);
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
@@ -178,10 +163,10 @@
}
}
// Test small bg, large fg with Screen (uses shader blend)
- SkBlendMode mode = SkBlendMode::kScreen;
- SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(10, 10, 60, 60));
- sk_sp<SkImageFilter> cropped(SkOffsetImageFilter::Make(0, 0, foreground, &cropRect));
- paint.setImageFilter(SkXfermodeImageFilter::Make(mode, cropped, background, nullptr));
+ SkIRect cropRect = SkIRect::MakeXYWH(10, 10, 60, 60);
+ sk_sp<SkImageFilter> cropped(SkImageFilters::Offset(0, 0, foreground, &cropRect));
+ paint.setImageFilter(SkImageFilters::Xfermode(SkBlendMode::kScreen, cropped, background,
+ nullptr));
DrawClippedPaint(canvas, clipRect, paint, x, y);
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
@@ -189,7 +174,8 @@
y += fBitmap.height() + MARGIN;
}
// Test small fg, large bg with Screen (uses shader blend)
- paint.setImageFilter(SkXfermodeImageFilter::Make(mode, background, cropped, nullptr));
+ paint.setImageFilter(SkImageFilters::Xfermode(SkBlendMode::kScreen, background, cropped,
+ nullptr));
DrawClippedPaint(canvas, clipRect, paint, x, y);
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {
@@ -199,10 +185,9 @@
// Test small fg, large bg with SrcIn with a crop that forces it to full size.
// This tests that SkXfermodeImageFilter correctly applies the compositing mode to
// the region outside the foreground.
- mode = SkBlendMode::kSrcIn;
- SkImageFilter::CropRect cropRectFull(SkRect::MakeXYWH(0, 0, 80, 80));
- paint.setImageFilter(SkXfermodeImageFilter::Make(mode, background,
- cropped, &cropRectFull));
+ SkIRect cropRectFull = SkIRect::MakeXYWH(0, 0, 80, 80);
+ paint.setImageFilter(SkImageFilters::Xfermode(SkBlendMode::kSrcIn, background, cropped,
+ &cropRectFull));
DrawClippedPaint(canvas, clipRect, paint, x, y);
x += fBitmap.width() + MARGIN;
if (x + fBitmap.width() > WIDTH) {