LightingBaseBench(bool small) : fIsSmall(small) { }
protected:
- void draw(int loops, SkCanvas* canvas, SkImageFilter* imageFilter) const {
+ void draw(int loops, SkCanvas* canvas, sk_sp<SkImageFilter> imageFilter) const {
SkRect r = fIsSmall ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_SMALL) :
SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_LARGE);
SkPaint paint;
- paint.setImageFilter(imageFilter)->unref();
+ paint.setImageFilter(std::move(imageFilter));
for (int i = 0; i < loops; i++) {
canvas->drawRect(r, paint);
}
class LightingPointLitDiffuseBench : public LightingBaseBench {
public:
- LightingPointLitDiffuseBench(bool small) : INHERITED(small) {
- }
+ LightingPointLitDiffuseBench(bool small) : INHERITED(small) { }
protected:
const char* onGetName() override {
}
void onDraw(int loops, SkCanvas* canvas) override {
- draw(loops, canvas, SkLightingImageFilter::CreatePointLitDiffuse(GetPointLocation(),
- GetWhite(),
- GetSurfaceScale(),
- GetKd()));
+ draw(loops, canvas, SkLightingImageFilter::MakePointLitDiffuse(GetPointLocation(),
+ GetWhite(),
+ GetSurfaceScale(),
+ GetKd(),
+ nullptr));
}
private:
class LightingDistantLitDiffuseBench : public LightingBaseBench {
public:
- LightingDistantLitDiffuseBench(bool small) : INHERITED(small) {
- }
+ LightingDistantLitDiffuseBench(bool small) : INHERITED(small) { }
protected:
const char* onGetName() override {
}
void onDraw(int loops, SkCanvas* canvas) override {
- draw(loops, canvas, SkLightingImageFilter::CreateDistantLitDiffuse(GetDistantDirection(),
- GetWhite(),
- GetSurfaceScale(),
- GetKd()));
+ draw(loops, canvas, SkLightingImageFilter::MakeDistantLitDiffuse(GetDistantDirection(),
+ GetWhite(),
+ GetSurfaceScale(),
+ GetKd(),
+ nullptr));
}
private:
class LightingSpotLitDiffuseBench : public LightingBaseBench {
public:
- LightingSpotLitDiffuseBench(bool small) : INHERITED(small) {
- }
+ LightingSpotLitDiffuseBench(bool small) : INHERITED(small) { }
protected:
const char* onGetName() override {
}
void onDraw(int loops, SkCanvas* canvas) override {
- draw(loops, canvas, SkLightingImageFilter::CreateSpotLitDiffuse(GetSpotLocation(),
- GetSpotTarget(),
- GetSpotExponent(),
- GetCutoffAngle(),
- GetWhite(),
- GetSurfaceScale(),
- GetKd()));
+ draw(loops, canvas, SkLightingImageFilter::MakeSpotLitDiffuse(GetSpotLocation(),
+ GetSpotTarget(),
+ GetSpotExponent(),
+ GetCutoffAngle(),
+ GetWhite(),
+ GetSurfaceScale(),
+ GetKd(),
+ nullptr));
}
private:
class LightingPointLitSpecularBench : public LightingBaseBench {
public:
- LightingPointLitSpecularBench(bool small) : INHERITED(small) {
- }
+ LightingPointLitSpecularBench(bool small) : INHERITED(small) { }
protected:
const char* onGetName() override {
}
void onDraw(int loops, SkCanvas* canvas) override {
- draw(loops, canvas, SkLightingImageFilter::CreatePointLitSpecular(GetPointLocation(),
- GetWhite(),
- GetSurfaceScale(),
- GetKs(),
- GetShininess()));
+ draw(loops, canvas, SkLightingImageFilter::MakePointLitSpecular(GetPointLocation(),
+ GetWhite(),
+ GetSurfaceScale(),
+ GetKs(),
+ GetShininess(),
+ nullptr));
}
private:
class LightingDistantLitSpecularBench : public LightingBaseBench {
public:
- LightingDistantLitSpecularBench(bool small) : INHERITED(small) {
- }
+ LightingDistantLitSpecularBench(bool small) : INHERITED(small) { }
protected:
const char* onGetName() override {
}
void onDraw(int loops, SkCanvas* canvas) override {
- draw(loops, canvas, SkLightingImageFilter::CreateDistantLitSpecular(GetDistantDirection(),
- GetWhite(),
- GetSurfaceScale(),
- GetKs(),
- GetShininess()));
+ draw(loops, canvas, SkLightingImageFilter::MakeDistantLitSpecular(GetDistantDirection(),
+ GetWhite(),
+ GetSurfaceScale(),
+ GetKs(),
+ GetShininess(),
+ nullptr));
}
private:
class LightingSpotLitSpecularBench : public LightingBaseBench {
public:
- LightingSpotLitSpecularBench(bool small) : INHERITED(small) {
- }
+ LightingSpotLitSpecularBench(bool small) : INHERITED(small) { }
protected:
const char* onGetName() override {
}
void onDraw(int loops, SkCanvas* canvas) override {
- draw(loops, canvas, SkLightingImageFilter::CreateSpotLitSpecular(GetSpotLocation(),
- GetSpotTarget(),
- GetSpotExponent(),
- GetCutoffAngle(),
- GetWhite(),
- GetSurfaceScale(),
- GetKs(),
- GetShininess()));
+ draw(loops, canvas, SkLightingImageFilter::MakeSpotLitSpecular(GetSpotLocation(),
+ GetSpotTarget(),
+ GetSpotExponent(),
+ GetCutoffAngle(),
+ GetWhite(),
+ GetSurfaceScale(),
+ GetKs(),
+ GetShininess(),
+ nullptr));
}
private:
case COMPOSE:
filter = SkComposeImageFilter::Make(make_image_filter(), make_image_filter());
break;
- case DISTANT_LIGHT: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
+ case DISTANT_LIGHT:
filter = (R(2) == 1)
- ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreateDistantLitDiffuse(make_point(),
- make_color(), make_scalar(), make_scalar(),
- subFilter.get()))
- : sk_sp<SkImageFilter>(SkLightingImageFilter::CreateDistantLitSpecular(make_point(),
- make_color(), make_scalar(),
- make_scalar(), SkIntToScalar(R(10)),
- subFilter.get()));
+ ? SkLightingImageFilter::MakeDistantLitDiffuse(make_point(), make_color(),
+ make_scalar(), make_scalar(),
+ make_image_filter())
+ : SkLightingImageFilter::MakeDistantLitSpecular(make_point(), make_color(),
+ make_scalar(), make_scalar(),
+ SkIntToScalar(R(10)),
+ make_image_filter());
break;
- }
- case POINT_LIGHT: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
+ case POINT_LIGHT:
filter = (R(2) == 1)
- ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreatePointLitDiffuse(make_point(),
- make_color(), make_scalar(), make_scalar(),
- subFilter.get()))
- : sk_sp<SkImageFilter>(SkLightingImageFilter::CreatePointLitSpecular(make_point(),
- make_color(), make_scalar(), make_scalar(),
- SkIntToScalar(R(10)),
- subFilter.get()));
+ ? SkLightingImageFilter::MakePointLitDiffuse(make_point(), make_color(),
+ make_scalar(), make_scalar(),
+ make_image_filter())
+ : SkLightingImageFilter::MakePointLitSpecular(make_point(), make_color(),
+ make_scalar(), make_scalar(),
+ SkIntToScalar(R(10)),
+ make_image_filter());
break;
- }
- case SPOT_LIGHT: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
+ case SPOT_LIGHT:
filter = (R(2) == 1)
- ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreateSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
- make_point(), make_scalar(), make_scalar(),
- make_color(), make_scalar(), make_scalar(),
- subFilter.get()))
- : sk_sp<SkImageFilter>(SkLightingImageFilter::CreateSpotLitSpecular(SkPoint3::Make(0, 0, 0),
- make_point(), make_scalar(), make_scalar(),
- make_color(), make_scalar(), make_scalar(),
- SkIntToScalar(R(10)), subFilter.get()));
+ ? SkLightingImageFilter::MakeSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
+ make_point(), make_scalar(),
+ make_scalar(), make_color(),
+ make_scalar(), make_scalar(),
+ make_image_filter())
+ : SkLightingImageFilter::MakeSpotLitSpecular(SkPoint3::Make(0, 0, 0),
+ make_point(), make_scalar(),
+ make_scalar(), make_color(),
+ make_scalar(), make_scalar(),
+ SkIntToScalar(R(10)),
+ make_image_filter());
break;
- }
case NOISE: {
- sk_sp<SkShader> shader((R(2) == 1) ?
- SkPerlinNoiseShader::MakeFractalNoise(
- make_scalar(true), make_scalar(true), R(10.0f), make_scalar()) :
- SkPerlinNoiseShader::MakeTurbulence(
- make_scalar(true), make_scalar(true), R(10.0f), make_scalar()));
+ sk_sp<SkShader> shader((R(2) == 1)
+ ? SkPerlinNoiseShader::MakeFractalNoise(make_scalar(true), make_scalar(true),
+ R(10.0f), make_scalar())
+ : SkPerlinNoiseShader::MakeTurbulence(make_scalar(true), make_scalar(true),
+ R(10.0f), make_scalar()));
SkPaint paint;
paint.setShader(shader);
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
return surface->makeImageSnapshot();
}
-static void draw_clipped_filter(SkCanvas* canvas, SkImageFilter* filter, size_t i,
+static void draw_clipped_filter(SkCanvas* canvas, sk_sp<SkImageFilter> filter, size_t i,
const SkRect& primBounds, const SkRect& clipBounds) {
SkPaint paint;
paint.setColor(SK_ColorWHITE);
- paint.setImageFilter(filter);
+ paint.setImageFilter(std::move(filter));
paint.setAntiAlias(true);
canvas->save();
canvas->clipRect(clipBounds);
resizeMatrix.setScale(RESIZE_FACTOR_X, RESIZE_FACTOR_Y);
SkPoint3 pointLocation = SkPoint3::Make(32, 32, SkIntToScalar(10));
- SkImageFilter* filters[] = {
- SkBlurImageFilter::Make(SkIntToScalar(12), SkIntToScalar(12), nullptr).release(),
- SkDropShadowImageFilter::Make(SkIntToScalar(10), SkIntToScalar(10),
- SkIntToScalar(3), SkIntToScalar(3), SK_ColorGREEN,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
- nullptr).release(),
- SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
+ 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),
+ sk_sp<SkImageFilter>(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
SkDisplacementMapEffect::kR_ChannelSelectorType,
SkIntToScalar(12),
gradient.get(),
- checkerboard.get()),
- SkDilateImageFilter::Make(2, 2, checkerboard).release(),
- SkErodeImageFilter::Make(2, 2, checkerboard).release(),
- SkOffsetImageFilter::Make(SkIntToScalar(-16), SkIntToScalar(32), nullptr).release(),
- SkImageFilter::MakeMatrixFilter(resizeMatrix, kNone_SkFilterQuality, nullptr).release(),
- SkLightingImageFilter::CreatePointLitDiffuse(pointLocation, SK_ColorWHITE, SK_Scalar1,
- SkIntToScalar(2), checkerboard.get()),
+ checkerboard.get())),
+ 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),
};
}
canvas->restore();
- for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
- SkSafeUnref(filters[i]);
- }
-
SkPaint noisePaint;
noisePaint.setShader(SkPerlinNoiseShader::MakeFractalNoise(0.1f, 0.05f, 1, 0));
canvas->translate(SK_ARRAY_COUNT(filters)*(r.width() + margin), 0);
for (int xOffset = 0; xOffset < 80; xOffset += 16) {
bounds.fLeft = SkIntToScalar(xOffset);
- draw_clipped_filter(canvas, rectFilter.get(), 0, r, bounds);
+ draw_clipped_filter(canvas, rectFilter, 0, r, bounds);
canvas->translate(0, r.height() + margin);
}
}
0, 1, 0, 0, sk255,
0, 0, 1, 0, 0,
0, 0, 0, 0, sk255 };
- auto cfAlphaTrans(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
+ sk_sp<SkColorFilter> cfAlphaTrans(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
SkScalar MARGIN = SkIntToScalar(12);
&bigRect));
Draw(canvas, checkerboard, rect,
- sk_sp<SkImageFilter>(SkLightingImageFilter::CreatePointLitDiffuse(pointLocation,
- SK_ColorWHITE,
- surfaceScale,
- kd,
- noopCropped.get(),
- &bigRect)));
+ SkLightingImageFilter::MakePointLitDiffuse(pointLocation,
+ SK_ColorWHITE,
+ surfaceScale,
+ kd,
+ noopCropped,
+ &bigRect));
canvas->restore();
canvas->translate(0, SkIntToScalar(80));
#define RESIZE_FACTOR SkIntToScalar(4)
+static sk_sp<SkImage> make_gradient_circle(int width, int height) {
+ SkScalar x = SkIntToScalar(width / 2);
+ SkScalar y = SkIntToScalar(height / 2);
+ SkScalar radius = SkScalarMul(SkMinScalar(x, y), SkIntToScalar(4) / SkIntToScalar(5));
+ sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(width, height));
+ SkCanvas* canvas = surface->getCanvas();
+ canvas->clear(0x00000000);
+ SkColor colors[2];
+ colors[0] = SK_ColorWHITE;
+ colors[1] = SK_ColorBLACK;
+ SkPaint paint;
+ paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(x, y), radius, colors, nullptr,
+ 2, SkShader::kClamp_TileMode));
+ canvas->drawCircle(x, y, radius, paint);
+
+ return surface->makeImageSnapshot();
+}
+
+
namespace skiagm {
class ImageFiltersScaledGM : public GM {
void onOnceBeforeDraw() override {
fCheckerboard = SkImage::MakeFromBitmap(
sk_tool_utils::create_checkerboard_bitmap(64, 64, 0xFFA0A0A0, 0xFF404040, 8));
- fGradientCircle = MakeGradientCircle(64, 64);
+ fGradientCircle = make_gradient_circle(64, 64);
}
void onDraw(SkCanvas* canvas) override {
sk_sp<SkImageFilter> gradient(SkImageSource::Make(fGradientCircle));
sk_sp<SkImageFilter> checkerboard(SkImageSource::Make(fCheckerboard));
- sk_sp<SkShader> noise(SkPerlinNoiseShader::MakeFractalNoise(
- SkDoubleToScalar(0.1), SkDoubleToScalar(0.05), 1, 0));
+
SkPaint noisePaint;
- noisePaint.setShader(noise);
+ noisePaint.setShader(SkPerlinNoiseShader::MakeFractalNoise(SkDoubleToScalar(0.1),
+ SkDoubleToScalar(0.05), 1, 0));
SkPoint3 pointLocation = SkPoint3::Make(0, 0, SkIntToScalar(10));
SkPoint3 spotLocation = SkPoint3::Make(SkIntToScalar(-10),
SkMatrix resizeMatrix;
resizeMatrix.setScale(RESIZE_FACTOR, RESIZE_FACTOR);
- SkImageFilter* filters[] = {
- SkBlurImageFilter::Make(SkIntToScalar(4), SkIntToScalar(4), nullptr).release(),
- SkDropShadowImageFilter::Make(SkIntToScalar(5), SkIntToScalar(10),
- SkIntToScalar(3), SkIntToScalar(3), SK_ColorYELLOW,
- SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr).release(),
- SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
+ 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),
+ sk_sp<SkImageFilter>(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
SkDisplacementMapEffect::kR_ChannelSelectorType,
SkIntToScalar(12),
gradient.get(),
- checkerboard.get()),
- SkDilateImageFilter::Make(1, 1, checkerboard).release(),
- SkErodeImageFilter::Make(1, 1, checkerboard).release(),
- SkOffsetImageFilter::Make(SkIntToScalar(32), 0, nullptr).release(),
- SkImageFilter::MakeMatrixFilter(resizeMatrix, kNone_SkFilterQuality, nullptr).release(),
- SkPaintImageFilter::Make(noisePaint).release(),
- SkLightingImageFilter::CreatePointLitDiffuse(pointLocation, white, surfaceScale, kd),
- SkLightingImageFilter::CreateSpotLitDiffuse(spotLocation, spotTarget, spotExponent,
- cutoffAngle, white, surfaceScale, kd),
+ checkerboard.get())),
+ 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),
};
SkVector scales[] = {
canvas->restore();
canvas->translate(0, r.height() * scales[j].fY + margin);
}
-
- for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
- filters[i]->unref();
- }
}
private:
- static sk_sp<SkImage> MakeGradientCircle(int width, int height) {
- SkScalar x = SkIntToScalar(width / 2);
- SkScalar y = SkIntToScalar(height / 2);
- SkScalar radius = SkScalarMul(SkMinScalar(x, y), SkIntToScalar(4) / SkIntToScalar(5));
- auto surface(SkSurface::MakeRasterN32Premul(width, height));
- SkCanvas* canvas = surface->getCanvas();
- canvas->clear(0x00000000);
- SkColor colors[2];
- colors[0] = SK_ColorWHITE;
- colors[1] = SK_ColorBLACK;
- SkPaint paint;
- paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(x, y), radius, colors, nullptr,
- 2, SkShader::kClamp_TileMode));
- canvas->drawCircle(x, y, radius, paint);
-
- return surface->makeImageSnapshot();
- }
-
sk_sp<SkImage> fCheckerboard, fGradientCircle;
typedef GM INHERITED;
int y = 0;
for (int i = 0; i < 3; i++) {
const SkImageFilter::CropRect* cr = (i == 1) ? &cropRect : (i == 2) ? &fullSizeCropRect : nullptr;
- SkImageFilter* input = (i == 2) ? noopCropped.get() : nullptr;
- paint.setImageFilter(SkLightingImageFilter::CreatePointLitDiffuse(pointLocation,
+ sk_sp<SkImageFilter> input = (i == 2) ? noopCropped : nullptr;
+ paint.setImageFilter(SkLightingImageFilter::MakePointLitDiffuse(pointLocation,
+ white,
+ surfaceScale,
+ kd,
+ input,
+ cr));
+ drawClippedBitmap(canvas, paint, 0, y);
+
+ paint.setImageFilter(SkLightingImageFilter::MakeDistantLitDiffuse(distantDirection,
white,
surfaceScale,
kd,
input,
- cr))->unref();
- drawClippedBitmap(canvas, paint, 0, y);
-
- paint.setImageFilter(SkLightingImageFilter::CreateDistantLitDiffuse(distantDirection,
- white,
- surfaceScale,
- kd,
- input,
- cr))->unref();
+ cr));
drawClippedBitmap(canvas, paint, 110, y);
- paint.setImageFilter(SkLightingImageFilter::CreateSpotLitDiffuse(spotLocation,
- spotTarget,
- spotExponent,
- cutoffAngle,
- white,
- surfaceScale,
- kd,
- input,
- cr))->unref();
+ paint.setImageFilter(SkLightingImageFilter::MakeSpotLitDiffuse(spotLocation,
+ spotTarget,
+ spotExponent,
+ cutoffAngle,
+ white,
+ surfaceScale,
+ kd,
+ input,
+ cr));
drawClippedBitmap(canvas, paint, 220, y);
y += 110;
- paint.setImageFilter(SkLightingImageFilter::CreatePointLitSpecular(pointLocation,
+ paint.setImageFilter(SkLightingImageFilter::MakePointLitSpecular(pointLocation,
+ white,
+ surfaceScale,
+ ks,
+ shininess,
+ input,
+ cr));
+ drawClippedBitmap(canvas, paint, 0, y);
+
+ paint.setImageFilter(SkLightingImageFilter::MakeDistantLitSpecular(distantDirection,
white,
surfaceScale,
ks,
shininess,
input,
- cr))->unref();
- drawClippedBitmap(canvas, paint, 0, y);
-
- paint.setImageFilter(SkLightingImageFilter::CreateDistantLitSpecular(distantDirection,
- white,
- surfaceScale,
- ks,
- shininess,
- input,
- cr))->unref();
+ cr));
drawClippedBitmap(canvas, paint, 110, y);
- paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(spotLocation,
- spotTarget,
- spotExponent,
- cutoffAngle,
- white,
- surfaceScale,
- ks,
- shininess,
- input,
- cr))->unref();
+ paint.setImageFilter(SkLightingImageFilter::MakeSpotLitSpecular(spotLocation,
+ spotTarget,
+ spotExponent,
+ cutoffAngle,
+ white,
+ surfaceScale,
+ ks,
+ shininess,
+ input,
+ cr));
drawClippedBitmap(canvas, paint, 220, y);
y += 110;
class SK_API SkLightingImageFilter : public SkImageFilter {
public:
- static SkImageFilter* CreateDistantLitDiffuse(const SkPoint3& direction,
+ static sk_sp<SkImageFilter> MakeDistantLitDiffuse(const SkPoint3& direction,
SkColor lightColor, SkScalar surfaceScale, SkScalar kd,
- SkImageFilter* input = NULL, const CropRect* cropRect = NULL);
+ sk_sp<SkImageFilter> input, const CropRect* cropRect = nullptr);
+ static sk_sp<SkImageFilter> MakePointLitDiffuse(const SkPoint3& location,
+ SkColor lightColor, SkScalar surfaceScale, SkScalar kd,
+ sk_sp<SkImageFilter> input, const CropRect* cropRect = nullptr);
+ static sk_sp<SkImageFilter> MakeSpotLitDiffuse(const SkPoint3& location,
+ const SkPoint3& target, SkScalar specularExponent, SkScalar cutoffAngle,
+ SkColor lightColor, SkScalar surfaceScale, SkScalar kd,
+ sk_sp<SkImageFilter> input, const CropRect* cropRect = nullptr);
+ static sk_sp<SkImageFilter> MakeDistantLitSpecular(const SkPoint3& direction,
+ SkColor lightColor, SkScalar surfaceScale, SkScalar ks,
+ SkScalar shininess, sk_sp<SkImageFilter> input, const CropRect* cropRect = nullptr);
+ static sk_sp<SkImageFilter> MakePointLitSpecular(const SkPoint3& location,
+ SkColor lightColor, SkScalar surfaceScale, SkScalar ks,
+ SkScalar shininess, sk_sp<SkImageFilter> input, const CropRect* cropRect = nullptr);
+ static sk_sp<SkImageFilter> MakeSpotLitSpecular(const SkPoint3& location,
+ const SkPoint3& target, SkScalar specularExponent, SkScalar cutoffAngle,
+ SkColor lightColor, SkScalar surfaceScale, SkScalar ks,
+ SkScalar shininess, sk_sp<SkImageFilter> input, const CropRect* cropRect = nullptr);
+
+ SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
+
+#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
+ static SkImageFilter* CreateDistantLitDiffuse(const SkPoint3& direction,
+ SkColor lightColor, SkScalar surfaceScale, SkScalar kd,
+ SkImageFilter* input = NULL, const CropRect* cropRect = NULL) {
+ return MakeDistantLitDiffuse(direction, lightColor, surfaceScale, kd,
+ sk_ref_sp<SkImageFilter>(input), cropRect).release();
+ }
static SkImageFilter* CreatePointLitDiffuse(const SkPoint3& location,
SkColor lightColor, SkScalar surfaceScale, SkScalar kd,
- SkImageFilter* input = NULL, const CropRect* cropRect = NULL);
+ SkImageFilter* input = NULL, const CropRect* cropRect = NULL) {
+ return MakePointLitDiffuse(location, lightColor, surfaceScale, kd,
+ sk_ref_sp<SkImageFilter>(input), cropRect).release();
+ }
static SkImageFilter* CreateSpotLitDiffuse(const SkPoint3& location,
const SkPoint3& target, SkScalar specularExponent, SkScalar cutoffAngle,
SkColor lightColor, SkScalar surfaceScale, SkScalar kd,
- SkImageFilter* input = NULL, const CropRect* cropRect = NULL);
+ SkImageFilter* input = NULL, const CropRect* cropRect = NULL) {
+ return MakeSpotLitDiffuse(location, target, specularExponent, cutoffAngle,
+ lightColor, surfaceScale, kd,
+ sk_ref_sp<SkImageFilter>(input), cropRect).release();
+ }
static SkImageFilter* CreateDistantLitSpecular(const SkPoint3& direction,
SkColor lightColor, SkScalar surfaceScale, SkScalar ks,
- SkScalar shininess, SkImageFilter* input = NULL, const CropRect* cropRect = NULL);
+ SkScalar shininess, SkImageFilter* input = NULL, const CropRect* cropRect = NULL) {
+ return MakeDistantLitSpecular(direction, lightColor, surfaceScale, ks, shininess,
+ sk_ref_sp<SkImageFilter>(input), cropRect).release();
+ }
static SkImageFilter* CreatePointLitSpecular(const SkPoint3& location,
SkColor lightColor, SkScalar surfaceScale, SkScalar ks,
- SkScalar shininess, SkImageFilter* input = NULL, const CropRect* cropRect = NULL);
+ SkScalar shininess, SkImageFilter* input = NULL, const CropRect* cropRect = NULL) {
+ return MakePointLitSpecular(location, lightColor, surfaceScale, ks, shininess,
+ sk_ref_sp<SkImageFilter>(input), cropRect).release();
+ }
static SkImageFilter* CreateSpotLitSpecular(const SkPoint3& location,
const SkPoint3& target, SkScalar specularExponent, SkScalar cutoffAngle,
SkColor lightColor, SkScalar surfaceScale, SkScalar ks,
- SkScalar shininess, SkImageFilter* input = NULL, const CropRect* cropRect = NULL);
- ~SkLightingImageFilter();
-
- SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
+ SkScalar shininess, SkImageFilter* input = NULL, const CropRect* cropRect = NULL) {
+ return MakeSpotLitSpecular(location, target, specularExponent, cutoffAngle,
+ lightColor, surfaceScale, ks, shininess,
+ sk_ref_sp<SkImageFilter>(input), cropRect).release();
+ }
+#endif
protected:
- SkLightingImageFilter(SkImageFilterLight* light,
+ SkLightingImageFilter(sk_sp<SkImageFilterLight> light,
SkScalar surfaceScale,
- SkImageFilter* input,
+ sk_sp<SkImageFilter> input,
const CropRect* cropRect);
void flatten(SkWriteBuffer&) const override;
const SkImageFilterLight* light() const { return fLight.get(); }
bool affectsTransparentBlack() const override { return true; }
private:
- typedef SkImageFilter INHERITED;
- SkAutoTUnref<SkImageFilterLight> fLight;
+ sk_sp<SkImageFilterLight> fLight;
SkScalar fSurfaceScale;
+
+ typedef SkImageFilter INHERITED;
};
#endif
case COMPOSE:
filter = SkComposeImageFilter::Make(make_image_filter(), make_image_filter());
break;
- case DISTANT_LIGHT: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
+ case DISTANT_LIGHT:
filter = (R(2) == 1)
- ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreateDistantLitDiffuse(make_point(),
- make_color(), make_scalar(), make_scalar(),
- subFilter.get()))
- : sk_sp<SkImageFilter>(SkLightingImageFilter::CreateDistantLitSpecular(make_point(),
- make_color(), make_scalar(),
- make_scalar(), SkIntToScalar(R(10)),
- subFilter.get()));
+ ? SkLightingImageFilter::MakeDistantLitDiffuse(make_point(), make_color(),
+ make_scalar(), make_scalar(),
+ make_image_filter())
+ : SkLightingImageFilter::MakeDistantLitSpecular(make_point(), make_color(),
+ make_scalar(), make_scalar(),
+ SkIntToScalar(R(10)),
+ make_image_filter());
break;
- }
- case POINT_LIGHT: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
+ case POINT_LIGHT:
filter = (R(2) == 1)
- ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreatePointLitDiffuse(make_point(),
- make_color(), make_scalar(), make_scalar(),
- subFilter.get()))
- : sk_sp<SkImageFilter>(SkLightingImageFilter::CreatePointLitSpecular(make_point(),
- make_color(), make_scalar(), make_scalar(),
- SkIntToScalar(R(10)),
- subFilter.get()));
+ ? SkLightingImageFilter::MakePointLitDiffuse(make_point(), make_color(),
+ make_scalar(), make_scalar(),
+ make_image_filter())
+ : SkLightingImageFilter::MakePointLitSpecular(make_point(), make_color(),
+ make_scalar(), make_scalar(),
+ SkIntToScalar(R(10)),
+ make_image_filter());
break;
- }
- case SPOT_LIGHT: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
+ case SPOT_LIGHT:
filter = (R(2) == 1)
- ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreateSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
- make_point(), make_scalar(), make_scalar(),
- make_color(), make_scalar(), make_scalar(),
- subFilter.get()))
- : sk_sp<SkImageFilter>(SkLightingImageFilter::CreateSpotLitSpecular(SkPoint3::Make(0, 0, 0),
- make_point(), make_scalar(), make_scalar(),
- make_color(), make_scalar(), make_scalar(),
- SkIntToScalar(R(10)), subFilter.get()));
+ ? SkLightingImageFilter::MakeSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
+ make_point(), make_scalar(),
+ make_scalar(), make_color(),
+ make_scalar(), make_scalar(),
+ make_image_filter())
+ : SkLightingImageFilter::MakeSpotLitSpecular(SkPoint3::Make(0, 0, 0),
+ make_point(), make_scalar(),
+ make_scalar(), make_color(),
+ make_scalar(), make_scalar(),
+ SkIntToScalar(R(10)),
+ make_image_filter());
break;
- }
case NOISE: {
- sk_sp<SkShader> shader((R(2) == 1) ?
- SkPerlinNoiseShader::MakeFractalNoise(
- make_scalar(true), make_scalar(true), R(10.0f), make_scalar()) :
- SkPerlinNoiseShader::MakeTurbulence(
- make_scalar(true), make_scalar(true), R(10.0f), make_scalar()));
+ sk_sp<SkShader> shader((R(2) == 1)
+ ? SkPerlinNoiseShader::MakeFractalNoise(make_scalar(true), make_scalar(true),
+ R(10.0f), make_scalar())
+ : SkPerlinNoiseShader::MakeTurbulence(make_scalar(true), make_scalar(true),
+ R(10.0f), make_scalar()));
SkPaint paint;
paint.setShader(shader);
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
class SkLightingImageFilterInternal : public SkLightingImageFilter {
protected:
- SkLightingImageFilterInternal(SkImageFilterLight* light,
+ SkLightingImageFilterInternal(sk_sp<SkImageFilterLight> light,
SkScalar surfaceScale,
- SkImageFilter* input,
+ sk_sp<SkImageFilter> input,
const CropRect* cropRect)
- : INHERITED(light, surfaceScale, input, cropRect) {}
+ : INHERITED(std::move(light), surfaceScale, std::move(input), cropRect) {
+ }
#if SK_SUPPORT_GPU
bool canFilterImageGPU() const override { return true; }
class SkDiffuseLightingImageFilter : public SkLightingImageFilterInternal {
public:
- static SkImageFilter* Create(SkImageFilterLight* light, SkScalar surfaceScale,
- SkScalar kd, SkImageFilter*,
- const CropRect*);
+ static sk_sp<SkImageFilter> Make(sk_sp<SkImageFilterLight> light,
+ SkScalar surfaceScale,
+ SkScalar kd,
+ sk_sp<SkImageFilter>,
+ const CropRect*);
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiffuseLightingImageFilter)
SkScalar kd() const { return fKD; }
protected:
- SkDiffuseLightingImageFilter(SkImageFilterLight* light, SkScalar surfaceScale,
- SkScalar kd, SkImageFilter* input, const CropRect* cropRect);
+ SkDiffuseLightingImageFilter(sk_sp<SkImageFilterLight> light, SkScalar surfaceScale,
+ SkScalar kd,
+ sk_sp<SkImageFilter> input, const CropRect* cropRect);
void flatten(SkWriteBuffer& buffer) const override;
bool onFilterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
SkBitmap* result, SkIPoint* offset) const override;
class SkSpecularLightingImageFilter : public SkLightingImageFilterInternal {
public:
- static SkImageFilter* Create(SkImageFilterLight* light, SkScalar surfaceScale,
- SkScalar ks, SkScalar shininess, SkImageFilter*, const CropRect*);
+ static sk_sp<SkImageFilter> Make(sk_sp<SkImageFilterLight> light,
+ SkScalar surfaceScale,
+ SkScalar ks, SkScalar shininess,
+ sk_sp<SkImageFilter>, const CropRect*);
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSpecularLightingImageFilter)
SkScalar shininess() const { return fShininess; }
protected:
- SkSpecularLightingImageFilter(SkImageFilterLight* light, SkScalar surfaceScale, SkScalar ks,
- SkScalar shininess, SkImageFilter* input, const CropRect*);
+ SkSpecularLightingImageFilter(sk_sp<SkImageFilterLight> light,
+ SkScalar surfaceScale, SkScalar ks,
+ SkScalar shininess,
+ sk_sp<SkImageFilter> input, const CropRect*);
void flatten(SkWriteBuffer& buffer) const override;
bool onFilterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
SkBitmap* result, SkIPoint* offset) const override;
}
///////////////////////////////////////////////////////////////////////////////
-SkLightingImageFilter::SkLightingImageFilter(SkImageFilterLight* light, SkScalar surfaceScale,
- SkImageFilter* input, const CropRect* cropRect)
- : INHERITED(1, &input, cropRect)
- , fLight(SkRef(light))
- , fSurfaceScale(surfaceScale / 255)
-{}
-
-SkImageFilter* SkLightingImageFilter::CreateDistantLitDiffuse(const SkPoint3& direction,
- SkColor lightColor,
- SkScalar surfaceScale,
- SkScalar kd,
- SkImageFilter* input,
- const CropRect* cropRect) {
- SkAutoTUnref<SkImageFilterLight> light(new SkDistantLight(direction, lightColor));
- return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect);
-}
-
-SkImageFilter* SkLightingImageFilter::CreatePointLitDiffuse(const SkPoint3& location,
- SkColor lightColor,
- SkScalar surfaceScale,
- SkScalar kd,
- SkImageFilter* input,
- const CropRect* cropRect) {
- SkAutoTUnref<SkImageFilterLight> light(new SkPointLight(location, lightColor));
- return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect);
-}
-
-SkImageFilter* SkLightingImageFilter::CreateSpotLitDiffuse(const SkPoint3& location,
- const SkPoint3& target,
- SkScalar specularExponent,
- SkScalar cutoffAngle,
- SkColor lightColor,
- SkScalar surfaceScale,
- SkScalar kd,
- SkImageFilter* input,
- const CropRect* cropRect) {
- SkAutoTUnref<SkImageFilterLight> light(
- new SkSpotLight(location, target, specularExponent, cutoffAngle, lightColor));
- return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect);
-}
-
-SkImageFilter* SkLightingImageFilter::CreateDistantLitSpecular(const SkPoint3& direction,
+SkLightingImageFilter::SkLightingImageFilter(sk_sp<SkImageFilterLight> light,
+ SkScalar surfaceScale,
+ sk_sp<SkImageFilter> input, const CropRect* cropRect)
+ : INHERITED(&input, 1, cropRect)
+ , fLight(std::move(light))
+ , fSurfaceScale(surfaceScale / 255) {
+}
+
+sk_sp<SkImageFilter> SkLightingImageFilter::MakeDistantLitDiffuse(const SkPoint3& direction,
+ SkColor lightColor,
+ SkScalar surfaceScale,
+ SkScalar kd,
+ sk_sp<SkImageFilter> input,
+ const CropRect* cropRect) {
+ sk_sp<SkImageFilterLight> light(new SkDistantLight(direction, lightColor));
+ return SkDiffuseLightingImageFilter::Make(std::move(light), surfaceScale, kd,
+ std::move(input), cropRect);
+}
+
+sk_sp<SkImageFilter> SkLightingImageFilter::MakePointLitDiffuse(const SkPoint3& location,
+ SkColor lightColor,
+ SkScalar surfaceScale,
+ SkScalar kd,
+ sk_sp<SkImageFilter> input,
+ const CropRect* cropRect) {
+ sk_sp<SkImageFilterLight> light(new SkPointLight(location, lightColor));
+ return SkDiffuseLightingImageFilter::Make(std::move(light), surfaceScale, kd,
+ std::move(input), cropRect);
+}
+
+sk_sp<SkImageFilter> SkLightingImageFilter::MakeSpotLitDiffuse(const SkPoint3& location,
+ const SkPoint3& target,
+ SkScalar specularExponent,
+ SkScalar cutoffAngle,
SkColor lightColor,
SkScalar surfaceScale,
- SkScalar ks,
- SkScalar shine,
- SkImageFilter* input,
+ SkScalar kd,
+ sk_sp<SkImageFilter> input,
const CropRect* cropRect) {
- SkAutoTUnref<SkImageFilterLight> light(new SkDistantLight(direction, lightColor));
- return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect);
-}
-
-SkImageFilter* SkLightingImageFilter::CreatePointLitSpecular(const SkPoint3& location,
- SkColor lightColor,
- SkScalar surfaceScale,
- SkScalar ks,
- SkScalar shine,
- SkImageFilter* input,
- const CropRect* cropRect) {
- SkAutoTUnref<SkImageFilterLight> light(new SkPointLight(location, lightColor));
- return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect);
-}
-
-SkImageFilter* SkLightingImageFilter::CreateSpotLitSpecular(const SkPoint3& location,
- const SkPoint3& target,
- SkScalar specularExponent,
- SkScalar cutoffAngle,
- SkColor lightColor,
- SkScalar surfaceScale,
- SkScalar ks,
- SkScalar shine,
- SkImageFilter* input,
- const CropRect* cropRect) {
- SkAutoTUnref<SkImageFilterLight> light(
+ sk_sp<SkImageFilterLight> light(
+ new SkSpotLight(location, target, specularExponent, cutoffAngle, lightColor));
+ return SkDiffuseLightingImageFilter::Make(std::move(light), surfaceScale, kd,
+ std::move(input), cropRect);
+}
+
+sk_sp<SkImageFilter> SkLightingImageFilter::MakeDistantLitSpecular(const SkPoint3& direction,
+ SkColor lightColor,
+ SkScalar surfaceScale,
+ SkScalar ks,
+ SkScalar shine,
+ sk_sp<SkImageFilter> input,
+ const CropRect* cropRect) {
+ sk_sp<SkImageFilterLight> light(new SkDistantLight(direction, lightColor));
+ return SkSpecularLightingImageFilter::Make(std::move(light), surfaceScale, ks, shine,
+ std::move(input), cropRect);
+}
+
+sk_sp<SkImageFilter> SkLightingImageFilter::MakePointLitSpecular(const SkPoint3& location,
+ SkColor lightColor,
+ SkScalar surfaceScale,
+ SkScalar ks,
+ SkScalar shine,
+ sk_sp<SkImageFilter> input,
+ const CropRect* cropRect) {
+ sk_sp<SkImageFilterLight> light(new SkPointLight(location, lightColor));
+ return SkSpecularLightingImageFilter::Make(std::move(light), surfaceScale, ks, shine,
+ std::move(input), cropRect);
+}
+
+sk_sp<SkImageFilter> SkLightingImageFilter::MakeSpotLitSpecular(const SkPoint3& location,
+ const SkPoint3& target,
+ SkScalar specularExponent,
+ SkScalar cutoffAngle,
+ SkColor lightColor,
+ SkScalar surfaceScale,
+ SkScalar ks,
+ SkScalar shine,
+ sk_sp<SkImageFilter> input,
+ const CropRect* cropRect) {
+ sk_sp<SkImageFilterLight> light(
new SkSpotLight(location, target, specularExponent, cutoffAngle, lightColor));
- return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect);
+ return SkSpecularLightingImageFilter::Make(std::move(light), surfaceScale, ks, shine,
+ std::move(input), cropRect);
}
-SkLightingImageFilter::~SkLightingImageFilter() {}
-
void SkLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
fLight->flattenLight(buffer);
///////////////////////////////////////////////////////////////////////////////
-SkImageFilter* SkDiffuseLightingImageFilter::Create(SkImageFilterLight* light,
- SkScalar surfaceScale,
- SkScalar kd,
- SkImageFilter* input,
- const CropRect* cropRect) {
- if (nullptr == light) {
+sk_sp<SkImageFilter> SkDiffuseLightingImageFilter::Make(sk_sp<SkImageFilterLight> light,
+ SkScalar surfaceScale,
+ SkScalar kd,
+ sk_sp<SkImageFilter> input,
+ const CropRect* cropRect) {
+ if (!light) {
return nullptr;
}
if (!SkScalarIsFinite(surfaceScale) || !SkScalarIsFinite(kd)) {
if (kd < 0) {
return nullptr;
}
- return new SkDiffuseLightingImageFilter(light, surfaceScale, kd, input, cropRect);
+ return sk_sp<SkImageFilter>(new SkDiffuseLightingImageFilter(std::move(light), surfaceScale,
+ kd, std::move(input), cropRect));
}
-SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkImageFilterLight* light,
+SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(sk_sp<SkImageFilterLight> light,
SkScalar surfaceScale,
SkScalar kd,
- SkImageFilter* input,
+ sk_sp<SkImageFilter> input,
const CropRect* cropRect)
- : INHERITED(light, surfaceScale, input, cropRect),
- fKD(kd)
-{
+ : INHERITED(std::move(light), surfaceScale, std::move(input), cropRect)
+ , fKD(kd) {
}
sk_sp<SkFlattenable> SkDiffuseLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
- SkAutoTUnref<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
+ sk_sp<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
SkScalar surfaceScale = buffer.readScalar();
SkScalar kd = buffer.readScalar();
- return sk_sp<SkFlattenable>(Create(light, surfaceScale, kd, common.getInput(0).get(),
- &common.cropRect()));
+ return Make(std::move(light), surfaceScale, kd, common.getInput(0), &common.cropRect());
}
void SkDiffuseLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
///////////////////////////////////////////////////////////////////////////////
-SkImageFilter* SkSpecularLightingImageFilter::Create(SkImageFilterLight* light,
- SkScalar surfaceScale,
- SkScalar ks,
- SkScalar shininess,
- SkImageFilter* input,
- const CropRect* cropRect) {
- if (nullptr == light) {
+sk_sp<SkImageFilter> SkSpecularLightingImageFilter::Make(sk_sp<SkImageFilterLight> light,
+ SkScalar surfaceScale,
+ SkScalar ks,
+ SkScalar shininess,
+ sk_sp<SkImageFilter> input,
+ const CropRect* cropRect) {
+ if (!light) {
return nullptr;
}
if (!SkScalarIsFinite(surfaceScale) || !SkScalarIsFinite(ks) || !SkScalarIsFinite(shininess)) {
if (ks < 0) {
return nullptr;
}
- return new SkSpecularLightingImageFilter(light, surfaceScale, ks, shininess, input, cropRect);
+ return sk_sp<SkImageFilter>(new SkSpecularLightingImageFilter(std::move(light), surfaceScale,
+ ks, shininess,
+ std::move(input), cropRect));
}
-SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkImageFilterLight* light,
+SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(sk_sp<SkImageFilterLight> light,
SkScalar surfaceScale,
SkScalar ks,
SkScalar shininess,
- SkImageFilter* input,
+ sk_sp<SkImageFilter> input,
const CropRect* cropRect)
- : INHERITED(light, surfaceScale, input, cropRect),
- fKS(ks),
- fShininess(shininess)
-{
+ : INHERITED(std::move(light), surfaceScale, std::move(input), cropRect)
+ , fKS(ks)
+ , fShininess(shininess) {
}
sk_sp<SkFlattenable> SkSpecularLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
- SkAutoTUnref<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
+ sk_sp<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
SkScalar surfaceScale = buffer.readScalar();
SkScalar ks = buffer.readScalar();
SkScalar shine = buffer.readScalar();
- return sk_sp<SkFlattenable>(Create(light, surfaceScale, ks, shine, common.getInput(0).get(),
- &common.cropRect()));
+ return Make(std::move(light), surfaceScale, ks, shine, common.getInput(0),
+ &common.cropRect());
}
void SkSpecularLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
public:
FilterList(sk_sp<SkImageFilter> input, const SkImageFilter::CropRect* cropRect = nullptr) {
SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
- SkScalar kernel[9] = {
- SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
- SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
- SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
- };
- const SkISize kernelSize = SkISize::Make(3, 3);
- const SkScalar gain = SK_Scalar1, bias = 0;
const SkScalar five = SkIntToScalar(5);
- SkMatrix matrix;
-
- matrix.setTranslate(SK_Scalar1, SK_Scalar1);
- matrix.postRotate(SkIntToScalar(45), SK_Scalar1, SK_Scalar1);
-
{
sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorRED,
SkXfermode::kSrcIn_Mode));
this->addFilter("color filter",
- SkColorFilterImageFilter::Make(cf, input, cropRect).release());
+ SkColorFilterImageFilter::Make(std::move(cf), input, cropRect));
}
{
sk_sp<SkImage> gradientImage(SkImage::MakeFromBitmap(make_gradient_circle(64, 64)));
sk_sp<SkImageFilter> gradientSource(SkImageSource::Make(std::move(gradientImage)));
- this->addFilter("displacement map", SkDisplacementMapEffect::Create(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- 20.0f, gradientSource.get(), input.get(), cropRect));
+ this->addFilter("displacement map",
+ sk_sp<SkImageFilter>(SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ 20.0f, gradientSource.get(), input.get(), cropRect)));
}
this->addFilter("blur", SkBlurImageFilter::Make(SK_Scalar1,
SK_Scalar1,
input,
- cropRect).release());
+ cropRect));
this->addFilter("drop shadow", SkDropShadowImageFilter::Make(
SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_ColorGREEN,
SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
- input, cropRect).release());
- this->addFilter("diffuse lighting", SkLightingImageFilter::CreatePointLitDiffuse(
- location, SK_ColorGREEN, 0, 0, input.get(), cropRect));
+ input, cropRect));
+ this->addFilter("diffuse lighting",
+ SkLightingImageFilter::MakePointLitDiffuse(location, SK_ColorGREEN, 0, 0,
+ input, cropRect));
this->addFilter("specular lighting",
- SkLightingImageFilter::CreatePointLitSpecular(location, SK_ColorGREEN, 0, 0, 0,
- input.get(), cropRect));
- this->addFilter("matrix convolution",
+ SkLightingImageFilter::MakePointLitSpecular(location, SK_ColorGREEN, 0, 0, 0,
+ input, cropRect));
+ {
+ SkScalar kernel[9] = {
+ SkIntToScalar(1), SkIntToScalar(1), SkIntToScalar(1),
+ SkIntToScalar(1), SkIntToScalar(-7), SkIntToScalar(1),
+ SkIntToScalar(1), SkIntToScalar(1), SkIntToScalar(1),
+ };
+ const SkISize kernelSize = SkISize::Make(3, 3);
+ const SkScalar gain = SK_Scalar1, bias = 0;
+
+ this->addFilter("matrix convolution",
SkMatrixConvolutionImageFilter::Make(
kernelSize, kernel, gain, bias, SkIPoint::Make(1, 1),
SkMatrixConvolutionImageFilter::kRepeat_TileMode, false,
- input, cropRect).release());
+ input, cropRect));
+ }
+
this->addFilter("merge", SkMergeImageFilter::Make(input, input,
SkXfermode::kSrcOver_Mode,
- cropRect).release());
+ cropRect));
+
{
SkPaint greenColorShaderPaint;
greenColorShaderPaint.setShader(SkShader::MakeColorShader(SK_ColorGREEN));
this->addFilter("merge with disjoint inputs", SkMergeImageFilter::Make(
std::move(paintFilterLeft), std::move(paintFilterRight),
- SkXfermode::kSrcOver_Mode, cropRect).release());
+ SkXfermode::kSrcOver_Mode, cropRect));
}
this->addFilter("offset",
SkOffsetImageFilter::Make(SK_Scalar1, SK_Scalar1, input,
- cropRect).release());
- this->addFilter("dilate", SkDilateImageFilter::Make(3, 2, input, cropRect).release());
- this->addFilter("erode", SkErodeImageFilter::Make(2, 3, input, cropRect).release());
- this->addFilter("tile", SkTileImageFilter::Create(
+ cropRect));
+ this->addFilter("dilate", SkDilateImageFilter::Make(3, 2, input, cropRect));
+ this->addFilter("erode", SkErodeImageFilter::Make(2, 3, input, cropRect));
+ this->addFilter("tile", sk_sp<SkImageFilter>(SkTileImageFilter::Create(
SkRect::MakeXYWH(0, 0, 50, 50),
cropRect ? cropRect->rect() : SkRect::MakeXYWH(0, 0, 100, 100),
- input.get()));
+ input.get())));
+
if (!cropRect) {
+ SkMatrix matrix;
+
+ matrix.setTranslate(SK_Scalar1, SK_Scalar1);
+ matrix.postRotate(SkIntToScalar(45), SK_Scalar1, SK_Scalar1);
+
this->addFilter("matrix",
- SkImageFilter::MakeMatrixFilter(matrix, kLow_SkFilterQuality, input).release());
+ SkImageFilter::MakeMatrixFilter(matrix, kLow_SkFilterQuality, input));
}
-
{
sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(five, five, input));
this->addFilter("blur and offset", SkOffsetImageFilter::Make(five, five,
std::move(blur),
- cropRect).release());
+ cropRect));
}
{
SkRTreeFactory factory;
this->addFilter("picture and blur", SkBlurImageFilter::Make(five, five,
std::move(pictureFilter),
- cropRect).release());
+ cropRect));
}
{
SkPaint paint;
this->addFilter("paint and blur", SkBlurImageFilter::Make(five, five,
std::move(paintFilter),
- cropRect).release());
+ cropRect));
}
this->addFilter("xfermode", SkXfermodeImageFilter::Make(
- SkXfermode::Make(SkXfermode::kSrc_Mode), input, input, cropRect).release());
+ SkXfermode::Make(SkXfermode::kSrc_Mode), input, input, cropRect));
}
int count() const { return fFilters.count(); }
SkImageFilter* getFilter(int index) const { return fFilters[index].fFilter.get(); }
const char* getName(int index) const { return fFilters[index].fName; }
private:
struct Filter {
- Filter() : fName(nullptr), fFilter(nullptr) {}
- Filter(const char* name, SkImageFilter* filter) : fName(name), fFilter(filter) {}
+ Filter() : fName(nullptr) {}
+ Filter(const char* name, sk_sp<SkImageFilter> filter)
+ : fName(name)
+ , fFilter(std::move(filter)) {
+ }
const char* fName;
sk_sp<SkImageFilter> fFilter;
};
- void addFilter(const char* name, SkImageFilter* filter) {
- fFilters.push_back(Filter(name, filter));
+ void addFilter(const char* name, sk_sp<SkImageFilter> filter) {
+ fFilters.push_back(Filter(name, std::move(filter)));
}
SkTArray<Filter> fFilters;
sk_sp<SkImageFilter> bmSrc(SkImageSource::Make(std::move(image)));
SkPaint paint;
- paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(
+ paint.setImageFilter(SkLightingImageFilter::MakeSpotLitSpecular(
location, target, specularExponent, 180,
0xFFFFFFFF, SK_Scalar1, SK_Scalar1, SK_Scalar1,
- bmSrc.get()))->unref();
+ std::move(bmSrc)));
SkCanvas canvas(result);
SkRect r = SkRect::MakeWH(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize));
const SkImageInfo info = SkImageInfo::MakeN32Premul(widthHeight, widthHeight);
- SkAutoTUnref<SkBaseDevice> device(SkBitmapDevice::Create(info, props));
- SkImageFilter::DeviceProxy proxy(device);
+ sk_sp<SkBaseDevice> device(SkBitmapDevice::Create(info, props));
+ SkImageFilter::DeviceProxy proxy(device.get());
(*test)(&proxy, reporter, nullptr);
}
PFTest test) {
const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
- SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
- SkBudgeted::kNo,
- SkImageInfo::MakeN32Premul(widthHeight,
- widthHeight),
- 0,
- &props,
- SkGpuDevice::kUninit_InitContents));
- SkImageFilter::DeviceProxy proxy(device);
+ sk_sp<SkGpuDevice> device(SkGpuDevice::Create(context,
+ SkBudgeted::kNo,
+ SkImageInfo::MakeN32Premul(widthHeight,
+ widthHeight),
+ 0,
+ &props,
+ SkGpuDevice::kUninit_InitContents));
+ SkImageFilter::DeviceProxy proxy(device.get());
(*test)(&proxy, reporter, context);
}
// Check that, for now, SkPictureImageFilter does not serialize or
// deserialize its contained picture when the filter is serialized
// cross-process. Do this by "laundering" it through SkValidatingReadBuffer.
- SkAutoTUnref<SkData> data(SkValidatingSerializeFlattenable(imageFilter.get()));
- SkAutoTUnref<SkFlattenable> flattenable(SkValidatingDeserializeFlattenable(
+ sk_sp<SkData> data(SkValidatingSerializeFlattenable(imageFilter.get()));
+ sk_sp<SkFlattenable> flattenable(SkValidatingDeserializeFlattenable(
data->data(), data->size(), SkImageFilter::GetFlattenableType()));
SkImageFilter* unflattenedFilter = static_cast<SkImageFilter*>(flattenable.get());
DEF_TEST(ImageFilterCanComputeFastBounds, reporter) {
- SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
- SkAutoTUnref<SkImageFilter> lighting(SkLightingImageFilter::CreatePointLitDiffuse(
- location, SK_ColorGREEN, 0, 0));
- REPORTER_ASSERT(reporter, !lighting->canComputeFastBounds());
+ {
+ SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
+ sk_sp<SkImageFilter> lighting(SkLightingImageFilter::MakePointLitDiffuse(location,
+ SK_ColorGREEN,
+ 0, 0, nullptr));
+ REPORTER_ASSERT(reporter, !lighting->canComputeFastBounds());
+ }
{
sk_sp<SkImageFilter> gray(make_grayscale(nullptr, nullptr));
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(HugeBlurImageFilter_Gpu, reporter, ctxInfo) {
const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
- SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(ctxInfo.fGrContext,
- SkBudgeted::kNo,
- SkImageInfo::MakeN32Premul(100, 100),
- 0,
- &props,
- SkGpuDevice::kUninit_InitContents));
- SkCanvas canvas(device);
+ sk_sp<SkGpuDevice> device(SkGpuDevice::Create(ctxInfo.fGrContext,
+ SkBudgeted::kNo,
+ SkImageInfo::MakeN32Premul(100, 100),
+ 0,
+ &props,
+ SkGpuDevice::kUninit_InitContents));
+ SkCanvas canvas(device.get());
test_huge_blur(&canvas, reporter);
}
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(XfermodeImageFilterCroppedInput_Gpu, reporter, ctxInfo) {
const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
- SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(ctxInfo.fGrContext,
- SkBudgeted::kNo,
- SkImageInfo::MakeN32Premul(1, 1),
- 0,
- &props,
- SkGpuDevice::kUninit_InitContents));
- SkCanvas canvas(device);
+ sk_sp<SkGpuDevice> device(SkGpuDevice::Create(ctxInfo.fGrContext,
+ SkBudgeted::kNo,
+ SkImageInfo::MakeN32Premul(1, 1),
+ 0,
+ &props,
+ SkGpuDevice::kUninit_InitContents));
+ SkCanvas canvas(device.get());
test_xfermode_cropped_input(&canvas, reporter);
}
projects / platform / upstream / libSkiaSharp.git / commitdiff