virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
- paint.setImageFilter(new SkBlurImageFilter(fSigmaX, fSigmaY))->unref();
+ paint.setImageFilter(SkBlurImageFilter::Create(fSigmaX, fSigmaY))->unref();
for (int i = 0; i < loops; i++) {
canvas->drawBitmap(fCheckerboard, 0, 0, &paint);
virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
- SkAutoTUnref<SkImageFilter> displ(SkNEW_ARGS(SkBitmapSource, (fCheckerboard)));
+ SkAutoTUnref<SkImageFilter> displ(SkBitmapSource::Create(fCheckerboard));
// No displacement effect
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType, 0.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kG_ChannelSelectorType, 0.0f, displ))->unref();
for (int i = 0; i < loops; i++) {
this->drawClippedBitmap(canvas, 0, 0, paint);
virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
- SkAutoTUnref<SkImageFilter> displ(SkNEW_ARGS(SkBitmapSource, (fCheckerboard)));
+ SkAutoTUnref<SkImageFilter> displ(SkBitmapSource::Create(fCheckerboard));
// Displacement, with 1 alpha component (which isn't pre-multiplied)
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kB_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 16.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType, 16.0f, displ))->unref();
for (int i = 0; i < loops; i++) {
drawClippedBitmap(canvas, 100, 0, paint);
}
virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
- SkAutoTUnref<SkImageFilter> displ(SkNEW_ARGS(SkBitmapSource, (fCheckerboard)));
+ SkAutoTUnref<SkImageFilter> displ(SkBitmapSource::Create(fCheckerboard));
// Displacement, with 2 non-alpha components
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType, 32.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kB_ChannelSelectorType, 32.0f, displ))->unref();
for (int i = 0; i < loops; ++i) {
this->drawClippedBitmap(canvas, 200, 0, paint);
}
const int h = fIsSmall ? FILTER_HEIGHT_SMALL : FILTER_HEIGHT_LARGE;
SkPaint paint;
paint.setImageFilter(
- new SkMagnifierImageFilter(
+ SkMagnifierImageFilter::Create(
SkRect::MakeXYWH(SkIntToScalar(w / 4),
SkIntToScalar(h / 4),
SkIntToScalar(w / 2),
};
SkScalar gain = 0.3f, bias = SkIntToScalar(100);
SkIPoint target = SkIPoint::Make(1, 1);
- fFilter = new SkMatrixConvolutionImageFilter(kernelSize, kernel, gain, bias, target, tileMode, convolveAlpha);
+ fFilter = SkMatrixConvolutionImageFilter::Create(kernelSize, kernel, gain, bias, target, tileMode, convolveAlpha);
}
~MatrixConvolutionBench() {
private:
SkImageFilter* mergeBitmaps() {
- SkImageFilter* first = new SkBitmapSource(fCheckerboard);
- SkImageFilter* second = new SkBitmapSource(fBitmap);
+ SkImageFilter* first = SkBitmapSource::Create(fCheckerboard);
+ SkImageFilter* second = SkBitmapSource::Create(fBitmap);
SkAutoUnref aur0(first);
SkAutoUnref aur1(second);
- return new SkMergeImageFilter(first, second);
+ return SkMergeImageFilter::Create(first, second);
}
void make_bitmap() {
SkMorphologyImageFilter* mf = NULL;
switch (fStyle) {
case kDilate_MT:
- mf = new SkDilateImageFilter(SkScalarFloorToInt(fRadius),
- SkScalarFloorToInt(fRadius));
+ mf = SkDilateImageFilter::Create(SkScalarFloorToInt(fRadius),
+ SkScalarFloorToInt(fRadius));
break;
case kErode_MT:
- mf = new SkErodeImageFilter(SkScalarFloorToInt(fRadius),
- SkScalarFloorToInt(fRadius));
+ mf = SkErodeImageFilter::Create(SkScalarFloorToInt(fRadius),
+ SkScalarFloorToInt(fRadius));
break;
}
paint.setImageFilter(mf)->unref();
SkRect clipRect = SkRect::MakeXYWH(0, 0, 100, 100);
SkRect bounds;
fBitmap.getBounds(&bounds);
- SkAutoTUnref<SkImageFilter> bitmapSource(new SkBitmapSource(fBitmap));
- SkAutoTUnref<SkImageFilter> bitmapSourceSrcRect(new SkBitmapSource(fBitmap, srcRect, srcRect));
- SkAutoTUnref<SkImageFilter> bitmapSourceSrcRectDstRect(new SkBitmapSource(fBitmap, srcRect, dstRect));
- SkAutoTUnref<SkImageFilter> bitmapSourceDstRectOnly(new SkBitmapSource(fBitmap, bounds, dstRect));
+ SkAutoTUnref<SkImageFilter> bitmapSource(SkBitmapSource::Create(fBitmap));
+ SkAutoTUnref<SkImageFilter> bitmapSourceSrcRect(SkBitmapSource::Create(fBitmap, srcRect, srcRect));
+ SkAutoTUnref<SkImageFilter> bitmapSourceSrcRectDstRect(SkBitmapSource::Create(fBitmap, srcRect, dstRect));
+ SkAutoTUnref<SkImageFilter> bitmapSourceDstRectOnly(SkBitmapSource::Create(fBitmap, bounds, dstRect));
// Draw an unscaled bitmap.
fillRectFiltered(canvas, clipRect, bitmapSource);
#define MARGIN SkIntToScalar(10)
static SkImageFilter* make_blur(float amount, SkImageFilter* input = NULL) {
- return new SkBlurImageFilter(amount, amount, input);
+ return SkBlurImageFilter::Create(amount, amount, input);
}
static SkImageFilter* make_brightness(float amount, SkImageFilter* input = NULL) {
}
canvas->clear(0x00000000);
SkPaint paint;
- SkAutoTUnref<SkImageFilter> displ(SkNEW_ARGS(SkBitmapSource, (fCheckerboard)));
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType, 0.0f, displ)))->unref();
+ SkAutoTUnref<SkImageFilter> displ(SkBitmapSource::Create(fCheckerboard));
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kG_ChannelSelectorType, 0.0f, displ))->unref();
drawClippedBitmap(canvas, 0, 0, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kB_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 16.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType, 16.0f, displ))->unref();
drawClippedBitmap(canvas, 100, 0, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType, 32.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kB_ChannelSelectorType, 32.0f, displ))->unref();
drawClippedBitmap(canvas, 200, 0, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 48.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kG_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType, 48.0f, displ))->unref();
drawClippedBitmap(canvas, 300, 0, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 64.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType, 64.0f, displ))->unref();
drawClippedBitmap(canvas, 400, 0, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType, 40.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kG_ChannelSelectorType, 40.0f, displ))->unref();
drawClippedBitmap(canvas, 0, 100, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kB_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 40.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType, 40.0f, displ))->unref();
drawClippedBitmap(canvas, 100, 100, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType, 40.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kB_ChannelSelectorType, 40.0f, displ))->unref();
drawClippedBitmap(canvas, 200, 100, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 40.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kG_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType, 40.0f, displ))->unref();
drawClippedBitmap(canvas, 300, 100, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType, 40.0f, displ)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType, 40.0f, displ))->unref();
drawClippedBitmap(canvas, 400, 100, paint);
SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(30, 30, 40, 40));
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- 0.0f, displ, NULL, &cropRect)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kG_ChannelSelectorType,
+ 0.0f, displ, NULL, &cropRect))->unref();
drawClippedBitmap(canvas, 0, 200, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kB_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 16.0f, displ, NULL, &cropRect)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType,
+ 16.0f, displ, NULL, &cropRect))->unref();
drawClippedBitmap(canvas, 100, 200, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- 32.0f, displ, NULL, &cropRect)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ 32.0f, displ, NULL, &cropRect))->unref();
drawClippedBitmap(canvas, 200, 200, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 48.0f, displ, NULL, &cropRect)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kG_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType,
+ 48.0f, displ, NULL, &cropRect))->unref();
drawClippedBitmap(canvas, 300, 200, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 64.0f, displ, NULL, &cropRect)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType,
+ 64.0f, displ, NULL, &cropRect))->unref();
drawClippedBitmap(canvas, 400, 200, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- 40.0f, displ, NULL, &cropRect)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kG_ChannelSelectorType,
+ 40.0f, displ, NULL, &cropRect))->unref();
drawClippedBitmap(canvas, 0, 300, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kB_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, displ, NULL, &cropRect)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType,
+ 40.0f, displ, NULL, &cropRect))->unref();
drawClippedBitmap(canvas, 100, 300, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- 40.0f, displ, NULL, &cropRect)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ 40.0f, displ, NULL, &cropRect))->unref();
drawClippedBitmap(canvas, 200, 300, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, displ, NULL, &cropRect)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kG_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType,
+ 40.0f, displ, NULL, &cropRect))->unref();
drawClippedBitmap(canvas, 300, 300, paint);
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, displ, NULL, &cropRect)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType,
+ 40.0f, displ, NULL, &cropRect))->unref();
drawClippedBitmap(canvas, 400, 300, paint);
// Tests for images of different sizes
- displ.reset(SkNEW_ARGS(SkBitmapSource, (fSmall)));
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kG_ChannelSelectorType,
- 40.0f, displ)))->unref();
+ displ.reset(SkBitmapSource::Create(fSmall));
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kG_ChannelSelectorType,
+ 40.0f, displ))->unref();
drawClippedBitmap(canvas, 0, 400, paint);
- displ.reset(SkNEW_ARGS(SkBitmapSource, (fLarge)));
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kB_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, displ)))->unref();
+ displ.reset(SkBitmapSource::Create(fLarge));
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType,
+ 40.0f, displ))->unref();
drawClippedBitmap(canvas, 100, 400, paint);
- displ.reset(SkNEW_ARGS(SkBitmapSource, (fLargeW)));
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- 40.0f, displ)))->unref();
+ displ.reset(SkBitmapSource::Create(fLargeW));
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ 40.0f, displ))->unref();
drawClippedBitmap(canvas, 200, 400, paint);
- displ.reset(SkNEW_ARGS(SkBitmapSource, (fLargeH)));
- paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, displ)))->unref();
+ displ.reset(SkBitmapSource::Create(fLargeH));
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kG_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType,
+ 40.0f, displ))->unref();
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(SkNEW_ARGS(SkDisplacementMapEffect,
- (SkDisplacementMapEffect::kG_ChannelSelectorType,
- SkDisplacementMapEffect::kA_ChannelSelectorType,
- 40.0f, NULL)))->unref();
+ paint.setImageFilter(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kG_ChannelSelectorType,
+ SkDisplacementMapEffect::kA_ChannelSelectorType,
+ 40.0f, NULL))->unref();
drawClippedBitmap(canvas, 400, 400, paint);
}
SkImageFilter* filters[] = {
NULL,
- new SkDropShadowImageFilter(7.0f, 0.0f, 0.0f, 3.0f, SK_ColorBLUE),
- new SkDropShadowImageFilter(0.0f, 7.0f, 3.0f, 0.0f, SK_ColorBLUE),
- new SkDropShadowImageFilter(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE),
- new SkDropShadowImageFilter(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, cfif),
- new SkDropShadowImageFilter(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, NULL, &cropRect),
- new SkDropShadowImageFilter(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, NULL, &bogusRect),
+ SkDropShadowImageFilter::Create(7.0f, 0.0f, 0.0f, 3.0f, SK_ColorBLUE),
+ SkDropShadowImageFilter::Create(0.0f, 7.0f, 3.0f, 0.0f, SK_ColorBLUE),
+ SkDropShadowImageFilter::Create(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE),
+ SkDropShadowImageFilter::Create(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, cfif),
+ SkDropShadowImageFilter::Create(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, NULL, &cropRect),
+ SkDropShadowImageFilter::Create(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE, NULL, &bogusRect),
};
SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
virtual void onDraw(SkCanvas* canvas) {
SkPaint paint;
- paint.setImageFilter(new SkBlurImageFilter(fSigmaX, fSigmaY))->unref();
+ paint.setImageFilter(SkBlurImageFilter::Create(fSigmaX, fSigmaY))->unref();
canvas->saveLayer(NULL, &paint);
const char* str = "The quick brown fox jumped over the lazy dog.";
virtual void onDraw(SkCanvas* canvas) {
SkPaint paint;
- paint.setImageFilter(new SkBlurImageFilter(fSigmaX, fSigmaY))->unref();
+ paint.setImageFilter(SkBlurImageFilter::Create(fSigmaX, fSigmaY))->unref();
const SkScalar tile_size = SkIntToScalar(128);
SkRect bounds;
canvas->getClipBounds(&bounds);
class FailImageFilter : public SkImageFilter {
public:
- FailImageFilter() : INHERITED(0) {}
+ static FailImageFilter* Create() {
+ return SkNEW(FailImageFilter);
+ }
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(FailImageFilter)
protected:
+ FailImageFilter() : INHERITED(0) {}
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) const {
return false;
class IdentityImageFilter : public SkImageFilter {
public:
- IdentityImageFilter() : INHERITED(0) {}
+ static IdentityImageFilter* Create() {
+ return SkNEW(IdentityImageFilter);
+ }
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(IdentityImageFilter)
protected:
+ IdentityImageFilter() : INHERITED(0) {}
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) const {
*result = src;
SkXfermode::kSrcIn_Mode);
SkImageFilter* filters[] = {
NULL,
- new IdentityImageFilter,
- new FailImageFilter,
+ IdentityImageFilter::Create(),
+ FailImageFilter::Create(),
SkColorFilterImageFilter::Create(cf),
- new SkBlurImageFilter(12.0f, 0.0f),
- new SkDropShadowImageFilter(10.0f, 5.0f, 3.0f, SK_ColorBLUE),
+ SkBlurImageFilter::Create(12.0f, 0.0f),
+ SkDropShadowImageFilter::Create(10.0f, 5.0f, 3.0f, SK_ColorBLUE),
};
cf->unref();
}
canvas->clear(0x00000000);
- SkAutoTUnref<SkImageFilter> gradient(new SkBitmapSource(fGradientCircle));
- SkAutoTUnref<SkImageFilter> checkerboard(new SkBitmapSource(fCheckerboard));
+ SkAutoTUnref<SkImageFilter> gradient(SkBitmapSource::Create(fGradientCircle));
+ SkAutoTUnref<SkImageFilter> checkerboard(SkBitmapSource::Create(fCheckerboard));
SkAutoTUnref<SkShader> noise(SkPerlinNoiseShader::CreateFractalNoise(
SkDoubleToScalar(0.1), SkDoubleToScalar(0.05), 1, 0));
SkImageFilter* filters[] = {
- new SkBlurImageFilter(SkIntToScalar(12), SkIntToScalar(12)),
- new SkDropShadowImageFilter(SkIntToScalar(10), SkIntToScalar(10), SkIntToScalar(3),
- SK_ColorGREEN),
- new SkDisplacementMapEffect(SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkIntToScalar(12),
- gradient.get(),
- checkerboard.get()),
- new SkDilateImageFilter(2, 2, checkerboard.get()),
- new SkErodeImageFilter(2, 2, checkerboard.get()),
- new SkOffsetImageFilter(SkIntToScalar(-16), SkIntToScalar(32)),
- new SkResizeImageFilter(RESIZE_FACTOR_X, RESIZE_FACTOR_Y, SkPaint::kNone_FilterLevel),
+ SkBlurImageFilter::Create(SkIntToScalar(12), SkIntToScalar(12)),
+ SkDropShadowImageFilter::Create(SkIntToScalar(10), SkIntToScalar(10), SkIntToScalar(3),
+ SK_ColorGREEN),
+ SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkIntToScalar(12),
+ gradient.get(),
+ checkerboard.get()),
+ SkDilateImageFilter::Create(2, 2, checkerboard.get()),
+ SkErodeImageFilter::Create(2, 2, checkerboard.get()),
+ SkOffsetImageFilter::Create(SkIntToScalar(-16), SkIntToScalar(32)),
+ SkResizeImageFilter::Create(RESIZE_FACTOR_X, RESIZE_FACTOR_Y, SkPaint::kNone_FilterLevel),
SkRectShaderImageFilter::Create(noise),
};
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);
- SkAutoTUnref<SkImageFilter> offset(new SkOffsetImageFilter(
+ SkAutoTUnref<SkImageFilter> offset(SkOffsetImageFilter::Create(
SkIntToScalar(-10), SkIntToScalar(-10)));
SkAutoTUnref<SkImageFilter> cfOffset(SkColorFilterImageFilter::Create(cf.get(), offset.get()));
SkImageFilter* filters[] = {
NULL,
SkColorFilterImageFilter::Create(cf.get(), NULL, &cropRect),
- new SkBlurImageFilter(1.0f, 1.0f, NULL, &cropRect),
- new SkBlurImageFilter(8.0f, 0.0f, NULL, &cropRect),
- new SkBlurImageFilter(0.0f, 8.0f, NULL, &cropRect),
- new SkBlurImageFilter(8.0f, 8.0f, NULL, &cropRect),
- new SkMergeImageFilter(NULL, cfOffset.get(), SkXfermode::kSrcOver_Mode, &cropRect),
- new SkBlurImageFilter(8.0f, 8.0f, NULL, &bogusRect),
+ SkBlurImageFilter::Create(1.0f, 1.0f, NULL, &cropRect),
+ SkBlurImageFilter::Create(8.0f, 0.0f, NULL, &cropRect),
+ SkBlurImageFilter::Create(0.0f, 8.0f, NULL, &cropRect),
+ SkBlurImageFilter::Create(8.0f, 8.0f, NULL, &cropRect),
+ SkMergeImageFilter::Create(NULL, cfOffset.get(), SkXfermode::kSrcOver_Mode, &cropRect),
+ SkBlurImageFilter::Create(8.0f, 8.0f, NULL, &bogusRect),
SkColorFilterImageFilter::Create(cf.get(), NULL, &bogusRect),
};
}
canvas->clear(0x00000000);
{
- SkAutoTUnref<SkImageFilter> bitmapSource(new SkBitmapSource(fBitmap));
+ SkAutoTUnref<SkImageFilter> bitmapSource(SkBitmapSource::Create(fBitmap));
SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED,
SkXfermode::kSrcIn_Mode));
- SkAutoTUnref<SkImageFilter> blur(new SkBlurImageFilter(4.0f, 4.0f, bitmapSource));
- SkAutoTUnref<SkImageFilter> erode(new SkErodeImageFilter(4, 4, blur));
+ SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(4.0f, 4.0f, bitmapSource));
+ SkAutoTUnref<SkImageFilter> erode(SkErodeImageFilter::Create(4, 4, blur));
SkAutoTUnref<SkImageFilter> color(SkColorFilterImageFilter::Create(cf, erode));
- SkAutoTUnref<SkImageFilter> merge(new SkMergeImageFilter(blur, color));
+ SkAutoTUnref<SkImageFilter> merge(SkMergeImageFilter::Create(blur, color));
SkPaint paint;
paint.setImageFilter(merge);
canvas->translate(SkIntToScalar(100), 0);
}
{
- SkAutoTUnref<SkImageFilter> morph(new SkDilateImageFilter(5, 5));
+ SkAutoTUnref<SkImageFilter> morph(SkDilateImageFilter::Create(5, 5));
SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
0, SK_Scalar1, 0, 0, 0,
SkAutoTUnref<SkColorFilter> matrixFilter(SkColorMatrixFilter::Create(matrix));
SkAutoTUnref<SkImageFilter> colorMorph(SkColorFilterImageFilter::Create(matrixFilter, morph));
SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcOver_Mode));
- SkAutoTUnref<SkImageFilter> blendColor(new SkXfermodeImageFilter(mode, colorMorph));
+ SkAutoTUnref<SkImageFilter> blendColor(SkXfermodeImageFilter::Create(mode, colorMorph));
SkPaint paint;
paint.setImageFilter(blendColor);
SimpleOffsetFilter offsetFilter(SkIntToScalar(10), SkIntToScalar(10), matrixFilter);
SkAutoTUnref<SkXfermode> arith(SkArithmeticMode::Create(0, SK_Scalar1, SK_Scalar1, 0));
- SkXfermodeImageFilter arithFilter(arith, matrixFilter, &offsetFilter);
+ SkAutoTUnref<SkXfermodeImageFilter> arithFilter(
+ SkXfermodeImageFilter::Create(arith, matrixFilter, &offsetFilter));
SkPaint paint;
- paint.setImageFilter(&arithFilter);
+ paint.setImageFilter(arithFilter);
drawClippedBitmap(canvas, fBitmap, paint);
canvas->translate(SkIntToScalar(100), 0);
}
{
- SkAutoTUnref<SkImageFilter> blur(new SkBlurImageFilter(
+ SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(
SkIntToScalar(10), SkIntToScalar(10)));
SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcIn_Mode));
SkImageFilter::CropRect cropRect(SkRect::MakeWH(SkIntToScalar(95), SkIntToScalar(100)));
- SkAutoTUnref<SkImageFilter> blend(new SkXfermodeImageFilter(mode, blur, NULL, &cropRect));
+ SkAutoTUnref<SkImageFilter> blend(
+ SkXfermodeImageFilter::Create(mode, blur, NULL, &cropRect));
SkPaint paint;
paint.setImageFilter(blend);
}
canvas->clear(0x00000000);
- SkAutoTUnref<SkImageFilter> gradient(new SkBitmapSource(fGradientCircle));
- SkAutoTUnref<SkImageFilter> checkerboard(new SkBitmapSource(fCheckerboard));
+ SkAutoTUnref<SkImageFilter> gradient(SkBitmapSource::Create(fGradientCircle));
+ SkAutoTUnref<SkImageFilter> checkerboard(SkBitmapSource::Create(fCheckerboard));
SkAutoTUnref<SkShader> noise(SkPerlinNoiseShader::CreateFractalNoise(
SkDoubleToScalar(0.1), SkDoubleToScalar(0.05), 1, 0));
SkImageFilter* filters[] = {
- new SkBlurImageFilter(SkIntToScalar(4), SkIntToScalar(4)),
- new SkDropShadowImageFilter(SkIntToScalar(5), SkIntToScalar(10), SkIntToScalar(3),
- SK_ColorYELLOW),
- new SkDisplacementMapEffect(SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkIntToScalar(12),
- gradient.get(),
- checkerboard.get()),
- new SkDilateImageFilter(1, 1, checkerboard.get()),
- new SkErodeImageFilter(1, 1, checkerboard.get()),
- new SkOffsetImageFilter(SkIntToScalar(32), 0),
- new SkResizeImageFilter(RESIZE_FACTOR, RESIZE_FACTOR, SkPaint::kNone_FilterLevel),
+ SkBlurImageFilter::Create(SkIntToScalar(4), SkIntToScalar(4)),
+ SkDropShadowImageFilter::Create(SkIntToScalar(5), SkIntToScalar(10), SkIntToScalar(3),
+ SK_ColorYELLOW),
+ SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkIntToScalar(12),
+ gradient.get(),
+ checkerboard.get()),
+ SkDilateImageFilter::Create(1, 1, checkerboard.get()),
+ SkErodeImageFilter::Create(1, 1, checkerboard.get()),
+ SkOffsetImageFilter::Create(SkIntToScalar(32), 0),
+ SkResizeImageFilter::Create(RESIZE_FACTOR, RESIZE_FACTOR, SkPaint::kNone_FilterLevel),
SkRectShaderImageFilter::Create(noise),
};
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
paint.setImageFilter(
- new SkMagnifierImageFilter(
+ SkMagnifierImageFilter::Create(
SkRect::MakeXYWH(SkIntToScalar(100), SkIntToScalar(100),
SkIntToScalar(WIDTH / 2),
SkIntToScalar(HEIGHT / 2)),
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
SkAutoTUnref<SkImageFilter> imageFilter(
- new SkResizeImageFilter(RESIZE_FACTOR, RESIZE_FACTOR, SkPaint::kNone_FilterLevel));
+ SkResizeImageFilter::Create(RESIZE_FACTOR, RESIZE_FACTOR, SkPaint::kNone_FilterLevel));
paint.setImageFilter(imageFilter.get());
const SkScalar tile_size = SkIntToScalar(100);
SkRect bounds;
SkScalar gain = 0.3f, bias = SkIntToScalar(100);
SkPaint paint;
SkAutoTUnref<SkImageFilter> filter(
- SkNEW_ARGS(SkMatrixConvolutionImageFilter, (kernelSize,
- kernel,
- gain,
- bias,
- target,
- tileMode,
- convolveAlpha,
- NULL,
- cropRect)));
+ SkMatrixConvolutionImageFilter::Create(kernelSize,
+ kernel,
+ gain,
+ bias,
+ target,
+ tileMode,
+ convolveAlpha,
+ NULL,
+ cropRect));
paint.setImageFilter(filter);
canvas->save();
canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
for (unsigned i = 0; i < SK_ARRAY_COUNT(samples); ++i) {
const SkImageFilter::CropRect* cr = j & 0x02 ? &cropRect : NULL;
if (j & 0x01) {
- paint.setImageFilter(new SkErodeImageFilter(
+ paint.setImageFilter(SkErodeImageFilter::Create(
samples[i].fRadiusX,
samples[i].fRadiusY,
NULL,
cr))->unref();
} else {
- paint.setImageFilter(new SkDilateImageFilter(
+ paint.setImageFilter(SkDilateImageFilter::Create(
samples[i].fRadiusX,
samples[i].fRadiusY,
NULL,
bitmap->width() - i * 8,
bitmap->height() - i * 12);
SkImageFilter::CropRect rect(SkRect::Make(cropRect));
- SkAutoTUnref<SkImageFilter> tileInput(SkNEW_ARGS(SkBitmapSource, (*bitmap)));
+ SkAutoTUnref<SkImageFilter> tileInput(SkBitmapSource::Create(*bitmap));
SkScalar dx = SkIntToScalar(i*5);
SkScalar dy = SkIntToScalar(i*10);
- SkAutoTUnref<SkImageFilter> filter(SkNEW_ARGS(
- SkOffsetImageFilter, (dx, dy, tileInput, &rect)));
+ SkAutoTUnref<SkImageFilter> filter(
+ SkOffsetImageFilter::Create(dx, dy, tileInput, &rect));
paint.setImageFilter(filter);
drawClippedBitmap(canvas, *bitmap, paint, SK_Scalar1, cropRect);
canvas->translate(SkIntToScalar(bitmap->width() + MARGIN), 0);
SkIRect cropRect = SkIRect::MakeXYWH(0, 0, 100, 100);
SkImageFilter::CropRect rect(SkRect::Make(cropRect));
- SkAutoTUnref<SkImageFilter> filter(SkNEW_ARGS(
- SkOffsetImageFilter, (SkIntToScalar(-5), SkIntToScalar(-10), NULL, &rect)));
+ SkAutoTUnref<SkImageFilter> filter(
+ SkOffsetImageFilter::Create(SkIntToScalar(-5), SkIntToScalar(-10), NULL, &rect));
paint.setImageFilter(filter);
drawClippedBitmap(canvas, fBitmap, paint, SkIntToScalar(2), cropRect);
}
SkRect srcRect = SkRect::MakeXYWH(20, 20, 30, 30);
SkRect emptyRect = SkRect::MakeXYWH(20, 20, 0, 0);
SkRect bounds = SkRect::MakeXYWH(0, 0, 100, 100);
- SkAutoTUnref<SkImageFilter> pictureSource(new SkPictureImageFilter(&fPicture));
- SkAutoTUnref<SkImageFilter> pictureSourceSrcRect(new SkPictureImageFilter(&fPicture, srcRect));
- SkAutoTUnref<SkImageFilter> pictureSourceEmptyRect(new SkPictureImageFilter(&fPicture, emptyRect));
+ SkAutoTUnref<SkImageFilter> pictureSource(SkPictureImageFilter::Create(&fPicture));
+ SkAutoTUnref<SkImageFilter> pictureSourceSrcRect(SkPictureImageFilter::Create(&fPicture, srcRect));
+ SkAutoTUnref<SkImageFilter> pictureSourceEmptyRect(SkPictureImageFilter::Create(&fPicture, emptyRect));
// Draw the picture unscaled.
fillRectFiltered(canvas, bounds, pictureSource);
canvas->scale(deviceScaleX, deviceScaleY);
canvas->translate(-rect.x(), -rect.y());
SkAutoTUnref<SkImageFilter> imageFilter(
- new SkResizeImageFilter(SkScalarInvert(deviceScaleX),
- SkScalarInvert(deviceScaleY),
- filterLevel));
+ SkResizeImageFilter::Create(SkScalarInvert(deviceScaleX),
+ SkScalarInvert(deviceScaleY),
+ filterLevel));
SkPaint filteredPaint;
filteredPaint.setImageFilter(imageFilter.get());
canvas->saveLayer(&rect, &filteredPaint);
int dy = 10;
SkScalar sigma = 8;
- SkAutoTUnref<SkImageFilter> filter(new SkBlurImageFilter(sigma, sigma));
+ SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(sigma, sigma));
draw_2_bitmaps(canvas, bm, false, dx, dy);
dy += bm.height() + 20;
#define FILTER_WIDTH SkIntToScalar(150)
#define FILTER_HEIGHT SkIntToScalar(200)
-static SkImageFilter* make0() { return new SkDownSampleImageFilter(SK_Scalar1 / 5); }
-static SkImageFilter* make1() { return new SkOffsetImageFilter(SkIntToScalar(16), SkIntToScalar(16)); }
+static SkImageFilter* make0() { return SkDownSampleImageFilter::Create(SK_Scalar1 / 5); }
+static SkImageFilter* make1() { return SkOffsetImageFilter::Create(SkIntToScalar(16), SkIntToScalar(16)); }
static SkImageFilter* make2() {
SkColorFilter* cf = SkColorFilter::CreateModeFilter(SK_ColorBLUE,
SkXfermode::kSrcIn_Mode);
return SkColorFilterImageFilter::Create(cf);
}
static SkImageFilter* make3() {
- return new SkBlurImageFilter(8, 0);
+ return SkBlurImageFilter::Create(8, 0);
}
static SkImageFilter* make4() {
- SkImageFilter* outer = new SkOffsetImageFilter(SkIntToScalar(16), SkIntToScalar(16));
- SkImageFilter* inner = new SkDownSampleImageFilter(SK_Scalar1 / 5);
+ SkImageFilter* outer = SkOffsetImageFilter::Create(SkIntToScalar(16), SkIntToScalar(16));
+ SkImageFilter* inner = SkDownSampleImageFilter::Create(SK_Scalar1 / 5);
SkAutoUnref aur0(outer);
SkAutoUnref aur1(inner);
- return new SkComposeImageFilter(outer, inner);
+ return SkComposeImageFilter::Create(outer, inner);
}
static SkImageFilter* make5() {
- SkImageFilter* first = new SkOffsetImageFilter(SkIntToScalar(16), SkIntToScalar(16));
- SkImageFilter* second = new SkDownSampleImageFilter(SK_Scalar1 / 5);
+ SkImageFilter* first = SkOffsetImageFilter::Create(SkIntToScalar(16), SkIntToScalar(16));
+ SkImageFilter* second = SkDownSampleImageFilter::Create(SK_Scalar1 / 5);
SkAutoUnref aur0(first);
SkAutoUnref aur1(second);
- return new SkMergeImageFilter(first, second);
+ return SkMergeImageFilter::Create(first, second);
}
static SkImageFilter* make6() {
- SkImageFilter* outer = new SkOffsetImageFilter(SkIntToScalar(16), SkIntToScalar(16));
- SkImageFilter* inner = new SkDownSampleImageFilter(SK_Scalar1 / 5);
+ SkImageFilter* outer = SkOffsetImageFilter::Create(SkIntToScalar(16), SkIntToScalar(16));
+ SkImageFilter* inner = SkDownSampleImageFilter::Create(SK_Scalar1 / 5);
SkAutoUnref aur0(outer);
SkAutoUnref aur1(inner);
- SkImageFilter* compose = new SkComposeImageFilter(outer, inner);
+ SkImageFilter* compose = SkComposeImageFilter::Create(outer, inner);
SkAutoUnref aur2(compose);
SkColorFilter* cf = SkColorFilter::CreateModeFilter(0x880000FF,
SkImageFilter* blue = SkColorFilterImageFilter::Create(cf);
SkAutoUnref aur4(blue);
- return new SkMergeImageFilter(compose, blue);
+ return SkMergeImageFilter::Create(compose, blue);
}
static SkImageFilter* make7() {
- SkImageFilter* outer = new SkOffsetImageFilter(SkIntToScalar(16), SkIntToScalar(16));
+ SkImageFilter* outer = SkOffsetImageFilter::Create(SkIntToScalar(16), SkIntToScalar(16));
SkImageFilter* inner = make3();
SkAutoUnref aur0(outer);
SkAutoUnref aur1(inner);
- SkImageFilter* compose = new SkComposeImageFilter(outer, inner);
+ SkImageFilter* compose = SkComposeImageFilter::Create(outer, inner);
SkAutoUnref aur2(compose);
SkColorFilter* cf = SkColorFilter::CreateModeFilter(0x880000FF,
SkImageFilter* blue = SkColorFilterImageFilter::Create(cf);
SkAutoUnref aur4(blue);
- return new SkMergeImageFilter(compose, blue);
+ return SkMergeImageFilter::Create(compose, blue);
}
static void draw0(SkCanvas* canvas) {
SkIntToScalar(i * 4),
SkIntToScalar(bitmap->width() - i * 12),
SkIntToScalar(bitmap->height()) - i * 12);
- SkAutoTUnref<SkImageFilter> tileInput(SkNEW_ARGS(SkBitmapSource, (*bitmap)));
- SkAutoTUnref<SkImageFilter> filter(SkNEW_ARGS(
- SkTileImageFilter, (srcRect, dstRect, tileInput)));
+ SkAutoTUnref<SkImageFilter> tileInput(SkBitmapSource::Create(*bitmap));
+ SkAutoTUnref<SkImageFilter> filter(
+ SkTileImageFilter::Create(srcRect, dstRect, tileInput));
canvas->save();
canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
paint.setImageFilter(filter);
};
int x = 0, y = 0;
- SkAutoTUnref<SkImageFilter> background(SkNEW_ARGS(SkBitmapSource, (fCheckerboard)));
+ SkAutoTUnref<SkImageFilter> background(SkBitmapSource::Create(fCheckerboard));
for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(gModes[i].fMode));
- SkAutoTUnref<SkImageFilter> filter(SkNEW_ARGS(
- SkXfermodeImageFilter, (mode, background)));
+ SkAutoTUnref<SkImageFilter> filter(SkXfermodeImageFilter::Create(mode, background));
paint.setImageFilter(filter);
drawClippedBitmap(canvas, fBitmap, paint, x, y);
x += fBitmap.width() + MARGIN;
}
// Test arithmetic mode as image filter
SkAutoTUnref<SkXfermode> mode(SkArithmeticMode::Create(0, SK_Scalar1, SK_Scalar1, 0));
- SkAutoTUnref<SkImageFilter> filter(SkNEW_ARGS(SkXfermodeImageFilter, (mode, background)));
+ SkAutoTUnref<SkImageFilter> filter(SkXfermodeImageFilter::Create(mode, background));
paint.setImageFilter(filter);
drawClippedBitmap(canvas, fBitmap, paint, x, y);
x += fBitmap.width() + MARGIN;
y += fBitmap.height() + MARGIN;
}
// Test NULL mode
- filter.reset(SkNEW_ARGS(SkXfermodeImageFilter, (NULL, background)));
+ filter.reset(SkXfermodeImageFilter::Create(NULL, background));
paint.setImageFilter(filter);
drawClippedBitmap(canvas, fBitmap, paint, x, y);
x += fBitmap.width() + MARGIN;
SkRect clipRect = SkRect::MakeWH(SkIntToScalar(fBitmap.width() + 4),
SkIntToScalar(fBitmap.height() + 4));
// Test offsets on SrcMode (uses fixed-function blend)
- SkAutoTUnref<SkImageFilter> foreground(SkNEW_ARGS(SkBitmapSource, (fBitmap)));
- SkAutoTUnref<SkImageFilter> offsetForeground(SkNEW_ARGS(SkOffsetImageFilter,
- (SkIntToScalar(4), SkIntToScalar(-4), foreground)));
- SkAutoTUnref<SkImageFilter> offsetBackground(SkNEW_ARGS(SkOffsetImageFilter,
- (SkIntToScalar(4), SkIntToScalar(4), background)));
+ SkAutoTUnref<SkImageFilter> foreground(SkBitmapSource::Create(fBitmap));
+ SkAutoTUnref<SkImageFilter> offsetForeground(SkOffsetImageFilter::Create(
+ SkIntToScalar(4), SkIntToScalar(-4), foreground));
+ SkAutoTUnref<SkImageFilter> offsetBackground(SkOffsetImageFilter::Create(
+ SkIntToScalar(4), SkIntToScalar(4), background));
mode.reset(SkXfermode::Create(SkXfermode::kSrcOver_Mode));
- filter.reset(SkNEW_ARGS(SkXfermodeImageFilter,
- (mode, offsetBackground, offsetForeground)));
+ filter.reset(SkXfermodeImageFilter::Create(mode, offsetBackground, offsetForeground));
paint.setImageFilter(filter);
drawClippedPaint(canvas, clipRect, paint, x, y);
x += fBitmap.width() + MARGIN;
}
// Test offsets on Darken (uses shader blend)
mode.reset(SkXfermode::Create(SkXfermode::kDarken_Mode));
- filter.reset(SkNEW_ARGS(SkXfermodeImageFilter, (mode, offsetBackground, offsetForeground)));
+ filter.reset(SkXfermodeImageFilter::Create(mode, offsetBackground, offsetForeground));
paint.setImageFilter(filter);
drawClippedPaint(canvas, clipRect, paint, x, y);
x += fBitmap.width() + MARGIN;
fBitmap.height() + offsets[i][3]);
SkImageFilter::CropRect rect(SkRect::Make(cropRect));
mode.reset(SkXfermode::Create(sampledModes[i]));
- filter.reset(SkNEW_ARGS(SkXfermodeImageFilter,
- (mode, offsetBackground, offsetForeground, &rect)));
+ filter.reset(SkXfermodeImageFilter::Create(
+ mode, offsetBackground, offsetForeground, &rect));
paint.setImageFilter(filter);
drawClippedPaint(canvas, clipRect, paint, x, y);
x += fBitmap.width() + MARGIN;
class SK_API SkBicubicImageFilter : public SkImageFilter {
public:
+ virtual ~SkBicubicImageFilter();
+
+ static SkBicubicImageFilter* CreateMitchell(const SkSize& scale, SkImageFilter* input = NULL);
+
+ SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBicubicImageFilter)
+
+protected:
/** Construct a (scaling-only) bicubic resampling image filter.
@param scale How much to scale the image.
@param coefficients The 16 coefficients of the bicubic matrix.
@param input The input image filter. If NULL, the src bitmap
passed to filterImage() is used instead.
*/
-
SkBicubicImageFilter(const SkSize& scale, const SkScalar coefficients[16],
SkImageFilter* input = NULL);
- static SkBicubicImageFilter* CreateMitchell(const SkSize& scale, SkImageFilter* input = NULL);
- virtual ~SkBicubicImageFilter();
-
- SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBicubicImageFilter)
-
-protected:
SkBicubicImageFilter(SkReadBuffer& buffer);
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
class SK_API SkBitmapSource : public SkImageFilter {
public:
- explicit SkBitmapSource(const SkBitmap& bitmap);
- SkBitmapSource(const SkBitmap& bitmap, const SkRect& srcRect, const SkRect& dstRect);
+ static SkBitmapSource* Create(const SkBitmap& bitmap) {
+ return SkNEW_ARGS(SkBitmapSource, (bitmap));
+ }
+ static SkBitmapSource* Create(const SkBitmap& bitmap, const SkRect& srcRect,
+ const SkRect& dstRect) {
+ return SkNEW_ARGS(SkBitmapSource, (bitmap, srcRect, dstRect));
+ }
virtual void computeFastBounds(const SkRect& src, SkRect* dst) const SK_OVERRIDE;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBitmapSource)
SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
virtual bool onFilterBounds(const SkIRect& src, const SkMatrix& ctm, SkIRect* dst) const SK_OVERRIDE;
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ explicit SkBitmapSource(const SkBitmap& bitmap);
+ SkBitmapSource(const SkBitmap& bitmap, const SkRect& srcRect, const SkRect& dstRect);
+
private:
SkBitmap fBitmap;
SkRect fSrcRect, fDstRect;
class SK_API SkBlurImageFilter : public SkImageFilter {
public:
- SkBlurImageFilter(SkScalar sigmaX,
- SkScalar sigmaY,
- SkImageFilter* input = NULL,
- const CropRect* cropRect = NULL);
+ static SkBlurImageFilter* Create(SkScalar sigmaX,
+ SkScalar sigmaY,
+ SkImageFilter* input = NULL,
+ const CropRect* cropRect = NULL) {
+ return SkNEW_ARGS(SkBlurImageFilter, (sigmaX, sigmaY, input, cropRect));
+ }
+
virtual void computeFastBounds(const SkRect&, SkRect*) const SK_OVERRIDE;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurImageFilter)
virtual bool filterImageGPU(Proxy* proxy, const SkBitmap& src, const SkMatrix& ctm,
SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkBlurImageFilter(SkScalar sigmaX,
+ SkScalar sigmaY,
+ SkImageFilter* input = NULL,
+ const CropRect* cropRect = NULL);
+
private:
SkSize fSigma;
typedef SkImageFilter INHERITED;
class SK_API SkComposeImageFilter : public SkImageFilter {
public:
- SkComposeImageFilter(SkImageFilter* outer, SkImageFilter* inner) : INHERITED(outer, inner) {}
virtual ~SkComposeImageFilter();
+ static SkComposeImageFilter* Create(SkImageFilter* outer, SkImageFilter* inner) {
+ return SkNEW_ARGS(SkComposeImageFilter, (outer, inner));
+ }
+
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkComposeImageFilter)
protected:
SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
virtual bool onFilterBounds(const SkIRect&, const SkMatrix&, SkIRect*) const SK_OVERRIDE;
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkComposeImageFilter(SkImageFilter* outer, SkImageFilter* inner) : INHERITED(outer, inner) {}
+
private:
typedef SkImageFilter INHERITED;
};
kR_ChannelSelectorType,
kG_ChannelSelectorType,
kB_ChannelSelectorType,
- kA_ChannelSelectorType,
- kKeyBits = 3 // Max value is 4, so 3 bits are required at most
+ kA_ChannelSelectorType
};
- SkDisplacementMapEffect(ChannelSelectorType xChannelSelector,
- ChannelSelectorType yChannelSelector,
- SkScalar scale, SkImageFilter* displacement,
- SkImageFilter* color = NULL,
- const CropRect* cropRect = NULL);
-
~SkDisplacementMapEffect();
+ static SkDisplacementMapEffect* Create(ChannelSelectorType xChannelSelector,
+ ChannelSelectorType yChannelSelector,
+ SkScalar scale, SkImageFilter* displacement,
+ SkImageFilter* color = NULL,
+ const CropRect* cropRect = NULL) {
+ return SkNEW_ARGS(SkDisplacementMapEffect, (xChannelSelector, yChannelSelector, scale,
+ displacement, color, cropRect));
+ }
+
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDisplacementMapEffect)
virtual bool onFilterImage(Proxy* proxy,
explicit SkDisplacementMapEffect(SkReadBuffer& buffer);
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkDisplacementMapEffect(ChannelSelectorType xChannelSelector,
+ ChannelSelectorType yChannelSelector,
+ SkScalar scale, SkImageFilter* displacement,
+ SkImageFilter* color = NULL,
+ const CropRect* cropRect = NULL);
+
private:
ChannelSelectorType fXChannelSelector;
ChannelSelectorType fYChannelSelector;
class SK_API SkDropShadowImageFilter : public SkImageFilter {
public:
- SkDropShadowImageFilter(SkScalar dx, SkScalar dy, SkScalar sigma, SkColor, SkImageFilter* input = NULL);
- SkDropShadowImageFilter(SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY, SkColor, SkImageFilter* input = NULL, const CropRect* cropRect = NULL);
+ static SkDropShadowImageFilter* Create(SkScalar dx, SkScalar dy, SkScalar sigma,
+ SkColor color, SkImageFilter* input = NULL) {
+ return SkNEW_ARGS(SkDropShadowImageFilter, (dx, dy, sigma, color, input));
+ }
+ static SkDropShadowImageFilter* Create(SkScalar dx, SkScalar dy,
+ SkScalar sigmaX, SkScalar sigmaY, SkColor color,
+ SkImageFilter* input = NULL,
+ const CropRect* cropRect = NULL) {
+ return SkNEW_ARGS(SkDropShadowImageFilter, (dx, dy, sigmaX, sigmaY,
+ color, input, cropRect));
+ }
virtual void computeFastBounds(const SkRect&, SkRect*) const SK_OVERRIDE;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDropShadowImageFilter)
virtual bool onFilterBounds(const SkIRect& src, const SkMatrix&,
SkIRect* dst) const SK_OVERRIDE;
-
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkDropShadowImageFilter(SkScalar dx, SkScalar dy, SkScalar sigma, SkColor,
+ SkImageFilter* input = NULL);
+ SkDropShadowImageFilter(SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY, SkColor,
+ SkImageFilter* input = NULL, const CropRect* cropRect = NULL);
private:
SkScalar fDx, fDy, fSigmaX, fSigmaY;
class SK_API SkMagnifierImageFilter : public SkImageFilter {
public:
- SkMagnifierImageFilter(SkRect srcRect, SkScalar inset);
+ static SkMagnifierImageFilter* Create(const SkRect& srcRect, SkScalar inset) {
+ return SkNEW_ARGS(SkMagnifierImageFilter, (srcRect, inset));
+ }
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMagnifierImageFilter)
virtual bool asNewEffect(GrEffectRef** effect, GrTexture* texture, const SkMatrix& matrix, const SkIRect& bounds) const SK_OVERRIDE;
#endif
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkMagnifierImageFilter(const SkRect& srcRect, SkScalar inset);
+
private:
SkRect fSrcRect;
SkScalar fInset;
kClampToBlack_TileMode, /*!< Fill with transparent black. */
};
+ virtual ~SkMatrixConvolutionImageFilter();
+
/** Construct a matrix convolution image filter.
- @param kernelSize The kernel size in pixels, in each dimension (N by M).
- @param kernel The image processing kernel. Must contain N * M
- elements, in row order.
- @param gain A scale factor applied to each pixel after
- convolution. This can be used to normalize the
- kernel, if it does not sum to 1.
- @param bias A bias factor added to each pixel after convolution.
- @param target An offset applied to each pixel coordinate before
- convolution. This can be used to center the kernel
- over the image (e.g., a 3x3 kernel should have a
- target of {1, 1}).
- @param tileMode How accesses outside the image are treated. (@see
- TileMode).
+ @param kernelSize The kernel size in pixels, in each dimension (N by M).
+ @param kernel The image processing kernel. Must contain N * M
+ elements, in row order.
+ @param gain A scale factor applied to each pixel after
+ convolution. This can be used to normalize the
+ kernel, if it does not sum to 1.
+ @param bias A bias factor added to each pixel after convolution.
+ @param kernelOffset An offset applied to each pixel coordinate before
+ convolution. This can be used to center the kernel
+ over the image (e.g., a 3x3 kernel should have an
+ offset of {1, 1}).
+ @param tileMode How accesses outside the image are treated. (@see
+ TileMode).
@param convolveAlpha If true, all channels are convolved. If false,
- only the RGB channels are convolved, and
- alpha is copied from the source image.
- @param input The input image filter. If NULL, the src bitmap
- passed to filterImage() is used instead.
- @param cropRect The rectangle to which the output processing will be limited.
+ only the RGB channels are convolved, and
+ alpha is copied from the source image.
+ @param input The input image filter. If NULL, the src bitmap
+ passed to filterImage() is used instead.
+ @param cropRect The rectangle to which the output processing will be limited.
*/
-
- SkMatrixConvolutionImageFilter(const SkISize& kernelSize,
- const SkScalar* kernel,
- SkScalar gain,
- SkScalar bias,
- const SkIPoint& target,
- TileMode tileMode,
- bool convolveAlpha,
- SkImageFilter* input = NULL,
- const CropRect* cropRect = NULL);
- virtual ~SkMatrixConvolutionImageFilter();
+ static SkMatrixConvolutionImageFilter* Create(const SkISize& kernelSize,
+ const SkScalar* kernel,
+ SkScalar gain,
+ SkScalar bias,
+ const SkIPoint& kernelOffset,
+ TileMode tileMode,
+ bool convolveAlpha,
+ SkImageFilter* input = NULL,
+ const CropRect* cropRect = NULL) {
+ return SkNEW_ARGS(SkMatrixConvolutionImageFilter, (kernelSize, kernel, gain, bias,
+ kernelOffset, tileMode, convolveAlpha,
+ input, cropRect));
+ }
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMatrixConvolutionImageFilter)
const SkIRect& bounds) const SK_OVERRIDE;
#endif
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkMatrixConvolutionImageFilter(const SkISize& kernelSize,
+ const SkScalar* kernel,
+ SkScalar gain,
+ SkScalar bias,
+ const SkIPoint& kernelOffset,
+ TileMode tileMode,
+ bool convolveAlpha,
+ SkImageFilter* input = NULL,
+ const CropRect* cropRect = NULL);
+
private:
SkISize fKernelSize;
SkScalar* fKernel;
SkScalar fGain;
SkScalar fBias;
- SkIPoint fTarget;
+ SkIPoint fKernelOffset;
TileMode fTileMode;
bool fConvolveAlpha;
typedef SkImageFilter INHERITED;
class SK_API SkMergeImageFilter : public SkImageFilter {
public:
- SkMergeImageFilter(SkImageFilter* first, SkImageFilter* second,
- SkXfermode::Mode = SkXfermode::kSrcOver_Mode,
- const CropRect* cropRect = NULL);
- SkMergeImageFilter(SkImageFilter* filters[], int count,
- const SkXfermode::Mode modes[] = NULL,
- const CropRect* cropRect = NULL);
virtual ~SkMergeImageFilter();
+ static SkMergeImageFilter* Create(SkImageFilter* first, SkImageFilter* second,
+ SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode,
+ const CropRect* cropRect = NULL) {
+ return SkNEW_ARGS(SkMergeImageFilter, (first, second, mode, cropRect));
+ }
+ static SkMergeImageFilter* Create(SkImageFilter* filters[], int count,
+ const SkXfermode::Mode modes[] = NULL,
+ const CropRect* cropRect = NULL) {
+ return SkNEW_ARGS(SkMergeImageFilter, (filters, count, modes, cropRect));
+ }
+
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMergeImageFilter)
protected:
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
+
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkMergeImageFilter(SkImageFilter* first, SkImageFilter* second,
+ SkXfermode::Mode = SkXfermode::kSrcOver_Mode,
+ const CropRect* cropRect = NULL);
+ SkMergeImageFilter(SkImageFilter* filters[], int count,
+ const SkXfermode::Mode modes[] = NULL,
+ const CropRect* cropRect = NULL);
private:
uint8_t* fModes; // SkXfermode::Mode
class SK_API SkMorphologyImageFilter : public SkImageFilter {
public:
- SkMorphologyImageFilter(int radiusX, int radiusY, SkImageFilter* input, const CropRect* cropRect);
virtual void computeFastBounds(const SkRect& src, SkRect* dst) const SK_OVERRIDE;
virtual bool onFilterBounds(const SkIRect& src, const SkMatrix& ctm, SkIRect* dst) const SK_OVERRIDE;
int width, int height, int srcStride, int dstStride);
protected:
+ SkMorphologyImageFilter(int radiusX, int radiusY, SkImageFilter* input,
+ const CropRect* cropRect);
bool filterImageGeneric(Proc procX, Proc procY,
Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) const;
class SK_API SkDilateImageFilter : public SkMorphologyImageFilter {
public:
- SkDilateImageFilter(int radiusX, int radiusY,
- SkImageFilter* input = NULL,
- const CropRect* cropRect = NULL)
- : INHERITED(radiusX, radiusY, input, cropRect) {}
+ static SkDilateImageFilter* Create(int radiusX, int radiusY,
+ SkImageFilter* input = NULL,
+ const CropRect* cropRect = NULL) {
+ return SkNEW_ARGS(SkDilateImageFilter, (radiusX, radiusY, input, cropRect));
+ }
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
protected:
SkDilateImageFilter(SkReadBuffer& buffer) : INHERITED(buffer) {}
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkDilateImageFilter(int radiusX, int radiusY,
+ SkImageFilter* input = NULL,
+ const CropRect* cropRect = NULL)
+ : INHERITED(radiusX, radiusY, input, cropRect) {}
+
private:
typedef SkMorphologyImageFilter INHERITED;
};
class SK_API SkErodeImageFilter : public SkMorphologyImageFilter {
public:
- SkErodeImageFilter(int radiusX, int radiusY,
- SkImageFilter* input = NULL,
- const CropRect* cropRect = NULL)
- : INHERITED(radiusX, radiusY, input, cropRect) {}
+ static SkErodeImageFilter* Create(int radiusX, int radiusY,
+ SkImageFilter* input = NULL,
+ const CropRect* cropRect = NULL) {
+ return SkNEW_ARGS(SkErodeImageFilter, (radiusX, radiusY, input, cropRect));
+ }
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
protected:
SkErodeImageFilter(SkReadBuffer& buffer) : INHERITED(buffer) {}
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkErodeImageFilter(int radiusX, int radiusY,
+ SkImageFilter* input = NULL,
+ const CropRect* cropRect = NULL)
+ : INHERITED(radiusX, radiusY, input, cropRect) {}
+
private:
typedef SkMorphologyImageFilter INHERITED;
};
typedef SkImageFilter INHERITED;
public:
- SkOffsetImageFilter(SkScalar dx, SkScalar dy, SkImageFilter* input = NULL,
- const CropRect* cropRect = NULL);
+ static SkOffsetImageFilter* Create(SkScalar dx, SkScalar dy, SkImageFilter* input = NULL,
+ const CropRect* cropRect = NULL) {
+ return SkNEW_ARGS(SkOffsetImageFilter, (dx, dy, input, cropRect));
+ }
virtual void computeFastBounds(const SkRect& src, SkRect* dst) const SK_OVERRIDE;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkOffsetImageFilter)
SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
virtual bool onFilterBounds(const SkIRect&, const SkMatrix&, SkIRect*) const SK_OVERRIDE;
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkOffsetImageFilter(SkScalar dx, SkScalar dy, SkImageFilter* input = NULL,
+ const CropRect* cropRect = NULL);
+
private:
SkVector fOffset;
};
/**
* Refs the passed-in picture.
*/
- explicit SkPictureImageFilter(SkPicture* picture);
+ static SkPictureImageFilter* Create(SkPicture* picture) {
+ return SkNEW_ARGS(SkPictureImageFilter, (picture));
+ }
/**
- * Refs the passed-in picture. rect can be used to crop or expand the destination rect when
+ * Refs the passed-in picture. cropRect can be used to crop or expand the destination rect when
* the picture is drawn. (No scaling is implied by the dest rect; only the CTM is applied.)
*/
- SkPictureImageFilter(SkPicture* picture, const SkRect& rect);
+ static SkPictureImageFilter* Create(SkPicture* picture, const SkRect& cropRect) {
+ return SkNEW_ARGS(SkPictureImageFilter, (picture, cropRect));
+ }
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPictureImageFilter)
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ explicit SkPictureImageFilter(SkPicture* picture);
+ SkPictureImageFilter(SkPicture* picture, const SkRect& cropRect);
+
private:
SkPicture* fPicture;
- SkRect fRect;
+ SkRect fCropRect;
typedef SkImageFilter INHERITED;
};
class SK_API SkResizeImageFilter : public SkImageFilter {
public:
+ virtual ~SkResizeImageFilter();
+
/** Construct a (scaling-only) resampling image filter.
* @param sx The x scale parameter to apply when resizing.
* @param sy The y scale parameter to apply when resizing.
* @param input The input image filter. If NULL, the src bitmap
* passed to filterImage() is used instead.
*/
+ static SkResizeImageFilter* Create(SkScalar sx, SkScalar sy, SkPaint::FilterLevel filterLevel,
+ SkImageFilter* input = NULL) {
+ return SkNEW_ARGS(SkResizeImageFilter, (sx, sy, filterLevel, input));
+ }
- SkResizeImageFilter(SkScalar sx, SkScalar sy, SkPaint::FilterLevel filterLevel,
- SkImageFilter* input = NULL);
- virtual ~SkResizeImageFilter();
virtual void computeFastBounds(const SkRect&, SkRect*) const SK_OVERRIDE;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkResizeImageFilter)
virtual bool onFilterBounds(const SkIRect& src, const SkMatrix&,
SkIRect* dst) const SK_OVERRIDE;
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkResizeImageFilter(SkScalar sx, SkScalar sy, SkPaint::FilterLevel filterLevel,
+ SkImageFilter* input = NULL);
+
private:
SkScalar fSx, fSy;
SkPaint::FilterLevel fFilterLevel;
// Fun mode that scales down (only) and then scales back up to look pixelated
class SK_API SkDownSampleImageFilter : public SkImageFilter {
public:
- SkDownSampleImageFilter(SkScalar scale) : INHERITED(0), fScale(scale) {}
+ static SkDownSampleImageFilter* Create(SkScalar scale) {
+ return SkNEW_ARGS(SkDownSampleImageFilter, (scale));
+ }
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDownSampleImageFilter)
protected:
+ SkDownSampleImageFilter(SkScalar scale) : INHERITED(0), fScale(scale) {}
SkDownSampleImageFilter(SkReadBuffer& buffer);
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
typedef SkImageFilter INHERITED;
public:
- /** Tile image filter constructor
+ /** Create a tile image filter
@param srcRect Defines the pixels to tile
@param dstRect Defines the pixels where tiles are drawn
@param input Input from which the subregion defined by srcRect will be tiled
*/
- SkTileImageFilter(const SkRect& srcRect, const SkRect& dstRect, SkImageFilter* input)
- : INHERITED(input), fSrcRect(srcRect), fDstRect(dstRect) {}
+ static SkTileImageFilter* Create(const SkRect& srcRect, const SkRect& dstRect,
+ SkImageFilter* input) {
+ return SkNEW_ARGS(SkTileImageFilter, (srcRect, dstRect, input));
+ }
virtual bool onFilterImage(Proxy* proxy, const SkBitmap& src, const SkMatrix& ctm,
SkBitmap* dst, SkIPoint* offset) const SK_OVERRIDE;
virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkTileImageFilter(const SkRect& srcRect, const SkRect& dstRect, SkImageFilter* input)
+ : INHERITED(input), fSrcRect(srcRect), fDstRect(dstRect) {}
+
private:
SkRect fSrcRect;
SkRect fDstRect;
*/
public:
- SkXfermodeImageFilter(SkXfermode* mode, SkImageFilter* background,
- SkImageFilter* foreground = NULL, const CropRect* cropRect = NULL);
-
virtual ~SkXfermodeImageFilter();
+ static SkXfermodeImageFilter* Create(SkXfermode* mode, SkImageFilter* background,
+ SkImageFilter* foreground = NULL,
+ const CropRect* cropRect = NULL) {
+ return SkNEW_ARGS(SkXfermodeImageFilter, (mode, background, foreground, cropRect));
+ }
+
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkXfermodeImageFilter)
virtual bool onFilterImage(Proxy* proxy,
explicit SkXfermodeImageFilter(SkReadBuffer& buffer);
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+ SkXfermodeImageFilter(SkXfermode* mode, SkImageFilter* background,
+ SkImageFilter* foreground = NULL, const CropRect* cropRect = NULL);
+
private:
SkXfermode* fMode;
typedef SkImageFilter INHERITED;
filter = SkBicubicImageFilter::CreateMitchell(SkSize::Make(1, 1), make_image_filter());
break;
case MERGE:
- filter = new SkMergeImageFilter(make_image_filter(), make_image_filter(), make_xfermode());
+ filter = SkMergeImageFilter::Create(make_image_filter(), make_image_filter(), make_xfermode());
break;
case COLOR:
{
}
break;
case BLUR:
- filter = new SkBlurImageFilter(make_scalar(true), make_scalar(true), make_image_filter());
+ filter = SkBlurImageFilter::Create(make_scalar(true), make_scalar(true), make_image_filter());
break;
case MAGNIFIER:
- filter = new SkMagnifierImageFilter(make_rect(), make_scalar(true));
+ filter = SkMagnifierImageFilter::Create(make_rect(), make_scalar(true));
break;
case XFERMODE:
{
SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(make_xfermode()));
- filter = new SkXfermodeImageFilter(mode, make_image_filter(), make_image_filter());
+ filter = SkXfermodeImageFilter::Create(mode, make_image_filter(), make_image_filter());
}
break;
case OFFSET:
- filter = new SkOffsetImageFilter(make_scalar(), make_scalar(), make_image_filter());
+ filter = SkOffsetImageFilter::Create(make_scalar(), make_scalar(), make_image_filter());
break;
case COMPOSE:
- filter = new SkComposeImageFilter(make_image_filter(), make_image_filter());
+ filter = SkComposeImageFilter::Create(make_image_filter(), make_image_filter());
break;
case DISTANT_LIGHT:
filter = (R(2) == 1) ?
}
break;
case DROP_SHADOW:
- filter = new SkDropShadowImageFilter(make_scalar(), make_scalar(),
+ filter = SkDropShadowImageFilter::Create(make_scalar(), make_scalar(),
make_scalar(true), make_color(), make_image_filter());
break;
case MORPHOLOGY:
if (R(2) == 1) {
- filter = new SkDilateImageFilter(R(static_cast<float>(kBitmapSize)),
+ filter = SkDilateImageFilter::Create(R(static_cast<float>(kBitmapSize)),
R(static_cast<float>(kBitmapSize)), make_image_filter());
} else {
- filter = new SkErodeImageFilter(R(static_cast<float>(kBitmapSize)),
+ filter = SkErodeImageFilter::Create(R(static_cast<float>(kBitmapSize)),
R(static_cast<float>(kBitmapSize)), make_image_filter());
}
break;
case BITMAP:
if (R(2) == 1) {
- filter = new SkBitmapSource(make_bitmap(), make_rect(), make_rect());
+ filter = SkBitmapSource::Create(make_bitmap(), make_rect(), make_rect());
} else {
- filter = new SkBitmapSource(make_bitmap());
+ filter = SkBitmapSource::Create(make_bitmap());
}
break;
case DISPLACE:
- filter = new SkDisplacementMapEffect(make_channel_selector_type(),
- make_channel_selector_type(), make_scalar(),
- make_image_filter(false), make_image_filter());
+ filter = SkDisplacementMapEffect::Create(make_channel_selector_type(),
+ make_channel_selector_type(), make_scalar(),
+ make_image_filter(false), make_image_filter());
break;
case TILE:
- filter = new SkTileImageFilter(make_rect(), make_rect(), make_image_filter(false));
+ filter = SkTileImageFilter::Create(make_rect(), make_rect(), make_image_filter(false));
break;
case PICTURE:
{
drawSomething(pict->beginRecording(kBitmapSize, kBitmapSize));
pict->endRecording();
#endif
- filter = new SkPictureImageFilter(pict, make_rect());
+ filter = SkPictureImageFilter::Create(pict, make_rect());
}
break;
default:
namespace {
+#define kChannelSelectorKeyBits 3; // Max value is 4, so 3 bits are required at most
+
template<SkDisplacementMapEffect::ChannelSelectorType type>
uint32_t getValue(SkColor, const SkUnPreMultiply::Scale*) {
SkDEBUGFAIL("Unknown channel selector");
drawEffect.castEffect<GrDisplacementMapEffect>();
EffectKey xKey = displacementMap.xChannelSelector();
- EffectKey yKey = displacementMap.yChannelSelector() << SkDisplacementMapEffect::kKeyBits;
+ EffectKey yKey = displacementMap.yChannelSelector() << kChannelSelectorKeyBits;
return xKey | yKey;
}
matrix.mapVectors(&sigma, &localSigma, 1);
sigma.fX = SkMaxScalar(0, sigma.fX);
sigma.fY = SkMaxScalar(0, sigma.fY);
- SkAutoTUnref<SkImageFilter> blurFilter(new SkBlurImageFilter(sigma.fX, sigma.fY));
+ SkAutoTUnref<SkImageFilter> blurFilter(SkBlurImageFilter::Create(sigma.fX, sigma.fY));
SkAutoTUnref<SkColorFilter> colorFilter(SkColorFilter::CreateModeFilter(fColor, SkXfermode::kSrcIn_Mode));
SkPaint paint;
paint.setImageFilter(blurFilter.get());
}
// FIXME: implement single-input semantics
-SkMagnifierImageFilter::SkMagnifierImageFilter(SkRect srcRect, SkScalar inset)
+SkMagnifierImageFilter::SkMagnifierImageFilter(const SkRect& srcRect, SkScalar inset)
: INHERITED(0), fSrcRect(srcRect), fInset(inset) {
SkASSERT(srcRect.x() >= 0 && srcRect.y() >= 0 && inset >= 0);
}
const SkScalar* kernel,
SkScalar gain,
SkScalar bias,
- const SkIPoint& target,
+ const SkIPoint& kernelOffset,
TileMode tileMode,
bool convolveAlpha,
SkImageFilter* input,
fKernelSize(kernelSize),
fGain(gain),
fBias(bias),
- fTarget(target),
+ fKernelOffset(kernelOffset),
fTileMode(tileMode),
fConvolveAlpha(convolveAlpha) {
uint32_t size = fKernelSize.fWidth * fKernelSize.fHeight;
fKernel = SkNEW_ARRAY(SkScalar, size);
memcpy(fKernel, kernel, size * sizeof(SkScalar));
SkASSERT(kernelSize.fWidth >= 1 && kernelSize.fHeight >= 1);
- SkASSERT(target.fX >= 0 && target.fX < kernelSize.fWidth);
- SkASSERT(target.fY >= 0 && target.fY < kernelSize.fHeight);
+ SkASSERT(kernelOffset.fX >= 0 && kernelOffset.fX < kernelSize.fWidth);
+ SkASSERT(kernelOffset.fY >= 0 && kernelOffset.fY < kernelSize.fHeight);
}
SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter(SkReadBuffer& buffer)
}
fGain = buffer.readScalar();
fBias = buffer.readScalar();
- fTarget.fX = buffer.readInt();
- fTarget.fY = buffer.readInt();
+ fKernelOffset.fX = buffer.readInt();
+ fKernelOffset.fY = buffer.readInt();
fTileMode = (TileMode) buffer.readInt();
fConvolveAlpha = buffer.readBool();
buffer.validate((fKernel != 0) &&
buffer.writeScalarArray(fKernel, fKernelSize.fWidth * fKernelSize.fHeight);
buffer.writeScalar(fGain);
buffer.writeScalar(fBias);
- buffer.writeInt(fTarget.fX);
- buffer.writeInt(fTarget.fY);
+ buffer.writeInt(fKernelOffset.fX);
+ buffer.writeInt(fKernelOffset.fY);
buffer.writeInt((int) fTileMode);
buffer.writeBool(fConvolveAlpha);
}
for (int cy = 0; cy < fKernelSize.fHeight; cy++) {
for (int cx = 0; cx < fKernelSize.fWidth; cx++) {
SkPMColor s = PixelFetcher::fetch(src,
- x + cx - fTarget.fX,
- y + cy - fTarget.fY,
+ x + cx - fKernelOffset.fX,
+ y + cy - fKernelOffset.fY,
bounds);
SkScalar k = fKernel[cy * fKernelSize.fWidth + cx];
if (convolveAlpha) {
offset->fX = bounds.fLeft;
offset->fY = bounds.fTop;
bounds.offset(-srcOffset);
- SkIRect interior = SkIRect::MakeXYWH(bounds.left() + fTarget.fX,
- bounds.top() + fTarget.fY,
+ SkIRect interior = SkIRect::MakeXYWH(bounds.left() + fKernelOffset.fX,
+ bounds.top() + fKernelOffset.fY,
bounds.width() - fKernelSize.fWidth + 1,
bounds.height() - fKernelSize.fHeight + 1);
SkIRect top = SkIRect::MakeLTRB(bounds.left(), bounds.top(), bounds.right(), interior.top());
const SkScalar* kernel,
SkScalar gain,
SkScalar bias,
- const SkIPoint& target,
+ const SkIPoint& kernelOffset,
TileMode tileMode,
bool convolveAlpha) {
AutoEffectUnref effect(SkNEW_ARGS(GrMatrixConvolutionEffect, (texture,
kernel,
gain,
bias,
- target,
+ kernelOffset,
tileMode,
convolveAlpha)));
return CreateEffectRef(effect);
static const char* Name() { return "MatrixConvolution"; }
const SkIRect& bounds() const { return fBounds; }
const SkISize& kernelSize() const { return fKernelSize; }
- const float* target() const { return fTarget; }
+ const float* kernelOffset() const { return fKernelOffset; }
const float* kernel() const { return fKernel; }
float gain() const { return fGain; }
float bias() const { return fBias; }
const SkScalar* kernel,
SkScalar gain,
SkScalar bias,
- const SkIPoint& target,
+ const SkIPoint& kernelOffset,
TileMode tileMode,
bool convolveAlpha);
float *fKernel;
float fGain;
float fBias;
- float fTarget[2];
+ float fKernelOffset[2];
TileMode fTileMode;
bool fConvolveAlpha;
kFloat_GrSLType, "Bias");
const char* bounds = builder->getUniformCStr(fBoundsUni);
- const char* target = builder->getUniformCStr(fTargetUni);
+ const char* kernelOffset = builder->getUniformCStr(fTargetUni);
const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
const char* kernel = builder->getUniformCStr(fKernelUni);
const char* gain = builder->getUniformCStr(fGainUni);
int kHeight = fKernelSize.height();
builder->fsCodeAppend("\t\tvec4 sum = vec4(0, 0, 0, 0);\n");
- builder->fsCodeAppendf("\t\tvec2 coord = %s - %s * %s;\n", coords2D.c_str(), target, imgInc);
+ builder->fsCodeAppendf("\t\tvec2 coord = %s - %s * %s;\n", coords2D.c_str(), kernelOffset, imgInc);
builder->fsCodeAppendf("\t\tfor (int y = 0; y < %d; y++) {\n", kHeight);
builder->fsCodeAppendf("\t\t\tfor (int x = 0; x < %d; x++) {\n", kWidth);
builder->fsCodeAppendf("\t\t\t\tfloat k = %s[y * %d + x];\n", kernel, kWidth);
imageIncrement[0] = 1.0f / texture.width();
imageIncrement[1] = ySign / texture.height();
uman.set2fv(fImageIncrementUni, 1, imageIncrement);
- uman.set2fv(fTargetUni, 1, conv.target());
+ uman.set2fv(fTargetUni, 1, conv.kernelOffset());
uman.set1fv(fKernelUni, fKernelSize.width() * fKernelSize.height(), conv.kernel());
uman.set1f(fGainUni, conv.gain());
uman.set1f(fBiasUni, conv.bias());
const SkScalar* kernel,
SkScalar gain,
SkScalar bias,
- const SkIPoint& target,
+ const SkIPoint& kernelOffset,
TileMode tileMode,
bool convolveAlpha)
: INHERITED(texture, MakeDivByTextureWHMatrix(texture)),
for (int i = 0; i < kernelSize.width() * kernelSize.height(); i++) {
fKernel[i] = SkScalarToFloat(kernel[i]);
}
- fTarget[0] = static_cast<float>(target.x());
- fTarget[1] = static_cast<float>(target.y());
+ fKernelOffset[0] = static_cast<float>(kernelOffset.x());
+ fKernelOffset[1] = static_cast<float>(kernelOffset.y());
this->setWillNotUseInputColor();
}
fKernelSize.width() * fKernelSize.height() * sizeof(float)) &&
fGain == s.gain() &&
fBias == s.bias() &&
- fTarget == s.target() &&
+ fKernelOffset == s.kernelOffset() &&
fTileMode == s.tileMode() &&
fConvolveAlpha == s.convolveAlpha();
}
}
SkScalar gain = random->nextSScalar1();
SkScalar bias = random->nextSScalar1();
- SkIPoint target = SkIPoint::Make(random->nextRangeU(0, kernelSize.width()),
- random->nextRangeU(0, kernelSize.height()));
+ SkIPoint kernelOffset = SkIPoint::Make(random->nextRangeU(0, kernelSize.width()),
+ random->nextRangeU(0, kernelSize.height()));
SkIRect bounds = SkIRect::MakeXYWH(random->nextRangeU(0, textures[texIdx]->width()),
random->nextRangeU(0, textures[texIdx]->height()),
random->nextRangeU(0, textures[texIdx]->width()),
kernel.get(),
gain,
bias,
- target,
+ kernelOffset,
tileMode,
convolveAlpha);
}
fKernel,
fGain,
fBias,
- fTarget,
+ fKernelOffset,
fTileMode,
fConvolveAlpha);
return true;
SkPictureImageFilter::SkPictureImageFilter(SkPicture* picture)
: INHERITED(0, 0),
fPicture(picture),
- fRect(SkRect::MakeWH(picture ? SkIntToScalar(picture->width()) : 0,
- picture ? SkIntToScalar(picture->height()) : 0)) {
+ fCropRect(SkRect::MakeWH(picture ? SkIntToScalar(picture->width()) : 0,
+ picture ? SkIntToScalar(picture->height()) : 0)) {
SkSafeRef(fPicture);
}
-SkPictureImageFilter::SkPictureImageFilter(SkPicture* picture, const SkRect& rect)
+SkPictureImageFilter::SkPictureImageFilter(SkPicture* picture, const SkRect& cropRect)
: INHERITED(0, 0),
fPicture(picture),
- fRect(rect) {
+ fCropRect(cropRect) {
SkSafeRef(fPicture);
}
#else
buffer.readBool();
#endif
- buffer.readRect(&fRect);
+ buffer.readRect(&fCropRect);
}
void SkPictureImageFilter::flatten(SkWriteBuffer& buffer) const {
#else
buffer.writeBool(false);
#endif
- buffer.writeRect(fRect);
+ buffer.writeRect(fCropRect);
}
bool SkPictureImageFilter::onFilterImage(Proxy* proxy, const SkBitmap&, const SkMatrix& matrix,
SkRect floatBounds;
SkIRect bounds;
- matrix.mapRect(&floatBounds, fRect);
+ matrix.mapRect(&floatBounds, fCropRect);
floatBounds.roundOut(&bounds);
if (bounds.isEmpty()) {
void forceLinking() {
SkLightingImageFilter::CreateDistantLitDiffuse(SkPoint3(0,0,0), 0, 0, 0);
SkAlphaThresholdFilter::Create(SkRegion(), .5f, .5f);
- SkMagnifierImageFilter mag(SkRect::MakeWH(SK_Scalar1, SK_Scalar1), SK_Scalar1);
+ SkAutoTUnref<SkMagnifierImageFilter> mag(SkMagnifierImageFilter::Create(
+ SkRect::MakeWH(SK_Scalar1, SK_Scalar1), SK_Scalar1));
GrConfigConversionEffect::Create(NULL,
false,
GrConfigConversionEffect::kNone_PMConversion,
// 3 ) large negative specular exponent value
SkScalar specularExponent = -1000;
- SkAutoTUnref<SkImageFilter> bmSrc(new SkBitmapSource(bitmap));
+ SkAutoTUnref<SkImageFilter> bmSrc(SkBitmapSource::Create(bitmap));
SkPaint paint;
paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(
location, target, specularExponent, 180,
{
// This tests for scale bringing width to 0
SkSize scale = SkSize::Make(-0.001f, SK_Scalar1);
- SkAutoTUnref<SkImageFilter> bmSrc(new SkBitmapSource(bitmap));
+ SkAutoTUnref<SkImageFilter> bmSrc(SkBitmapSource::Create(bitmap));
SkAutoTUnref<SkBicubicImageFilter> bicubic(
SkBicubicImageFilter::CreateMitchell(scale, bmSrc));
SkBitmapDevice device(bitmap);
SkImageFilter* filters[] = {
SkColorFilterImageFilter::Create(cf.get(), input.get(), &cropRect),
- new SkDisplacementMapEffect(SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- 40.0f, input.get(), input.get(), &cropRect),
- new SkBlurImageFilter(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
- new SkDropShadowImageFilter(SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_ColorGREEN, input.get(), &cropRect),
+ SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ 40.0f, input.get(), input.get(), &cropRect),
+ SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
+ SkDropShadowImageFilter::Create(SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_ColorGREEN, input.get(), &cropRect),
SkLightingImageFilter::CreatePointLitDiffuse(location, SK_ColorGREEN, 0, 0, input.get(), &cropRect),
SkLightingImageFilter::CreatePointLitSpecular(location, SK_ColorGREEN, 0, 0, 0, input.get(), &cropRect),
- new SkMatrixConvolutionImageFilter(kernelSize, kernel, gain, bias, SkIPoint::Make(1, 1), SkMatrixConvolutionImageFilter::kRepeat_TileMode, false, input.get(), &cropRect),
- new SkMergeImageFilter(input.get(), input.get(), SkXfermode::kSrcOver_Mode, &cropRect),
- new SkOffsetImageFilter(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
- new SkOffsetImageFilter(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
- new SkDilateImageFilter(3, 2, input.get(), &cropRect),
- new SkErodeImageFilter(2, 3, input.get(), &cropRect),
- new SkTileImageFilter(inputCropRect.rect(), cropRect.rect(), input.get()),
- new SkXfermodeImageFilter(SkXfermode::Create(SkXfermode::kSrcOver_Mode), input.get(), input.get(), &cropRect),
+ SkMatrixConvolutionImageFilter::Create(kernelSize, kernel, gain, bias, SkIPoint::Make(1, 1), SkMatrixConvolutionImageFilter::kRepeat_TileMode, false, input.get(), &cropRect),
+ SkMergeImageFilter::Create(input.get(), input.get(), SkXfermode::kSrcOver_Mode, &cropRect),
+ SkOffsetImageFilter::Create(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
+ SkOffsetImageFilter::Create(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
+ SkDilateImageFilter::Create(3, 2, input.get(), &cropRect),
+ SkErodeImageFilter::Create(2, 3, input.get(), &cropRect),
+ SkTileImageFilter::Create(inputCropRect.rect(), cropRect.rect(), input.get()),
+ SkXfermodeImageFilter::Create(SkXfermode::Create(SkXfermode::kSrcOver_Mode), input.get(), input.get(), &cropRect),
};
for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
const SkBitmap& invalidBitmap,
bool shouldSucceed,
skiatest::Reporter* reporter) {
- SkBitmapSource validBitmapSource(validBitmap);
- SkBitmapSource invalidBitmapSource(invalidBitmap);
+ SkAutoTUnref<SkBitmapSource> validBitmapSource(SkBitmapSource::Create(validBitmap));
+ SkAutoTUnref<SkBitmapSource> invalidBitmapSource(SkBitmapSource::Create(invalidBitmap));
SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcOver_Mode));
- SkXfermodeImageFilter xfermodeImageFilter(mode, &invalidBitmapSource, &validBitmapSource);
+ SkAutoTUnref<SkXfermodeImageFilter> xfermodeImageFilter(
+ SkXfermodeImageFilter::Create(mode, invalidBitmapSource, validBitmapSource));
SkAutoTUnref<SkImageFilter> deserializedFilter(
TestFlattenableSerialization<SkImageFilter>(
- &xfermodeImageFilter, shouldSucceed, reporter));
+ xfermodeImageFilter, shouldSucceed, reporter));
// Try to render a small bitmap using the invalid deserialized filter
// to make sure we don't crash while trying to render it
projects / platform / upstream / libSkiaSharp.git / commitdiff