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" |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 10 | #include "SkCanvas.h" |
Cary Clark | a4083c9 | 2017-09-15 11:59:23 -0400 | [diff] [blame] | 11 | #include "SkColorData.h" |
Mike Reed | 6d9f429 | 2017-07-06 12:32:55 -0400 | [diff] [blame] | 12 | #include "SkColorSpaceXformer.h" |
Cary Clark | 4dc5a45 | 2018-05-21 11:56:57 -0400 | [diff] [blame] | 13 | #include "SkFlattenablePriv.h" |
Cary Clark | 60aaeb2 | 2017-11-03 08:06:09 -0400 | [diff] [blame] | 14 | #include "SkImageFilterPriv.h" |
commit-bot@chromium.org | 8b0e8ac | 2014-01-30 18:58:24 +0000 | [diff] [blame] | 15 | #include "SkReadBuffer.h" |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 16 | #include "SkSpecialImage.h" |
| 17 | #include "SkSpecialSurface.h" |
commit-bot@chromium.org | 8b0e8ac | 2014-01-30 18:58:24 +0000 | [diff] [blame] | 18 | #include "SkWriteBuffer.h" |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 19 | #if SK_SUPPORT_GPU |
Brian Salomon | c65aec9 | 2017-03-09 09:03:58 -0500 | [diff] [blame] | 20 | #include "GrClip.h" |
Brian Osman | 1cb4171 | 2017-10-19 12:54:52 -0400 | [diff] [blame] | 21 | #include "GrColorSpaceXform.h" |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 22 | #include "GrContext.h" |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 23 | #include "GrRenderTargetContext.h" |
Robert Phillips | 7f6cd90 | 2016-11-10 17:03:43 -0500 | [diff] [blame] | 24 | #include "GrTextureProxy.h" |
| 25 | |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 26 | #include "effects/GrConstColorProcessor.h" |
senorblanco | d762ca2 | 2015-04-07 12:16:55 -0700 | [diff] [blame] | 27 | #include "effects/GrTextureDomain.h" |
bsalomon | ae4738f | 2015-09-15 15:33:27 -0700 | [diff] [blame] | 28 | #include "effects/GrSimpleTextureEffect.h" |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 29 | #include "SkGr.h" |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 30 | #endif |
Mike Reed | ebfce6d | 2016-12-12 10:02:12 -0500 | [diff] [blame] | 31 | #include "SkClipOpPriv.h" |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 32 | |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 33 | class SkXfermodeImageFilter_Base : public SkImageFilter { |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 34 | public: |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 35 | SkXfermodeImageFilter_Base(SkBlendMode mode, sk_sp<SkImageFilter> inputs[2], |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 36 | const CropRect* cropRect); |
| 37 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 38 | SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkXfermodeImageFilter_Base) |
| 39 | |
| 40 | protected: |
| 41 | sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&, |
| 42 | SkIPoint* offset) const override; |
Matt Sarett | 6d72ed9 | 2017-04-10 16:35:33 -0400 | [diff] [blame] | 43 | sk_sp<SkImageFilter> onMakeColorSpace(SkColorSpaceXformer*) const override; |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 44 | |
Robert Phillips | 1207843 | 2018-05-17 11:17:39 -0400 | [diff] [blame] | 45 | SkIRect onFilterBounds(const SkIRect&, const SkMatrix& ctm, |
| 46 | MapDirection, const SkIRect* inputRect) const override; |
Xianzhu Wang | 0fa353c | 2017-08-25 16:27:04 -0700 | [diff] [blame] | 47 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 48 | #if SK_SUPPORT_GPU |
| 49 | sk_sp<SkSpecialImage> filterImageGPU(SkSpecialImage* source, |
| 50 | sk_sp<SkSpecialImage> background, |
| 51 | const SkIPoint& backgroundOffset, |
| 52 | sk_sp<SkSpecialImage> foreground, |
| 53 | const SkIPoint& foregroundOffset, |
| 54 | const SkIRect& bounds, |
| 55 | const OutputProperties& outputProperties) const; |
| 56 | #endif |
| 57 | |
| 58 | void flatten(SkWriteBuffer&) const override; |
| 59 | |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 60 | void drawForeground(SkCanvas* canvas, SkSpecialImage*, const SkIRect&) const; |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 61 | #if SK_SUPPORT_GPU |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 62 | std::unique_ptr<GrFragmentProcessor> makeFGFrag( |
| 63 | std::unique_ptr<GrFragmentProcessor> bgFP) const; |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 64 | #endif |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 65 | |
| 66 | private: |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 67 | static sk_sp<SkFlattenable> LegacyArithmeticCreateProc(SkReadBuffer& buffer); |
| 68 | |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 69 | SkBlendMode fMode; |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 70 | |
| 71 | friend class SkXfermodeImageFilter; |
| 72 | |
| 73 | typedef SkImageFilter INHERITED; |
| 74 | }; |
| 75 | |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 76 | /////////////////////////////////////////////////////////////////////////////// |
| 77 | |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 78 | sk_sp<SkImageFilter> SkXfermodeImageFilter::Make(SkBlendMode mode, |
robertphillips | 8c0326d | 2016-04-05 12:48:34 -0700 | [diff] [blame] | 79 | sk_sp<SkImageFilter> background, |
| 80 | sk_sp<SkImageFilter> foreground, |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 81 | const SkImageFilter::CropRect* cropRect) { |
robertphillips | 8c0326d | 2016-04-05 12:48:34 -0700 | [diff] [blame] | 82 | sk_sp<SkImageFilter> inputs[2] = { std::move(background), std::move(foreground) }; |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 83 | return sk_sp<SkImageFilter>(new SkXfermodeImageFilter_Base(mode, inputs, cropRect)); |
reed | cfb6bdf | 2016-03-29 11:32:50 -0700 | [diff] [blame] | 84 | } |
| 85 | |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 86 | SkXfermodeImageFilter_Base::SkXfermodeImageFilter_Base(SkBlendMode mode, |
| 87 | sk_sp<SkImageFilter> inputs[2], |
| 88 | const CropRect* cropRect) |
Mike Reed | 1834242 | 2016-10-04 10:06:20 -0400 | [diff] [blame] | 89 | : INHERITED(inputs, 2, cropRect) |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 90 | , fMode(mode) |
| 91 | {} |
| 92 | |
Mike Reed | 63544a4 | 2017-06-09 17:00:25 -0400 | [diff] [blame] | 93 | static unsigned unflatten_blendmode(SkReadBuffer& buffer) { |
| 94 | unsigned mode = buffer.read32(); |
Mike Reed | 70bc94f | 2017-06-08 12:45:52 -0400 | [diff] [blame] | 95 | (void)buffer.validate(mode <= (unsigned)SkBlendMode::kLastMode); |
| 96 | return mode; |
Mike Reed | 3ed485f | 2016-10-04 21:35:32 +0000 | [diff] [blame] | 97 | } |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 98 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 99 | sk_sp<SkFlattenable> SkXfermodeImageFilter_Base::CreateProc(SkReadBuffer& buffer) { |
reed | 9fa60da | 2014-08-21 07:59:51 -0700 | [diff] [blame] | 100 | SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2); |
Mike Reed | 63544a4 | 2017-06-09 17:00:25 -0400 | [diff] [blame] | 101 | unsigned mode = unflatten_blendmode(buffer); |
| 102 | if (!buffer.isValid()) { |
| 103 | return nullptr; |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 104 | } |
Mike Reed | 63544a4 | 2017-06-09 17:00:25 -0400 | [diff] [blame] | 105 | return SkXfermodeImageFilter::Make((SkBlendMode)mode, common.getInput(0), |
| 106 | common.getInput(1), &common.cropRect()); |
reed | 9fa60da | 2014-08-21 07:59:51 -0700 | [diff] [blame] | 107 | } |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 108 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 109 | void SkXfermodeImageFilter_Base::flatten(SkWriteBuffer& buffer) const { |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 110 | this->INHERITED::flatten(buffer); |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 111 | buffer.write32((unsigned)fMode); |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 112 | } |
| 113 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 114 | sk_sp<SkSpecialImage> SkXfermodeImageFilter_Base::onFilterImage(SkSpecialImage* source, |
Robert Phillips | c100d48 | 2018-07-10 10:11:01 -0400 | [diff] [blame] | 115 | const Context& ctx, |
| 116 | SkIPoint* offset) const { |
commit-bot@chromium.org | 7b32070 | 2013-07-10 21:22:18 +0000 | [diff] [blame] | 117 | SkIPoint backgroundOffset = SkIPoint::Make(0, 0); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 118 | sk_sp<SkSpecialImage> background(this->filterInput(0, source, ctx, &backgroundOffset)); |
| 119 | |
commit-bot@chromium.org | 7b32070 | 2013-07-10 21:22:18 +0000 | [diff] [blame] | 120 | SkIPoint foregroundOffset = SkIPoint::Make(0, 0); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 121 | sk_sp<SkSpecialImage> foreground(this->filterInput(1, source, ctx, &foregroundOffset)); |
| 122 | |
| 123 | SkIRect foregroundBounds = SkIRect::EmptyIRect(); |
| 124 | if (foreground) { |
| 125 | foregroundBounds = SkIRect::MakeXYWH(foregroundOffset.x(), foregroundOffset.y(), |
| 126 | foreground->width(), foreground->height()); |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 127 | } |
commit-bot@chromium.org | 1a4fb70 | 2013-09-26 16:09:28 +0000 | [diff] [blame] | 128 | |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 129 | SkIRect srcBounds = SkIRect::EmptyIRect(); |
| 130 | if (background) { |
| 131 | srcBounds = SkIRect::MakeXYWH(backgroundOffset.x(), backgroundOffset.y(), |
Robert Phillips | c100d48 | 2018-07-10 10:11:01 -0400 | [diff] [blame] | 132 | background->width(), background->height()); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 133 | } |
Ben Wagner | 63fd760 | 2017-10-09 15:45:33 -0400 | [diff] [blame] | 134 | |
senorblanco | 9db0427 | 2016-03-31 08:24:29 -0700 | [diff] [blame] | 135 | srcBounds.join(foregroundBounds); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 136 | if (srcBounds.isEmpty()) { |
| 137 | return nullptr; |
| 138 | } |
| 139 | |
senorblanco | 9db0427 | 2016-03-31 08:24:29 -0700 | [diff] [blame] | 140 | SkIRect bounds; |
| 141 | if (!this->applyCropRect(ctx, srcBounds, &bounds)) { |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 142 | return nullptr; |
senorblanco@chromium.org | ee845ae | 2014-04-01 19:15:23 +0000 | [diff] [blame] | 143 | } |
commit-bot@chromium.org | 1a4fb70 | 2013-09-26 16:09:28 +0000 | [diff] [blame] | 144 | |
senorblanco@chromium.org | 6776b82 | 2014-01-03 21:48:22 +0000 | [diff] [blame] | 145 | offset->fX = bounds.left(); |
| 146 | offset->fY = bounds.top(); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 147 | |
| 148 | #if SK_SUPPORT_GPU |
| 149 | if (source->isTextureBacked()) { |
| 150 | return this->filterImageGPU(source, |
Ben Wagner | 63fd760 | 2017-10-09 15:45:33 -0400 | [diff] [blame] | 151 | background, backgroundOffset, |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 152 | foreground, foregroundOffset, |
brianosman | 2a75e5d | 2016-09-22 07:15:37 -0700 | [diff] [blame] | 153 | bounds, ctx.outputProperties()); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 154 | } |
| 155 | #endif |
| 156 | |
brianosman | eed6b0e | 2016-09-23 13:04:05 -0700 | [diff] [blame] | 157 | sk_sp<SkSpecialSurface> surf(source->makeSurface(ctx.outputProperties(), bounds.size())); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 158 | if (!surf) { |
| 159 | return nullptr; |
| 160 | } |
| 161 | |
| 162 | SkCanvas* canvas = surf->getCanvas(); |
| 163 | SkASSERT(canvas); |
| 164 | |
robertphillips | 3806b8f | 2016-05-12 10:46:39 -0700 | [diff] [blame] | 165 | canvas->clear(0x0); // can't count on background to fully clear the background |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 166 | canvas->translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top())); |
| 167 | |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 168 | if (background) { |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 169 | SkPaint paint; |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 170 | paint.setBlendMode(SkBlendMode::kSrc); |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 171 | background->draw(canvas, |
| 172 | SkIntToScalar(backgroundOffset.fX), SkIntToScalar(backgroundOffset.fY), |
| 173 | &paint); |
| 174 | } |
| 175 | |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 176 | this->drawForeground(canvas, foreground.get(), foregroundBounds); |
Mike Reed | 10ff5bf | 2016-09-26 20:40:57 +0000 | [diff] [blame] | 177 | |
| 178 | return surf->makeImageSnapshot(); |
Mike Reed | 0530c88 | 2016-09-26 15:33:00 -0400 | [diff] [blame] | 179 | } |
| 180 | |
Xianzhu Wang | 0fa353c | 2017-08-25 16:27:04 -0700 | [diff] [blame] | 181 | SkIRect SkXfermodeImageFilter_Base::onFilterBounds(const SkIRect& src, |
| 182 | const SkMatrix& ctm, |
Robert Phillips | 1207843 | 2018-05-17 11:17:39 -0400 | [diff] [blame] | 183 | MapDirection dir, |
| 184 | const SkIRect* inputRect) const { |
| 185 | if (kReverse_MapDirection == dir) { |
| 186 | return SkImageFilter::onFilterBounds(src, ctm, dir, inputRect); |
Xianzhu Wang | 0fa353c | 2017-08-25 16:27:04 -0700 | [diff] [blame] | 187 | } |
| 188 | |
Robert Phillips | 1207843 | 2018-05-17 11:17:39 -0400 | [diff] [blame] | 189 | SkASSERT(!inputRect); |
Xianzhu Wang | 0fa353c | 2017-08-25 16:27:04 -0700 | [diff] [blame] | 190 | SkASSERT(2 == this->countInputs()); |
| 191 | auto getBackground = [&]() { |
Robert Phillips | 1207843 | 2018-05-17 11:17:39 -0400 | [diff] [blame] | 192 | return this->getInput(0) ? this->getInput(0)->filterBounds(src, ctm, dir, inputRect) : src; |
Xianzhu Wang | 0fa353c | 2017-08-25 16:27:04 -0700 | [diff] [blame] | 193 | }; |
| 194 | auto getForeground = [&]() { |
Robert Phillips | 1207843 | 2018-05-17 11:17:39 -0400 | [diff] [blame] | 195 | return this->getInput(1) ? this->getInput(1)->filterBounds(src, ctm, dir, inputRect) : src; |
Xianzhu Wang | 0fa353c | 2017-08-25 16:27:04 -0700 | [diff] [blame] | 196 | }; |
| 197 | switch (fMode) { |
| 198 | case SkBlendMode::kClear: |
| 199 | return SkIRect::MakeEmpty(); |
| 200 | |
| 201 | case SkBlendMode::kSrc: |
| 202 | case SkBlendMode::kDstATop: |
| 203 | return getForeground(); |
| 204 | |
| 205 | case SkBlendMode::kDst: |
| 206 | case SkBlendMode::kSrcATop: |
| 207 | return getBackground(); |
| 208 | |
| 209 | case SkBlendMode::kSrcIn: |
| 210 | case SkBlendMode::kDstIn: { |
| 211 | auto result = getBackground(); |
| 212 | if (!result.intersect(getForeground())) { |
| 213 | return SkIRect::MakeEmpty(); |
| 214 | } |
| 215 | return result; |
| 216 | } |
| 217 | |
| 218 | default: { |
| 219 | auto result = getBackground(); |
| 220 | result.join(getForeground()); |
| 221 | return result; |
| 222 | } |
| 223 | } |
| 224 | } |
| 225 | |
Matt Sarett | 6d72ed9 | 2017-04-10 16:35:33 -0400 | [diff] [blame] | 226 | sk_sp<SkImageFilter> SkXfermodeImageFilter_Base::onMakeColorSpace(SkColorSpaceXformer* xformer) |
| 227 | const { |
| 228 | SkASSERT(2 == this->countInputs()); |
Mike Reed | 6d9f429 | 2017-07-06 12:32:55 -0400 | [diff] [blame] | 229 | auto background = xformer->apply(this->getInput(0)); |
| 230 | auto foreground = xformer->apply(this->getInput(1)); |
| 231 | if (background.get() != this->getInput(0) || foreground.get() != this->getInput(1)) { |
| 232 | return SkXfermodeImageFilter::Make(fMode, std::move(background), std::move(foreground), |
| 233 | this->getCropRectIfSet()); |
Matt Sarett | 6d72ed9 | 2017-04-10 16:35:33 -0400 | [diff] [blame] | 234 | } |
Mike Reed | 6d9f429 | 2017-07-06 12:32:55 -0400 | [diff] [blame] | 235 | return this->refMe(); |
Matt Sarett | 6d72ed9 | 2017-04-10 16:35:33 -0400 | [diff] [blame] | 236 | } |
| 237 | |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 238 | void SkXfermodeImageFilter_Base::drawForeground(SkCanvas* canvas, SkSpecialImage* img, |
| 239 | const SkIRect& fgBounds) const { |
| 240 | SkPaint paint; |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 241 | paint.setBlendMode(fMode); |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 242 | if (img) { |
| 243 | img->draw(canvas, SkIntToScalar(fgBounds.fLeft), SkIntToScalar(fgBounds.fTop), &paint); |
| 244 | } |
| 245 | |
| 246 | SkAutoCanvasRestore acr(canvas, true); |
Mike Reed | c1f7774 | 2016-12-09 09:00:50 -0500 | [diff] [blame] | 247 | canvas->clipRect(SkRect::Make(fgBounds), kDifference_SkClipOp); |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 248 | paint.setColor(0); |
| 249 | canvas->drawPaint(paint); |
| 250 | } |
| 251 | |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 252 | #if SK_SUPPORT_GPU |
| 253 | |
Mike Reed | 2f07c28 | 2017-06-10 14:07:36 -0400 | [diff] [blame] | 254 | #include "effects/GrXfermodeFragmentProcessor.h" |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 255 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 256 | sk_sp<SkSpecialImage> SkXfermodeImageFilter_Base::filterImageGPU( |
brianosman | 2a75e5d | 2016-09-22 07:15:37 -0700 | [diff] [blame] | 257 | SkSpecialImage* source, |
| 258 | sk_sp<SkSpecialImage> background, |
| 259 | const SkIPoint& backgroundOffset, |
| 260 | sk_sp<SkSpecialImage> foreground, |
| 261 | const SkIPoint& foregroundOffset, |
| 262 | const SkIRect& bounds, |
| 263 | const OutputProperties& outputProperties) const { |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 264 | SkASSERT(source->isTextureBacked()); |
| 265 | |
| 266 | GrContext* context = source->getContext(); |
| 267 | |
Robert Phillips | 8e1c4e6 | 2017-02-19 12:27:01 -0500 | [diff] [blame] | 268 | sk_sp<GrTextureProxy> backgroundProxy, foregroundProxy; |
| 269 | |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 270 | if (background) { |
Robert Phillips | 8e1c4e6 | 2017-02-19 12:27:01 -0500 | [diff] [blame] | 271 | backgroundProxy = background->asTextureProxyRef(context); |
egdaniel | 38cd055 | 2015-01-14 08:05:11 -0800 | [diff] [blame] | 272 | } |
| 273 | |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 274 | if (foreground) { |
Robert Phillips | 8e1c4e6 | 2017-02-19 12:27:01 -0500 | [diff] [blame] | 275 | foregroundProxy = foreground->asTextureProxyRef(context); |
senorblanco | 06d54ad | 2016-01-13 13:48:54 -0800 | [diff] [blame] | 276 | } |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 277 | |
joshualitt | b245605 | 2015-07-08 09:36:59 -0700 | [diff] [blame] | 278 | GrPaint paint; |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 279 | std::unique_ptr<GrFragmentProcessor> bgFP; |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 280 | |
Robert Phillips | 8e1c4e6 | 2017-02-19 12:27:01 -0500 | [diff] [blame] | 281 | if (backgroundProxy) { |
| 282 | SkMatrix bgMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX), |
| 283 | -SkIntToScalar(backgroundOffset.fY)); |
Brian Osman | 2240be9 | 2017-10-18 13:15:13 -0400 | [diff] [blame] | 284 | bgFP = GrTextureDomainEffect::Make(std::move(backgroundProxy), bgMatrix, |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 285 | GrTextureDomain::MakeTexelDomain(background->subset()), |
| 286 | GrTextureDomain::kDecal_Mode, |
| 287 | GrSamplerState::Filter::kNearest); |
Brian Osman | bd2c653 | 2017-10-18 09:57:33 -0400 | [diff] [blame] | 288 | bgFP = GrColorSpaceXformEffect::Make(std::move(bgFP), background->getColorSpace(), |
Brian Osman | 21fc5ce | 2018-08-27 20:36:19 +0000 | [diff] [blame] | 289 | background->alphaType(), |
Brian Osman | 653f34d | 2018-06-14 11:44:02 -0400 | [diff] [blame] | 290 | outputProperties.colorSpace()); |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 291 | } else { |
Brian Osman | f28e55d | 2018-10-03 16:35:54 -0400 | [diff] [blame] | 292 | bgFP = GrConstColorProcessor::Make(SK_PMColor4fTRANSPARENT, |
Ethan Nicholas | e9d172a | 2017-11-20 12:12:24 -0500 | [diff] [blame] | 293 | GrConstColorProcessor::InputMode::kIgnore); |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 294 | } |
| 295 | |
Robert Phillips | 8e1c4e6 | 2017-02-19 12:27:01 -0500 | [diff] [blame] | 296 | if (foregroundProxy) { |
| 297 | SkMatrix fgMatrix = SkMatrix::MakeTrans(-SkIntToScalar(foregroundOffset.fX), |
| 298 | -SkIntToScalar(foregroundOffset.fY)); |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 299 | auto foregroundFP = GrTextureDomainEffect::Make( |
Brian Osman | 2240be9 | 2017-10-18 13:15:13 -0400 | [diff] [blame] | 300 | std::move(foregroundProxy), fgMatrix, |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 301 | GrTextureDomain::MakeTexelDomain(foreground->subset()), |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 302 | GrTextureDomain::kDecal_Mode, GrSamplerState::Filter::kNearest); |
Brian Osman | bd2c653 | 2017-10-18 09:57:33 -0400 | [diff] [blame] | 303 | foregroundFP = GrColorSpaceXformEffect::Make(std::move(foregroundFP), |
Brian Osman | 653f34d | 2018-06-14 11:44:02 -0400 | [diff] [blame] | 304 | foreground->getColorSpace(), |
Brian Osman | 21fc5ce | 2018-08-27 20:36:19 +0000 | [diff] [blame] | 305 | foreground->alphaType(), |
Brian Osman | bd2c653 | 2017-10-18 09:57:33 -0400 | [diff] [blame] | 306 | outputProperties.colorSpace()); |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 307 | paint.addColorFragmentProcessor(std::move(foregroundFP)); |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 308 | |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 309 | std::unique_ptr<GrFragmentProcessor> xferFP = this->makeFGFrag(std::move(bgFP)); |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 310 | |
| 311 | // A null 'xferFP' here means kSrc_Mode was used in which case we can just proceed |
| 312 | if (xferFP) { |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 313 | paint.addColorFragmentProcessor(std::move(xferFP)); |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 314 | } |
| 315 | } else { |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 316 | paint.addColorFragmentProcessor(std::move(bgFP)); |
bsalomon | ae4738f | 2015-09-15 15:33:27 -0700 | [diff] [blame] | 317 | } |
robertphillips | 4f03794 | 2016-02-09 05:09:27 -0800 | [diff] [blame] | 318 | |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 319 | paint.setPorterDuffXPFactory(SkBlendMode::kSrc); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 320 | |
Robert Phillips | 0c4b7b1 | 2018-03-06 08:20:37 -0500 | [diff] [blame] | 321 | sk_sp<GrRenderTargetContext> renderTargetContext( |
| 322 | context->contextPriv().makeDeferredRenderTargetContext( |
Robert Phillips | 7f6cd90 | 2016-11-10 17:03:43 -0500 | [diff] [blame] | 323 | SkBackingFit::kApprox, bounds.width(), bounds.height(), |
Brian Osman | a50205f | 2018-07-06 13:57:01 -0400 | [diff] [blame] | 324 | SkColorType2GrPixelConfig(outputProperties.colorType()), |
Robert Phillips | 7f6cd90 | 2016-11-10 17:03:43 -0500 | [diff] [blame] | 325 | sk_ref_sp(outputProperties.colorSpace()))); |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 326 | if (!renderTargetContext) { |
robertphillips | f230c6d | 2016-04-15 12:47:42 -0700 | [diff] [blame] | 327 | return nullptr; |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 328 | } |
| 329 | |
senorblanco | 06d54ad | 2016-01-13 13:48:54 -0800 | [diff] [blame] | 330 | SkMatrix matrix; |
| 331 | matrix.setTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top())); |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 332 | renderTargetContext->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, matrix, |
| 333 | SkRect::Make(bounds)); |
senorblanco@chromium.org | ee845ae | 2014-04-01 19:15:23 +0000 | [diff] [blame] | 334 | |
Brian Salomon | f3569f0 | 2017-10-24 12:52:33 -0400 | [diff] [blame] | 335 | return SkSpecialImage::MakeDeferredFromGpu( |
| 336 | context, |
| 337 | SkIRect::MakeWH(bounds.width(), bounds.height()), |
| 338 | kNeedNewImageUniqueID_SpecialImage, |
| 339 | renderTargetContext->asTextureProxyRef(), |
| 340 | renderTargetContext->colorSpaceInfo().refColorSpace()); |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 341 | } |
| 342 | |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 343 | std::unique_ptr<GrFragmentProcessor> SkXfermodeImageFilter_Base::makeFGFrag( |
| 344 | std::unique_ptr<GrFragmentProcessor> bgFP) const { |
Mike Reed | 2f07c28 | 2017-06-10 14:07:36 -0400 | [diff] [blame] | 345 | return GrXfermodeFragmentProcessor::MakeFromDstProcessor(std::move(bgFP), fMode); |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 346 | } |
| 347 | |
senorblanco@chromium.org | 86fc266 | 2013-05-31 17:49:12 +0000 | [diff] [blame] | 348 | #endif |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 349 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 350 | |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 351 | sk_sp<SkFlattenable> SkXfermodeImageFilter_Base::LegacyArithmeticCreateProc(SkReadBuffer& buffer) { |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 352 | SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2); |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 353 | // skip the unused mode (srcover) field |
Mike Reed | 63544a4 | 2017-06-09 17:00:25 -0400 | [diff] [blame] | 354 | SkDEBUGCODE(unsigned mode =) unflatten_blendmode(buffer); |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 355 | if (!buffer.isValid()) { |
| 356 | return nullptr; |
| 357 | } |
| 358 | SkASSERT(SkBlendMode::kSrcOver == (SkBlendMode)mode); |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 359 | float k[4]; |
| 360 | for (int i = 0; i < 4; ++i) { |
| 361 | k[i] = buffer.readScalar(); |
| 362 | } |
| 363 | const bool enforcePMColor = buffer.readBool(); |
Kevin Lubick | daebae9 | 2018-05-17 11:29:10 -0400 | [diff] [blame] | 364 | if (!buffer.isValid()) { |
| 365 | return nullptr; |
| 366 | } |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 367 | return SkArithmeticImageFilter::Make(k[0], k[1], k[2], k[3], enforcePMColor, common.getInput(0), |
| 368 | common.getInput(1), &common.cropRect()); |
Mike Reed | 403d154 | 2016-09-26 18:51:24 -0400 | [diff] [blame] | 369 | } |
| 370 | |
| 371 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 372 | |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 373 | SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermodeImageFilter) |
| 374 | SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkXfermodeImageFilter_Base) |
| 375 | // manually register the legacy serialized name "SkXfermodeImageFilter" |
| 376 | SkFlattenable::Register("SkXfermodeImageFilter", SkXfermodeImageFilter_Base::CreateProc, |
| 377 | SkFlattenable::kSkImageFilter_Type); |
Brian Salomon | 89cb821 | 2017-01-09 10:48:23 -0500 | [diff] [blame] | 378 | // manually register the legacy serialized name "SkArithmeticImageFilter" from when that filter |
| 379 | // was implemented as a xfermode image filter. |
| 380 | SkFlattenable::Register("SkArithmeticImageFilter", |
| 381 | SkXfermodeImageFilter_Base::LegacyArithmeticCreateProc, |
| 382 | SkFlattenable::kSkImageFilter_Type); |
Mike Reed | 667a007 | 2016-09-23 11:43:54 -0400 | [diff] [blame] | 383 | SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |