SkLayerDrawLooper::LayerInfo info;
info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit
| SkLayerDrawLooper::kColorFilter_Bit;
- info.fColorMode = SkXfermode::kSrc_Mode;
+ info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
info.fOffset = SkPoint::Make(SkIntToScalar(-1), SkIntToScalar(0));
info.fPostTranslate = false;
SkPaint* paint = looperBuilder.addLayerOnTop(info);
SkBlurMask::ConvertRadiusToSigma(0.5),
SkBlurMaskFilter::kHighQuality_BlurFlag));
paint->setColorFilter(SkColorFilter::MakeModeFilter(SK_ColorLTGRAY,
- SkXfermode::kSrcIn_Mode));
+ SkBlendMode::kSrcIn));
paint->setColor(SK_ColorGRAY);
}
{
}
static sk_sp<SkImageFilter> make_mode_blue(sk_sp<SkImageFilter> input) {
- sk_sp<SkColorFilter> filter(SkColorFilter::MakeModeFilter(SK_ColorBLUE,
- SkXfermode::kSrcIn_Mode));
+ sk_sp<SkColorFilter> filter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkBlendMode::kSrcIn));
return SkColorFilterImageFilter::Make(std::move(filter), std::move(input));
}
{ SkIntToScalar(src.fRight), SkIntToScalar(src.fBottom) },
};
canvas->drawVertices(SkCanvas::kTriangles_VertexMode,
- 4, verts, uvs, nullptr, nullptr,
- indices, 6, p2);
+ 4, verts, uvs, nullptr, indices, 6, p2);
} else {
canvas->drawBitmapRect(fAtlas, src, dst, &p,
SkCanvas::kFast_SrcRectConstraint);
for (int j = 0; j < loops; j++) {
sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(20.0f, 20.0f, nullptr));
sk_sp<SkImageFilter> inputs[kNumInputs];
+ SkBlendMode modes[kNumInputs];
for (int i = 0; i < kNumInputs; ++i) {
inputs[i] = blur;
+ modes[i] = SkBlendMode::kSrcOver;
}
SkPaint paint;
- paint.setImageFilter(SkMergeImageFilter::Make(inputs, kNumInputs));
+ paint.setImageFilter(SkMergeImageFilter::MakeN(inputs, kNumInputs, modes));
canvas->drawRect(rect, paint);
}
}
for (int j = 0; j < loops; j++) {
sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(20.0f, 20.0f, nullptr));
sk_sp<SkImageFilter> inputs[kNumInputs];
+ SkBlendMode modes[kNumInputs];
for (int i = 0; i < kNumInputs; ++i) {
inputs[i] = blur;
+ modes[i] = SkBlendMode::kSrcOver;
}
- sk_sp<SkImageFilter> mergeFilter = SkMergeImageFilter::Make(inputs, kNumInputs);
+ sk_sp<SkImageFilter> mergeFilter = SkMergeImageFilter::MakeN(inputs, kNumInputs, modes);
image = image->makeWithFilter(mergeFilter.get(), subset, subset, &discardSubset,
&offset);
SkASSERT(image && image->dimensions() == fImage->dimensions());
private:
sk_sp<SkImageFilter> mergeBitmaps() {
return SkMergeImageFilter::Make(SkImageSource::Make(fCheckerboard),
- SkImageSource::Make(fImage));
+ SkImageSource::Make(fImage), SkBlendMode::kSrcOver);
}
bool fIsSmall;
for (int i = 0; i < loops; i++) {
switch (fVertexMode) {
case kNone_VertexMode:
- canvas->drawPatch(fCubics, nullptr, nullptr, nullptr, fPaint);
+ canvas->drawPatch(fCubics, nullptr, nullptr, fPaint);
break;
case kColors_VertexMode:
- canvas->drawPatch(fCubics, fColors, nullptr, nullptr, fPaint);
+ canvas->drawPatch(fCubics, fColors, nullptr, fPaint);
break;
case kTexCoords_VertexMode:
- canvas->drawPatch(fCubics, nullptr, fTexCoords, nullptr, fPaint);
+ canvas->drawPatch(fCubics, nullptr, fTexCoords, fPaint);
break;
case kBoth_VertexMode:
- canvas->drawPatch(fCubics, fColors, fTexCoords, nullptr, fPaint);
+ canvas->drawPatch(fCubics, fColors, fTexCoords, fPaint);
break;
default:
break;
static const int kRows = 3;
static const int kCols = 4;
- fGrid.reset(kRows, kCols, SkPatchGrid::kColors_VertexType, nullptr);
+ fGrid.reset(kRows, kCols, SkPatchGrid::kColors_VertexType, SkBlendMode::kModulate);
for (int i = 0; i < kRows; i++) {
for (int j = 0; j < kCols; j++) {
SkPoint points[12];
// TODO: add a color filter to better match what is seen in the wild
info.fPaintBits = /* SkLayerDrawLooper::kColorFilter_Bit |*/
SkLayerDrawLooper::kMaskFilter_Bit;
- info.fColorMode = SkXfermode::kDst_Mode;
+ info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kDst;
info.fOffset.set(xOff, 0);
info.fPostTranslate = false;
for (int i = 0; i < loops; i++) {
canvas->drawVertices(SkCanvas::kTriangles_VertexMode, PTS,
- fPts, nullptr, fColors, nullptr, fIdx, IDX, paint);
+ fPts, nullptr, fColors, fIdx, IDX, paint);
}
}
private:
return SkTableColorFilter::MakeARGB(tableA, tableR, tableG, tableB);
}
case 3:
- return SkColorFilter::MakeModeFilter(make_color(), (SkXfermode::Mode)make_blendmode());
+ return SkColorFilter::MakeModeFilter(make_color(), make_blendmode());
case 4:
return SkColorMatrixFilter::MakeLightingFilter(make_color(), make_color());
case 5:
case MERGE:
filter = SkMergeImageFilter::Make(make_image_filter(),
make_image_filter(),
- (SkXfermode::Mode)make_blendmode());
+ make_blendmode());
break;
case COLOR: {
sk_sp<SkColorFilter> cf(make_color_filter());
canvas->drawRect(bounds, boundsPaint);
GrPaint grPaint;
- grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
SkAutoTUnref<GrDrawBatch> batch(
new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, klmSigns[c]));
canvas->drawRect(bounds, boundsPaint);
GrPaint grPaint;
- grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
SkAutoTUnref<GrDrawBatch> batch(
new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, 1.f));
canvas->drawRect(bounds, boundsPaint);
GrPaint grPaint;
- grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
GrPathUtils::QuadUVMatrix DevToUV(pts);
canvas->drawRect(testBounds, paint);
GrPaint grPaint;
- grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
SkRRect rrect = fRRect;
rrect.offset(SkIntToScalar(x + kGap), SkIntToScalar(y + kGap));
SkBlurMaskFilter::kHighQuality_BlurFlag));
paint.setColorFilter(SkColorFilter::MakeModeFilter(
SK_ColorRED,
- SkXfermode::kSrcIn_Mode));
+ SkBlendMode::kSrcIn));
paint.setAntiAlias(true);
canvas->drawRRect(rr, paint);
SkLayerDrawLooper::LayerInfo info;
info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit
| SkLayerDrawLooper::kColorFilter_Bit;
- info.fColorMode = SkXfermode::kSrc_Mode;
+ info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
info.fOffset = SkPoint::Make(SkIntToScalar(-1), SkIntToScalar(0));
info.fPostTranslate = false;
SkPaint* paint = looperBuilder.addLayerOnTop(info);
SkBlurMaskFilter::kHighQuality_BlurFlag));
paint->setColorFilter(SkColorFilter::MakeModeFilter(
sk_tool_utils::color_to_565(SK_ColorLTGRAY),
- SkXfermode::kSrcIn_Mode));
+ SkBlendMode::kSrcIn));
paint->setColor(sk_tool_utils::color_to_565(SK_ColorGRAY));
}
{
}
static sk_sp<SkColorFilter> make_cf2() {
- return SkColorFilter::MakeModeFilter(0x8044CC88, SkXfermode::kSrcATop_Mode);
+ return SkColorFilter::MakeModeFilter(0x8044CC88, SkBlendMode::kSrcATop);
}
static void draw_into_canvas(SkCanvas* canvas) {
}
static sk_sp<SkColorFilter> cf_make_colorize(SkColor color) {
- return SkColorFilter::MakeModeFilter(color, SkXfermode::kSrc_Mode);
+ return SkColorFilter::MakeModeFilter(color, SkBlendMode::kSrc);
}
static void sk_gm_get_colorfilters(SkTArray<sk_sp<SkColorFilter>>* array) {
#include "SkString.h"
#include "SkXfermode.h"
-static sk_sp<SkShader> make_shader(SkXfermode::Mode mode) {
+static sk_sp<SkShader> make_shader(SkBlendMode mode) {
SkPoint pts[2];
SkColor colors[2];
colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
- return SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB),
- SkXfermode::Make(mode));
+ return SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB), mode);
}
class ComposeShaderGM : public skiagm::GM {
public:
ComposeShaderGM() {
- fShader = make_shader(SkXfermode::kDstIn_Mode);
+ fShader = make_shader(SkBlendMode::kDstIn);
}
protected:
void onDraw(SkCanvas* canvas) override {
sk_sp<SkShader> shaders[] = {
- make_shader(SkXfermode::kDstIn_Mode),
- make_shader(SkXfermode::kSrcOver_Mode),
+ make_shader(SkBlendMode::kDstIn),
+ make_shader(SkBlendMode::kSrcOver),
};
SkPaint paint;
}
void onDraw(SkCanvas* canvas) override {
- auto xfer(SkXfermode::Make(SkXfermode::kDstOver_Mode));
+ SkBlendMode mode = SkBlendMode::kDstOver;
sk_sp<SkShader> shaders[] = {
// gradient should appear over color bitmap
- SkShader::MakeComposeShader(fLinearGradientShader, fColorBitmapShader, xfer),
+ SkShader::MakeComposeShader(fLinearGradientShader, fColorBitmapShader, mode),
// gradient should appear over alpha8 bitmap colorized by the paint color
- SkShader::MakeComposeShader(fLinearGradientShader, fAlpha8BitmapShader, xfer),
+ SkShader::MakeComposeShader(fLinearGradientShader, fAlpha8BitmapShader, mode),
};
SkPaint paint;
sk_sp<SkImage> skMaskImage = SkImage::MakeFromBitmap(skMask);
sk_sp<SkShader> skMaskShader = skMaskImage->makeShader(
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
- sk_sp<SkXfermode> dstInMode = SkXfermode::Make(SkXfermode::kSrcIn_Mode);
paint.setShader(
- SkShader::MakeComposeShader(skMaskShader, skSrcShader, dstInMode));
+ SkShader::MakeComposeShader(skMaskShader, skSrcShader, SkBlendMode::kSrcIn));
canvas->drawRect(r, paint);
}
}
GrPaint grPaint;
- grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
grPaint.addCoverageFragmentProcessor(std::move(fp));
SkAutoTUnref<GrDrawBatch> batch(new PolyBoundsBatch(p.getBounds(), 0xff000000));
}
GrPaint grPaint;
- grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
grPaint.addCoverageFragmentProcessor(std::move(fp));
SkAutoTUnref<GrDrawBatch> batch(new PolyBoundsBatch(rect, 0xff000000));
canvas->drawAtlas(atlas.get(), xform, tex, N, nullptr, &paint);
canvas->translate(0, 100);
- canvas->drawAtlas(atlas.get(), xform, tex, colors, N, SkXfermode::kSrcIn_Mode, nullptr, &paint);
+ canvas->drawAtlas(atlas.get(), xform, tex, colors, N, SkBlendMode::kSrcIn, nullptr, &paint);
}
private:
auto atlas = make_atlas(canvas, kAtlasSize);
const struct {
- SkXfermode::Mode fMode;
- const char* fLabel;
+ SkBlendMode fMode;
+ const char* fLabel;
} gModes[] = {
- { SkXfermode::kClear_Mode, "Clear" },
- { SkXfermode::kSrc_Mode, "Src" },
- { SkXfermode::kDst_Mode, "Dst" },
- { SkXfermode::kSrcOver_Mode, "SrcOver" },
- { SkXfermode::kDstOver_Mode, "DstOver" },
- { SkXfermode::kSrcIn_Mode, "SrcIn" },
- { SkXfermode::kDstIn_Mode, "DstIn" },
- { SkXfermode::kSrcOut_Mode, "SrcOut" },
- { SkXfermode::kDstOut_Mode, "DstOut" },
- { SkXfermode::kSrcATop_Mode, "SrcATop" },
- { SkXfermode::kDstATop_Mode, "DstATop" },
- { SkXfermode::kXor_Mode, "Xor" },
- { SkXfermode::kPlus_Mode, "Plus" },
- { SkXfermode::kModulate_Mode, "Mod" },
- { SkXfermode::kScreen_Mode, "Screen" },
- { SkXfermode::kOverlay_Mode, "Overlay" },
- { SkXfermode::kDarken_Mode, "Darken" },
- { SkXfermode::kLighten_Mode, "Lighten" },
- { SkXfermode::kColorDodge_Mode, "Dodge" },
- { SkXfermode::kColorBurn_Mode, "Burn" },
- { SkXfermode::kHardLight_Mode, "Hard" },
- { SkXfermode::kSoftLight_Mode, "Soft" },
- { SkXfermode::kDifference_Mode, "Diff" },
- { SkXfermode::kExclusion_Mode, "Exclusion" },
- { SkXfermode::kMultiply_Mode, "Multiply" },
- { SkXfermode::kHue_Mode, "Hue" },
- { SkXfermode::kSaturation_Mode, "Sat" },
- { SkXfermode::kColor_Mode, "Color" },
- { SkXfermode::kLuminosity_Mode, "Luminosity"},
+ { SkBlendMode::kClear, "Clear" },
+ { SkBlendMode::kSrc, "Src" },
+ { SkBlendMode::kDst, "Dst" },
+ { SkBlendMode::kSrcOver, "SrcOver" },
+ { SkBlendMode::kDstOver, "DstOver" },
+ { SkBlendMode::kSrcIn, "SrcIn" },
+ { SkBlendMode::kDstIn, "DstIn" },
+ { SkBlendMode::kSrcOut, "SrcOut" },
+ { SkBlendMode::kDstOut, "DstOut" },
+ { SkBlendMode::kSrcATop, "SrcATop" },
+ { SkBlendMode::kDstATop, "DstATop" },
+ { SkBlendMode::kXor, "Xor" },
+ { SkBlendMode::kPlus, "Plus" },
+ { SkBlendMode::kModulate, "Mod" },
+ { SkBlendMode::kScreen, "Screen" },
+ { SkBlendMode::kOverlay, "Overlay" },
+ { SkBlendMode::kDarken, "Darken" },
+ { SkBlendMode::kLighten, "Lighten" },
+ { SkBlendMode::kColorDodge, "Dodge" },
+ { SkBlendMode::kColorBurn, "Burn" },
+ { SkBlendMode::kHardLight, "Hard" },
+ { SkBlendMode::kSoftLight, "Soft" },
+ { SkBlendMode::kDifference, "Diff" },
+ { SkBlendMode::kExclusion, "Exclusion" },
+ { SkBlendMode::kMultiply, "Multiply" },
+ { SkBlendMode::kHue, "Hue" },
+ { SkBlendMode::kSaturation, "Sat" },
+ { SkBlendMode::kColor, "Color" },
+ { SkBlendMode::kLuminosity, "Luminosity"},
};
SkColor gColors[] = {
SkLayerDrawLooper::LayerInfo info;
info.fPaintBits = SkLayerDrawLooper::kStyle_Bit | SkLayerDrawLooper::kMaskFilter_Bit;
- info.fColorMode = SkXfermode::kSrc_Mode;
+ info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
for (size_t i = 0; i < SK_ARRAY_COUNT(gParams); i++) {
info.fOffset.set(gParams[i].fOffset, gParams[i].fOffset);
};
sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorMAGENTA,
- SkXfermode::kSrcIn_Mode));
+ SkBlendMode::kSrcIn));
sk_sp<SkImageFilter> cfif(SkColorFilterImageFilter::Make(std::move(cf), nullptr));
SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)),
SkImageFilter::CropRect::kHasAll_CropEdge);
// this combination of emboss+colorfilter used to crash -- so we exercise it to
// confirm that we have a fix.
- paint.setColorFilter(SkColorFilter::MakeModeFilter(0xFFFF0000, SkXfermode::kSrcATop_Mode));
+ paint.setColorFilter(SkColorFilter::MakeModeFilter(0xFFFF0000, SkBlendMode::kSrcATop));
canvas->translate(bm.width() + SkIntToScalar(10), 0);
canvas->drawBitmap(bm, 10, 10, &paint);
}
SkPoint::Make(0, gScalarSize)
};
canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode, 4, vertices, nullptr, fColors,
- nullptr, nullptr, 0, paint);
+ SkBlendMode::kModulate, nullptr, 0, paint);
}
const char* label() override {
return "Vertices";
draw_bitmap,
};
- auto cf = SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode);
+ auto cf = SkColorFilter::MakeModeFilter(SK_ColorRED, SkBlendMode::kSrcIn);
sk_sp<SkImageFilter> filters[] = {
nullptr,
IdentityImageFilter::Make(nullptr),
ImageFiltersText_CF() : ImageFiltersTextBaseGM("color") {}
void installFilter(SkPaint* paint) override {
- paint->setColorFilter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode));
+ paint->setColorFilter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkBlendMode::kSrcIn));
}
};
DEF_GM( return new ImageFiltersText_CF; )
};
sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorBLUE,
- SkXfermode::kSrcIn_Mode));
+ SkBlendMode::kSrcIn));
SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)),
SkImageFilter::CropRect::kHasAll_CropEdge);
SkImageFilter::CropRect bogusRect(SkRect::Make(SkIRect::MakeXYWH(-100, -100, 10, 10)),
SkErodeImageFilter::Make(8, 8, nullptr, &cropRect),
SkMergeImageFilter::Make(nullptr,
std::move(cfOffset),
- SkXfermode::kSrcOver_Mode,
+ SkBlendMode::kSrcOver,
&cropRect),
SkBlurImageFilter::Make(8.0f, 8.0f, nullptr, &bogusRect),
SkColorFilterImageFilter::Make(cf, nullptr, &bogusRect),
{
sk_sp<SkImageFilter> bitmapSource(SkImageSource::Make(fImage));
sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorRED,
- SkXfermode::kSrcIn_Mode));
+ SkBlendMode::kSrcIn));
sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(4.0f, 4.0f, std::move(bitmapSource)));
sk_sp<SkImageFilter> erode(SkErodeImageFilter::Make(4, 4, blur));
sk_sp<SkImageFilter> color(SkColorFilterImageFilter::Make(std::move(cf),
std::move(erode)));
- sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(blur, color));
+ sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(blur, color,
+ SkBlendMode::kSrcOver));
SkPaint paint;
paint.setImageFilter(std::move(merge));
{
// Test that crop offsets are absolute, not relative to the parent's crop rect.
sk_sp<SkColorFilter> cf1(SkColorFilter::MakeModeFilter(SK_ColorBLUE,
- SkXfermode::kSrcIn_Mode));
+ SkBlendMode::kSrcIn));
sk_sp<SkColorFilter> cf2(SkColorFilter::MakeModeFilter(SK_ColorGREEN,
- SkXfermode::kSrcIn_Mode));
+ SkBlendMode::kSrcIn));
SkImageFilter::CropRect outerRect(SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(10),
SkIntToScalar(80), SkIntToScalar(80)));
SkImageFilter::CropRect innerRect(SkRect::MakeXYWH(SkIntToScalar(20), SkIntToScalar(20),
SkISize onISize() override { return SkISize::Make(440, 530); }
void onDraw(SkCanvas* canvas) override {
- auto cf = SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkXfermode::kSrc_Mode);
+ auto cf = SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkBlendMode::kSrc);
sk_sp<SkImageFilter> filters[] = {
SkColorFilterImageFilter::Make(std::move(cf), nullptr),
SkBlurImageFilter::Make(2.0f, 2.0f, nullptr),
info.fPaintBits = SkLayerDrawLooper::kColorFilter_Bit |
SkLayerDrawLooper::kMaskFilter_Bit;
- info.fColorMode = SkXfermode::kSrc_Mode;
+ info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
info.fOffset.set(xOff, yOff);
info.fPostTranslate = false;
paint->setMaskFilter(MakeBlur());
- paint->setColorFilter(SkColorFilter::MakeModeFilter(color, SkXfermode::kSrcIn_Mode));
+ paint->setColorFilter(SkColorFilter::MakeModeFilter(color, SkBlendMode::kSrcIn));
return looperBuilder.detach();
}
info.fPaintBits = SkLayerDrawLooper::kColorFilter_Bit |
SkLayerDrawLooper::kMaskFilter_Bit;
- info.fColorMode = SkXfermode::kSrc_Mode;
+ info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
info.fPostTranslate = false;
SkPaint* paint;
paint->setMaskFilter(MakeBlur());
- paint->setColorFilter(SkColorFilter::MakeModeFilter(gColors[i],
- SkXfermode::kSrcIn_Mode));
+ paint->setColorFilter(SkColorFilter::MakeModeFilter(gColors[i], SkBlendMode::kSrcIn));
}
return looperBuilder.detach();
// used with shaders
SkColor alphas[] = {0xFFFFFFFF, 0x80808080};
- SkXfermode::Mode modes[] = { // currently just doing the Modes expressible as Coeffs
- SkXfermode::kClear_Mode,
- SkXfermode::kSrc_Mode,
- SkXfermode::kDst_Mode,
- SkXfermode::kSrcOver_Mode,
- SkXfermode::kDstOver_Mode,
- SkXfermode::kSrcIn_Mode,
- SkXfermode::kDstIn_Mode,
- SkXfermode::kSrcOut_Mode,
- SkXfermode::kDstOut_Mode,
- SkXfermode::kSrcATop_Mode,
- SkXfermode::kDstATop_Mode,
- SkXfermode::kXor_Mode,
- SkXfermode::kPlus_Mode,
- SkXfermode::kModulate_Mode,
+ const SkBlendMode modes[] = { // currently just doing the Modes expressible as Coeffs
+ SkBlendMode::kClear,
+ SkBlendMode::kSrc,
+ SkBlendMode::kDst,
+ SkBlendMode::kSrcOver,
+ SkBlendMode::kDstOver,
+ SkBlendMode::kSrcIn,
+ SkBlendMode::kDstIn,
+ SkBlendMode::kSrcOut,
+ SkBlendMode::kDstOut,
+ SkBlendMode::kSrcATop,
+ SkBlendMode::kDstATop,
+ SkBlendMode::kXor,
+ SkBlendMode::kPlus,
+ SkBlendMode::kModulate,
};
SkPaint paint;
step.fY = SkIntToScalar(y*kTileHeight);
step.fPaint = new SkPaint;
step.fPaint->setColorFilter(
- SkColorFilter::MakeModeFilter(colors[x][y], SkXfermode::kModulate_Mode));
+ SkColorFilter::MakeModeFilter(colors[x][y], SkBlendMode::kModulate));
step.fSurf = create_compat_surface(finalCanvas, kTileWidth, kTileHeight);
{0.0f, 0.0f}, {100.0f, 0.0f}, {100.0f,100.0f}, {0.0f, 100.0f}}
;
- const SkXfermode::Mode modes[] = {
- SkXfermode::kSrc_Mode,
- SkXfermode::kDst_Mode,
- SkXfermode::kModulate_Mode,
+ const SkBlendMode modes[] = {
+ SkBlendMode::kSrc,
+ SkBlendMode::kDst,
+ SkBlendMode::kModulate,
};
sk_sp<SkShader> shader(make_shader());
canvas->save();
for (int y = 0; y < 3; y++) {
- sk_sp<SkXfermode> xfer(SkXfermode::Make(modes[y]));
-
for (int x = 0; x < 4; x++) {
canvas->save();
canvas->translate(x * 350.0f, y * 350.0f);
switch (x) {
case 0:
- canvas->drawPatch(cubics, nullptr, nullptr, xfer, paint);
+ canvas->drawPatch(cubics, nullptr, nullptr, modes[y], paint);
break;
case 1:
- canvas->drawPatch(cubics, colors, nullptr, xfer, paint);
+ canvas->drawPatch(cubics, colors, nullptr, modes[y], paint);
break;
case 2:
paint.setShader(shader);
- canvas->drawPatch(cubics, nullptr, texCoords, xfer, paint);
+ canvas->drawPatch(cubics, nullptr, texCoords, modes[y], paint);
paint.setShader(nullptr);
break;
case 3:
paint.setShader(shader);
- canvas->drawPatch(cubics, colors, texCoords, xfer, paint);
+ canvas->drawPatch(cubics, colors, texCoords, modes[y], paint);
paint.setShader(nullptr);
break;
default:
constexpr int kCols = 4;
canvas->scale(3, 3);
- SkPatchGrid grid(kRows, kCols, SkPatchGrid::kColors_VertexType, nullptr);
+ SkPatchGrid grid(kRows, kCols, SkPatchGrid::kColors_VertexType);
for (int i = 0; i < kRows; i++) {
for (int j = 0; j < kCols; j++) {
SkPoint points[12];
if (kEffect_Type == fType) {
#if SK_SUPPORT_GPU
GrPaint grPaint;
- grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
SkRRect rrect = fRRects[curRRect];
rrect.offset(SkIntToScalar(x), SkIntToScalar(y));
paint.setMaskFilter(
SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 0.78867501f,
SkBlurMaskFilter::kHighQuality_BlurFlag));
- paint.setColorFilter(SkColorFilter::MakeModeFilter(0xBFFFFFFF, SkXfermode::kSrcIn_Mode));
+ paint.setColorFilter(SkColorFilter::MakeModeFilter(0xBFFFFFFF, SkBlendMode::kSrcIn));
canvas->clipPath(clipPath, true);
canvas->drawPath(drawPath, paint);
COLOR_COUNT = 3,
MODE_COUNT = 4,
};
- const SkColor* fColors;
- const SkXfermode::Mode* fModes;
- SkString fName;
+ const SkColor* fColors;
+ const SkBlendMode* fModes;
+ SkString fName;
public:
- ComposeColorFilterGM(const SkColor colors[], const SkXfermode::Mode modes[],
+ ComposeColorFilterGM(const SkColor colors[], const SkBlendMode modes[],
const char suffix[])
: fColors(colors), fModes(modes)
{
};
const SkColor gColors0[] = { SK_ColorCYAN, SK_ColorMAGENTA, SK_ColorYELLOW };
-const SkXfermode::Mode gModes0[] = {
- SkXfermode::kOverlay_Mode,
- SkXfermode::kDarken_Mode,
- SkXfermode::kColorBurn_Mode,
- SkXfermode::kExclusion_Mode,
+const SkBlendMode gModes0[] = {
+ SkBlendMode::kOverlay,
+ SkBlendMode::kDarken,
+ SkBlendMode::kColorBurn,
+ SkBlendMode::kExclusion,
};
DEF_GM( return new ComposeColorFilterGM(gColors0, gModes0, "wacky"); )
const SkColor gColors1[] = { 0x80FF0000, 0x8000FF00, 0x800000FF };
-const SkXfermode::Mode gModes1[] = {
- SkXfermode::kSrcOver_Mode,
- SkXfermode::kXor_Mode,
- SkXfermode::kDstOut_Mode,
- SkXfermode::kSrcATop_Mode,
+const SkBlendMode gModes1[] = {
+ SkBlendMode::kSrcOver,
+ SkBlendMode::kXor,
+ SkBlendMode::kDstOut,
+ SkBlendMode::kSrcATop,
};
DEF_GM( return new ComposeColorFilterGM(gColors1, gModes1, "alpha"); )
GrFixedClip clip(SkIRect::MakeWH(2*S, 2*S));
GrPaint paint;
- paint.setPorterDuffXPFactory(SkXfermode::kSrcOver_Mode);
+ paint.setPorterDuffXPFactory(SkBlendMode::kSrcOver);
SkMatrix vm;
if (i) {
SkLayerDrawLooper::LayerInfo info;
info.fPaintBits = bits;
- info.fColorMode = SkXfermode::kSrc_Mode;
+ info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
for (size_t i = 0; i < size; i++) {
info.fOffset.set(settings[i].fOffset, settings[i].fOffset);
for (int m = 0; m < GrTextureDomain::kModeCount; ++m) {
GrTextureDomain::Mode mode = (GrTextureDomain::Mode) m;
GrPaint grPaint;
- grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
sk_sp<GrFragmentProcessor> fp(
GrTextureDomainEffect::Make(texture, nullptr, textureMatrices[tm],
GrTextureDomain::MakeTexelDomain(texture,
dstRect = SkRect::MakeXYWH(0, 0, 100, 100);
SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(5, 5, 40, 40));
sk_sp<SkColorFilter> greenCF = SkColorFilter::MakeModeFilter(SK_ColorGREEN,
- SkXfermode::kSrc_Mode);
+ SkBlendMode::kSrc);
sk_sp<SkImageFilter> green(SkColorFilterImageFilter::Make(std::move(greenCF),
nullptr,
&cropRect));
}
static sk_sp<SkColorFilter> make_color_filter() {
- return SkColorFilter::MakeModeFilter(0xFFAABBCC, SkXfermode::kDarken_Mode);
+ return SkColorFilter::MakeModeFilter(0xFFAABBCC, SkBlendMode::kDarken);
}
class VerticesGM : public skiagm::GM {
{ fColors, fTexs , fShader2, fColorFilter, 0x80 },
};
- const SkXfermode::Mode modes[] = {
- SkXfermode::kClear_Mode,
- SkXfermode::kSrc_Mode,
- SkXfermode::kDst_Mode,
- SkXfermode::kSrcOver_Mode,
- SkXfermode::kDstOver_Mode,
- SkXfermode::kSrcIn_Mode,
- SkXfermode::kDstIn_Mode,
- SkXfermode::kSrcOut_Mode,
- SkXfermode::kDstOut_Mode,
- SkXfermode::kSrcATop_Mode,
- SkXfermode::kDstATop_Mode,
- SkXfermode::kXor_Mode,
- SkXfermode::kPlus_Mode,
- SkXfermode::kModulate_Mode,
- SkXfermode::kScreen_Mode,
- SkXfermode::kOverlay_Mode,
- SkXfermode::kDarken_Mode,
- SkXfermode::kLighten_Mode,
- SkXfermode::kColorDodge_Mode,
- SkXfermode::kColorBurn_Mode,
- SkXfermode::kHardLight_Mode,
- SkXfermode::kSoftLight_Mode,
- SkXfermode::kDifference_Mode,
- SkXfermode::kExclusion_Mode,
- SkXfermode::kMultiply_Mode,
- SkXfermode::kHue_Mode,
- SkXfermode::kSaturation_Mode,
- SkXfermode::kColor_Mode,
- SkXfermode::kLuminosity_Mode,
+ const SkBlendMode modes[] = {
+ SkBlendMode::kClear,
+ SkBlendMode::kSrc,
+ SkBlendMode::kDst,
+ SkBlendMode::kSrcOver,
+ SkBlendMode::kDstOver,
+ SkBlendMode::kSrcIn,
+ SkBlendMode::kDstIn,
+ SkBlendMode::kSrcOut,
+ SkBlendMode::kDstOut,
+ SkBlendMode::kSrcATop,
+ SkBlendMode::kDstATop,
+ SkBlendMode::kXor,
+ SkBlendMode::kPlus,
+ SkBlendMode::kModulate,
+ SkBlendMode::kScreen,
+ SkBlendMode::kOverlay,
+ SkBlendMode::kDarken,
+ SkBlendMode::kLighten,
+ SkBlendMode::kColorDodge,
+ SkBlendMode::kColorBurn,
+ SkBlendMode::kHardLight,
+ SkBlendMode::kSoftLight,
+ SkBlendMode::kDifference,
+ SkBlendMode::kExclusion,
+ SkBlendMode::kMultiply,
+ SkBlendMode::kHue,
+ SkBlendMode::kSaturation,
+ SkBlendMode::kColor,
+ SkBlendMode::kLuminosity,
};
SkPaint paint;
canvas->translate(4, 4);
int x = 0;
for (size_t j = 0; j < SK_ARRAY_COUNT(modes); ++j) {
- auto xfer = SkXfermode::Make(modes[j]);
canvas->save();
for (size_t i = 0; i < SK_ARRAY_COUNT(rec); ++i) {
paint.setShader(rec[i].fShader);
canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode,
SK_ARRAY_COUNT(fPts), fPts,
rec[i].fTexs, rec[i].fColors,
- xfer, fan, SK_ARRAY_COUNT(fan), paint);
+ modes[j], fan, SK_ARRAY_COUNT(fan), paint);
canvas->translate(40, 0);
++x;
}
for (int i = 0; i < 6; ++i) {
GrPaint grPaint;
- grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
sk_sp<GrFragmentProcessor> fp(GrYUVEffect::MakeYUVToRGB(
texture[indices[i][0]], texture[indices[i][1]], texture[indices[i][2]], sizes,
static_cast<SkYUVColorSpace>(space), false));
SkScalar x = kDrawPad + kTestPad;
GrPaint grPaint;
- grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
sk_sp<GrFragmentProcessor> fp(
GrYUVEffect::MakeYUVToRGB(texture[0], texture[1], texture[2], sizes,
static_cast<SkYUVColorSpace>(space), true));
"SK_SUPPORT_LEGACY_SHADER_ISABITMAP",
"SK_SUPPORT_LEGACY_COLOR_SPACE_FACTORIES",
"SK_SUPPORT_LEGACY_SHADER_ASALOCALMATRIXSHADER",
+ "SK_SUPPORT_LEGACY_XFERMODE_PARAM",
]
const SkPoint& offset, const SkPaint& paint) override;
virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
const SkPoint verts[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) override;
virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y, const SkPaint&) override;
in _texture_ space (not uv space) for each vertex.
@param colors May be null. If not null, specifies a color for each
vertex, to be interpolated across the triangle.
- @param xmode Used if both texs and colors are present. In this
+ @param mode Used if both texs and colors are present. In this
case the colors are combined with the texture using mode,
- before being drawn using the paint. If mode is null, then
- kModulate_Mode is used.
+ before being drawn using the paint.
@param indices If not null, array of indices to reference into the
vertex (texs, colors) array.
@param indexCount number of entries in the indices array (if not null)
*/
void drawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SkBlendMode mode,
const uint16_t indices[], int indexCount,
const SkPaint& paint);
void drawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
+ const SkColor colors[], const uint16_t indices[], int indexCount,
+ const SkPaint& paint) {
+ this->drawVertices(vmode, vertexCount, vertices, texs, colors, SkBlendMode::kModulate,
+ indices, indexCount, paint);
+ }
+
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ void drawVertices(VertexMode vmode, int vertexCount,
+ const SkPoint vertices[], const SkPoint texs[],
+ const SkColor colors[], SkXfermode* xmode,
+ const uint16_t indices[], int indexCount,
+ const SkPaint& paint) {
+ this->drawVertices(vmode, vertexCount, vertices, texs, colors,
+ xmode ? xmode->blend() : SkBlendMode::kModulate,
+ indices, indexCount, paint);
+ }
+ void drawVertices(VertexMode vmode, int vertexCount,
+ const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], const sk_sp<SkXfermode>& xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
this->drawVertices(vmode, vertexCount, vertices, texs, colors, xmode.get(),
indices, indexCount, paint);
}
+#endif
/**
Draw a cubic coons patch
their order is clockwise starting at the top left corner.
@param texCoords specifies the texture coordinates that will be bilerp across the patch,
their order is the same as the colors.
- @param xmode specifies how are the colors and the textures combined if both of them are
+ @param mode specifies how are the colors and the textures combined if both of them are
present.
@param paint Specifies the shader/texture if present.
*/
void drawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint);
+ const SkPoint texCoords[4], SkBlendMode mode, const SkPaint& paint);
+ void drawPatch(const SkPoint cubics[12], const SkColor colors[4],
+ const SkPoint texCoords[4], const SkPaint& paint) {
+ this->drawPatch(cubics, colors, texCoords, SkBlendMode::kModulate, paint);
+ }
+
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ void drawPatch(const SkPoint cubics[12], const SkColor colors[4],
+ const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
+ this->drawPatch(cubics, colors, texCoords, xmode ? xmode->blend() : SkBlendMode::kModulate,
+ paint);
+ }
void drawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4],
const sk_sp<SkXfermode>& xmode, const SkPaint& paint) {
this->drawPatch(cubics, colors, texCoords, xmode.get(), paint);
}
+#endif
/**
* Draw a set of sprites from the atlas. Each is specified by a tex rectangle in the
* xform maps [0, 0, tex.width, tex.height] -> quad
*
* The color array is optional. When specified, each color modulates the pixels in its
- * corresponding quad (via the specified SkXfermode::Mode).
+ * corresponding quad (via the specified SkBlendMode).
*
* The cullRect is optional. When specified, it must be a conservative bounds of all of the
* resulting transformed quads, allowing the canvas to skip drawing if the cullRect does not
* intersect the current clip.
*
* The paint is optional. If specified, its antialiasing, alpha, color-filter, image-filter
- * and xfermode are used to affect each of the quads.
+ * and blendmode are used to affect each of the quads.
*/
void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
- const SkColor colors[], int count, SkXfermode::Mode, const SkRect* cullRect,
+ const SkColor colors[], int count, SkBlendMode, const SkRect* cullRect,
const SkPaint* paint);
-
+ void drawAtlas(const sk_sp<SkImage>& atlas, const SkRSXform xform[], const SkRect tex[],
+ const SkColor colors[], int count, SkBlendMode mode, const SkRect* cullRect,
+ const SkPaint* paint) {
+ this->drawAtlas(atlas.get(), xform, tex, colors, count, mode, cullRect, paint);
+ }
void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], int count,
const SkRect* cullRect, const SkPaint* paint) {
- this->drawAtlas(atlas, xform, tex, NULL, count, SkXfermode::kDst_Mode, cullRect, paint);
+ this->drawAtlas(atlas, xform, tex, nullptr, count, SkBlendMode::kDst, cullRect, paint);
}
-
void drawAtlas(const sk_sp<SkImage>& atlas, const SkRSXform xform[], const SkRect tex[],
- const SkColor colors[], int count, SkXfermode::Mode mode, const SkRect* cull,
+ int count, const SkRect* cullRect, const SkPaint* paint) {
+ this->drawAtlas(atlas.get(), xform, tex, nullptr, count, SkBlendMode::kDst,
+ cullRect, paint);
+ }
+
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
+ const SkColor colors[], int count, SkXfermode::Mode mode, const SkRect* cullRect,
const SkPaint* paint) {
- this->drawAtlas(atlas.get(), xform, tex, colors, count, mode, cull, paint);
+ this->drawAtlas(atlas, xform, tex, colors, count, (SkBlendMode)mode, cullRect, paint);
}
+
void drawAtlas(const sk_sp<SkImage>& atlas, const SkRSXform xform[], const SkRect tex[],
- int count, const SkRect* cullRect, const SkPaint* paint) {
- this->drawAtlas(atlas.get(), xform, tex, nullptr, count, SkXfermode::kDst_Mode,
- cullRect, paint);
+ const SkColor colors[], int count, SkXfermode::Mode mode, const SkRect* cull,
+ const SkPaint* paint) {
+ this->drawAtlas(atlas.get(), xform, tex, colors, count, (SkBlendMode)mode, cull, paint);
}
+#endif
/**
* Draw the contents of this drawable into the canvas. If the canvas is async
const SkPaint& paint);
virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint);
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM, const SkPaint& paint);
virtual void onDrawDrawable(SkDrawable*, const SkMatrix*);
virtual void onDrawRRect(const SkRRect&, const SkPaint&);
virtual void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&);
virtual void onDrawVertices(VertexMode, int vertexCount, const SkPoint vertices[],
- const SkPoint texs[], const SkColor colors[], SkXfermode*,
+ const SkPoint texs[], const SkColor colors[], SK_XFERMODE_PARAM,
const uint16_t indices[], int indexCount, const SkPaint&);
virtual void onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[],
- int count, SkXfermode::Mode, const SkRect* cull, const SkPaint*);
+ int count, SK_XFERMODE_MODE_PARAM, const SkRect* cull, const SkPaint*);
virtual void onDrawPath(const SkPath&, const SkPaint&);
virtual void onDrawImage(const SkImage*, SkScalar dx, SkScalar dy, const SkPaint*);
virtual void onDrawImageRect(const SkImage*, const SkRect*, const SkRect&, const SkPaint*,
* returns true, and sets (if not NULL) the color and mode appropriately.
* If not, this returns false and ignores the parameters.
*/
- virtual bool asColorMode(SkColor* color, SkXfermode::Mode* mode) const;
+ virtual bool asColorMode(SkColor* color, SK_XFERMODE_MODE_PARAM* mode) const;
/**
* If the filter can be represented by a 5x4 matrix, this
If the Mode is DST, this function will return NULL (since that
mode will have no effect on the result).
@param c The source color used with the specified mode
- @param mode The xfermode mode that is applied to each color in
+ @param mode The blend that is applied to each color in
the colorfilter's filterSpan[16,32] methods
@return colorfilter object that applies the src color and mode,
or NULL if the mode will have no effect.
*/
- static sk_sp<SkColorFilter> MakeModeFilter(SkColor c, SkXfermode::Mode mode);
- static sk_sp<SkColorFilter> MakeModeFilter(SkColor c, SkBlendMode mode) {
- return MakeModeFilter(c, (SkXfermode::Mode)mode);
+ static sk_sp<SkColorFilter> MakeModeFilter(SkColor c, SkBlendMode mode);
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ static sk_sp<SkColorFilter> MakeModeFilter(SkColor c, SkXfermode::Mode mode) {
+ return MakeModeFilter(c, (SkBlendMode)mode);
}
+#endif
/** Construct a colorfilter whose effect is to first apply the inner filter and then apply
* the outer filter to the result of the inner's.
const SkPoint& offset, const SkPaint& paint) = 0;
virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
const SkPoint verts[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) = 0;
// default implementation unrolls the blob runs.
const SkPaint& paint, SkDrawFilter* drawFilter);
// default implementation calls drawVertices
virtual void drawPatch(const SkDraw&, const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint);
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM, const SkPaint& paint);
// default implementation calls drawPath
virtual void drawAtlas(const SkDraw&, const SkImage* atlas, const SkRSXform[], const SkRect[],
- const SkColor[], int count, SkXfermode::Mode, const SkPaint&);
+ const SkColor[], int count, SK_XFERMODE_MODE_PARAM, const SkPaint&);
virtual void drawAnnotation(const SkDraw&, const SkRect&, const char[], SkData*) {}
const SkPoint& offset, const SkPaint& paint) const;
void drawVertices(SkCanvas::VertexMode mode, int count,
const SkPoint vertices[], const SkPoint textures[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SkBlendMode bmode,
const uint16_t indices[], int ptCount,
const SkPaint& paint) const;
// V48: Read and write extended SkTextBlobs.
// V49: Gradients serialized as SkColor4f + SkColorSpace
// V50: SkXfermode -> SkBlendMode
+ // V51: more SkXfermode -> SkBlendMode
// Only SKPs within the min/current picture version range (inclusive) can be read.
static const uint32_t MIN_PICTURE_VERSION = 35; // Produced by Chrome M39.
- static const uint32_t CURRENT_PICTURE_VERSION = 50;
+ static const uint32_t CURRENT_PICTURE_VERSION = 51;
static_assert(MIN_PICTURE_VERSION <= 41,
"Remove kFontFileName and related code from SkFontDescriptor.cpp.");
struct ComposeRec {
const SkShader* fShaderA;
const SkShader* fShaderB;
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
const SkXfermode* fMode;
+#endif
+ SkBlendMode fBlendMode;
};
virtual bool asACompose(ComposeRec*) const { return false; }
*/
static sk_sp<SkShader> MakeColorShader(const SkColor4f&, sk_sp<SkColorSpace>);
+ static sk_sp<SkShader> MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src, SkBlendMode);
+
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
static sk_sp<SkShader> MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src,
- SkXfermode::Mode);
+ SkXfermode::Mode mode) {
+ return MakeComposeShader(dst, src, (SkBlendMode)mode);
+ }
/**
* Create a new compose shader, given shaders dst, src, and a combining xfermode mode.
* The caller is responsible for managing its reference-count for the xfer (if not null).
*/
static sk_sp<SkShader> MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src,
- sk_sp<SkXfermode> xfer);
+ sk_sp<SkXfermode> xfer) {
+ return MakeComposeShader(dst, src, xfer ? xfer->blend() : SkBlendMode::kSrcOver);
+ }
+#endif
/** Call this to create a new shader that will draw with the specified bitmap.
*
#include <string.h>
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ #define SK_XFERMODE_PARAM SkXfermode*
+ #define SK_XFERMODE_MODE_PARAM SkXfermode::Mode
+#else
+ #define SK_XFERMODE_PARAM SkBlendMode
+ #define SK_XFERMODE_MODE_PARAM SkBlendMode
+#endif
+
/**
* sk_careful_memcpy() is just like memcpy(), but guards against undefined behavior.
*
/** Return an SkXfermode object for the specified mode.
*/
- static sk_sp<SkXfermode> Make(Mode);
+ static sk_sp<SkXfermode> Make(SkBlendMode);
+ static sk_sp<SkXfermode> Make(Mode m) { return Make((SkBlendMode)m); }
/**
* Skia maintains global xfermode objects corresponding to each BlendMode. This returns a
return xfer.get();
}
- static sk_sp<SkXfermode> Make(SkBlendMode bm) {
- return Make((Mode)bm);
- }
-
SkBlendMode blend() const {
Mode mode;
SkAssertResult(this->asMode(&mode));
* src and dst parameters.
*/
static bool ModeAsCoeff(Mode mode, Coeff* src, Coeff* dst);
+ static bool ModeAsCoeff(SkBlendMode mode, Coeff* src, Coeff* dst) {
+ return ModeAsCoeff((Mode)mode, src, dst);
+ }
/**
* Returns whether or not the xfer mode can support treating coverage as alpha
*/
struct SK_API LayerInfo {
BitFlags fPaintBits;
- SkXfermode::Mode fColorMode;
+ SK_XFERMODE_MODE_PARAM fColorMode;
SkVector fOffset;
bool fPostTranslate; //!< applies to fOffset
~SkMergeImageFilter() override;
static sk_sp<SkImageFilter> Make(sk_sp<SkImageFilter> first, sk_sp<SkImageFilter> second,
- SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode,
+ SkBlendMode, const CropRect* cropRect = nullptr);
+ static sk_sp<SkImageFilter> MakeN(sk_sp<SkImageFilter>[], int count, const SkBlendMode[],
const CropRect* cropRect = nullptr);
+
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ static sk_sp<SkImageFilter> Make(sk_sp<SkImageFilter> first, sk_sp<SkImageFilter> second,
+ SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode,
+ const CropRect* cropRect = nullptr) {
+ return Make(first, second, (SkBlendMode)mode, cropRect);
+ }
static sk_sp<SkImageFilter> Make(sk_sp<SkImageFilter> filters[],
int count,
const SkXfermode::Mode modes[] = nullptr,
- const CropRect* cropRect = nullptr);
+ const CropRect* cropRect = nullptr) {
+ static_assert(sizeof(SkXfermode::Mode) == sizeof(SkBlendMode), "size mismatch");
+ return MakeN(filters, count, (const SkBlendMode*)modes, cropRect);
+ }
+#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMergeImageFilter)
bool onCanHandleComplexCTM() const override { return true; }
private:
- SkMergeImageFilter(sk_sp<SkImageFilter> filters[], int count, const SkXfermode::Mode modes[],
+ SkMergeImageFilter(sk_sp<SkImageFilter> filters[], int count, const SkBlendMode modes[],
const CropRect* cropRect);
uint8_t* fModes; // SkXfermode::Mode
intptr_t fStorage[16];
void initAllocModes();
- void initModes(const SkXfermode::Mode []);
+ void initModes(const SkBlendMode[]);
typedef SkImageFilter INHERITED;
};
}
void setPorterDuffXPFactory(SkBlendMode mode) {
- fXPFactory = GrPorterDuffXPFactory::Make((SkXfermode::Mode)mode);
- }
-
- void setPorterDuffXPFactory(SkXfermode::Mode mode) {
fXPFactory = GrPorterDuffXPFactory::Make(mode);
}
* coefficients.
*/
namespace GrCustomXfermode {
- bool IsSupportedMode(SkXfermode::Mode mode);
- sk_sp<GrXPFactory> MakeXPFactory(SkXfermode::Mode mode);
+ bool IsSupportedMode(SkBlendMode mode);
+ sk_sp<GrXPFactory> MakeXPFactory(SkBlendMode mode);
};
#endif
class GrPorterDuffXPFactory : public GrXPFactory {
public:
- static sk_sp<GrXPFactory> Make(SkXfermode::Mode mode);
- static sk_sp<GrXPFactory> Make(SkBlendMode mode) {
- return Make((SkXfermode::Mode)mode);
- }
+ static sk_sp<GrXPFactory> Make(SkBlendMode mode);
void getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
GrXPFactory::InvariantBlendedColor*) const override;
static bool SrcOverWillNeedDstTexture(const GrCaps&, const GrPipelineOptimizations&);
private:
- GrPorterDuffXPFactory(SkXfermode::Mode);
+ GrPorterDuffXPFactory(SkBlendMode);
GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
const GrPipelineOptimizations& optimizations,
GR_DECLARE_XP_FACTORY_TEST;
static void TestGetXPOutputTypes(const GrXferProcessor*, int* outPrimary, int* outSecondary);
- SkXfermode::Mode fXfermode;
+ SkBlendMode fXfermode;
friend class GrPorterDuffTest; // for TestGetXPOutputTypes()
typedef GrXPFactory INHERITED;
#ifndef GrXfermodeFragmentProcessor_DEFINED
#define GrXfermodeFragmentProcessor_DEFINED
-#include "SkXfermode.h"
+#include "SkRefCnt.h"
+#include "SkBlendMode.h"
class GrFragmentProcessor;
/** The color input to the returned processor is treated as the src and the passed in processor
is the dst. */
sk_sp<GrFragmentProcessor> MakeFromDstProcessor(sk_sp<GrFragmentProcessor> dst,
- SkXfermode::Mode mode);
+ SkBlendMode mode);
/** The color input to the returned processor is treated as the dst and the passed in processor
is the src. */
sk_sp<GrFragmentProcessor> MakeFromSrcProcessor(sk_sp<GrFragmentProcessor> src,
- SkXfermode::Mode mode);
+ SkBlendMode mode);
/** Takes the input color, which is assumed to be unpremultiplied, passes it as an opaque color
to both src and dst. The outputs of a src and dst are blended using mode and the original
input's alpha is applied to the blended color to produce a premul output. */
sk_sp<GrFragmentProcessor> MakeFromTwoProcessors(sk_sp<GrFragmentProcessor> src,
sk_sp<GrFragmentProcessor> dst,
- SkXfermode::Mode mode);
+ SkBlendMode mode);
};
#endif
PODArray<SkPoint> cubics;
PODArray<SkColor> colors;
PODArray<SkPoint> texCoords;
- sk_sp<SkXfermode> xmode);
+ SkBlendMode bmode);
RECORD(DrawAtlas, kDraw_Tag|kHasImage_Tag|kHasPaint_Tag,
Optional<SkPaint> paint;
sk_sp<const SkImage> atlas;
PODArray<SkRect> texs;
PODArray<SkColor> colors;
int count;
- SkXfermode::Mode mode;
+ SkBlendMode mode;
Optional<SkRect> cull);
RECORD(DrawVertices, kDraw_Tag|kHasPaint_Tag,
SkPaint paint;
PODArray<SkPoint> vertices;
PODArray<SkPoint> texs;
PODArray<SkColor> colors;
- sk_sp<SkXfermode> xmode;
+ SkBlendMode bmode;
PODArray<uint16_t> indices;
int indexCount);
RECORD(DrawAnnotation, 0, // TODO: kDraw_Tag, skia:5548
virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
const SkPaint& paint) override;
virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) override;
void onDrawPaint(const SkPaint&) override;
const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint&) override;
const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint&) override;
void onDrawTextRSXform(const void* text, size_t byteLength, const SkRSXform xform[],
const SkRect* cull, const SkPaint& paint) override;
virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) override;
void onDrawPaint(const SkPaint&) override;
const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint&) override;
const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint&) override;
void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) override;
void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
"SK_SUPPORT_LEGACY_XFERMODE_OBJECT",
"SK_SUPPORT_LEGACY_COLOR_SPACE_FACTORIES",
"SK_SUPPORT_LEGACY_SHADER_ASALOCALMATRIXSHADER",
+ "SK_SUPPORT_LEGACY_XFERMODE_PARAM",
]
################################################################################
{ fTexX - texWidth, fTexY + texHeight}}
;
- sk_sp<SkXfermode> xfer(SkXfermode::Make(SkXfermode::kSrc_Mode));
-
SkScalar scaleFreq = 2.0;
fShader1 = SkPerlinNoiseShader2::MakeImprovedNoise(fXFreq/scaleFreq, fYFreq/scaleFreq, 4,
fSeed);
- fShaderCompose = SkShader::MakeComposeShader(fShader0, fShader1, nullptr);
+ fShaderCompose = SkShader::MakeComposeShader(fShader0, fShader1, SkBlendMode::kSrcOver);
paint.setShader(fShaderCompose);
if (fShowGrid) {
tex = nullptr;
}
- canvas->drawPatch(fPts, nullptr, tex, xfer, paint);
+ canvas->drawPatch(fPts, nullptr, tex, SkBlendMode::kSrc, paint);
draw_control_points(canvas, fPts);
}
auto shaderB = SkGradientShader::MakeLinear(pts, colors2, nullptr,
2, SkShader::kClamp_TileMode);
return SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB),
- SkXfermode::Make(SkXfermode::kDstIn_Mode));
+ SkBlendMode::kDstIn);
}
virtual void startTest() {
static void draw_atlas(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],
const SkRect tex[], const SkColor colors[], int count, const SkRect* cull,
const SkPaint* paint) {
- canvas->drawAtlas(atlas, xform, tex, colors, count, SkXfermode::kModulate_Mode, cull, paint);
+ canvas->drawAtlas(atlas, xform, tex, colors, count, SkBlendMode::kModulate, cull, paint);
}
static void draw_atlas_sim(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],
return;
}
- static const SkXfermode::Mode gModes[] = {
- SkXfermode::kClear_Mode,
- SkXfermode::kSrc_Mode,
- SkXfermode::kDst_Mode,
- SkXfermode::kSrcOver_Mode,
- SkXfermode::kDstOver_Mode,
- SkXfermode::kSrcIn_Mode,
- SkXfermode::kDstIn_Mode,
- SkXfermode::kSrcOut_Mode,
- SkXfermode::kDstOut_Mode,
- SkXfermode::kSrcATop_Mode,
- SkXfermode::kDstATop_Mode,
- SkXfermode::kXor_Mode,
- SkXfermode::kPlus_Mode,
- SkXfermode::kModulate_Mode,
+ static const SkBlendMode gModes[] = {
+ SkBlendMode::kClear,
+ SkBlendMode::kSrc,
+ SkBlendMode::kDst,
+ SkBlendMode::kSrcOver,
+ SkBlendMode::kDstOver,
+ SkBlendMode::kSrcIn,
+ SkBlendMode::kDstIn,
+ SkBlendMode::kSrcOut,
+ SkBlendMode::kDstOut,
+ SkBlendMode::kSrcATop,
+ SkBlendMode::kDstATop,
+ SkBlendMode::kXor,
+ SkBlendMode::kPlus,
+ SkBlendMode::kModulate,
};
static const SkColor gColors[] = {
case MERGE:
filter = SkMergeImageFilter::Make(make_image_filter(),
make_image_filter(),
- (SkXfermode::Mode)make_xfermode());
+ make_xfermode());
break;
case COLOR: {
sk_sp<SkColorFilter> cf(make_color_filter());
t += dt;
canvas->drawVertices(SkCanvas::kTriangleStrip_VertexMode, stripCount,
strip, doTextures ? tex : nullptr,
- doColors ? colors : nullptr, nullptr,
- nullptr, 0, paint);
+ doColors ? colors : nullptr, nullptr, 0, paint);
}
}
auto shaderB = SkShader::MakeBitmapShader(bm,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
- return SkShader::MakeComposeShader(std::move(shaderB), std::move(shaderA),
- SkXfermode::Make(SkXfermode::kDstIn_Mode));
+ return SkShader::MakeComposeShader(std::move(shaderB), std::move(shaderA), SkBlendMode::kDstIn);
}
class ShaderView : public SampleView {
auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
fShader = SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB),
- SkXfermode::Make(SkXfermode::kDstIn_Mode));
+ SkBlendMode::kDstIn);
}
protected:
static void draw_atlas(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],
const SkRect tex[], const SkColor colors[], int count, const SkRect* cull,
const SkPaint* paint) {
- canvas->drawAtlas(atlas, xform, tex, colors, count, SkXfermode::kModulate_Mode, cull, paint);
+ canvas->drawAtlas(atlas, xform, tex, colors, count, SkBlendMode::kModulate, cull, paint);
}
static void draw_atlas_sim(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],
paint.setShader(nullptr);
canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
fRecs[i].fVerts, fRecs[i].fTexs,
- nullptr, nullptr, nullptr, 0, paint);
+ nullptr, nullptr, 0, paint);
canvas->translate(SkIntToScalar(210), 0);
paint.setShader(fShader0);
canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
fRecs[i].fVerts, fRecs[i].fTexs,
- nullptr, nullptr, nullptr, 0, paint);
+ nullptr, nullptr, 0, paint);
canvas->translate(SkIntToScalar(210), 0);
paint.setShader(fShader1);
canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
fRecs[i].fVerts, fRecs[i].fTexs,
- nullptr, nullptr, nullptr, 0, paint);
+ nullptr, nullptr, 0, paint);
canvas->restore();
canvas->translate(0, SkIntToScalar(250));
paint.setShader(nullptr);
canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
fRecs[i].fVerts, fRecs[i].fTexs,
- nullptr, nullptr, nullptr, 0, paint);
+ nullptr, nullptr, 0, paint);
canvas->translate(SkIntToScalar(250), 0);
paint.setShader(fShader0);
canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
fRecs[i].fVerts, fRecs[i].fTexs,
- nullptr, nullptr, nullptr, 0, paint);
+ nullptr, nullptr, 0, paint);
canvas->translate(SkIntToScalar(250), 0);
paint.setShader(fShader1);
canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
fRecs[i].fVerts, fRecs[i].fTexs,
- nullptr, nullptr, nullptr, 0, paint);
+ nullptr, nullptr, 0, paint);
canvas->restore();
canvas->translate(0, SkIntToScalar(250));
void SkBitmapDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
int vertexCount,
const SkPoint verts[], const SkPoint textures[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
- draw.drawVertices(vmode, vertexCount, verts, textures, colors, xmode,
+ SkBlendMode bmode;
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ bmode = xmode ? xmode->blend() : SkBlendMode::kModulate;
+#else
+ bmode = xmode;
+#endif
+ draw.drawVertices(vmode, vertexCount, verts, textures, colors, bmode,
indices, indexCount, paint);
}
}
void SkCanvas::drawVertices(VertexMode vmode, int vertexCount, const SkPoint vertices[],
- const SkPoint texs[], const SkColor colors[], SkXfermode* xmode,
+ const SkPoint texs[], const SkColor colors[], SkBlendMode bmode,
const uint16_t indices[], int indexCount, const SkPaint& paint) {
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ SkXfermode* xmode = SkXfermode::Peek(bmode);
+#else
+ SkBlendMode xmode = bmode;
+#endif
this->onDrawVertices(vmode, vertexCount, vertices, texs, colors, xmode,
indices, indexCount, paint);
}
}
void SkCanvas::drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
- const SkColor colors[], int count, SkXfermode::Mode mode,
+ const SkColor colors[], int count, SkBlendMode mode,
const SkRect* cull, const SkPaint* paint) {
RETURN_ON_NULL(atlas);
if (count <= 0) {
return;
}
SkASSERT(atlas);
- SkASSERT(xform);
SkASSERT(tex);
- this->onDrawAtlas(atlas, xform, tex, colors, count, mode, cull, paint);
+ this->onDrawAtlas(atlas, xform, tex, colors, count, (SK_XFERMODE_MODE_PARAM)mode, cull, paint);
}
void SkCanvas::drawAnnotation(const SkRect& rect, const char key[], SkData* value) {
void SkCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint verts[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawVertices()");
}
void SkCanvas::drawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
+ const SkPoint texCoords[4], SkBlendMode bmode,
+ const SkPaint& paint) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawPatch()");
if (nullptr == cubics) {
return;
}
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ SkXfermode* xmode = SkXfermode::Peek(bmode);
+#else
+ SkBlendMode xmode = bmode;
+#endif
this->onDrawPatch(cubics, colors, texCoords, xmode, paint);
}
void SkCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
+ const SkPaint& paint) {
// Since a patch is always within the convex hull of the control points, we discard it when its
// bounding rectangle is completely outside the current clip.
SkRect bounds;
}
void SkCanvas::onDrawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
- const SkColor colors[], int count, SkXfermode::Mode mode,
+ const SkColor colors[], int count, SK_XFERMODE_MODE_PARAM mode,
const SkRect* cull, const SkPaint* paint) {
if (cull && this->quickReject(*cull)) {
return;
#include "GrFragmentProcessor.h"
#endif
-bool SkColorFilter::asColorMode(SkColor* color, SkXfermode::Mode* mode) const {
+bool SkColorFilter::asColorMode(SkColor* color, SK_XFERMODE_MODE_PARAM* mode) const {
return false;
}
#include "SkXfermode.h"
#include "SkString.h"
+sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src,
+ SkBlendMode mode) {
+ if (!src || !dst) {
+ return nullptr;
+ }
+ if (SkBlendMode::kSrc == mode) {
+ return src;
+ }
+ if (SkBlendMode::kDst == mode) {
+ return dst;
+ }
+ return sk_sp<SkShader>(new SkComposeShader(std::move(dst), std::move(src), mode));
+}
+
///////////////////////////////////////////////////////////////////////////////
size_t SkComposeShader::onContextSize(const ContextRec& rec) const {
sk_sp<SkFlattenable> SkComposeShader::CreateProc(SkReadBuffer& buffer) {
sk_sp<SkShader> shaderA(buffer.readShader());
sk_sp<SkShader> shaderB(buffer.readShader());
- sk_sp<SkXfermode> mode(buffer.readXfermode());
+ SkBlendMode mode;
+ if (buffer.isVersionLT(SkReadBuffer::kXfermodeToBlendMode2_Version)) {
+ sk_sp<SkXfermode> xfer = buffer.readXfermode();
+ mode = xfer ? xfer->blend() : SkBlendMode::kSrcOver;
+ } else {
+ mode = (SkBlendMode)buffer.read32();
+ }
if (!shaderA || !shaderB) {
return nullptr;
}
- return sk_make_sp<SkComposeShader>(std::move(shaderA), std::move(shaderB), std::move(mode));
+ return sk_make_sp<SkComposeShader>(std::move(shaderA), std::move(shaderB), mode);
}
void SkComposeShader::flatten(SkWriteBuffer& buffer) const {
buffer.writeFlattenable(fShaderA.get());
buffer.writeFlattenable(fShaderB.get());
- buffer.writeFlattenable(fMode.get());
+ buffer.write32((int)fMode);
}
template <typename T> void safe_call_destructor(T* obj) {
if (rec) {
rec->fShaderA = fShaderA.get();
rec->fShaderB = fShaderB.get();
- rec->fMode = fMode.get();
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ rec->fMode = SkXfermode::Peek(fMode);
+#endif
+ rec->fBlendMode = fMode;
}
return true;
}
void SkComposeShader::ComposeShaderContext::shadeSpan(int x, int y, SkPMColor result[], int count) {
SkShader::Context* shaderContextA = fShaderContextA;
SkShader::Context* shaderContextB = fShaderContextB;
- SkXfermode* mode = static_cast<const SkComposeShader&>(fShader).fMode.get();
+ SkBlendMode mode = static_cast<const SkComposeShader&>(fShader).fMode;
unsigned scale = SkAlpha255To256(this->getPaintAlpha());
SkPMColor tmp[TMP_COLOR_COUNT];
- if (nullptr == mode) { // implied SRC_OVER
+ SkXfermode* xfer = SkXfermode::Peek(mode);
+ if (nullptr == xfer) { // implied SRC_OVER
// TODO: when we have a good test-case, should use SkBlitRow::Proc32
// for these loops
do {
shaderContextA->shadeSpan(x, y, result, n);
shaderContextB->shadeSpan(x, y, tmp, n);
- mode->xfer32(result, tmp, n, nullptr);
+ xfer->xfer32(result, tmp, n, nullptr);
if (256 != scale) {
for (int i = 0; i < n; i++) {
/////////////////////////////////////////////////////////////////////
sk_sp<GrFragmentProcessor> SkComposeShader::asFragmentProcessor(const AsFPArgs& args) const {
- // Fragment processor will only support SkXfermode::Mode modes currently.
- SkXfermode::Mode mode;
- if (!(SkXfermode::AsMode(fMode, &mode))) {
- return nullptr;
- }
-
- switch (mode) {
- case SkXfermode::kClear_Mode:
+ switch (fMode) {
+ case SkBlendMode::kClear:
return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
GrConstColorProcessor::kIgnore_InputMode);
break;
- case SkXfermode::kSrc_Mode:
+ case SkBlendMode::kSrc:
return fShaderB->asFragmentProcessor(args);
break;
- case SkXfermode::kDst_Mode:
+ case SkBlendMode::kDst:
return fShaderA->asFragmentProcessor(args);
break;
default:
return nullptr;
}
return GrXfermodeFragmentProcessor::MakeFromTwoProcessors(std::move(fpB),
- std::move(fpA), mode);
+ std::move(fpA), fMode);
}
}
#endif
fShaderA->toString(str);
str->append(" ShaderB: ");
fShaderB->toString(str);
- if (fMode) {
- str->append(" Xfermode: ");
- fMode->toString(str);
+ if (SkBlendMode::kSrcOver != fMode) {
+ str->appendf(" Xfermode: %s", SkXfermode::ModeName(fMode));
}
this->INHERITED::toString(str);
str->append(")");
}
#endif
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src,
- sk_sp<SkXfermode> xfer) {
- if (!dst || !src) {
- return nullptr;
- }
- return sk_make_sp<SkComposeShader>(std::move(dst), std::move(src), std::move(xfer));
-}
-
-sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src,
- SkXfermode::Mode mode) {
- return MakeComposeShader(std::move(dst), std::move(src), SkXfermode::Make(mode));
-}
#define SkComposeShader_DEFINED
#include "SkShader.h"
-#include "SkXfermode.h"
+#include "SkBlendMode.h"
///////////////////////////////////////////////////////////////////////////////////////////
@param mode The xfermode that combines the colors from the two shaders. If mode
is null, then SRC_OVER is assumed.
*/
- SkComposeShader(sk_sp<SkShader> sA, sk_sp<SkShader> sB, sk_sp<SkXfermode> mode)
+ SkComposeShader(sk_sp<SkShader> sA, sk_sp<SkShader> sB, SkBlendMode mode)
: fShaderA(std::move(sA))
, fShaderB(std::move(sB))
- , fMode(std::move(mode))
+ , fMode(mode)
{}
#if SK_SUPPORT_GPU
private:
sk_sp<SkShader> fShaderA;
sk_sp<SkShader> fShaderB;
- sk_sp<SkXfermode> fMode;
+ SkBlendMode fMode;
typedef SkShader INHERITED;
};
}
void SkBaseDevice::drawPatch(const SkDraw& draw, const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode, const SkPaint& paint) {
SkPatchUtils::VertexData data;
SkISize lod = SkPatchUtils::GetLevelOfDetail(cubics, draw.fMatrix);
void SkBaseDevice::drawAtlas(const SkDraw& draw, const SkImage* atlas, const SkRSXform xform[],
const SkRect tex[], const SkColor colors[], int count,
- SkXfermode::Mode mode, const SkPaint& paint) {
+ SK_XFERMODE_MODE_PARAM mode, const SkPaint& paint) {
SkPath path;
path.setIsVolatile(true);
pnt.setShader(std::move(shader));
if (colors) {
- pnt.setColorFilter(SkColorFilter::MakeModeFilter(colors[i], mode));
+ pnt.setColorFilter(SkColorFilter::MakeModeFilter(colors[i], (SkBlendMode)mode));
}
path.rewind();
void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count,
const SkPoint vertices[], const SkPoint textures[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SkBlendMode bmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) const {
SkASSERT(0 == count || vertices);
} else {
// colors * texture
SkASSERT(shader);
- sk_sp<SkXfermode> xfer = xmode ? sk_ref_sp(xmode)
- : SkXfermode::Make(SkXfermode::kModulate_Mode);
- p.setShader(SkShader::MakeComposeShader(triShader, sk_ref_sp(shader), std::move(xfer)));
+ p.setShader(SkShader::MakeComposeShader(triShader, sk_ref_sp(shader), bmode));
}
}
struct DrawPatch final : Op {
static const auto kType = Type::DrawPatch;
DrawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texs[4],
- SkXfermode* xfermode, const SkPaint& paint)
- : xfermode(sk_ref_sp(xfermode)), paint(paint) {
+ SK_XFERMODE_PARAM xfermode, const SkPaint& paint)
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ : xfermode(sk_ref_sp(xfermode)), paint(paint)
+#else
+ : xfermode(xfermode), paint(paint)
+#endif
+ {
copy_v(this->cubics, cubics, 12);
if (colors) { copy_v(this->colors, colors, 4); has_colors = true; }
if (texs ) { copy_v(this->texs , texs , 4); has_texs = true; }
SkPoint cubics[12];
SkColor colors[4];
SkPoint texs[4];
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
sk_sp<SkXfermode> xfermode;
+#else
+ SkBlendMode xfermode;
+#endif
SkPaint paint;
bool has_colors = false;
bool has_texs = false;
void draw(SkCanvas* c, const SkMatrix&) {
c->drawPatch(cubics, has_colors ? colors : nullptr, has_texs ? texs : nullptr,
- xfermode.get(), paint);
+ xfermode, paint);
}
};
struct DrawPoints final : Op {
};
struct DrawVertices final : Op {
static const auto kType = Type::DrawVertices;
- DrawVertices(SkCanvas::VertexMode mode, int count, SkXfermode* xfermode, int nindices,
+ DrawVertices(SkCanvas::VertexMode mode, int count, SK_XFERMODE_PARAM xfermode, int nindices,
const SkPaint& paint, bool has_texs, bool has_colors, bool has_indices)
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
: mode(mode), count(count), xfermode(sk_ref_sp(xfermode)), nindices(nindices)
+#else
+ : mode(mode), count(count), xfermode(xfermode), nindices(nindices)
+#endif
, paint(paint), has_texs(has_texs), has_colors(has_colors), has_indices(has_indices) {}
SkCanvas::VertexMode mode;
int count;
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
sk_sp<SkXfermode> xfermode;
+#else
+ SkBlendMode xfermode;
+#endif
int nindices;
SkPaint paint;
bool has_texs;
if (has_indices) {
indices = pod<uint16_t>(this, offset);
}
- c->drawVertices(mode, count, vertices, texs, colors, xfermode.get(),
+ c->drawVertices(mode, count, vertices, texs, colors, xfermode,
indices, nindices, paint);
}
};
struct DrawAtlas final : Op {
static const auto kType = Type::DrawAtlas;
- DrawAtlas(const SkImage* atlas, int count, SkXfermode::Mode xfermode,
+ DrawAtlas(const SkImage* atlas, int count, SK_XFERMODE_MODE_PARAM xfermode,
const SkRect* cull, const SkPaint* paint, bool has_colors)
: atlas(sk_ref_sp(atlas)), count(count), xfermode(xfermode), has_colors(has_colors) {
if (cull) { this->cull = *cull; }
}
sk_sp<const SkImage> atlas;
int count;
- SkXfermode::Mode xfermode;
+ SK_XFERMODE_MODE_PARAM xfermode;
SkRect cull = kUnset;
SkPaint paint;
bool has_colors;
}
void SkLiteDL::drawPatch(const SkPoint points[12], const SkColor colors[4], const SkPoint texs[4],
- SkXfermode* xfermode, const SkPaint& paint) {
+ SK_XFERMODE_PARAM xfermode, const SkPaint& paint) {
this->push<DrawPatch>(0, points, colors, texs, xfermode, paint);
}
void SkLiteDL::drawPoints(SkCanvas::PointMode mode, size_t count, const SkPoint points[],
copy_v(pod, points,count);
}
void SkLiteDL::drawVertices(SkCanvas::VertexMode mode, int count, const SkPoint vertices[],
- const SkPoint texs[], const SkColor colors[], SkXfermode* xfermode,
+ const SkPoint texs[], const SkColor colors[], SK_XFERMODE_PARAM xfermode,
const uint16_t indices[], int nindices, const SkPaint& paint) {
size_t bytes = count * sizeof(SkPoint);
if (texs ) { bytes += count * sizeof(SkPoint); }
indices, indices ? nindices : 0);
}
void SkLiteDL::drawAtlas(const SkImage* atlas, const SkRSXform xforms[], const SkRect texs[],
- const SkColor colors[], int count, SkXfermode::Mode xfermode,
+ const SkColor colors[], int count, SK_XFERMODE_MODE_PARAM xfermode,
const SkRect* cull, const SkPaint* paint) {
size_t bytes = count*(sizeof(SkRSXform) + sizeof(SkRect));
if (colors) {
const SkRect&, const SkPaint*);
void drawPatch(const SkPoint[12], const SkColor[4], const SkPoint[4],
- SkXfermode*, const SkPaint&);
+ SK_XFERMODE_PARAM, const SkPaint&);
void drawPoints(SkCanvas::PointMode, size_t, const SkPoint[], const SkPaint&);
void drawVertices(SkCanvas::VertexMode, int, const SkPoint[], const SkPoint[], const SkColor[],
- SkXfermode*, const uint16_t[], int, const SkPaint&);
+ SK_XFERMODE_PARAM, const uint16_t[], int, const SkPaint&);
void drawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[], int,
- SkXfermode::Mode, const SkRect*, const SkPaint*);
+ SK_XFERMODE_MODE_PARAM, const SkRect*, const SkPaint*);
void setBounds(const SkRect& bounds);
void SkLiteRecorder::onDrawPatch(const SkPoint cubics[12],
const SkColor colors[4], const SkPoint texCoords[4],
- SkXfermode* xfermode, const SkPaint& paint) {
+ SK_XFERMODE_PARAM xfermode, const SkPaint& paint) {
fDL->drawPatch(cubics, colors, texCoords, xfermode, paint);
}
void SkLiteRecorder::onDrawPoints(SkCanvas::PointMode mode,
void SkLiteRecorder::onDrawVertices(SkCanvas::VertexMode mode,
int count, const SkPoint vertices[],
const SkPoint texs[], const SkColor colors[],
- SkXfermode* xfermode,
+ SK_XFERMODE_PARAM xfermode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
fDL->drawVertices(mode, count, vertices, texs, colors, xfermode, indices, indexCount, paint);
const SkRect texs[],
const SkColor colors[],
int count,
- SkXfermode::Mode xfermode,
+ SK_XFERMODE_MODE_PARAM xfermode,
const SkRect* cull,
const SkPaint* paint) {
fDL->drawAtlas(atlas, xforms, texs, colors, count, xfermode, cull, paint);
SrcRectConstraint) override;
void onDrawPatch(const SkPoint[12], const SkColor[4],
- const SkPoint[4], SkXfermode*, const SkPaint&) override;
+ const SkPoint[4], SK_XFERMODE_PARAM, const SkPaint&) override;
void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
void onDrawVertices(VertexMode, int, const SkPoint[], const SkPoint[], const SkColor[],
- SkXfermode*, const uint16_t[], int, const SkPaint&) override;
+ SK_XFERMODE_PARAM, const uint16_t[], int, const SkPaint&) override;
void onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[],
- int, SkXfermode::Mode, const SkRect*, const SkPaint*) override;
+ int, SK_XFERMODE_MODE_PARAM, const SkRect*, const SkPaint*) override;
#ifdef SK_EXPERIMENTAL_SHADOWING
void didTranslateZ(SkScalar) override;
}
#endif
-bool SkModeColorFilter::asColorMode(SkColor* color, SkXfermode::Mode* mode) const {
+bool SkModeColorFilter::asColorMode(SkColor* color, SK_XFERMODE_MODE_PARAM* mode) const {
if (color) {
*color = fColor;
}
if (mode) {
- *mode = fMode;
+ *mode = (SK_XFERMODE_MODE_PARAM)fMode;
}
return true;
}
uint32_t SkModeColorFilter::getFlags() const {
uint32_t flags = 0;
switch (fMode) {
- case SkXfermode::kDst_Mode: //!< [Da, Dc]
- case SkXfermode::kSrcATop_Mode: //!< [Da, Sc * Da + (1 - Sa) * Dc]
+ case SkBlendMode::kDst: //!< [Da, Dc]
+ case SkBlendMode::kSrcATop: //!< [Da, Sc * Da + (1 - Sa) * Dc]
flags |= kAlphaUnchanged_Flag;
default:
break;
}
void SkModeColorFilter::filterSpan4f(const SkPM4f shader[], int count, SkPM4f result[]) const {
- SkXfermodeProc4f proc = SkXfermode::GetProc4f(fMode);
+ SkXfermodeProc4f proc = SkXfermode::GetProc4f((SkXfermode::Mode)fMode);
for (int i = 0; i < count; i++) {
result[i] = proc(fPM4f, shader[i]);
void SkModeColorFilter::flatten(SkWriteBuffer& buffer) const {
buffer.writeColor(fColor);
- buffer.writeUInt(fMode);
+ buffer.writeUInt((int)fMode);
}
void SkModeColorFilter::updateCache() {
fPMColor = SkPreMultiplyColor(fColor);
- fProc = SkXfermode::GetProc(fMode);
+ fProc = SkXfermode::GetProc((SkXfermode::Mode)fMode);
fPM4f = SkColor4f::FromColor(fColor).premul();
}
sk_sp<SkFlattenable> SkModeColorFilter::CreateProc(SkReadBuffer& buffer) {
SkColor color = buffer.readColor();
- SkXfermode::Mode mode = (SkXfermode::Mode)buffer.readUInt();
+ SkBlendMode mode = (SkBlendMode)buffer.readUInt();
return SkColorFilter::MakeModeFilter(color, mode);
}
sk_sp<GrFragmentProcessor> SkModeColorFilter::asFragmentProcessor(
GrContext*, SkColorSpace* dstColorSpace) const {
- if (SkXfermode::kDst_Mode == fMode) {
+ if (SkBlendMode::kDst == fMode) {
return nullptr;
}
#ifdef SK_DEBUG
// With a solid color input this should always be able to compute the blended color
// (at least for coeff modes)
- if (fMode <= SkXfermode::kLastCoeffMode) {
+ if ((unsigned)fMode <= (unsigned)SkBlendMode::kLastCoeffMode) {
static SkRandom gRand;
GrInvariantOutput io(GrPremulColor(gRand.nextU()), kRGBA_GrColorComponentFlags,
false);
class Src_SkModeColorFilter final : public SkModeColorFilter {
public:
- Src_SkModeColorFilter(SkColor color) : INHERITED(color, SkXfermode::kSrc_Mode) {}
+ Src_SkModeColorFilter(SkColor color) : INHERITED(color, SkBlendMode::kSrc) {}
void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const override {
sk_memset32(result, this->getPMColor(), count);
class SrcOver_SkModeColorFilter final : public SkModeColorFilter {
public:
- SrcOver_SkModeColorFilter(SkColor color) : INHERITED(color, SkXfermode::kSrcOver_Mode) { }
+ SrcOver_SkModeColorFilter(SkColor color) : INHERITED(color, SkBlendMode::kSrcOver) { }
void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const override {
SkBlitRow::Color32(result, shader, count, this->getPMColor());
///////////////////////////////////////////////////////////////////////////////
-sk_sp<SkColorFilter> SkColorFilter::MakeModeFilter(SkColor color, SkXfermode::Mode mode) {
+sk_sp<SkColorFilter> SkColorFilter::MakeModeFilter(SkColor color, SkBlendMode mode) {
if (!SkIsValidMode(mode)) {
return nullptr;
}
// first collaps some modes if possible
- if (SkXfermode::kClear_Mode == mode) {
+ if (SkBlendMode::kClear == mode) {
color = 0;
- mode = SkXfermode::kSrc_Mode;
- } else if (SkXfermode::kSrcOver_Mode == mode) {
+ mode = SkBlendMode::kSrc;
+ } else if (SkBlendMode::kSrcOver == mode) {
if (0 == alpha) {
- mode = SkXfermode::kDst_Mode;
+ mode = SkBlendMode::kDst;
} else if (255 == alpha) {
- mode = SkXfermode::kSrc_Mode;
+ mode = SkBlendMode::kSrc;
}
// else just stay srcover
}
// weed out combinations that are noops, and just return null
- if (SkXfermode::kDst_Mode == mode ||
- (0 == alpha && (SkXfermode::kSrcOver_Mode == mode ||
- SkXfermode::kDstOver_Mode == mode ||
- SkXfermode::kDstOut_Mode == mode ||
- SkXfermode::kSrcATop_Mode == mode ||
- SkXfermode::kXor_Mode == mode ||
- SkXfermode::kDarken_Mode == mode)) ||
- (0xFF == alpha && SkXfermode::kDstIn_Mode == mode)) {
+ if (SkBlendMode::kDst == mode ||
+ (0 == alpha && (SkBlendMode::kSrcOver == mode ||
+ SkBlendMode::kDstOver == mode ||
+ SkBlendMode::kDstOut == mode ||
+ SkBlendMode::kSrcATop == mode ||
+ SkBlendMode::kXor == mode ||
+ SkBlendMode::kDarken == mode)) ||
+ (0xFF == alpha && SkBlendMode::kDstIn == mode)) {
return nullptr;
}
switch (mode) {
- case SkXfermode::kSrc_Mode:
+ case SkBlendMode::kSrc:
return sk_make_sp<Src_SkModeColorFilter>(color);
- case SkXfermode::kSrcOver_Mode:
+ case SkBlendMode::kSrcOver:
return sk_make_sp<SrcOver_SkModeColorFilter>(color);
default:
return SkModeColorFilter::Make(color, mode);
class SkModeColorFilter : public SkColorFilter {
public:
- static sk_sp<SkColorFilter> Make(SkColor color, SkXfermode::Mode mode) {
+ static sk_sp<SkColorFilter> Make(SkColor color, SkBlendMode mode) {
return sk_sp<SkColorFilter>(new SkModeColorFilter(color, mode));
}
SkColor getColor() const { return fColor; }
- SkXfermode::Mode getMode() const { return fMode; }
+ SkBlendMode getMode() const { return fMode; }
SkPMColor getPMColor() const { return fPMColor; }
- bool asColorMode(SkColor*, SkXfermode::Mode*) const override;
+ bool asColorMode(SkColor*, SK_XFERMODE_MODE_PARAM*) const override;
uint32_t getFlags() const override;
void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const override;
void filterSpan4f(const SkPM4f shader[], int count, SkPM4f result[]) const override;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkModeColorFilter)
protected:
- SkModeColorFilter(SkColor color, SkXfermode::Mode mode) {
+ SkModeColorFilter(SkColor color, SkBlendMode mode) {
fColor = color;
fMode = mode;
this->updateCache();
private:
SkColor fColor;
- SkXfermode::Mode fMode;
+ SkBlendMode fMode;
// cache
SkPMColor fPMColor;
SkXfermodeProc fProc;
// Declare function pointers here...
// May return nullptr if we haven't specialized the given Mode.
- extern SkXfermode* (*create_xfermode)(const ProcCoeff&, SkXfermode::Mode);
+ extern SkXfermode* (*create_xfermode)(const ProcCoeff&, SkBlendMode);
typedef void (*BoxBlur)(const SkPMColor*, int, const SkIRect& srcBounds, SkPMColor*, int, int, int, int, int);
extern BoxBlur box_blur_xx, box_blur_xy, box_blur_yx;
const SkRSXform* xform = (const SkRSXform*)reader->skip(count * sizeof(SkRSXform));
const SkRect* tex = (const SkRect*)reader->skip(count * sizeof(SkRect));
const SkColor* colors = nullptr;
- SkXfermode::Mode mode = SkXfermode::kDst_Mode;
+ SkBlendMode mode = SkBlendMode::kDst;
if (flags & DRAW_ATLAS_HAS_COLORS) {
colors = (const SkColor*)reader->skip(count * sizeof(SkColor));
- mode = (SkXfermode::Mode)reader->readUInt();
+ mode = (SkBlendMode)reader->readUInt();
}
const SkRect* cull = nullptr;
if (flags & DRAW_ATLAS_HAS_CULL) {
texCoords = (const SkPoint*)reader->skip(SkPatchUtils::kNumCorners *
sizeof(SkPoint));
}
- sk_sp<SkXfermode> xfer;
+ SkBlendMode bmode = SkBlendMode::kModulate;
if (flag & DRAW_VERTICES_HAS_XFER) {
- int mode = reader->readInt();
- if (mode < 0 || mode > SkXfermode::kLastMode) {
- mode = SkXfermode::kModulate_Mode;
+ unsigned mode = reader->readInt();
+ if (mode <= (unsigned)SkBlendMode::kLastMode) {
+ bmode = (SkBlendMode)mode;
}
- xfer = SkXfermode::Make((SkXfermode::Mode)mode);
}
BREAK_ON_READ_ERROR(reader);
if (paint) {
- canvas->drawPatch(cubics, colors, texCoords, std::move(xfer), *paint);
+ canvas->drawPatch(cubics, colors, texCoords, bmode, *paint);
}
} break;
case DRAW_PATH: {
}
} break;
case DRAW_VERTICES: {
- sk_sp<SkXfermode> xfer;
const SkPaint* paint = fPictureData->getPaint(reader);
DrawVertexFlags flags = (DrawVertexFlags)reader->readInt();
SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader->readInt();
iCount = reader->readInt();
indices = (const uint16_t*)reader->skip(iCount * sizeof(uint16_t));
}
+ SkBlendMode bmode = SkBlendMode::kModulate;
if (flags & DRAW_VERTICES_HAS_XFER) {
- int mode = reader->readInt();
- if (mode < 0 || mode > SkXfermode::kLastMode) {
- mode = SkXfermode::kModulate_Mode;
+ unsigned mode = reader->readInt();
+ if (mode <= (unsigned)SkBlendMode::kLastMode) {
+ bmode = (SkBlendMode)mode;
}
- xfer = SkXfermode::Make((SkXfermode::Mode)mode);
}
BREAK_ON_READ_ERROR(reader);
if (paint) {
canvas->drawVertices(vmode, vCount, verts, texs, colors,
- xfer, indices, iCount, *paint);
+ bmode, indices, iCount, *paint);
}
} break;
case RESTORE:
void SkPictureRecord::onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xfer,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
uint32_t flags = 0;
if (indexCount > 0) {
flags |= DRAW_VERTICES_HAS_INDICES;
}
- if (xfer) {
- SkXfermode::Mode mode;
- if (xfer->asMode(&mode) && SkXfermode::kModulate_Mode != mode) {
- flags |= DRAW_VERTICES_HAS_XFER;
- }
+ SkBlendMode bmode = SkBlendMode::kModulate;
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ if (xmode) {
+ bmode = xmode->blend();
+ }
+#else
+ bmode = xmode;
+#endif
+ if (SkBlendMode::kModulate != bmode) {
+ flags |= DRAW_VERTICES_HAS_XFER;
}
// op + paint index + flags + vmode + vCount + vertices
fWriter.writePad(indices, indexCount * sizeof(uint16_t));
}
if (flags & DRAW_VERTICES_HAS_XFER) {
- SkXfermode::Mode mode = SkXfermode::kModulate_Mode;
- (void)xfer->asMode(&mode);
- this->addInt(mode);
+ this->addInt((int)bmode);
}
this->validate(initialOffset, size);
}
void SkPictureRecord::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) {
// op + paint index + patch 12 control points + flag + patch 4 colors + 4 texture coordinates
size_t size = 2 * kUInt32Size + SkPatchUtils::kNumCtrlPts * sizeof(SkPoint) + kUInt32Size;
flag |= DRAW_VERTICES_HAS_TEXS;
size += SkPatchUtils::kNumCorners * sizeof(SkPoint);
}
+ SkBlendMode bmode = SkBlendMode::kModulate;
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
if (xmode) {
- SkXfermode::Mode mode;
- if (xmode->asMode(&mode) && SkXfermode::kModulate_Mode != mode) {
- flag |= DRAW_VERTICES_HAS_XFER;
- size += kUInt32Size;
- }
+ bmode = xmode->blend();
+ }
+#else
+ bmode = xmode;
+#endif
+ if (SkBlendMode::kModulate != bmode) {
+ flag |= DRAW_VERTICES_HAS_XFER;
+ size += kUInt32Size;
}
size_t initialOffset = this->addDraw(DRAW_PATCH, &size);
fWriter.write(texCoords, SkPatchUtils::kNumCorners * sizeof(SkPoint));
}
if (flag & DRAW_VERTICES_HAS_XFER) {
- SkXfermode::Mode mode = SkXfermode::kModulate_Mode;
- xmode->asMode(&mode);
- this->addInt(mode);
+ this->addInt((int)bmode);
}
this->validate(initialOffset, size);
}
void SkPictureRecord::onDrawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
- const SkColor colors[], int count, SkXfermode::Mode mode,
+ const SkColor colors[], int count, SK_XFERMODE_MODE_PARAM mode,
const SkRect* cull, const SkPaint* paint) {
// [op + paint-index + atlas-index + flags + count] + [xform] + [tex] + [*colors + mode] + cull
size_t size = 5 * kUInt32Size + count * sizeof(SkRSXform) + count * sizeof(SkRect);
// write optional parameters
if (colors) {
fWriter.write(colors, count * sizeof(SkColor));
- this->addInt(mode);
+ this->addInt((int)mode);
}
if (cull) {
fWriter.write(cull, sizeof(SkRect));
const SkPaint& paint) override;
void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) override;
void onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[], int,
- SkXfermode::Mode, const SkRect*, const SkPaint*) override;
+ SK_XFERMODE_MODE_PARAM, const SkRect*, const SkPaint*) override;
void onDrawPaint(const SkPaint&) override;
void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint&) override;
kBlurMaskFilterWritesOccluder = 47,
kGradientShaderFloatColor_Version = 49,
kXfermodeToBlendMode_Version = 50,
+ kXfermodeToBlendMode2_Version = 51,
};
/**
DRAW(DrawOval, drawOval(r.oval, r.paint));
DRAW(DrawPaint, drawPaint(r.paint));
DRAW(DrawPath, drawPath(r.path, r.paint));
-DRAW(DrawPatch, drawPatch(r.cubics, r.colors, r.texCoords, r.xmode, r.paint));
+DRAW(DrawPatch, drawPatch(r.cubics, r.colors, r.texCoords, r.bmode, r.paint));
DRAW(DrawPicture, drawPicture(r.picture.get(), &r.matrix, r.paint));
#ifdef SK_EXPERIMENTAL_SHADOWING
DRAW(DrawAtlas, drawAtlas(r.atlas.get(),
r.xforms, r.texs, r.colors, r.count, r.mode, r.cull, r.paint));
DRAW(DrawVertices, drawVertices(r.vmode, r.vertexCount, r.vertices, r.texs, r.colors,
- r.xmode, r.indices, r.indexCount, r.paint));
+ r.bmode, r.indices, r.indexCount, r.paint));
DRAW(DrawAnnotation, drawAnnotation(r.rect, r.key.c_str(), r.value.get()));
#undef DRAW
void SkRecorder::onDrawVertices(VertexMode vmode,
int vertexCount, const SkPoint vertices[],
const SkPoint texs[], const SkColor colors[],
- SkXfermode* xmode,
+ SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount, const SkPaint& paint) {
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ SkBlendMode bmode = xmode ? xmode->blend() : SkBlendMode::kModulate;
+#else
+ SkBlendMode bmode = xmode;
+#endif
APPEND(DrawVertices, paint,
vmode,
vertexCount,
this->copy(vertices, vertexCount),
texs ? this->copy(texs, vertexCount) : nullptr,
colors ? this->copy(colors, vertexCount) : nullptr,
- sk_ref_sp(xmode),
+ bmode,
this->copy(indices, indexCount),
indexCount);
}
void SkRecorder::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
+ const SkPaint& paint) {
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ SkBlendMode bmode = xmode ? xmode->blend() : SkBlendMode::kModulate;
+#else
+ SkBlendMode bmode = xmode;
+#endif
APPEND(DrawPatch, paint,
cubics ? this->copy(cubics, SkPatchUtils::kNumCtrlPts) : nullptr,
colors ? this->copy(colors, SkPatchUtils::kNumCorners) : nullptr,
texCoords ? this->copy(texCoords, SkPatchUtils::kNumCorners) : nullptr,
- sk_ref_sp(xmode));
+ bmode);
}
void SkRecorder::onDrawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
- const SkColor colors[], int count, SkXfermode::Mode mode,
+ const SkColor colors[], int count, SK_XFERMODE_MODE_PARAM mode,
const SkRect* cull, const SkPaint* paint) {
APPEND(DrawAtlas, this->copy(paint),
sk_ref_sp(atlas),
this->copy(tex, count),
this->copy(colors, count),
count,
- mode,
+ (SkBlendMode)mode,
this->copy(cull));
}
SkScalar y,
const SkPaint& paint) override;
void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) override;
void onDrawPaint(const SkPaint&) override;
const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint&) override;
void onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[],
- int count, SkXfermode::Mode, const SkRect* cull, const SkPaint*) override;
+ int count, SK_XFERMODE_MODE_PARAM, const SkRect* cull, const SkPaint*) override;
void onClipRect(const SkRect& rect, ClipOp, ClipEdgeStyle) override;
void onClipRRect(const SkRRect& rrect, ClipOp, ClipEdgeStyle) override;
#define SkValidationUtils_DEFINED
#include "SkBitmap.h"
-#include "SkXfermode.h"
+#include "SkBlendMode.h"
/** Returns true if coeff's value is in the SkXfermode::Coeff enum.
*/
return coeff >= 0 && coeff < SkXfermode::kCoeffCount;
}
-/** Returns true if mode's value is in the SkXfermode::Mode enum.
+/** Returns true if mode's value is in the SkBlendMode enum.
*/
-static inline bool SkIsValidMode(SkXfermode::Mode mode) {
- return (mode >= 0) && (mode <= SkXfermode::kLastMode);
+static inline bool SkIsValidMode(SkBlendMode mode) {
+ return (unsigned)mode <= (unsigned)SkBlendMode::kLastMode;
}
/** Returns true if the rect's dimensions are between 0 and SK_MaxS32
}
void SkProcCoeffXfermode::flatten(SkWriteBuffer& buffer) const {
- buffer.write32(fMode);
+ buffer.write32((int)fMode);
}
bool SkProcCoeffXfermode::asMode(Mode* mode) const {
if (mode) {
- *mode = fMode;
+ *mode = (Mode)fMode;
}
return true;
}
#endif
-sk_sp<SkXfermode> SkXfermode::Make(Mode mode) {
- if ((unsigned)mode >= kModeCount) {
+sk_sp<SkXfermode> SkXfermode::Make(SkBlendMode mode) {
+ if ((unsigned)mode > (unsigned)SkBlendMode::kLastMode) {
// report error
return nullptr;
}
// Skia's "default" mode is srcover. nullptr in SkPaint is interpreted as srcover
// so we can just return nullptr from the factory.
- if (kSrcOver_Mode == mode) {
+ if (SkBlendMode::kSrcOver == mode) {
return nullptr;
}
- SkASSERT(SK_ARRAY_COUNT(gProcCoeffs) == kModeCount);
+ const int COUNT_BLENDMODES = (int)SkBlendMode::kLastMode + 1;
+ SkASSERT(SK_ARRAY_COUNT(gProcCoeffs) == COUNT_BLENDMODES);
- static SkOnce once[SkXfermode::kLastMode+1];
- static SkXfermode* cached[SkXfermode::kLastMode+1];
+ static SkOnce once[COUNT_BLENDMODES];
+ static SkXfermode* cached[COUNT_BLENDMODES];
- once[mode]([mode] {
- ProcCoeff rec = gProcCoeffs[mode];
+ once[(int)mode]([mode] {
+ ProcCoeff rec = gProcCoeffs[(int)mode];
if (auto xfermode = SkOpts::create_xfermode(rec, mode)) {
- cached[mode] = xfermode;
+ cached[(int)mode] = xfermode;
} else {
- cached[mode] = new SkProcCoeffXfermode(rec, mode);
+ cached[(int)mode] = new SkProcCoeffXfermode(rec, mode);
}
});
- return sk_ref_sp(cached[mode]);
+ return sk_ref_sp(cached[(int)mode]);
}
SkXfermodeProc SkXfermode::GetProc(Mode mode) {
return result;
}
- SkASSERT(GrCustomXfermode::IsSupportedMode((SkXfermode::Mode)mode));
- return GrCustomXfermode::MakeXPFactory((SkXfermode::Mode)mode);
+ SkASSERT(GrCustomXfermode::IsSupportedMode(mode));
+ return GrCustomXfermode::MakeXPFactory(mode);
}
#endif
class SK_API SkProcCoeffXfermode : public SkXfermode {
public:
- SkProcCoeffXfermode(const ProcCoeff& rec, Mode mode) {
+ SkProcCoeffXfermode(const ProcCoeff& rec, SkBlendMode mode) {
fMode = mode;
fProc = rec.fProc;
// these may be valid, or may be CANNOT_USE_COEFF
protected:
void flatten(SkWriteBuffer& buffer) const override;
- Mode getMode() const { return fMode; }
+ SkBlendMode getMode() const { return fMode; }
SkXfermodeProc getProc() const { return fProc; }
private:
SkXfermodeProc fProc;
- Mode fMode;
+ SkBlendMode fMode;
Coeff fSrcCoeff, fDstCoeff;
friend class SkXfermode;
// be baked into the blurred mask.
SkColor opaqueColor = SkColorSetA(fBlurColor, 255);
//The SrcIn xfer mode will multiply 'color' by the incoming alpha
- fColorFilter = SkColorFilter::MakeModeFilter(opaqueColor, SkXfermode::kSrcIn_Mode);
+ fColorFilter = SkColorFilter::MakeModeFilter(opaqueColor, SkBlendMode::kSrcIn);
} else {
fColorFilter = nullptr;
}
const SkColor opaqueAlphaMask = SK_ColorBLACK;
// omit the alpha and compare only the RGB values
if (0 == (add & ~opaqueAlphaMask)) {
- return SkColorFilter::MakeModeFilter(mul | opaqueAlphaMask,
- SkXfermode::Mode::kModulate_Mode);
+ return SkColorFilter::MakeModeFilter(mul | opaqueAlphaMask, SkBlendMode::kModulate);
}
SkColorMatrix matrix;
SkPaint paint;
paint.setImageFilter(SkBlurImageFilter::Make(sigma.fX, sigma.fY, nullptr));
- paint.setColorFilter(SkColorFilter::MakeModeFilter(fColor, SkXfermode::kSrcIn_Mode));
+ paint.setColorFilter(SkColorFilter::MakeModeFilter(fColor, SkBlendMode::kSrcIn));
SkVector offsetVec = SkVector::Make(fDx, fDy);
ctx.ctm().mapVectors(&offsetVec, 1);
SkLayerDrawLooper::LayerInfo::LayerInfo() {
fPaintBits = 0; // ignore our paint fields
- fColorMode = SkXfermode::kDst_Mode; // ignore our color
+ fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kDst; // ignore our color
fOffset.set(0, 0);
fPostTranslate = false;
}
return new (storage) LayerDrawLooperContext(this);
}
-static SkColor xferColor(SkColor src, SkColor dst, SkXfermode::Mode mode) {
+static SkColor xferColor(SkColor src, SkColor dst, SkBlendMode mode) {
switch (mode) {
- case SkXfermode::kSrc_Mode:
+ case SkBlendMode::kSrc:
return src;
- case SkXfermode::kDst_Mode:
+ case SkBlendMode::kDst:
return dst;
default: {
SkPMColor pmS = SkPreMultiplyColor(src);
SkPMColor pmD = SkPreMultiplyColor(dst);
- SkPMColor result = SkXfermode::GetProc(mode)(pmS, pmD);
+ SkPMColor result = SkXfermode::GetProc((SkXfermode::Mode)mode)(pmS, pmD);
return SkUnPreMultiply::PMColorToColor(result);
}
}
void SkLayerDrawLooper::LayerDrawLooperContext::ApplyInfo(
SkPaint* dst, const SkPaint& src, const LayerInfo& info) {
- dst->setColor(xferColor(src.getColor(), dst->getColor(), info.fColorMode));
+ dst->setColor(xferColor(src.getColor(), dst->getColor(), (SkBlendMode)info.fColorMode));
BitFlags bits = info.fPaintBits;
SkPaint::TextEncoding encoding = dst->getTextEncoding();
if ((rec->fInfo.fPaintBits & ~kMaskFilter_Bit)) {
return false;
}
- if (SkXfermode::kSrc_Mode != rec->fInfo.fColorMode) {
+ if (SkBlendMode::kSrc != (SkBlendMode)rec->fInfo.fColorMode) {
return false;
}
const SkMaskFilter* mf = rec->fPaint.getMaskFilter();
if (rec->fInfo.fPaintBits) {
return false;
}
- if (SkXfermode::kDst_Mode != rec->fInfo.fColorMode) {
+ if (SkBlendMode::kDst != (SkBlendMode)rec->fInfo.fColorMode) {
return false;
}
if (!rec->fInfo.fOffset.equals(0, 0)) {
buffer.writeInt(0);
buffer.writeInt(rec->fInfo.fPaintBits);
- buffer.writeInt(rec->fInfo.fColorMode);
+ buffer.writeInt((int)rec->fInfo.fColorMode);
buffer.writePoint(rec->fInfo.fOffset);
buffer.writeBool(rec->fInfo.fPostTranslate);
buffer.writePaint(rec->fPaint);
(void)buffer.readInt();
info.fPaintBits = buffer.readInt();
- info.fColorMode = (SkXfermode::Mode)buffer.readInt();
+ info.fColorMode = (SK_XFERMODE_MODE_PARAM)buffer.readInt();
buffer.readPoint(&info.fOffset);
info.fPostTranslate = buffer.readBool();
buffer.readPaint(builder.addLayerOnTop(info));
}
str->append(") ");
- static const char* gModeStrings[SkXfermode::kLastMode+1] = {
+ static const char* gModeStrings[(int)SkBlendMode::kLastMode+1] = {
"kClear", "kSrc", "kDst", "kSrcOver", "kDstOver", "kSrcIn", "kDstIn",
"kSrcOut", "kDstOut", "kSrcATop", "kDstATop", "kXor", "kPlus",
"kMultiply", "kScreen", "kOverlay", "kDarken", "kLighten", "kColorDodge",
"kColorBurn", "kHardLight", "kSoftLight", "kDifference", "kExclusion"
};
- str->appendf("mode: %s ", gModeStrings[rec->fInfo.fColorMode]);
+ str->appendf("mode: %s ", gModeStrings[(int)rec->fInfo.fColorMode]);
str->append("offset: (");
str->appendScalar(rec->fInfo.fOffset.fX);
sk_sp<SkImageFilter> SkMergeImageFilter::Make(sk_sp<SkImageFilter> first,
sk_sp<SkImageFilter> second,
- SkXfermode::Mode mode,
+ SkBlendMode mode,
const CropRect* cropRect) {
sk_sp<SkImageFilter> inputs[2] = { first, second };
- SkXfermode::Mode modes[2] = { mode, mode };
+ SkBlendMode modes[2] = { mode, mode };
return sk_sp<SkImageFilter>(new SkMergeImageFilter(inputs, 2, modes, cropRect));
}
-sk_sp<SkImageFilter> SkMergeImageFilter::Make(sk_sp<SkImageFilter> filters[],
- int count,
- const SkXfermode::Mode modes[],
- const CropRect* cropRect) {
+sk_sp<SkImageFilter> SkMergeImageFilter::MakeN(sk_sp<SkImageFilter> filters[], int count,
+ const SkBlendMode modes[],
+ const CropRect* cropRect) {
return sk_sp<SkImageFilter>(new SkMergeImageFilter(filters, count, modes, cropRect));
}
}
}
-void SkMergeImageFilter::initModes(const SkXfermode::Mode modes[]) {
+void SkMergeImageFilter::initModes(const SkBlendMode modes[]) {
if (modes) {
this->initAllocModes();
int inputCount = this->countInputs();
for (int i = 0; i < inputCount; ++i) {
- fModes[i] = SkToU8(modes[i]);
+ fModes[i] = SkToU8((unsigned)modes[i]);
}
} else {
fModes = nullptr;
}
SkMergeImageFilter::SkMergeImageFilter(sk_sp<SkImageFilter> filters[], int count,
- const SkXfermode::Mode modes[],
+ const SkBlendMode modes[],
const CropRect* cropRect)
: INHERITED(filters, count, cropRect) {
SkASSERT(count >= 0);
const int count = common.inputCount();
bool hasModes = buffer.readBool();
if (hasModes) {
- SkAutoSTArray<4, SkXfermode::Mode> modes(count);
+ SkAutoSTArray<4, SkBlendMode> modes(count);
SkAutoSTArray<4, uint8_t> modes8(count);
if (!buffer.readByteArray(modes8.get(), count)) {
return nullptr;
}
for (int i = 0; i < count; ++i) {
- modes[i] = (SkXfermode::Mode)modes8[i];
+ modes[i] = (SkBlendMode)modes8[i];
buffer.validate(SkIsValidMode(modes[i]));
}
if (!buffer.isValid()) {
return nullptr;
}
- return Make(common.inputs(), count, modes.get(), &common.cropRect());
+ return MakeN(common.inputs(), count, modes.get(), &common.cropRect());
}
- return Make(common.inputs(), count, nullptr, &common.cropRect());
+ return MakeN(common.inputs(), count, nullptr, &common.cropRect());
}
void SkMergeImageFilter::flatten(SkWriteBuffer& buffer) const {
rec.fProc = SkXfermode::GetProc(SkXfermode::kSrcOver_Mode);
SkXfermode::ModeAsCoeff(SkXfermode::kSrcOver_Mode, &rec.fSC, &rec.fDC);
- srcover.reset(new SkProcCoeffXfermode(rec, SkXfermode::kSrcOver_Mode));
+ srcover.reset(new SkProcCoeffXfermode(rec, SkBlendMode::kSrcOver));
xfer = srcover.get();
}
if (!fp) {
return nullptr;
}
- return GrXfermodeFragmentProcessor::MakeFromDstProcessor(std::move(fp),
- SkXfermode::kDstIn_Mode);
+ return GrXfermodeFragmentProcessor::MakeFromDstProcessor(std::move(fp), SkBlendMode::kDstIn);
}
sk_sp<GrFragmentProcessor> GrFragmentProcessor::PremulInput(sk_sp<GrFragmentProcessor> fp) {
GrPaint paint;
paint.setColor4f(GrColor4f::FromGrColor(color));
- paint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::Mode::kSrc_Mode));
+ paint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
this->drawRect(clip, paint, SkMatrix::I(), clearRect);
} else if (isFull) {
void SkGpuDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
int vertexCount, const SkPoint vertices[],
const SkPoint texs[], const SkColor colors[],
- SkXfermode* xmode,
+ SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
ASSERT_SINGLE_OWNER
if (colors) {
// When there are texs and colors the shader and colors are combined using xmode. A null
// xmode is defined to mean modulate.
- SkXfermode::Mode colorMode;
- if (xmode) {
- if (!xmode->asMode(&colorMode)) {
- return;
- }
- } else {
- colorMode = SkXfermode::kModulate_Mode;
- }
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ SkBlendMode colorMode = xmode ? xmode->blend() : SkBlendMode::kModulate;
+#else
+ SkBlendMode colorMode = xmode;
+#endif
if (!SkPaintToGrPaintWithXfermode(this->context(), fRenderTargetContext.get(), paint,
*draw.fMatrix, colorMode, false, &grPaint)) {
return;
void SkGpuDevice::drawAtlas(const SkDraw& draw, const SkImage* atlas, const SkRSXform xform[],
const SkRect texRect[], const SkColor colors[], int count,
- SkXfermode::Mode mode, const SkPaint& paint) {
+ SK_XFERMODE_MODE_PARAM mode, const SkPaint& paint) {
ASSERT_SINGLE_OWNER
if (paint.isAntiAlias()) {
this->INHERITED::drawAtlas(draw, atlas, xform, texRect, colors, count, mode, paint);
GrPaint grPaint;
if (colors) {
if (!SkPaintToGrPaintWithXfermode(this->context(), fRenderTargetContext.get(), p,
- *draw.fMatrix, mode, true, &grPaint)) {
+ *draw.fMatrix, (SkBlendMode)mode, true, &grPaint)) {
return;
}
} else {
void drawTextBlob(const SkDraw&, const SkTextBlob*, SkScalar x, SkScalar y,
const SkPaint& paint, SkDrawFilter* drawFilter) override;
void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount, const SkPoint verts[],
- const SkPoint texs[], const SkColor colors[], SkXfermode* xmode,
+ const SkPoint texs[], const SkColor colors[], SK_XFERMODE_PARAM,
const uint16_t indices[], int indexCount, const SkPaint&) override;
void drawAtlas(const SkDraw&, const SkImage* atlas, const SkRSXform[], const SkRect[],
- const SkColor[], int count, SkXfermode::Mode, const SkPaint&) override;
+ const SkColor[], int count, SK_XFERMODE_MODE_PARAM, const SkPaint&) override;
void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y, const SkPaint&) override;
void drawImage(const SkDraw&, const SkImage*, SkScalar x, SkScalar y, const SkPaint&) override;
////////////////////////////////////////////////////////////////////////////////////////////////
-static inline bool blend_requires_shader(const SkXfermode::Mode mode, bool primitiveIsSrc) {
+static inline bool blend_requires_shader(const SkBlendMode mode, bool primitiveIsSrc) {
if (primitiveIsSrc) {
- return SkXfermode::kSrc_Mode != mode;
+ return SkBlendMode::kSrc != mode;
} else {
- return SkXfermode::kDst_Mode != mode;
+ return SkBlendMode::kDst != mode;
}
}
const SkPaint& skPaint,
const SkMatrix& viewM,
sk_sp<GrFragmentProcessor>* shaderProcessor,
- SkXfermode::Mode* primColorMode,
+ SkBlendMode* primColorMode,
bool primitiveIsSrc,
GrPaint* grPaint) {
grPaint->setAntiAlias(skPaint.isAntiAlias());
}
/** Blends the SkPaint's shader (or color if no shader) with a per-primitive color which must
-be setup as a vertex attribute using the specified SkXfermode::Mode. */
+be setup as a vertex attribute using the specified SkBlendMode. */
bool SkPaintToGrPaintWithXfermode(GrContext* context,
GrRenderTargetContext* rtc,
const SkPaint& skPaint,
const SkMatrix& viewM,
- SkXfermode::Mode primColorMode,
+ SkBlendMode primColorMode,
bool primitiveIsSrc,
GrPaint* grPaint) {
return skpaint_to_grpaint_impl(context, rtc, skPaint, viewM, nullptr, &primColorMode,
GrRenderTargetContext* rtc,
const SkPaint& skPaint,
const SkMatrix& viewM,
- SkXfermode::Mode primColorMode,
+ SkBlendMode primColorMode,
bool primitiveIsSrc,
GrPaint* grPaint);
applied to the primitive color after interpolation. */
inline bool SkPaintToGrPaintWithPrimitiveColor(GrContext* context, GrRenderTargetContext* rtc,
const SkPaint& skPaint, GrPaint* grPaint) {
- return SkPaintToGrPaintWithXfermode(context, rtc, skPaint, SkMatrix::I(), SkXfermode::kDst_Mode,
+ return SkPaintToGrPaintWithXfermode(context, rtc, skPaint, SkMatrix::I(), SkBlendMode::kDst,
false, grPaint);
}
#include "glsl/GrGLSLUniformHandler.h"
#include "glsl/GrGLSLXferProcessor.h"
-bool GrCustomXfermode::IsSupportedMode(SkXfermode::Mode mode) {
- return mode > SkXfermode::kLastCoeffMode && mode <= SkXfermode::kLastMode;
+bool GrCustomXfermode::IsSupportedMode(SkBlendMode mode) {
+ return (int)mode > (int)SkBlendMode::kLastCoeffMode &&
+ (int)mode <= (int)SkBlendMode::kLastMode;
}
///////////////////////////////////////////////////////////////////////////////
// Static helpers
///////////////////////////////////////////////////////////////////////////////
-static GrBlendEquation hw_blend_equation(SkXfermode::Mode mode) {
- enum { kOffset = kOverlay_GrBlendEquation - SkXfermode::kOverlay_Mode };
- return static_cast<GrBlendEquation>(mode + kOffset);
-
- GR_STATIC_ASSERT(kOverlay_GrBlendEquation == SkXfermode::kOverlay_Mode + kOffset);
- GR_STATIC_ASSERT(kDarken_GrBlendEquation == SkXfermode::kDarken_Mode + kOffset);
- GR_STATIC_ASSERT(kLighten_GrBlendEquation == SkXfermode::kLighten_Mode + kOffset);
- GR_STATIC_ASSERT(kColorDodge_GrBlendEquation == SkXfermode::kColorDodge_Mode + kOffset);
- GR_STATIC_ASSERT(kColorBurn_GrBlendEquation == SkXfermode::kColorBurn_Mode + kOffset);
- GR_STATIC_ASSERT(kHardLight_GrBlendEquation == SkXfermode::kHardLight_Mode + kOffset);
- GR_STATIC_ASSERT(kSoftLight_GrBlendEquation == SkXfermode::kSoftLight_Mode + kOffset);
- GR_STATIC_ASSERT(kDifference_GrBlendEquation == SkXfermode::kDifference_Mode + kOffset);
- GR_STATIC_ASSERT(kExclusion_GrBlendEquation == SkXfermode::kExclusion_Mode + kOffset);
- GR_STATIC_ASSERT(kMultiply_GrBlendEquation == SkXfermode::kMultiply_Mode + kOffset);
- GR_STATIC_ASSERT(kHSLHue_GrBlendEquation == SkXfermode::kHue_Mode + kOffset);
- GR_STATIC_ASSERT(kHSLSaturation_GrBlendEquation == SkXfermode::kSaturation_Mode + kOffset);
- GR_STATIC_ASSERT(kHSLColor_GrBlendEquation == SkXfermode::kColor_Mode + kOffset);
- GR_STATIC_ASSERT(kHSLLuminosity_GrBlendEquation == SkXfermode::kLuminosity_Mode + kOffset);
- GR_STATIC_ASSERT(kGrBlendEquationCnt == SkXfermode::kLastMode + 1 + kOffset);
+static GrBlendEquation hw_blend_equation(SkBlendMode mode) {
+ enum { kOffset = kOverlay_GrBlendEquation - (int)SkBlendMode::kOverlay };
+ return static_cast<GrBlendEquation>((int)mode + kOffset);
+
+ GR_STATIC_ASSERT(kOverlay_GrBlendEquation == (int)SkBlendMode::kOverlay + kOffset);
+ GR_STATIC_ASSERT(kDarken_GrBlendEquation == (int)SkBlendMode::kDarken + kOffset);
+ GR_STATIC_ASSERT(kLighten_GrBlendEquation == (int)SkBlendMode::kLighten + kOffset);
+ GR_STATIC_ASSERT(kColorDodge_GrBlendEquation == (int)SkBlendMode::kColorDodge + kOffset);
+ GR_STATIC_ASSERT(kColorBurn_GrBlendEquation == (int)SkBlendMode::kColorBurn + kOffset);
+ GR_STATIC_ASSERT(kHardLight_GrBlendEquation == (int)SkBlendMode::kHardLight + kOffset);
+ GR_STATIC_ASSERT(kSoftLight_GrBlendEquation == (int)SkBlendMode::kSoftLight + kOffset);
+ GR_STATIC_ASSERT(kDifference_GrBlendEquation == (int)SkBlendMode::kDifference + kOffset);
+ GR_STATIC_ASSERT(kExclusion_GrBlendEquation == (int)SkBlendMode::kExclusion + kOffset);
+ GR_STATIC_ASSERT(kMultiply_GrBlendEquation == (int)SkBlendMode::kMultiply + kOffset);
+ GR_STATIC_ASSERT(kHSLHue_GrBlendEquation == (int)SkBlendMode::kHue + kOffset);
+ GR_STATIC_ASSERT(kHSLSaturation_GrBlendEquation == (int)SkBlendMode::kSaturation + kOffset);
+ GR_STATIC_ASSERT(kHSLColor_GrBlendEquation == (int)SkBlendMode::kColor + kOffset);
+ GR_STATIC_ASSERT(kHSLLuminosity_GrBlendEquation == (int)SkBlendMode::kLuminosity + kOffset);
+ GR_STATIC_ASSERT(kGrBlendEquationCnt == (int)SkBlendMode::kLastMode + 1 + kOffset);
}
static bool can_use_hw_blend_equation(GrBlendEquation equation,
class CustomXP : public GrXferProcessor {
public:
- CustomXP(SkXfermode::Mode mode, GrBlendEquation hwBlendEquation)
+ CustomXP(SkBlendMode mode, GrBlendEquation hwBlendEquation)
: fMode(mode),
fHWBlendEquation(hwBlendEquation) {
this->initClassID<CustomXP>();
}
- CustomXP(const DstTexture* dstTexture, bool hasMixedSamples, SkXfermode::Mode mode)
+ CustomXP(const DstTexture* dstTexture, bool hasMixedSamples, SkBlendMode mode)
: INHERITED(dstTexture, true, hasMixedSamples),
fMode(mode),
fHWBlendEquation(static_cast<GrBlendEquation>(-1)) {
GrGLSLXferProcessor* createGLSLInstance() const override;
- SkXfermode::Mode mode() const { return fMode; }
+ SkBlendMode mode() const { return fMode; }
bool hasHWBlendEquation() const { return -1 != static_cast<int>(fHWBlendEquation); }
GrBlendEquation hwBlendEquation() const {
bool onIsEqual(const GrXferProcessor& xpBase) const override;
- const SkXfermode::Mode fMode;
+ const SkBlendMode fMode;
const GrBlendEquation fHWBlendEquation;
typedef GrXferProcessor INHERITED;
GR_STATIC_ASSERT(GrGLSLCaps::kLast_AdvBlendEqInteraction < 4);
}
if (!xp.hasHWBlendEquation() || caps.mustEnableSpecificAdvBlendEqs()) {
- key |= xp.mode() << 3;
+ key |= (int)xp.mode() << 3;
}
b->add32(key);
}
///////////////////////////////////////////////////////////////////////////////
class CustomXPFactory : public GrXPFactory {
public:
- CustomXPFactory(SkXfermode::Mode mode);
+ CustomXPFactory(SkBlendMode mode);
void getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
GrXPFactory::InvariantBlendedColor*) const override;
GR_DECLARE_XP_FACTORY_TEST;
- SkXfermode::Mode fMode;
- GrBlendEquation fHWBlendEquation;
+ SkBlendMode fMode;
+ GrBlendEquation fHWBlendEquation;
typedef GrXPFactory INHERITED;
};
-CustomXPFactory::CustomXPFactory(SkXfermode::Mode mode)
+CustomXPFactory::CustomXPFactory(SkBlendMode mode)
: fMode(mode),
fHWBlendEquation(hw_blend_equation(mode)) {
SkASSERT(GrCustomXfermode::IsSupportedMode(fMode));
int mode = d->fRandom->nextRangeU(SkXfermode::kLastCoeffMode + 1,
SkXfermode::kLastSeparableMode);
- return sk_sp<GrXPFactory>(new CustomXPFactory(static_cast<SkXfermode::Mode>(mode)));
+ return sk_sp<GrXPFactory>(new CustomXPFactory(static_cast<SkBlendMode>(mode)));
}
///////////////////////////////////////////////////////////////////////////////
-sk_sp<GrXPFactory> GrCustomXfermode::MakeXPFactory(SkXfermode::Mode mode) {
+sk_sp<GrXPFactory> GrCustomXfermode::MakeXPFactory(SkBlendMode mode) {
if (!GrCustomXfermode::IsSupportedMode(mode)) {
return nullptr;
} else {
static BlendFormula get_blend_formula(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
bool hasMixedSamples,
- SkXfermode::Mode xfermode) {
- SkASSERT(xfermode >= 0 && xfermode <= SkXfermode::kLastCoeffMode);
+ SkBlendMode xfermode) {
+ SkASSERT((unsigned)xfermode <= (unsigned)SkBlendMode::kLastCoeffMode);
SkASSERT(!coveragePOI.isFourChannelOutput());
bool conflatesCoverage = !coveragePOI.isSolidWhite() || hasMixedSamples;
- return gBlendTable[colorPOI.isOpaque()][conflatesCoverage][xfermode];
+ return gBlendTable[colorPOI.isOpaque()][conflatesCoverage][(int)xfermode];
}
static BlendFormula get_lcd_blend_formula(const GrProcOptInfo& coveragePOI,
- SkXfermode::Mode xfermode) {
- SkASSERT(xfermode >= 0 && xfermode <= SkXfermode::kLastCoeffMode);
+ SkBlendMode xfermode) {
+ SkASSERT((unsigned)xfermode <= (unsigned)SkBlendMode::kLastCoeffMode);
SkASSERT(coveragePOI.isFourChannelOutput());
- return gLCDBlendTable[xfermode];
+ return gLCDBlendTable[(int)xfermode];
}
///////////////////////////////////////////////////////////////////////////////
public:
ShaderPDXferProcessor(const DstTexture* dstTexture,
bool hasMixedSamples,
- SkXfermode::Mode xfermode)
+ SkBlendMode xfermode)
: INHERITED(dstTexture, true, hasMixedSamples)
, fXfermode(xfermode) {
this->initClassID<ShaderPDXferProcessor>();
GrGLSLXferProcessor* createGLSLInstance() const override;
- SkXfermode::Mode getXfermode() const { return fXfermode; }
+ SkBlendMode getXfermode() const { return fXfermode; }
private:
GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations&, bool, GrColor*,
return fXfermode == xp.fXfermode;
}
- const SkXfermode::Mode fXfermode;
+ const SkBlendMode fXfermode;
typedef GrXferProcessor INHERITED;
};
public:
static void GenKey(const GrProcessor& processor, GrProcessorKeyBuilder* b) {
const ShaderPDXferProcessor& xp = processor.cast<ShaderPDXferProcessor>();
- b->add32(xp.getXfermode());
+ b->add32((int)xp.getXfermode());
}
private:
class PDLCDXferProcessor : public GrXferProcessor {
public:
- static GrXferProcessor* Create(SkXfermode::Mode xfermode, const GrProcOptInfo& colorPOI);
+ static GrXferProcessor* Create(SkBlendMode xfermode, const GrProcOptInfo& colorPOI);
~PDLCDXferProcessor() override;
this->initClassID<PDLCDXferProcessor>();
}
-GrXferProcessor* PDLCDXferProcessor::Create(SkXfermode::Mode xfermode,
+GrXferProcessor* PDLCDXferProcessor::Create(SkBlendMode xfermode,
const GrProcOptInfo& colorPOI) {
- if (SkXfermode::kSrcOver_Mode != xfermode) {
+ if (SkBlendMode::kSrcOver != xfermode) {
return nullptr;
}
///////////////////////////////////////////////////////////////////////////////
-GrPorterDuffXPFactory::GrPorterDuffXPFactory(SkXfermode::Mode xfermode)
+GrPorterDuffXPFactory::GrPorterDuffXPFactory(SkBlendMode xfermode)
: fXfermode(xfermode) {
- SkASSERT(fXfermode <= SkXfermode::kLastCoeffMode);
+ SkASSERT((unsigned)fXfermode <= (unsigned)SkBlendMode::kLastCoeffMode);
this->initClassID<GrPorterDuffXPFactory>();
}
-sk_sp<GrXPFactory> GrPorterDuffXPFactory::Make(SkXfermode::Mode xfermode) {
- static GrPorterDuffXPFactory gClearPDXPF(SkXfermode::kClear_Mode);
- static GrPorterDuffXPFactory gSrcPDXPF(SkXfermode::kSrc_Mode);
- static GrPorterDuffXPFactory gDstPDXPF(SkXfermode::kDst_Mode);
- static GrPorterDuffXPFactory gSrcOverPDXPF(SkXfermode::kSrcOver_Mode);
- static GrPorterDuffXPFactory gDstOverPDXPF(SkXfermode::kDstOver_Mode);
- static GrPorterDuffXPFactory gSrcInPDXPF(SkXfermode::kSrcIn_Mode);
- static GrPorterDuffXPFactory gDstInPDXPF(SkXfermode::kDstIn_Mode);
- static GrPorterDuffXPFactory gSrcOutPDXPF(SkXfermode::kSrcOut_Mode);
- static GrPorterDuffXPFactory gDstOutPDXPF(SkXfermode::kDstOut_Mode);
- static GrPorterDuffXPFactory gSrcATopPDXPF(SkXfermode::kSrcATop_Mode);
- static GrPorterDuffXPFactory gDstATopPDXPF(SkXfermode::kDstATop_Mode);
- static GrPorterDuffXPFactory gXorPDXPF(SkXfermode::kXor_Mode);
- static GrPorterDuffXPFactory gPlusPDXPF(SkXfermode::kPlus_Mode);
- static GrPorterDuffXPFactory gModulatePDXPF(SkXfermode::kModulate_Mode);
- static GrPorterDuffXPFactory gScreenPDXPF(SkXfermode::kScreen_Mode);
+sk_sp<GrXPFactory> GrPorterDuffXPFactory::Make(SkBlendMode xfermode) {
+ static GrPorterDuffXPFactory gClearPDXPF(SkBlendMode::kClear);
+ static GrPorterDuffXPFactory gSrcPDXPF(SkBlendMode::kSrc);
+ static GrPorterDuffXPFactory gDstPDXPF(SkBlendMode::kDst);
+ static GrPorterDuffXPFactory gSrcOverPDXPF(SkBlendMode::kSrcOver);
+ static GrPorterDuffXPFactory gDstOverPDXPF(SkBlendMode::kDstOver);
+ static GrPorterDuffXPFactory gSrcInPDXPF(SkBlendMode::kSrcIn);
+ static GrPorterDuffXPFactory gDstInPDXPF(SkBlendMode::kDstIn);
+ static GrPorterDuffXPFactory gSrcOutPDXPF(SkBlendMode::kSrcOut);
+ static GrPorterDuffXPFactory gDstOutPDXPF(SkBlendMode::kDstOut);
+ static GrPorterDuffXPFactory gSrcATopPDXPF(SkBlendMode::kSrcATop);
+ static GrPorterDuffXPFactory gDstATopPDXPF(SkBlendMode::kDstATop);
+ static GrPorterDuffXPFactory gXorPDXPF(SkBlendMode::kXor);
+ static GrPorterDuffXPFactory gPlusPDXPF(SkBlendMode::kPlus);
+ static GrPorterDuffXPFactory gModulatePDXPF(SkBlendMode::kModulate);
+ static GrPorterDuffXPFactory gScreenPDXPF(SkBlendMode::kScreen);
static GrPorterDuffXPFactory* gFactories[] = {
&gClearPDXPF, &gSrcPDXPF, &gDstPDXPF, &gSrcOverPDXPF, &gDstOverPDXPF, &gSrcInPDXPF,
&gDstInPDXPF, &gSrcOutPDXPF, &gDstOutPDXPF, &gSrcATopPDXPF, &gDstATopPDXPF, &gXorPDXPF,
&gPlusPDXPF, &gModulatePDXPF, &gScreenPDXPF
};
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFactories) == SkXfermode::kLastCoeffMode + 1);
+ GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFactories) == (int)SkBlendMode::kLastCoeffMode + 1);
- if (xfermode < 0 || xfermode > SkXfermode::kLastCoeffMode) {
+ if ((int)xfermode < 0 || (int)xfermode > (int)SkBlendMode::kLastCoeffMode) {
return nullptr;
}
- return sk_sp<GrXPFactory>(SkRef(gFactories[xfermode]));
+ return sk_sp<GrXPFactory>(SkRef(gFactories[(int)xfermode]));
}
GrXferProcessor*
}
BlendFormula blendFormula;
if (optimizations.fCoveragePOI.isFourChannelOutput()) {
- if (SkXfermode::kSrcOver_Mode == fXfermode &&
+ if (SkBlendMode::kSrcOver == fXfermode &&
kRGBA_GrColorComponentFlags == optimizations.fColorPOI.validFlags() &&
!caps.shaderCaps()->dualSourceBlendingSupport() &&
!caps.shaderCaps()->dstReadInShaderSupport()) {
void GrPorterDuffXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
InvariantBlendedColor* blendedColor) const {
// Find the blended color info based on the formula that does not have coverage.
- BlendFormula colorFormula = gBlendTable[colorPOI.isOpaque()][0][fXfermode];
+ BlendFormula colorFormula = gBlendTable[colorPOI.isOpaque()][0][(int)fXfermode];
if (colorFormula.usesDstColor()) {
blendedColor->fWillBlendWithDst = true;
blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
// blend. The one exception is when we are using srcover mode and we know the input color into
// the XP.
if (optimizations.fCoveragePOI.isFourChannelOutput()) {
- if (SkXfermode::kSrcOver_Mode == fXfermode &&
+ if (SkBlendMode::kSrcOver == fXfermode &&
kRGBA_GrColorComponentFlags == optimizations.fColorPOI.validFlags() &&
!caps.shaderCaps()->dstReadInShaderSupport()) {
return false;
GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
sk_sp<GrXPFactory> GrPorterDuffXPFactory::TestCreate(GrProcessorTestData* d) {
- SkXfermode::Mode mode = SkXfermode::Mode(d->fRandom->nextULessThan(SkXfermode::kLastCoeffMode));
+ SkBlendMode mode = SkBlendMode(d->fRandom->nextULessThan((int)SkBlendMode::kLastCoeffMode));
return GrPorterDuffXPFactory::Make(mode);
}
bool hasMixedSamples,
const GrXferProcessor::DstTexture* dstTexture) {
if (optimizations.fOverrides.fUsePLSDstRead) {
- return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkXfermode::kSrcOver_Mode);
+ return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkBlendMode::kSrcOver);
}
// We want to not make an xfer processor if possible. Thus for the simple case where we are not
// back to this trick for rendering SrcOver LCD text instead of doing a
// dst copy.
SkASSERT(!dstTexture || !dstTexture->texture());
- return PDLCDXferProcessor::Create(SkXfermode::kSrcOver_Mode, optimizations.fColorPOI);
+ return PDLCDXferProcessor::Create(SkBlendMode::kSrcOver, optimizations.fColorPOI);
}
BlendFormula blendFormula;
- blendFormula = get_lcd_blend_formula(optimizations.fCoveragePOI, SkXfermode::kSrcOver_Mode);
+ blendFormula = get_lcd_blend_formula(optimizations.fCoveragePOI, SkBlendMode::kSrcOver);
if (blendFormula.hasSecondaryOutput() && !caps.shaderCaps()->dualSourceBlendingSupport()) {
- return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkXfermode::kSrcOver_Mode);
+ return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkBlendMode::kSrcOver);
}
SkASSERT(!dstTexture || !dstTexture->texture());
return false;
}
return get_lcd_blend_formula(optimizations.fCoveragePOI,
- SkXfermode::kSrcOver_Mode).hasSecondaryOutput();
+ SkBlendMode::kSrcOver).hasSecondaryOutput();
}
// We fallback on the shader XP when the blend formula would use dual source blending but we
static const bool kHasMixedSamples = false;
SkASSERT(!caps.usesMixedSamples()); // We never use mixed samples without dual source blending.
return get_blend_formula(optimizations.fColorPOI, optimizations.fCoveragePOI,
- kHasMixedSamples, SkXfermode::kSrcOver_Mode).hasSecondaryOutput();
+ kHasMixedSamples, SkBlendMode::kSrcOver).hasSecondaryOutput();
}
class ComposeTwoFragmentProcessor : public GrFragmentProcessor {
public:
ComposeTwoFragmentProcessor(sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst,
- SkXfermode::Mode mode)
+ SkBlendMode mode)
: fMode(mode) {
this->initClassID<ComposeTwoFragmentProcessor>();
SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(std::move(src));
const char* name() const override { return "ComposeTwo"; }
void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
- b->add32(fMode);
+ b->add32((int)fMode);
}
- SkXfermode::Mode getMode() const { return fMode; }
+ SkBlendMode getMode() const { return fMode; }
protected:
bool onIsEqual(const GrFragmentProcessor& other) const override {
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
- SkXfermode::Mode fMode;
+ SkBlendMode fMode;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
sk_sp<GrFragmentProcessor> fpA(GrProcessorUnitTest::MakeChildFP(d));
sk_sp<GrFragmentProcessor> fpB(GrProcessorUnitTest::MakeChildFP(d));
- SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(
- d->fRandom->nextRangeU(0, SkXfermode::kLastMode));
+ SkBlendMode mode = static_cast<SkBlendMode>(
+ d->fRandom->nextRangeU(0, (int)SkBlendMode::kLastMode));
return sk_sp<GrFragmentProcessor>(
new ComposeTwoFragmentProcessor(std::move(fpA), std::move(fpB), mode));
}
this->emitChild(1, inputColor, &dstColor, args);
// emit blend code
- SkXfermode::Mode mode = cs.getMode();
+ SkBlendMode mode = cs.getMode();
fragBuilder->codeAppendf("// Compose Xfer Mode: %s\n", SkXfermode::ModeName(mode));
GrGLSLBlend::AppendMode(fragBuilder,
srcColor.c_str(),
}
sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromTwoProcessors(
- sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode) {
+ sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst, SkBlendMode mode) {
switch (mode) {
- case SkXfermode::kClear_Mode:
+ case SkBlendMode::kClear:
return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
GrConstColorProcessor::kIgnore_InputMode);
- case SkXfermode::kSrc_Mode:
+ case SkBlendMode::kSrc:
return src;
- case SkXfermode::kDst_Mode:
+ case SkBlendMode::kDst:
return dst;
default:
return sk_sp<GrFragmentProcessor>(
kSrc_Child,
};
- ComposeOneFragmentProcessor(sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode, Child child)
+ ComposeOneFragmentProcessor(sk_sp<GrFragmentProcessor> dst, SkBlendMode mode, Child child)
: fMode(mode)
, fChild(child) {
this->initClassID<ComposeOneFragmentProcessor>();
}
void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
- GR_STATIC_ASSERT((SkXfermode::kLastMode & SK_MaxU16) == SkXfermode::kLastMode);
- b->add32(fMode | (fChild << 16));
+ GR_STATIC_ASSERT(((int)SkBlendMode::kLastMode & SK_MaxU16) == (int)SkBlendMode::kLastMode);
+ b->add32((int)fMode | (fChild << 16));
}
- SkXfermode::Mode mode() const { return fMode; }
+ SkBlendMode mode() const { return fMode; }
Child child() const { return fChild; }
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
- SkXfermode::Mode fMode;
- Child fChild;
+ SkBlendMode fMode;
+ Child fChild;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
public:
void emitCode(EmitArgs& args) override {
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
- SkXfermode::Mode mode = args.fFp.cast<ComposeOneFragmentProcessor>().mode();
+ SkBlendMode mode = args.fFp.cast<ComposeOneFragmentProcessor>().mode();
ComposeOneFragmentProcessor::Child child =
args.fFp.cast<ComposeOneFragmentProcessor>().child();
SkString childColor("child");
// For now, we'll prevent either children from being a shader with children to prevent the
// possibility of an arbitrarily large tree of procs.
sk_sp<GrFragmentProcessor> dst(GrProcessorUnitTest::MakeChildFP(d));
- SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(
- d->fRandom->nextRangeU(0, SkXfermode::kLastMode));
+ SkBlendMode mode = static_cast<SkBlendMode>(
+ d->fRandom->nextRangeU(0, (int)SkBlendMode::kLastMode));
ComposeOneFragmentProcessor::Child child = d->fRandom->nextBool() ?
ComposeOneFragmentProcessor::kDst_Child :
ComposeOneFragmentProcessor::kSrc_Child;
//////////////////////////////////////////////////////////////////////////////
sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromDstProcessor(
- sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode) {
+ sk_sp<GrFragmentProcessor> dst, SkBlendMode mode) {
switch (mode) {
- case SkXfermode::kClear_Mode:
+ case SkBlendMode::kClear:
return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
GrConstColorProcessor::kIgnore_InputMode);
- case SkXfermode::kSrc_Mode:
+ case SkBlendMode::kSrc:
return nullptr;
default:
return sk_sp<GrFragmentProcessor>(
}
sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromSrcProcessor(
- sk_sp<GrFragmentProcessor> src, SkXfermode::Mode mode) {
+ sk_sp<GrFragmentProcessor> src, SkBlendMode mode) {
switch (mode) {
- case SkXfermode::kClear_Mode:
+ case SkBlendMode::kClear:
return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
GrConstColorProcessor::kIgnore_InputMode);
- case SkXfermode::kDst_Mode:
+ case SkBlendMode::kDst:
return nullptr;
default:
return sk_sp<GrFragmentProcessor>(
static void emit_advanced_xfermode_code(GrGLSLFragmentBuilder* fsBuilder, const char* srcColor,
const char* dstColor, const char* outputColor,
- SkXfermode::Mode mode) {
+ SkBlendMode mode) {
SkASSERT(srcColor);
SkASSERT(dstColor);
SkASSERT(outputColor);
outputColor, srcColor, srcColor, dstColor);
switch (mode) {
- case SkXfermode::kOverlay_Mode:
+ case SkBlendMode::kOverlay:
// Overlay is Hard-Light with the src and dst reversed
hard_light(fsBuilder, outputColor, dstColor, srcColor);
break;
- case SkXfermode::kDarken_Mode:
+ case SkBlendMode::kDarken:
fsBuilder->codeAppendf("%s.rgb = min((1.0 - %s.a) * %s.rgb + %s.rgb, "
"(1.0 - %s.a) * %s.rgb + %s.rgb);",
outputColor,
srcColor, dstColor, srcColor,
dstColor, srcColor, dstColor);
break;
- case SkXfermode::kLighten_Mode:
+ case SkBlendMode::kLighten:
fsBuilder->codeAppendf("%s.rgb = max((1.0 - %s.a) * %s.rgb + %s.rgb, "
"(1.0 - %s.a) * %s.rgb + %s.rgb);",
outputColor,
srcColor, dstColor, srcColor,
dstColor, srcColor, dstColor);
break;
- case SkXfermode::kColorDodge_Mode:
+ case SkBlendMode::kColorDodge:
color_dodge_component(fsBuilder, outputColor, srcColor, dstColor, 'r');
color_dodge_component(fsBuilder, outputColor, srcColor, dstColor, 'g');
color_dodge_component(fsBuilder, outputColor, srcColor, dstColor, 'b');
break;
- case SkXfermode::kColorBurn_Mode:
+ case SkBlendMode::kColorBurn:
color_burn_component(fsBuilder, outputColor, srcColor, dstColor, 'r');
color_burn_component(fsBuilder, outputColor, srcColor, dstColor, 'g');
color_burn_component(fsBuilder, outputColor, srcColor, dstColor, 'b');
break;
- case SkXfermode::kHardLight_Mode:
+ case SkBlendMode::kHardLight:
hard_light(fsBuilder, outputColor, srcColor, dstColor);
break;
- case SkXfermode::kSoftLight_Mode:
+ case SkBlendMode::kSoftLight:
fsBuilder->codeAppendf("if (0.0 == %s.a) {", dstColor);
fsBuilder->codeAppendf("%s.rgba = %s;", outputColor, srcColor);
fsBuilder->codeAppendf("} else {");
soft_light_component_pos_dst_alpha(fsBuilder, outputColor, srcColor, dstColor, 'b');
fsBuilder->codeAppendf("}");
break;
- case SkXfermode::kDifference_Mode:
+ case SkBlendMode::kDifference:
fsBuilder->codeAppendf("%s.rgb = %s.rgb + %s.rgb -"
"2.0 * min(%s.rgb * %s.a, %s.rgb * %s.a);",
outputColor, srcColor, dstColor, srcColor, dstColor,
dstColor, srcColor);
break;
- case SkXfermode::kExclusion_Mode:
+ case SkBlendMode::kExclusion:
fsBuilder->codeAppendf("%s.rgb = %s.rgb + %s.rgb - "
"2.0 * %s.rgb * %s.rgb;",
outputColor, dstColor, srcColor, dstColor, srcColor);
break;
- case SkXfermode::kMultiply_Mode:
+ case SkBlendMode::kMultiply:
fsBuilder->codeAppendf("%s.rgb = (1.0 - %s.a) * %s.rgb + "
"(1.0 - %s.a) * %s.rgb + "
"%s.rgb * %s.rgb;",
outputColor, srcColor, dstColor, dstColor, srcColor,
srcColor, dstColor);
break;
- case SkXfermode::kHue_Mode: {
+ case SkBlendMode::kHue: {
// SetLum(SetSat(S * Da, Sat(D * Sa)), Sa*Da, D*Sa) + (1 - Sa) * D + (1 - Da) * S
SkString setSat, setLum;
add_sat_function(fsBuilder, &setSat);
outputColor, srcColor, dstColor, dstColor, srcColor);
break;
}
- case SkXfermode::kSaturation_Mode: {
+ case SkBlendMode::kSaturation: {
// SetLum(SetSat(D * Sa, Sat(S * Da)), Sa*Da, D*Sa)) + (1 - Sa) * D + (1 - Da) * S
SkString setSat, setLum;
add_sat_function(fsBuilder, &setSat);
outputColor, srcColor, dstColor, dstColor, srcColor);
break;
}
- case SkXfermode::kColor_Mode: {
+ case SkBlendMode::kColor: {
// SetLum(S * Da, Sa* Da, D * Sa) + (1 - Sa) * D + (1 - Da) * S
SkString setLum;
add_lum_function(fsBuilder, &setLum);
outputColor, srcColor, dstColor, dstColor, srcColor);
break;
}
- case SkXfermode::kLuminosity_Mode: {
+ case SkBlendMode::kLuminosity: {
// SetLum(D * Sa, Sa* Da, S * Da) + (1 - Sa) * D + (1 - Da) * S
SkString setLum;
add_lum_function(fsBuilder, &setLum);
void GrGLSLBlend::AppendMode(GrGLSLFragmentBuilder* fsBuilder, const char* srcColor,
const char* dstColor, const char* outColor,
- SkXfermode::Mode mode) {
+ SkBlendMode mode) {
SkXfermode::Coeff srcCoeff, dstCoeff;
if (SkXfermode::ModeAsCoeff(mode, &srcCoeff, &dstCoeff)) {
* variables to the outColor variable.
*/
void AppendMode(GrGLSLFragmentBuilder* fsBuilder, const char* srcColor,
- const char* dstColor, const char* outColor, SkXfermode::Mode mode);
+ const char* dstColor, const char* outColor, SkBlendMode mode);
void AppendRegionOp(GrGLSLFragmentBuilder* fsBuilder, const char* srcColor,
const char* dstColor, const char* outColor, SkRegion::Op regionOp);
}
GrPaint paint;
- paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
+ paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
paint.addColorFragmentProcessor(
GrYUVEffect::MakeYUVToRGB(yTex.get(), uTex.get(), vTex.get(), yuvSizes, colorSpace, nv12));
template <typename Xfermode>
class Sk4pxXfermode : public SkProcCoeffXfermode {
public:
- Sk4pxXfermode(const ProcCoeff& rec, SkXfermode::Mode mode)
+ Sk4pxXfermode(const ProcCoeff& rec, SkBlendMode mode)
: INHERITED(rec, mode) {}
void xfer32(SkPMColor dst[], const SkPMColor src[], int n, const SkAlpha aa[]) const override {
template <typename Xfermode>
class Sk4fXfermode : public SkProcCoeffXfermode {
public:
- Sk4fXfermode(const ProcCoeff& rec, SkXfermode::Mode mode)
+ Sk4fXfermode(const ProcCoeff& rec, SkBlendMode mode)
: INHERITED(rec, mode) {}
void xfer32(SkPMColor dst[], const SkPMColor src[], int n, const SkAlpha aa[]) const override {
namespace SK_OPTS_NS {
-static SkXfermode* create_xfermode(const ProcCoeff& rec, SkXfermode::Mode mode) {
+static SkXfermode* create_xfermode(const ProcCoeff& rec, SkBlendMode mode) {
switch (mode) {
#define CASE(Xfermode) \
- case SkXfermode::k##Xfermode##_Mode: return new Sk4pxXfermode<Xfermode>(rec, mode)
+ case SkBlendMode::k##Xfermode: return new Sk4pxXfermode<Xfermode>(rec, mode)
CASE(Clear);
CASE(Src);
CASE(Dst);
#undef CASE
#define CASE(Xfermode) \
- case SkXfermode::k##Xfermode##_Mode: return new Sk4fXfermode<Xfermode>(rec, mode)
+ case SkBlendMode::k##Xfermode: return new Sk4fXfermode<Xfermode>(rec, mode)
CASE(ColorDodge);
CASE(ColorBurn);
CASE(SoftLight);
void SkPDFDevice::drawVertices(const SkDraw& d, SkCanvas::VertexMode,
int vertexCount, const SkPoint verts[],
const SkPoint texs[], const SkColor colors[],
- SkXfermode* xmode, const uint16_t indices[],
+ SK_XFERMODE_PARAM xmode, const uint16_t indices[],
int indexCount, const SkPaint& paint) {
if (d.fRC->isEmpty()) {
return;
void drawVertices(const SkDraw&, SkCanvas::VertexMode,
int vertexCount, const SkPoint verts[],
const SkPoint texs[], const SkColor colors[],
- SkXfermode* xmode, const uint16_t indices[],
+ SK_XFERMODE_PARAM, const uint16_t indices[],
int indexCount, const SkPaint& paint) override;
void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
const SkPaint&) override;
}
void SkPipeCanvas::onDrawAtlas(const SkImage* image, const SkRSXform xform[], const SkRect rect[],
- const SkColor colors[], int count, SkXfermode::Mode mode,
+ const SkColor colors[], int count, SK_XFERMODE_MODE_PARAM mode,
const SkRect* cull, const SkPaint* paint) {
unsigned extra = (unsigned)mode;
SkASSERT(0 == (extra & ~kMode_DrawAtlasMask));
void SkPipeCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
SkASSERT(vertexCount > 0);
}
extra |= (unsigned)vmode << kVMode_DrawVerticesShift;
- SkXfermode::Mode mode = SkXfermode::kModulate_Mode;
- if (xmode && !SkXfermode::AsMode(xmode, &mode)) {
- mode = (SkXfermode::Mode)0xFF; // sentinel for read the xfer later
- }
- extra |= (unsigned)mode << kXMode_DrawVerticesShift;
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ SkBlendMode bmode = xmode ? xmode->blend() : SkBlendMode::kModulate;
+#else
+ SkBlendMode bmode = xmode;
+#endif
+ extra |= (unsigned)bmode << kXMode_DrawVerticesShift;
if (texs) {
extra |= kHasTex_DrawVerticesMask;
if (vertexCount > kVCount_DrawVerticesMask) {
writer.write32(vertexCount);
}
- if (mode == (SkXfermode::Mode)0xFF) {
- writer.writeFlattenable(xmode);
- }
writer.write(vertices, vertexCount * sizeof(SkPoint));
if (texs) {
writer.write(texs, vertexCount * sizeof(SkPoint));
}
void SkPipeCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xfer,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) {
SkPipeWriter writer(this);
unsigned extra = 0;
- SkXfermode::Mode mode = SkXfermode::kModulate_Mode;
- if (xfer && !xfer->asMode(&mode)) {
- mode = (SkXfermode::Mode)kExplicitXfer_DrawPatchExtraValue;
- } else {
- xfer = nullptr; // signal that we're using the mode enum
- }
- SkASSERT(0 == (mode & ~kModeEnum_DrawPatchExtraMask));
- extra = (unsigned)mode;
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ SkBlendMode bmode = xmode ? xmode->blend() : SkBlendMode::kModulate;
+#else
+ SkBlendMode bmode = xmode;
+#endif
+ SkASSERT(0 == ((int)bmode & ~kModeEnum_DrawPatchExtraMask));
+ extra = (unsigned)bmode;
if (colors) {
extra |= kHasColors_DrawPatchExtraMask;
}
if (texCoords) {
writer.write(texCoords, sizeof(SkPoint) * 4);
}
- if (xfer) {
- xfer->flatten(writer);
- }
write_paint(writer, paint, kGeometry_PaintUsage);
}
void onDrawArc(const SkRect&, SkScalar startAngle, SkScalar sweepAngle, bool useCenter,
const SkPaint&) override;
void onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[],
- int count, SkXfermode::Mode, const SkRect* cull, const SkPaint*) override;
+ int count, SK_XFERMODE_MODE_PARAM, const SkRect* cull, const SkPaint*) override;
void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
const SkPaint&) override;
void onDrawTextRSXform(const void* text, size_t byteLength, const SkRSXform xform[],
const SkRect* cull, const SkPaint& paint) override;
void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4],
- SkXfermode*, const SkPaint&) override;
+ SK_XFERMODE_PARAM, const SkPaint&) override;
void onDrawPaint(const SkPaint&) override;
void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM,
const uint16_t indices[], int indexCount,
const SkPaint&) override;
static void drawAtlas_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
SkASSERT(SkPipeVerb::kDrawAtlas == unpack_verb(packedVerb));
- SkXfermode::Mode mode = (SkXfermode::Mode)(packedVerb & kMode_DrawAtlasMask);
+ SkBlendMode mode = (SkBlendMode)(packedVerb & kMode_DrawAtlasMask);
sk_sp<SkImage> image(reader.readImage());
int count = reader.read32();
const SkRSXform* xform = skip<SkRSXform>(reader, count);
if (packedVerb & kHasTexture_DrawPatchExtraMask) {
tex = skip<SkPoint>(reader, 4);
}
- sk_sp<SkXfermode> xfer;
- unsigned mode = packedVerb & kModeEnum_DrawPatchExtraMask;
- if (kExplicitXfer_DrawPatchExtraValue == mode) {
- xfer = reader.readXfermode();
- } else {
- if (mode != SkXfermode::kSrcOver_Mode) {
- xfer = SkXfermode::Make((SkXfermode::Mode)mode);
- }
- }
- canvas->drawPatch(cubics, colors, tex, xfer.get(), read_paint(reader));
+ SkBlendMode mode = (SkBlendMode)(packedVerb & kModeEnum_DrawPatchExtraMask);
+ canvas->drawPatch(cubics, colors, tex, mode, read_paint(reader));
}
static void drawPaint_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
if (0 == vertexCount) {
vertexCount = reader.read32();
}
- sk_sp<SkXfermode> xfer;
- unsigned xmode = (packedVerb & kXMode_DrawVerticesMask) >> kXMode_DrawVerticesShift;
- if (0xFF == xmode) {
- xfer = reader.readXfermode();
- } else {
- xfer = SkXfermode::Make((SkXfermode::Mode)xmode);
- }
+ SkBlendMode bmode = (SkBlendMode)
+ ((packedVerb & kXMode_DrawVerticesMask) >> kXMode_DrawVerticesShift);
const SkPoint* vertices = skip<SkPoint>(reader, vertexCount);
const SkPoint* texs = nullptr;
if (packedVerb & kHasTex_DrawVerticesMask) {
indices = skip<uint16_t>(reader, indexCount);
}
- canvas->drawVertices(vmode, vertexCount, vertices, texs, colors, xfer.get(),
+ canvas->drawVertices(vmode, vertexCount, vertices, texs, colors, bmode,
indices, indexCount, read_paint(reader));
}
void SkSVGDevice::drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
const SkPoint verts[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
// todo
const SkPaint& paint) override;
void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
const SkPoint verts[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) override;
void SkDeferredCanvas::onDrawAtlas(const SkImage* image, const SkRSXform xform[],
const SkRect rects[], const SkColor colors[],
- int count, SkXfermode::Mode mode,
+ int count, SK_XFERMODE_MODE_PARAM mode,
const SkRect* cull, const SkPaint* paint) {
this->flush_before_saves();
fCanvas->drawAtlas(image, xform, rects, colors, count, mode, cull, paint);
void SkDeferredCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
this->flush_before_saves();
}
void SkDeferredCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) {
this->flush_before_saves();
fCanvas->drawPatch(cubics, colors, texCoords, xmode, paint);
virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
const SkPaint& paint) override;
virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) override;
void onDrawPaint(const SkPaint&) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint&) override;
void onDrawAtlas(const SkImage* image, const SkRSXform xform[],
const SkRect rects[], const SkColor colors[],
- int count, SkXfermode::Mode mode,
+ int count, SK_XFERMODE_MODE_PARAM mode,
const SkRect* cull, const SkPaint* paint) override;
void onClipRect(const SkRect&, ClipOp, ClipEdgeStyle) override;
void SkDumpCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
this->dump(kDrawVertices_Verb, &paint, "drawVertices(%s [%d] %g %g ...)",
}
void SkDumpCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) {
//dumps corner points and colors in clockwise order starting on upper-left corner
this->dump(kDrawPatch_Verb, &paint, "drawPatch(Vertices{[%f, %f], [%f, %f], [%f, %f], [%f, %f]}\
texs = texStorage;
}
- get_ref<SkCanvas>(L, 1)->drawPatch(cubics, colors, texs, nullptr, *get_obj<SkPaint>(L, 5));
+ get_ref<SkCanvas>(L, 1)->drawPatch(cubics, colors, texs, *get_obj<SkPaint>(L, 5));
return 0;
}
void SkLuaCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
AUTO_LUA("drawVertices");
SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode));
canvas->drawVertices(SkCanvas::kTriangles_VertexMode,
- rows * cols, verts, idx.tex(), colors, nullptr,
+ rows * cols, verts, idx.tex(), colors, SkBlendMode::kModulate,
idx.indices(), idx.indexCount(), p);
}
}
void SkNWayCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
Iter iter(fList);
}
void SkNWayCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) {
Iter iter(fList);
while (iter.next()) {
void SkPaintFilterCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
AutoPaintFilter apf(this, kVertices_Type, paint);
}
void SkPaintFilterCanvas::onDrawPatch(const SkPoint cubics[], const SkColor colors[],
- const SkPoint texCoords[], SkXfermode* xmode,
+ const SkPoint texCoords[], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) {
AutoPaintFilter apf(this, kPatch_Type, paint);
if (apf.shouldDraw()) {
#include "SkPatchGrid.h"
#include "SkPatchUtils.h"
-SkPatchGrid::SkPatchGrid(int rows, int cols, VertexType flags, SkXfermode* xfer)
+SkPatchGrid::SkPatchGrid(int rows, int cols, VertexType flags)
: fRows(0)
, fCols(0)
, fModeFlags(kNone_VertexType)
, fTexCoords(nullptr)
, fHrzCtrlPts(nullptr)
, fVrtCtrlPts(nullptr)
- , fXferMode(nullptr) {
- this->reset(rows, cols, flags, xfer);
+{
+ this->reset(rows, cols, flags, SkBlendMode::kModulate);
}
SkPatchGrid::~SkPatchGrid() {
return true;
}
-void SkPatchGrid::reset(int rows, int cols, VertexType flags, SkXfermode* xMode) {
+void SkPatchGrid::reset(int rows, int cols, VertexType flags, SkBlendMode blendmode) {
delete[] fCornerPts;
delete[] fCornerColors;
delete[] fTexCoords;
fCols = cols;
fRows = rows;
fModeFlags = flags;
- fXferMode = xMode;
+ fBlendMode = blendmode;
fCornerPts = new SkPoint[(fRows + 1) * (fCols + 1)];
fHrzCtrlPts = new SkPoint[(fRows + 1) * fCols * 2];
fModeFlags & kTexs_VertexType ? texCoords : nullptr,
maxCols[x], maxRows[y])) {
canvas->drawVertices(SkCanvas::kTriangles_VertexMode, data.fVertexCount,
- data.fPoints, data.fTexCoords, data.fColors, fXferMode,
+ data.fPoints, data.fTexCoords, data.fColors, fBlendMode,
data.fIndices, data.fIndexCount, paint);
}
}
kColorsAndTexs_VertexType = 0x03
};
- SkPatchGrid(int rows = 0, int cols = 0, VertexType flags = kNone_VertexType,
- SkXfermode* xfer = nullptr);
+ SkPatchGrid(int rows = 0, int cols = 0, VertexType flags = kNone_VertexType);
~SkPatchGrid();
/**
* Resets the grid of patches to contain rows and cols of patches.
*/
- void reset(int rows, int cols, VertexType flags, SkXfermode* xMode);
+ void reset(int rows, int cols, VertexType flags, SkBlendMode);
/**
* Draws the grid of patches. The patches are drawn starting at patch (0,0) drawing columns, so
SkPoint* fTexCoords;
SkPoint* fHrzCtrlPts;
SkPoint* fVrtCtrlPts;
- SkXfermode* fXferMode;
+ SkBlendMode fBlendMode = SkBlendMode::kModulate;
};
void SkXPSDevice::drawVertices(const SkDraw&, SkCanvas::VertexMode,
int vertexCount, const SkPoint verts[],
const SkPoint texs[], const SkColor colors[],
- SkXfermode* xmode, const uint16_t indices[],
+ SK_XFERMODE_PARAM xmode, const uint16_t indices[],
int indexCount, const SkPaint& paint) {
//TODO: override this for XPS
SkDEBUGF(("XPS drawVertices not yet implemented."));
SkCanvas::VertexMode,
int vertexCount, const SkPoint verts[],
const SkPoint texs[], const SkColor colors[],
- SkXfermode* xmode,
+ SK_XFERMODE_PARAM xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) override;
void draw(SkCanvas* canvas, SkPaint* paint) {
canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode, 4, fPts, fPts,
- nullptr, nullptr, nullptr, 0, *paint);
+ nullptr, SkBlendMode::kModulate, nullptr, 0, *paint);
}
};
SkLayerDrawLooper::LayerInfo info;
info.fPaintBits = 0;
- info.fColorMode = SkXfermode::kDst_Mode;
+ info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kDst;
builder->addLayer(info);
}
SkLayerDrawLooper::LayerInfo info;
info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit;
- info.fColorMode = SkXfermode::kSrc_Mode;
+ info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
SkPaint* paint = builder->addLayer(info);
paint->setMaskFilter(std::move(mf));
}
paint.setShader(SkShader::MakeBitmapShader(d.fBitmap, SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode));
canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode, 4, pts, pts,
- nullptr, nullptr, nullptr, 0, paint);
+ nullptr, SkBlendMode::kModulate, nullptr, 0, paint);
}
// NYI: issue 240.
TEST_STEP_NO_PDF(DrawVerticesShader, DrawVerticesShaderTestStep);
static sk_sp<SkColorFilter> make_filter() {
// pick a filter that cannot compose with itself via newComposed()
- return SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kColorBurn_Mode);
+ return SkColorFilter::MakeModeFilter(SK_ColorRED, SkBlendMode::kColorBurn);
}
static void test_composecolorfilter_limit(skiatest::Reporter* reporter) {
REPORTER_ASSERT(reporter, false); // we never saw a nullptr :(
}
-#define ILLEGAL_MODE ((SkXfermode::Mode)-1)
+#define ILLEGAL_MODE ((SkBlendMode)-1)
DEF_TEST(ColorFilter, reporter) {
SkRandom rand;
- for (int mode = 0; mode <= SkXfermode::kLastMode; mode++) {
+ for (int mode = 0; mode <= (int)SkBlendMode::kLastMode; mode++) {
SkColor color = rand.nextU();
// ensure we always get a filter, by avoiding the possibility of a
// special case that would return nullptr (if color's alpha is 0 or 0xFF)
color = SkColorSetA(color, 0x7F);
- auto cf = SkColorFilter::MakeModeFilter(color, (SkXfermode::Mode)mode);
+ auto cf = SkColorFilter::MakeModeFilter(color, (SkBlendMode)mode);
// allow for no filter if we're in Dst mode (its a no op)
- if (SkXfermode::kDst_Mode == mode && nullptr == cf) {
+ if (SkBlendMode::kDst == (SkBlendMode)mode && nullptr == cf) {
continue;
}
REPORTER_ASSERT(reporter, cf);
SkColor c = ~color;
- SkXfermode::Mode m = ILLEGAL_MODE;
+ SkBlendMode m = ILLEGAL_MODE;
SkColor expectedColor = color;
- SkXfermode::Mode expectedMode = (SkXfermode::Mode)mode;
+ SkBlendMode expectedMode = (SkBlendMode)mode;
// SkDebugf("--- mc [%d %x] ", mode, color);
- REPORTER_ASSERT(reporter, cf->asColorMode(&c, &m));
+ REPORTER_ASSERT(reporter, cf->asColorMode(&c, (SK_XFERMODE_MODE_PARAM*)&m));
// handle special-case folding by the factory
- if (SkXfermode::kClear_Mode == mode) {
+ if (SkBlendMode::kClear == (SkBlendMode)mode) {
if (c != expectedColor) {
expectedColor = 0;
}
if (m != expectedMode) {
- expectedMode = SkXfermode::kSrc_Mode;
+ expectedMode = SkBlendMode::kSrc;
}
}
REPORTER_ASSERT(reporter, cf2);
SkColor c2 = ~color;
- SkXfermode::Mode m2 = ILLEGAL_MODE;
- REPORTER_ASSERT(reporter, cf2->asColorMode(&c2, &m2));
+ SkBlendMode m2 = ILLEGAL_MODE;
+ REPORTER_ASSERT(reporter, cf2->asColorMode(&c2, (SK_XFERMODE_MODE_PARAM*)&m2));
REPORTER_ASSERT(reporter, c2 == expectedColor);
REPORTER_ASSERT(reporter, m2 == expectedMode);
}
shape = shape.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec, 1.f);
GrPaint paint;
- paint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ paint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
GrNoClip noClip;
GrPathRenderer::DrawPathArgs args;
}
sk_sp<GrFragmentProcessor> minLevelsChild(create_random_proc_tree(d, minLevels, maxLevels - 1));
sk_sp<GrFragmentProcessor> otherChild(create_random_proc_tree(d, 1, maxLevels - 1));
- SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(d->fRandom->nextRangeU(0,
- SkXfermode::kLastCoeffMode));
+ SkBlendMode mode = static_cast<SkBlendMode>(d->fRandom->nextRangeU(0,
+ (int)SkBlendMode::kLastCoeffMode));
sk_sp<GrFragmentProcessor> fp;
if (d->fRandom->nextF() < 0.5f) {
fp = GrXfermodeFragmentProcessor::MakeFromTwoProcessors(std::move(minLevelsChild),
GrProcessorTestData ptd(&random, context, context->caps(),
renderTargetContext.get(), dummyTextures);
GrPaint grPaint;
- grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
sk_sp<GrFragmentProcessor> fp(
GrProcessorTestFactory<GrFragmentProcessor>::MakeIdx(i, &ptd));
GrColor inputColor; // "[color]"
SkColor filterColor; // "with filter color [color]"
- SkXfermode::Mode filterMode; // "in mode [mode]"
+ SkBlendMode filterMode; // "in mode [mode]"
// "produces"
uint32_t outputComponents; // "rgb of", "red of", "alpha of", ...
GetConstantComponentTestCase filterTests[] = {
// A color filtered with Clear produces black.
- { kRGBA, gr_white, SK_ColorBLACK, SkXfermode::kClear_Mode, kRGBA, gr_black },
- { kRGBA, gr_c1, SK_ColorWHITE, SkXfermode::kClear_Mode, kRGBA, gr_black },
- { kR, gr_white, c1, SkXfermode::kClear_Mode, kRGBA, gr_black },
+ { kRGBA, gr_white, SK_ColorBLACK, SkBlendMode::kClear, kRGBA, gr_black },
+ { kRGBA, gr_c1, SK_ColorWHITE, SkBlendMode::kClear, kRGBA, gr_black },
+ { kR, gr_white, c1, SkBlendMode::kClear, kRGBA, gr_black },
// A color filtered with a color in mode Src, produces the filter color.
- { kRGBA, gr_c2, c1, SkXfermode::kSrc_Mode, kRGBA, gr_c1 },
- { kA, gr_c1, c1, SkXfermode::kSrc_Mode, kRGBA, gr_c1 },
+ { kRGBA, gr_c2, c1, SkBlendMode::kSrc, kRGBA, gr_c1 },
+ { kA, gr_c1, c1, SkBlendMode::kSrc, kRGBA, gr_c1 },
// A color filtered with SrcOver produces a color.
- { kRGBA, gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kSrcOver_Mode, kRGBA, GrColorPackRGBA(164, 164, 164, 192)},
+ { kRGBA, gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkBlendMode::kSrcOver, kRGBA, GrColorPackRGBA(164, 164, 164, 192)},
// An unknown color with known alpha filtered with SrcOver produces an unknown color with known alpha.
- { kA , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kSrcOver_Mode, kA , GrColorPackRGBA(0, 0, 0, 192)},
+ { kA , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkBlendMode::kSrcOver, kA , GrColorPackRGBA(0, 0, 0, 192)},
// A color with unknown alpha filtered with SrcOver produces a color with unknown alpha.
- { kRGB , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kSrcOver_Mode, kRGB, GrColorPackRGBA(164, 164, 164, 0)},
+ { kRGB , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkBlendMode::kSrcOver, kRGB, GrColorPackRGBA(164, 164, 164, 0)},
// A color filtered with DstOver produces a color.
- { kRGBA, gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kDstOver_Mode, kRGBA, GrColorPackRGBA(178, 178, 178, 192)},
+ { kRGBA, gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkBlendMode::kDstOver, kRGBA, GrColorPackRGBA(178, 178, 178, 192)},
// An unknown color with known alpha filtered with DstOver produces an unknown color with known alpha.
- { kA , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kDstOver_Mode, kA , GrColorPackRGBA(0, 0, 0, 192)},
+ { kA , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkBlendMode::kDstOver, kA , GrColorPackRGBA(0, 0, 0, 192)},
// A color with unknown alpha filtered with DstOver produces an unknown color.
- { kRGB , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kDstOver_Mode, 0 , gr_black},
+ { kRGB , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkBlendMode::kDstOver, 0 , gr_black},
// An unknown color with known alpha and red component filtered with Multiply produces an unknown color with known red and alpha.
- { kR|kA , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kModulate_Mode, kR|kA, GrColorPackRGBA(50, 0, 0, 64) }
+ { kR|kA , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkBlendMode::kModulate, kR|kA, GrColorPackRGBA(50, 0, 0, 64) }
};
GrPaint paint;
class GrPorterDuffTest {
public:
struct XPInfo {
- XPInfo(skiatest::Reporter* reporter, SkXfermode::Mode xfermode, const GrCaps& caps,
+ XPInfo(skiatest::Reporter* reporter, SkBlendMode xfermode, const GrCaps& caps,
const GrPipelineOptimizations& optimizations) {
sk_sp<GrXPFactory> xpf(GrPorterDuffXPFactory::Make(xfermode));
SkAutoTUnref<GrXferProcessor> xp(
SkASSERT(!opt.fCoveragePOI.isSolidWhite());
SkASSERT(opt.fCoveragePOI.isFourChannelOutput());
- for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
- SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
+ for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
+ SkBlendMode xfermode = static_cast<SkBlendMode>(m);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, opt);
switch (xfermode) {
- case SkXfermode::kClear_Mode:
+ case SkBlendMode::kClear:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(0 == xpi.fBlendedColor.fKnownColor);
TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrc_Mode:
+ case SkBlendMode::kSrc:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kIS2C_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDst_Mode:
+ case SkBlendMode::kDst:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kSkipDraw_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcOver_Mode:
+ case SkBlendMode::kSrcOver:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kIS2C_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstOver_Mode:
+ case SkBlendMode::kDstOver:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcIn_Mode:
+ case SkBlendMode::kSrcIn:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kIS2C_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstIn_Mode:
+ case SkBlendMode::kDstIn:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcOut_Mode:
+ case SkBlendMode::kSrcOut:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kIS2C_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstOut_Mode:
+ case SkBlendMode::kDstOut:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kISC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcATop_Mode:
+ case SkBlendMode::kSrcATop:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kIS2C_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstATop_Mode:
+ case SkBlendMode::kDstATop:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kIS2C_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kXor_Mode:
+ case SkBlendMode::kXor:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kIS2C_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kPlus_Mode:
+ case SkBlendMode::kPlus:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kModulate_Mode:
+ case SkBlendMode::kModulate:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kScreen_Mode:
+ case SkBlendMode::kScreen:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
SkASSERT(!optimizations.fCoveragePOI.isSolidWhite());
SkASSERT(!optimizations.fCoveragePOI.isFourChannelOutput());
- for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
- SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
+ for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
+ SkBlendMode xfermode = static_cast<SkBlendMode>(m);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, optimizations);
switch (xfermode) {
- case SkXfermode::kClear_Mode:
+ case SkBlendMode::kClear:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(0 == xpi.fBlendedColor.fKnownColor);
TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrc_Mode:
+ case SkBlendMode::kSrc:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kIS2A_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDst_Mode:
+ case SkBlendMode::kDst:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kSkipDraw_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcOver_Mode:
+ case SkBlendMode::kSrcOver:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstOver_Mode:
+ case SkBlendMode::kDstOver:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcIn_Mode:
+ case SkBlendMode::kSrcIn:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kIS2A_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstIn_Mode:
+ case SkBlendMode::kDstIn:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcOut_Mode:
+ case SkBlendMode::kSrcOut:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kIS2A_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstOut_Mode:
+ case SkBlendMode::kDstOut:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcATop_Mode:
+ case SkBlendMode::kSrcATop:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstATop_Mode:
+ case SkBlendMode::kDstATop:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kIS2C_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kXor_Mode:
+ case SkBlendMode::kXor:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kPlus_Mode:
+ case SkBlendMode::kPlus:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kModulate_Mode:
+ case SkBlendMode::kModulate:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kScreen_Mode:
+ case SkBlendMode::kScreen:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
SkASSERT(optimizations.fCoveragePOI.isSolidWhite());
SkASSERT(!optimizations.fCoveragePOI.isFourChannelOutput());
- for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
- SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
+ for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
+ SkBlendMode xfermode = static_cast<SkBlendMode>(m);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, optimizations);
switch (xfermode) {
- case SkXfermode::kClear_Mode:
+ case SkBlendMode::kClear:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(0 == xpi.fBlendedColor.fKnownColor);
TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrc_Mode:
+ case SkBlendMode::kSrc:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(229 == GrColorUnpackR(xpi.fBlendedColor.fKnownColor));
TEST_ASSERT(154 == GrColorUnpackB(xpi.fBlendedColor.fKnownColor));
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDst_Mode:
+ case SkBlendMode::kDst:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kSkipDraw_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcOver_Mode:
+ case SkBlendMode::kSrcOver:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag |
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstOver_Mode:
+ case SkBlendMode::kDstOver:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcIn_Mode:
+ case SkBlendMode::kSrcIn:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstIn_Mode:
+ case SkBlendMode::kDstIn:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kSA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcOut_Mode:
+ case SkBlendMode::kSrcOut:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstOut_Mode:
+ case SkBlendMode::kDstOut:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag |
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcATop_Mode:
+ case SkBlendMode::kSrcATop:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag |
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstATop_Mode:
+ case SkBlendMode::kDstATop:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kSA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kXor_Mode:
+ case SkBlendMode::kXor:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag |
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kPlus_Mode:
+ case SkBlendMode::kPlus:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kModulate_Mode:
+ case SkBlendMode::kModulate:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kSC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kScreen_Mode:
+ case SkBlendMode::kScreen:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag |
SkASSERT(!optimizations.fCoveragePOI.isSolidWhite());
SkASSERT(!optimizations.fCoveragePOI.isFourChannelOutput());
- for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
- SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
+ for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
+ SkBlendMode xfermode = static_cast<SkBlendMode>(m);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, optimizations);
switch (xfermode) {
- case SkXfermode::kClear_Mode:
+ case SkBlendMode::kClear:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(0 == xpi.fBlendedColor.fKnownColor);
TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrc_Mode:
+ case SkBlendMode::kSrc:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(255 == GrColorUnpackA(xpi.fBlendedColor.fKnownColor));
TEST_ASSERT(kA_GrColorComponentFlag == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDst_Mode:
+ case SkBlendMode::kDst:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kSkipDraw_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcOver_Mode:
+ case SkBlendMode::kSrcOver:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(255 == GrColorUnpackA(xpi.fBlendedColor.fKnownColor));
TEST_ASSERT(kA_GrColorComponentFlag == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstOver_Mode:
+ case SkBlendMode::kDstOver:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcIn_Mode:
+ case SkBlendMode::kSrcIn:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstIn_Mode:
+ case SkBlendMode::kDstIn:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kSkipDraw_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcOut_Mode:
+ case SkBlendMode::kSrcOut:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstOut_Mode:
+ case SkBlendMode::kDstOut:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(0 == xpi.fBlendedColor.fKnownColor);
TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcATop_Mode:
+ case SkBlendMode::kSrcATop:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstATop_Mode:
+ case SkBlendMode::kDstATop:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kXor_Mode:
+ case SkBlendMode::kXor:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kPlus_Mode:
+ case SkBlendMode::kPlus:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kModulate_Mode:
+ case SkBlendMode::kModulate:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kNone_OptFlags) == xpi.fOptFlags);
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kScreen_Mode:
+ case SkBlendMode::kScreen:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags);
SkASSERT(optimizations.fCoveragePOI.isSolidWhite());
SkASSERT(!optimizations.fCoveragePOI.isFourChannelOutput());
- for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
- SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
+ for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
+ SkBlendMode xfermode = static_cast<SkBlendMode>(m);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, optimizations);
switch (xfermode) {
- case SkXfermode::kClear_Mode:
+ case SkBlendMode::kClear:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(0 == xpi.fBlendedColor.fKnownColor);
TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrc_Mode:
+ case SkBlendMode::kSrc:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(82 == GrColorUnpackG(xpi.fBlendedColor.fKnownColor));
TEST_ASSERT(255 == GrColorUnpackA(xpi.fBlendedColor.fKnownColor));
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDst_Mode:
+ case SkBlendMode::kDst:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kSkipDraw_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcOver_Mode:
+ case SkBlendMode::kSrcOver:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(82 == GrColorUnpackG(xpi.fBlendedColor.fKnownColor));
TEST_ASSERT(255 == GrColorUnpackA(xpi.fBlendedColor.fKnownColor));
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstOver_Mode:
+ case SkBlendMode::kDstOver:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcIn_Mode:
+ case SkBlendMode::kSrcIn:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstIn_Mode:
+ case SkBlendMode::kDstIn:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kSkipDraw_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcOut_Mode:
+ case SkBlendMode::kSrcOut:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstOut_Mode:
+ case SkBlendMode::kDstOut:
TEST_ASSERT(!xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(0 == xpi.fBlendedColor.fKnownColor);
TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kSrcATop_Mode:
+ case SkBlendMode::kSrcATop:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kDstATop_Mode:
+ case SkBlendMode::kDstATop:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kXor_Mode:
+ case SkBlendMode::kXor:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kPlus_Mode:
+ case SkBlendMode::kPlus:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag |
TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kModulate_Mode:
+ case SkBlendMode::kModulate:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);
TEST_ASSERT(kSC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
break;
- case SkXfermode::kScreen_Mode:
+ case SkBlendMode::kScreen:
TEST_ASSERT(xpi.fBlendedColor.fWillBlendWithDst);
TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fBlendedColor.fKnownColorFlags);
TEST_ASSERT((kIgnoreCoverage_OptFlag |
SkASSERT(kRGBA_GrColorComponentFlags == colorPOI.validFlags());
SkASSERT(covPOI.isFourChannelOutput());
- sk_sp<GrXPFactory> xpf(GrPorterDuffXPFactory::Make(SkXfermode::kSrcOver_Mode));
+ sk_sp<GrXPFactory> xpf(GrPorterDuffXPFactory::Make(SkBlendMode::kSrcOver));
TEST_ASSERT(!xpf->willNeedDstTexture(caps, opts));
SkAutoTUnref<GrXferProcessor> xp(
optimizations.fCoveragePOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255),
kRGBA_GrColorComponentFlags, true);
}
- for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
- SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
+ for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
+ SkBlendMode xfermode = static_cast<SkBlendMode>(m);
sk_sp<GrXPFactory> xpf(GrPorterDuffXPFactory::Make(xfermode));
GrXferProcessor::DstTexture* dstTexture =
xpf->willNeedDstTexture(caps, optimizations) ? &fakeDstTexture : 0;
{
sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorRED,
- SkXfermode::kSrcIn_Mode));
+ SkBlendMode::kSrcIn));
this->addFilter("color filter",
SkColorFilterImageFilter::Make(std::move(cf), input, cropRect));
}
this->addFilter("merge", SkMergeImageFilter::Make(input, input,
- SkXfermode::kSrcOver_Mode,
+ SkBlendMode::kSrcOver,
cropRect));
{
this->addFilter("merge with disjoint inputs", SkMergeImageFilter::Make(
std::move(paintFilterLeft), std::move(paintFilterRight),
- SkXfermode::kSrcOver_Mode, cropRect));
+ SkBlendMode::kSrcOver, cropRect));
}
this->addFilter("offset",
static sk_sp<SkImageFilter> make_blue(sk_sp<SkImageFilter> input,
const SkImageFilter::CropRect* cropRect) {
sk_sp<SkColorFilter> filter(SkColorFilter::MakeModeFilter(SK_ColorBLUE,
- SkXfermode::kSrcIn_Mode));
+ SkBlendMode::kSrcIn));
return SkColorFilterImageFilter::Make(std::move(filter), std::move(input), cropRect);
}
sk_sp<SkSpecialImage> source(create_empty_special_image(context, 5));
SkImageFilter::OutputProperties noColorSpace(nullptr);
SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeXYWH(0, 0, 1, 1), nullptr, noColorSpace);
- sk_sp<SkColorFilter> green(SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkXfermode::kSrc_Mode));
+ sk_sp<SkColorFilter> green(SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkBlendMode::kSrc));
SkASSERT(green->affectsTransparentBlack());
sk_sp<SkImageFilter> greenFilter(SkColorFilterImageFilter::Make(std::move(green),
std::move(failFilter)));
SkMatrix matrix;
matrix.setTranslate(SkIntToScalar(50), 0);
- sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorWHITE, SkXfermode::kSrc_Mode));
+ sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorWHITE, SkBlendMode::kSrc));
sk_sp<SkImageFilter> cfif(SkColorFilterImageFilter::Make(std::move(cf), nullptr));
sk_sp<SkImageFilter> imageFilter(SkImageFilter::MakeMatrixFilter(matrix,
kNone_SkFilterQuality,
greenBM.eraseColor(SK_ColorGREEN);
sk_sp<SkImage> greenImage(SkImage::MakeFromBitmap(greenBM));
sk_sp<SkImageFilter> source(SkImageSource::Make(std::move(greenImage)));
- sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(source, source));
+ sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(source, source, SkBlendMode::kSrcOver));
sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, 1));
SkPictureRecorder recorder;
sk_sp<SkColorFilter> green(SkColorFilter::MakeModeFilter(SK_ColorGREEN,
- SkXfermode::kSrc_Mode));
+ SkBlendMode::kSrc));
sk_sp<SkImageFilter> imageFilter(SkColorFilterImageFilter::Make(green, nullptr));
SkPaint imageFilterPaint;
imageFilterPaint.setImageFilter(std::move(imageFilter));
bitmap.eraseARGB(255, 255, 255, 255);
sk_sp<SkColorFilter> green(SkColorFilter::MakeModeFilter(SK_ColorGREEN,
- SkXfermode::kSrcIn_Mode));
+ SkBlendMode::kSrcIn));
sk_sp<SkImageFilter> greenFilter(SkColorFilterImageFilter::Make(green, nullptr));
SkImageFilter::CropRect cropRect(SkRect::MakeEmpty());
sk_sp<SkImageFilter> croppedOut(SkColorFilterImageFilter::Make(green, nullptr, &cropRect));
*/
DEF_TEST(ImageFilterComplexCTM, reporter) {
// just need a colorfilter to exercise the corresponding imagefilter
- sk_sp<SkColorFilter> cf = SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcATop_Mode);
+ sk_sp<SkColorFilter> cf = SkColorFilter::MakeModeFilter(SK_ColorRED, SkBlendMode::kSrcATop);
sk_sp<SkImageFilter> cfif = SkColorFilterImageFilter::Make(cf, nullptr); // can handle
sk_sp<SkImageFilter> blif = SkBlurImageFilter::Make(3, 3, nullptr); // cannot handle
} recs[] = {
{ cfif, true },
{ SkColorFilterImageFilter::Make(cf, cfif), true },
- { SkMergeImageFilter::Make(cfif, cfif), true },
+ { SkMergeImageFilter::Make(cfif, cfif, SkBlendMode::kSrcOver), true },
{ SkComposeImageFilter::Make(cfif, cfif), true },
{ blif, false },
{ SkBlurImageFilter::Make(3, 3, cfif), false },
{ SkColorFilterImageFilter::Make(cf, blif), false },
- { SkMergeImageFilter::Make(cfif, blif), false },
+ { SkMergeImageFilter::Make(cfif, blif, SkBlendMode::kSrcOver), false },
{ SkComposeImageFilter::Make(blif, cfif), false },
};
SkRect rect = SkRect::MakeWH(SkIntToScalar(rtS), SkIntToScalar(rtS));
GrNoClip noClip;
GrPaint paint;
- paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
+ paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
GrTextureParams mipMapParams(SkShader::kRepeat_TileMode, GrTextureParams::kMipMap_FilterMode);
paint.addColorTextureProcessor(texture, nullptr, SkMatrix::MakeScale(0.5f), mipMapParams);
GrTessellatingPathRenderer tess;
GrPaint paint;
- paint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+ paint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
GrNoClip noClip;
GrStyle style(SkStrokeRec::kFill_InitStyle);
}
void SkDebugCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM xmode,
const SkPaint& paint) {
- this->addDrawCommand(new SkDrawPatchCommand(cubics, colors, texCoords, xmode, paint));
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ SkBlendMode bmode = xmode ? xmode->blend() : SkBlendMode::kModulate;
+#else
+ SkBlendMode bmode = xmode;
+#endif
+ this->addDrawCommand(new SkDrawPatchCommand(cubics, colors, texCoords, bmode, paint));
}
void SkDebugCanvas::onDrawVertices(VertexMode vmode, int vertexCount, const SkPoint vertices[],
const SkPoint texs[], const SkColor colors[],
- SkXfermode*, const uint16_t indices[], int indexCount,
+ SK_XFERMODE_PARAM xmode, const uint16_t indices[], int indexCount,
const SkPaint& paint) {
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PARAM
+ SkBlendMode bmode = xmode ? xmode->blend() : SkBlendMode::kModulate;
+#else
+ SkBlendMode bmode = xmode;
+#endif
this->addDrawCommand(new SkDrawVerticesCommand(vmode, vertexCount, vertices,
- texs, colors, nullptr, indices, indexCount, paint));
+ texs, colors, bmode, indices, indexCount, paint));
}
void SkDebugCanvas::willRestore() {
const SkPaint& paint) override;
void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) override;
+ const SkPoint texCoords[4], SK_XFERMODE_PARAM, const SkPaint& paint) override;
void onDrawPaint(const SkPaint&) override;
void onDrawRect(const SkRect&, const SkPaint&) override;
void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xmode,
+ const SkColor colors[], SK_XFERMODE_PARAM,
const uint16_t indices[], int indexCount,
const SkPaint&) override;
void onDrawPath(const SkPath&, const SkPaint&) override;
}
SkDrawPatchCommand::SkDrawPatchCommand(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xfermode,
+ const SkPoint texCoords[4], SkBlendMode bmode,
const SkPaint& paint)
- : INHERITED(kDrawPatch_OpType) {
+ : INHERITED(kDrawPatch_OpType)
+ , fBlendMode(bmode)
+{
memcpy(fCubics, cubics, sizeof(fCubics));
if (colors != nullptr) {
memcpy(fColors, colors, sizeof(fColors));
} else {
fTexCoordsPtr = nullptr;
}
- if (xfermode != nullptr) {
- fXfermode.reset(SkRef(xfermode));
- }
fPaint = paint;
fInfo.push(SkObjectParser::PaintToString(paint));
}
void SkDrawPatchCommand::execute(SkCanvas* canvas) const {
- canvas->drawPatch(fCubics, fColorsPtr, fTexCoordsPtr, fXfermode, fPaint);
+ canvas->drawPatch(fCubics, fColorsPtr, fTexCoordsPtr, fBlendMode, fPaint);
}
Json::Value SkDrawPatchCommand::toJSON(UrlDataManager& urlDataManager) const {
}
result[SKDEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS] = texCoords;
}
- if (fXfermode.get() != nullptr) {
- Json::Value jsonXfermode;
- flatten(fXfermode, &jsonXfermode, urlDataManager);
- result[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE] = jsonXfermode;
- }
+ // fBlendMode
return result;
}
else {
texCoordsPtr = nullptr;
}
- SkAutoTUnref<SkXfermode> xfermode;
- if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_XFERMODE)) {
- Json::Value jsonXfermode = command[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE];
- xfermode.reset((SkXfermode*) load_flattenable(jsonXfermode, urlDataManager));
- }
+
+ SkBlendMode bmode = SkBlendMode::kSrcOver; // TODO: extract from json
+
SkPaint paint;
extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
- return new SkDrawPatchCommand(cubics, colorsPtr, texCoordsPtr, xfermode, paint);
+ return new SkDrawPatchCommand(cubics, colorsPtr, texCoordsPtr, bmode, paint);
}
SkDrawRectCommand::SkDrawRectCommand(const SkRect& rect, const SkPaint& paint)
SkDrawVerticesCommand::SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xfermode,
+ const SkColor colors[], SkBlendMode bmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint)
- : INHERITED(kDrawVertices_OpType) {
+ : INHERITED(kDrawVertices_OpType)
+ , fBlendMode(bmode)
+{
fVmode = vmode;
fVertexCount = vertexCount;
fColors = nullptr;
}
- fXfermode = xfermode;
- if (fXfermode) {
- fXfermode->ref();
- }
-
if (indexCount > 0) {
fIndices = new uint16_t[indexCount];
memcpy(fIndices, indices, indexCount * sizeof(uint16_t));
delete [] fVertices;
delete [] fTexs;
delete [] fColors;
- SkSafeUnref(fXfermode);
delete [] fIndices;
}
void SkDrawVerticesCommand::execute(SkCanvas* canvas) const {
canvas->drawVertices(fVmode, fVertexCount, fVertices,
- fTexs, fColors, fXfermode, fIndices,
+ fTexs, fColors, fBlendMode, fIndices,
fIndexCount, fPaint);
}
class SkDrawPatchCommand : public SkDrawCommand {
public:
SkDrawPatchCommand(const SkPoint cubics[12], const SkColor colors[4],
- const SkPoint texCoords[4], SkXfermode* xmode,
+ const SkPoint texCoords[4], SkBlendMode bmode,
const SkPaint& paint);
void execute(SkCanvas* canvas) const override;
Json::Value toJSON(UrlDataManager& urlDataManager) const override;
SkColor fColors[4];
SkPoint* fTexCoordsPtr;
SkPoint fTexCoords[4];
- SkAutoTUnref<SkXfermode> fXfermode;
+ SkBlendMode fBlendMode;
SkPaint fPaint;
typedef SkDrawCommand INHERITED;
public:
SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
- const SkColor colors[], SkXfermode* xfermode,
+ const SkColor colors[], SkBlendMode,
const uint16_t indices[], int indexCount,
const SkPaint& paint);
virtual ~SkDrawVerticesCommand();
SkPoint* fVertices;
SkPoint* fTexs;
SkColor* fColors;
- SkXfermode* fXfermode;
+ SkBlendMode fBlendMode;
uint16_t* fIndices;
int fIndexCount;
SkPaint fPaint;
projects / platform / upstream / libSkiaSharp.git / commitdiff