senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2013 The Android Open Source Project |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #include "SkXfermodeImageFilter.h" |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 9 | #include "SkArithmeticImageFilter.h" |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 10 | #include "SkArithmeticModePriv.h" |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 11 | #include "SkCanvas.h" |
| 12 | #include "SkColorPriv.h" |
commit-bot@chromium.org | 8b0e8ac | 2014-01-30 18:58:24 +0000 | [diff] [blame] | 13 | #include "SkReadBuffer.h" |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 14 | #include "SkSpecialImage.h" |
| 15 | #include "SkSpecialSurface.h" |
commit-bot@chromium.org | 8b0e8ac | 2014-01-30 18:58:24 +0000 | [diff] [blame] | 16 | #include "SkWriteBuffer.h" |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 17 | #if SK_SUPPORT_GPU |
| 18 | #include "GrContext.h" |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 19 | #include "GrRenderTargetContext.h" |
Robert Phillips | 7f6cd90 | 2016-11-10 17:03:43 -0500 | [diff] [blame] | 20 | #include "GrTextureProxy.h" |
| 21 | |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 22 | #include "effects/GrConstColorProcessor.h" |
senorblanco | d762ca2 | 2015-04-07 12:16:55 -0700 | [diff] [blame] | 23 | #include "effects/GrTextureDomain.h" |
bsalomon | ae4738f | 2015-09-15 15:33:27 -0700 | [diff] [blame] | 24 | #include "effects/GrSimpleTextureEffect.h" |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 25 | #include "SkGr.h" |
brianosman | 2695eaa | 2016-09-21 06:45:09 -0700 | [diff] [blame] | 26 | #include "SkGrPriv.h" |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 27 | #endif |
Mike Reed | ebfce6d | 2016-12-12 10:02:12 -0500 | [diff] [blame] | 28 | #include "SkClipOpPriv.h" |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 29 | |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 30 | class SkXfermodeImageFilter_Base : public SkImageFilter { |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 31 | public: |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 32 | SkXfermodeImageFilter_Base(SkBlendMode mode, sk_sp<SkImageFilter> inputs[2], |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 33 | const CropRect* cropRect); |
| 34 | |
| 35 | SK_TO_STRING_OVERRIDE() |
| 36 | SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkXfermodeImageFilter_Base) |
| 37 | |
| 38 | protected: |
| 39 | sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&, |
| 40 | SkIPoint* offset) const override; |
| 41 | |
| 42 | #if SK_SUPPORT_GPU |
| 43 | sk_sp<SkSpecialImage> filterImageGPU(SkSpecialImage* source, |
| 44 | sk_sp<SkSpecialImage> background, |
| 45 | const SkIPoint& backgroundOffset, |
| 46 | sk_sp<SkSpecialImage> foreground, |
| 47 | const SkIPoint& foregroundOffset, |
| 48 | const SkIRect& bounds, |
| 49 | const OutputProperties& outputProperties) const; |
| 50 | #endif |
| 51 | |
| 52 | void flatten(SkWriteBuffer&) const override; |
| 53 | |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 54 | void drawForeground(SkCanvas* canvas, SkSpecialImage*, const SkIRect&) const; |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 55 | #if SK_SUPPORT_GPU |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 56 | sk_sp<GrFragmentProcessor> makeFGFrag(sk_sp<GrFragmentProcessor> bgFP) const; |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 57 | #endif |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 58 | |
| 59 | private: |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 60 | static sk_sp<SkFlattenable> LegacyArithmeticCreateProc(SkReadBuffer& buffer); |
| 61 | |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 62 | SkBlendMode fMode; |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 63 | |
| 64 | friend class SkXfermodeImageFilter; |
| 65 | |
| 66 | typedef SkImageFilter INHERITED; |
| 67 | }; |
| 68 | |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 69 | /////////////////////////////////////////////////////////////////////////////// |
| 70 | |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 71 | sk_sp<SkImageFilter> SkXfermodeImageFilter::Make(SkBlendMode mode, |
robertphillips | 8c0326d | 2016-04-05 12:48:34 -0700 | [diff] [blame] | 72 | sk_sp<SkImageFilter> background, |
| 73 | sk_sp<SkImageFilter> foreground, |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 74 | const SkImageFilter::CropRect* cropRect) { |
robertphillips | 8c0326d | 2016-04-05 12:48:34 -0700 | [diff] [blame] | 75 | sk_sp<SkImageFilter> inputs[2] = { std::move(background), std::move(foreground) }; |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 76 | return sk_sp<SkImageFilter>(new SkXfermodeImageFilter_Base(mode, inputs, cropRect)); |
reed | cfb6bdf | 2016-03-29 11:32:50 -0700 | [diff] [blame] | 77 | } |
| 78 | |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 79 | SkXfermodeImageFilter_Base::SkXfermodeImageFilter_Base(SkBlendMode mode, |
| 80 | sk_sp<SkImageFilter> inputs[2], |
| 81 | const CropRect* cropRect) |
Mike Reed | 1834242 | 2016-10-04 10:06:20 -0400 | [diff] [blame] | 82 | : INHERITED(inputs, 2, cropRect) |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 83 | , fMode(mode) |
| 84 | {} |
| 85 | |
| 86 | static int unflatten_blendmode(SkReadBuffer& buffer, SkArithmeticParams* arith) { |
| 87 | if (buffer.isVersionLT(SkReadBuffer::kXfermodeToBlendMode_Version)) { |
| 88 | sk_sp<SkXfermode> xfer = buffer.readXfermode(); |
| 89 | if (xfer) { |
| 90 | if (xfer->isArithmetic(arith)) { |
| 91 | return -1; |
| 92 | } |
| 93 | return (int)xfer->blend(); |
| 94 | } else { |
| 95 | return (int)SkBlendMode::kSrcOver; |
| 96 | } |
| 97 | } else { |
| 98 | uint32_t mode = buffer.read32(); |
| 99 | (void)buffer.validate(mode <= (unsigned)SkBlendMode::kLastMode); |
| 100 | return mode; |
| 101 | } |
Mike Reed | 3ed485f | 2016-10-04 21:35:32 +0000 | [diff] [blame] | 102 | } |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 103 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 104 | sk_sp<SkFlattenable> SkXfermodeImageFilter_Base::CreateProc(SkReadBuffer& buffer) { |
reed | 9fa60da | 2014-08-21 07:59:51 -0700 | [diff] [blame] | 105 | SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2); |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 106 | SkArithmeticParams arith; |
| 107 | int mode = unflatten_blendmode(buffer, &arith); |
| 108 | if (mode >= 0) { |
| 109 | return SkXfermodeImageFilter::Make((SkBlendMode)mode, common.getInput(0), |
| 110 | common.getInput(1), &common.cropRect()); |
| 111 | } else { |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 112 | return SkArithmeticImageFilter::Make(arith.fK[0], arith.fK[1], arith.fK[2], arith.fK[3], |
| 113 | arith.fEnforcePMColor, common.getInput(0), |
| 114 | common.getInput(1), &common.cropRect()); |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 115 | } |
reed | 9fa60da | 2014-08-21 07:59:51 -0700 | [diff] [blame] | 116 | } |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 117 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 118 | void SkXfermodeImageFilter_Base::flatten(SkWriteBuffer& buffer) const { |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 119 | this->INHERITED::flatten(buffer); |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 120 | buffer.write32((unsigned)fMode); |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 121 | } |
| 122 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 123 | sk_sp<SkSpecialImage> SkXfermodeImageFilter_Base::onFilterImage(SkSpecialImage* source, |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 124 | const Context& ctx, |
| 125 | SkIPoint* offset) const { |
commit-bot@chromium.org | 7b32070 | 2013-07-10 21:22:18 +0000 | [diff] [blame] | 126 | SkIPoint backgroundOffset = SkIPoint::Make(0, 0); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 127 | sk_sp<SkSpecialImage> background(this->filterInput(0, source, ctx, &backgroundOffset)); |
| 128 | |
commit-bot@chromium.org | 7b32070 | 2013-07-10 21:22:18 +0000 | [diff] [blame] | 129 | SkIPoint foregroundOffset = SkIPoint::Make(0, 0); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 130 | sk_sp<SkSpecialImage> foreground(this->filterInput(1, source, ctx, &foregroundOffset)); |
| 131 | |
| 132 | SkIRect foregroundBounds = SkIRect::EmptyIRect(); |
| 133 | if (foreground) { |
| 134 | foregroundBounds = SkIRect::MakeXYWH(foregroundOffset.x(), foregroundOffset.y(), |
| 135 | foreground->width(), foreground->height()); |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 136 | } |
commit-bot@chromium.org | 1a4fb70 | 2013-09-26 16:09:28 +0000 | [diff] [blame] | 137 | |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 138 | SkIRect srcBounds = SkIRect::EmptyIRect(); |
| 139 | if (background) { |
| 140 | srcBounds = SkIRect::MakeXYWH(backgroundOffset.x(), backgroundOffset.y(), |
| 141 | background->width(), background->height()); |
| 142 | } |
| 143 | |
senorblanco | 9db0427 | 2016-03-31 08:24:29 -0700 | [diff] [blame] | 144 | srcBounds.join(foregroundBounds); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 145 | if (srcBounds.isEmpty()) { |
| 146 | return nullptr; |
| 147 | } |
| 148 | |
senorblanco | 9db0427 | 2016-03-31 08:24:29 -0700 | [diff] [blame] | 149 | SkIRect bounds; |
| 150 | if (!this->applyCropRect(ctx, srcBounds, &bounds)) { |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 151 | return nullptr; |
senorblanco@chromium.org | ee845ae | 2014-04-01 19:15:23 +0000 | [diff] [blame] | 152 | } |
commit-bot@chromium.org | 1a4fb70 | 2013-09-26 16:09:28 +0000 | [diff] [blame] | 153 | |
senorblanco@chromium.org | 6776b82 | 2014-01-03 21:48:22 +0000 | [diff] [blame] | 154 | offset->fX = bounds.left(); |
| 155 | offset->fY = bounds.top(); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 156 | |
| 157 | #if SK_SUPPORT_GPU |
| 158 | if (source->isTextureBacked()) { |
| 159 | return this->filterImageGPU(source, |
| 160 | background, backgroundOffset, |
| 161 | foreground, foregroundOffset, |
brianosman | 2a75e5d | 2016-09-22 07:15:37 -0700 | [diff] [blame] | 162 | bounds, ctx.outputProperties()); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 163 | } |
| 164 | #endif |
| 165 | |
brianosman | eed6b0e | 2016-09-23 13:04:05 -0700 | [diff] [blame] | 166 | sk_sp<SkSpecialSurface> surf(source->makeSurface(ctx.outputProperties(), bounds.size())); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 167 | if (!surf) { |
| 168 | return nullptr; |
| 169 | } |
| 170 | |
| 171 | SkCanvas* canvas = surf->getCanvas(); |
| 172 | SkASSERT(canvas); |
| 173 | |
robertphillips | 3806b8f | 2016-05-12 10:46:39 -0700 | [diff] [blame] | 174 | canvas->clear(0x0); // can't count on background to fully clear the background |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 175 | canvas->translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top())); |
| 176 | |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 177 | if (background) { |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 178 | SkPaint paint; |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 179 | paint.setBlendMode(SkBlendMode::kSrc); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 180 | background->draw(canvas, |
| 181 | SkIntToScalar(backgroundOffset.fX), SkIntToScalar(backgroundOffset.fY), |
| 182 | &paint); |
| 183 | } |
| 184 | |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 185 | this->drawForeground(canvas, foreground.get(), foregroundBounds); |
Mike Reed | 10ff5bf | 2016-09-26 20:40:57 +0000 | [diff] [blame] | 186 | |
| 187 | return surf->makeImageSnapshot(); |
Mike Reed | 0530c88 | 2016-09-26 15:33:00 -0400 | [diff] [blame] | 188 | } |
| 189 | |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 190 | void SkXfermodeImageFilter_Base::drawForeground(SkCanvas* canvas, SkSpecialImage* img, |
| 191 | const SkIRect& fgBounds) const { |
| 192 | SkPaint paint; |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 193 | paint.setBlendMode(fMode); |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 194 | if (img) { |
| 195 | img->draw(canvas, SkIntToScalar(fgBounds.fLeft), SkIntToScalar(fgBounds.fTop), &paint); |
| 196 | } |
| 197 | |
| 198 | SkAutoCanvasRestore acr(canvas, true); |
Mike Reed | c1f7774 | 2016-12-09 09:00:50 -0500 | [diff] [blame] | 199 | canvas->clipRect(SkRect::Make(fgBounds), kDifference_SkClipOp); |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 200 | paint.setColor(0); |
| 201 | canvas->drawPaint(paint); |
| 202 | } |
| 203 | |
robertphillips | f3f5bad | 2014-12-19 13:49:15 -0800 | [diff] [blame] | 204 | #ifndef SK_IGNORE_TO_STRING |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 205 | void SkXfermodeImageFilter_Base::toString(SkString* str) const { |
robertphillips | f3f5bad | 2014-12-19 13:49:15 -0800 | [diff] [blame] | 206 | str->appendf("SkXfermodeImageFilter: ("); |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 207 | str->appendf("blendmode: (%d)", (int)fMode); |
robertphillips | 6319518 | 2015-06-08 06:21:14 -0700 | [diff] [blame] | 208 | if (this->getInput(0)) { |
| 209 | str->appendf("foreground: ("); |
| 210 | this->getInput(0)->toString(str); |
| 211 | str->appendf(")"); |
| 212 | } |
| 213 | if (this->getInput(1)) { |
| 214 | str->appendf("background: ("); |
| 215 | this->getInput(1)->toString(str); |
| 216 | str->appendf(")"); |
| 217 | } |
| 218 | str->append(")"); |
robertphillips | f3f5bad | 2014-12-19 13:49:15 -0800 | [diff] [blame] | 219 | } |
| 220 | #endif |
| 221 | |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 222 | #if SK_SUPPORT_GPU |
| 223 | |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 224 | #include "SkXfermode_proccoeff.h" |
| 225 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 226 | sk_sp<SkSpecialImage> SkXfermodeImageFilter_Base::filterImageGPU( |
brianosman | 2a75e5d | 2016-09-22 07:15:37 -0700 | [diff] [blame] | 227 | SkSpecialImage* source, |
| 228 | sk_sp<SkSpecialImage> background, |
| 229 | const SkIPoint& backgroundOffset, |
| 230 | sk_sp<SkSpecialImage> foreground, |
| 231 | const SkIPoint& foregroundOffset, |
| 232 | const SkIRect& bounds, |
| 233 | const OutputProperties& outputProperties) const { |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 234 | SkASSERT(source->isTextureBacked()); |
| 235 | |
| 236 | GrContext* context = source->getContext(); |
| 237 | |
| 238 | sk_sp<GrTexture> backgroundTex, foregroundTex; |
| 239 | |
| 240 | if (background) { |
robertphillips | c91fd34 | 2016-04-25 12:32:54 -0700 | [diff] [blame] | 241 | backgroundTex = background->asTextureRef(context); |
egdaniel | 38cd055 | 2015-01-14 08:05:11 -0800 | [diff] [blame] | 242 | } |
| 243 | |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 244 | if (foreground) { |
robertphillips | c91fd34 | 2016-04-25 12:32:54 -0700 | [diff] [blame] | 245 | foregroundTex = foreground->asTextureRef(context); |
senorblanco | 06d54ad | 2016-01-13 13:48:54 -0800 | [diff] [blame] | 246 | } |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 247 | |
joshualitt | b245605 | 2015-07-08 09:36:59 -0700 | [diff] [blame] | 248 | GrPaint paint; |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 249 | sk_sp<GrFragmentProcessor> bgFP; |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 250 | |
| 251 | if (backgroundTex) { |
Joe Gregorio | a7d61a6 | 2017-01-17 19:20:54 +0000 | [diff] [blame^] | 252 | SkMatrix backgroundMatrix; |
| 253 | backgroundMatrix.setIDiv(backgroundTex->width(), backgroundTex->height()); |
| 254 | backgroundMatrix.preTranslate(-SkIntToScalar(backgroundOffset.fX), |
| 255 | -SkIntToScalar(backgroundOffset.fY)); |
Brian Osman | 7dc5452 | 2016-12-20 10:36:35 -0500 | [diff] [blame] | 256 | sk_sp<GrColorSpaceXform> bgXform = GrColorSpaceXform::Make(background->getColorSpace(), |
| 257 | outputProperties.colorSpace()); |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 258 | bgFP = GrTextureDomainEffect::Make( |
Brian Osman | 7dc5452 | 2016-12-20 10:36:35 -0500 | [diff] [blame] | 259 | backgroundTex.get(), std::move(bgXform), backgroundMatrix, |
Robert Phillips | e98234f | 2017-01-09 14:23:59 -0500 | [diff] [blame] | 260 | GrTextureDomain::MakeTexelDomain(background->subset()), |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 261 | GrTextureDomain::kDecal_Mode, |
Brian Salomon | 514baff | 2016-11-17 15:17:07 -0500 | [diff] [blame] | 262 | GrSamplerParams::kNone_FilterMode); |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 263 | } else { |
Brian Osman | 618d304 | 2016-10-25 10:51:28 -0400 | [diff] [blame] | 264 | bgFP = GrConstColorProcessor::Make(GrColor4f::TransparentBlack(), |
| 265 | GrConstColorProcessor::kIgnore_InputMode); |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 266 | } |
| 267 | |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 268 | if (foregroundTex) { |
Joe Gregorio | a7d61a6 | 2017-01-17 19:20:54 +0000 | [diff] [blame^] | 269 | SkMatrix foregroundMatrix; |
| 270 | foregroundMatrix.setIDiv(foregroundTex->width(), foregroundTex->height()); |
| 271 | foregroundMatrix.preTranslate(-SkIntToScalar(foregroundOffset.fX), |
| 272 | -SkIntToScalar(foregroundOffset.fY)); |
Brian Osman | 7dc5452 | 2016-12-20 10:36:35 -0500 | [diff] [blame] | 273 | sk_sp<GrColorSpaceXform> fgXform = GrColorSpaceXform::Make(foreground->getColorSpace(), |
| 274 | outputProperties.colorSpace()); |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 275 | sk_sp<GrFragmentProcessor> foregroundFP; |
commit-bot@chromium.org | 7b32070 | 2013-07-10 21:22:18 +0000 | [diff] [blame] | 276 | |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 277 | foregroundFP = GrTextureDomainEffect::Make( |
Brian Osman | 7dc5452 | 2016-12-20 10:36:35 -0500 | [diff] [blame] | 278 | foregroundTex.get(), std::move(fgXform), foregroundMatrix, |
Robert Phillips | e98234f | 2017-01-09 14:23:59 -0500 | [diff] [blame] | 279 | GrTextureDomain::MakeTexelDomain(foreground->subset()), |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 280 | GrTextureDomain::kDecal_Mode, |
Brian Salomon | 514baff | 2016-11-17 15:17:07 -0500 | [diff] [blame] | 281 | GrSamplerParams::kNone_FilterMode); |
senorblanco | d762ca2 | 2015-04-07 12:16:55 -0700 | [diff] [blame] | 282 | |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 283 | paint.addColorFragmentProcessor(std::move(foregroundFP)); |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 284 | |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 285 | sk_sp<GrFragmentProcessor> xferFP = this->makeFGFrag(bgFP); |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 286 | |
| 287 | // A null 'xferFP' here means kSrc_Mode was used in which case we can just proceed |
| 288 | if (xferFP) { |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 289 | paint.addColorFragmentProcessor(std::move(xferFP)); |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 290 | } |
| 291 | } else { |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 292 | paint.addColorFragmentProcessor(std::move(bgFP)); |
bsalomon | ae4738f | 2015-09-15 15:33:27 -0700 | [diff] [blame] | 293 | } |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 294 | |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 295 | paint.setPorterDuffXPFactory(SkBlendMode::kSrc); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 296 | |
Robert Phillips | 7f6cd90 | 2016-11-10 17:03:43 -0500 | [diff] [blame] | 297 | sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext( |
| 298 | SkBackingFit::kApprox, bounds.width(), bounds.height(), |
| 299 | GrRenderableConfigForColorSpace(outputProperties.colorSpace()), |
| 300 | sk_ref_sp(outputProperties.colorSpace()))); |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 301 | if (!renderTargetContext) { |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 302 | return nullptr; |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 303 | } |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 304 | paint.setGammaCorrect(renderTargetContext->isGammaCorrect()); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 305 | |
senorblanco | 06d54ad | 2016-01-13 13:48:54 -0800 | [diff] [blame] | 306 | SkMatrix matrix; |
| 307 | matrix.setTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top())); |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 308 | renderTargetContext->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, matrix, |
| 309 | SkRect::Make(bounds)); |
senorblanco@chromium.org | ee845ae | 2014-04-01 19:15:23 +0000 | [diff] [blame] | 310 | |
Robert Phillips | 7f6cd90 | 2016-11-10 17:03:43 -0500 | [diff] [blame] | 311 | return SkSpecialImage::MakeDeferredFromGpu(context, |
| 312 | SkIRect::MakeWH(bounds.width(), bounds.height()), |
| 313 | kNeedNewImageUniqueID_SpecialImage, |
| 314 | sk_ref_sp(renderTargetContext->asDeferredTexture()), |
Robert Phillips | 75a475c | 2017-01-13 09:18:59 -0500 | [diff] [blame] | 315 | renderTargetContext->refColorSpace()); |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 316 | } |
| 317 | |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 318 | sk_sp<GrFragmentProcessor> |
| 319 | SkXfermodeImageFilter_Base::makeFGFrag(sk_sp<GrFragmentProcessor> bgFP) const { |
| 320 | // A null fMode is interpreted to mean kSrcOver_Mode (to match raster). |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 321 | SkXfermode* xfer = SkXfermode::Peek(fMode); |
| 322 | sk_sp<SkXfermode> srcover; |
| 323 | if (!xfer) { |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 324 | // It would be awesome to use SkXfermode::Create here but it knows better |
| 325 | // than us and won't return a kSrcOver_Mode SkXfermode. That means we |
| 326 | // have to get one the hard way. |
| 327 | struct ProcCoeff rec; |
Mike Reed | 6a01554 | 2016-11-09 10:38:09 -0500 | [diff] [blame] | 328 | rec.fProc = SkXfermode::GetProc(SkBlendMode::kSrcOver); |
| 329 | SkXfermode::ModeAsCoeff(SkBlendMode::kSrcOver, &rec.fSC, &rec.fDC); |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 330 | |
Mike Reed | 7d954ad | 2016-10-28 15:42:34 -0400 | [diff] [blame] | 331 | srcover.reset(new SkProcCoeffXfermode(rec, SkBlendMode::kSrcOver)); |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 332 | xfer = srcover.get(); |
| 333 | |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 334 | } |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 335 | return xfer->makeFragmentProcessorForImageFilter(std::move(bgFP)); |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 336 | } |
| 337 | |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 338 | #endif |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 339 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 340 | |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 341 | sk_sp<SkFlattenable> SkXfermodeImageFilter_Base::LegacyArithmeticCreateProc(SkReadBuffer& buffer) { |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 342 | SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2); |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 343 | // skip the unused mode (srcover) field |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 344 | SkDEBUGCODE(int mode =) unflatten_blendmode(buffer, nullptr); |
| 345 | if (!buffer.isValid()) { |
| 346 | return nullptr; |
| 347 | } |
| 348 | SkASSERT(SkBlendMode::kSrcOver == (SkBlendMode)mode); |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 349 | float k[4]; |
| 350 | for (int i = 0; i < 4; ++i) { |
| 351 | k[i] = buffer.readScalar(); |
| 352 | } |
| 353 | const bool enforcePMColor = buffer.readBool(); |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 354 | return SkArithmeticImageFilter::Make(k[0], k[1], k[2], k[3], enforcePMColor, common.getInput(0), |
| 355 | common.getInput(1), &common.cropRect()); |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 356 | } |
| 357 | |
| 358 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 359 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 360 | SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermodeImageFilter) |
| 361 | SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkXfermodeImageFilter_Base) |
| 362 | // manually register the legacy serialized name "SkXfermodeImageFilter" |
| 363 | SkFlattenable::Register("SkXfermodeImageFilter", SkXfermodeImageFilter_Base::CreateProc, |
| 364 | SkFlattenable::kSkImageFilter_Type); |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 365 | // manually register the legacy serialized name "SkArithmeticImageFilter" from when that filter |
| 366 | // was implemented as a xfermode image filter. |
| 367 | SkFlattenable::Register("SkArithmeticImageFilter", |
| 368 | SkXfermodeImageFilter_Base::LegacyArithmeticCreateProc, |
| 369 | SkFlattenable::kSkImageFilter_Type); |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 370 | SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |