bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2012 Google Inc. |
| 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 "GrConfigConversionEffect.h" |
Brian Salomon | c65aec9 | 2017-03-09 09:03:58 -0500 | [diff] [blame] | 9 | #include "../private/GrGLSL.h" |
| 10 | #include "GrClip.h" |
bsalomon@google.com | b1456d7 | 2012-11-02 18:23:45 +0000 | [diff] [blame] | 11 | #include "GrContext.h" |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 12 | #include "GrRenderTargetContext.h" |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 13 | #include "SkMatrix.h" |
egdaniel | 64c4728 | 2015-11-13 06:54:19 -0800 | [diff] [blame] | 14 | #include "glsl/GrGLSLFragmentProcessor.h" |
egdaniel | 2d721d3 | 2015-11-11 13:06:05 -0800 | [diff] [blame] | 15 | #include "glsl/GrGLSLFragmentShaderBuilder.h" |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 16 | |
egdaniel | 64c4728 | 2015-11-13 06:54:19 -0800 | [diff] [blame] | 17 | class GrGLConfigConversionEffect : public GrGLSLFragmentProcessor { |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 18 | public: |
robertphillips | 9cdb992 | 2016-02-03 12:25:40 -0800 | [diff] [blame] | 19 | void emitCode(EmitArgs& args) override { |
bsalomon | 6c9cd55 | 2016-01-22 07:17:34 -0800 | [diff] [blame] | 20 | const GrConfigConversionEffect& cce = args.fFp.cast<GrConfigConversionEffect>(); |
cdalton | 8528541 | 2016-02-18 12:37:07 -0800 | [diff] [blame] | 21 | GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 22 | |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 23 | // Use highp throughout the shader to avoid some precision issues on specific GPUs. |
| 24 | fragBuilder->elevateDefaultPrecision(kHigh_GrSLPrecision); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 25 | |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 26 | if (nullptr == args.fInputColor) { |
| 27 | // could optimize this case, but we aren't for now. |
| 28 | args.fInputColor = "vec4(1)"; |
| 29 | } |
| 30 | fragBuilder->codeAppendf("vec4 color = %s;", args.fInputColor); |
changjun.yang | cecc91c | 2014-08-19 18:24:30 -0700 | [diff] [blame] | 31 | |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 32 | switch (cce.pmConversion()) { |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 33 | case GrConfigConversionEffect::kMulByAlpha_RoundUp_PMConversion: |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 34 | fragBuilder->codeAppend( |
| 35 | "color.rgb = ceil(color.rgb * color.a * 255.0) / 255.0;"); |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 36 | break; |
| 37 | case GrConfigConversionEffect::kMulByAlpha_RoundDown_PMConversion: |
| 38 | // Add a compensation(0.001) here to avoid the side effect of the floor operation. |
| 39 | // In Intel GPUs, the integer value converted from floor(%s.r * 255.0) / 255.0 |
| 40 | // is less than the integer value converted from %s.r by 1 when the %s.r is |
| 41 | // converted from the integer value 2^n, such as 1, 2, 4, 8, etc. |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 42 | fragBuilder->codeAppend( |
| 43 | "color.rgb = floor(color.rgb * color.a * 255.0 + 0.001) / 255.0;"); |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 44 | break; |
| 45 | case GrConfigConversionEffect::kDivByAlpha_RoundUp_PMConversion: |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 46 | fragBuilder->codeAppend( |
| 47 | "color.rgb = color.a <= 0.0 ? vec3(0,0,0) : ceil(color.rgb / color.a * 255.0) / 255.0;"); |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 48 | break; |
| 49 | case GrConfigConversionEffect::kDivByAlpha_RoundDown_PMConversion: |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 50 | fragBuilder->codeAppend( |
| 51 | "color.rgb = color.a <= 0.0 ? vec3(0,0,0) : floor(color.rgb / color.a * 255.0) / 255.0;"); |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 52 | break; |
| 53 | default: |
| 54 | SkFAIL("Unknown conversion op."); |
| 55 | break; |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 56 | } |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 57 | fragBuilder->codeAppendf("%s = color;", args.fOutputColor); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 58 | } |
| 59 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 60 | static inline void GenKey(const GrProcessor& processor, const GrShaderCaps&, |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 61 | GrProcessorKeyBuilder* b) { |
bsalomon | 6c9cd55 | 2016-01-22 07:17:34 -0800 | [diff] [blame] | 62 | const GrConfigConversionEffect& cce = processor.cast<GrConfigConversionEffect>(); |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 63 | uint32_t key = cce.pmConversion(); |
bsalomon | 63e99f7 | 2014-07-21 08:03:14 -0700 | [diff] [blame] | 64 | b->add32(key); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 65 | } |
| 66 | |
| 67 | private: |
egdaniel | 64c4728 | 2015-11-13 06:54:19 -0800 | [diff] [blame] | 68 | typedef GrGLSLFragmentProcessor INHERITED; |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 69 | |
| 70 | }; |
| 71 | |
| 72 | /////////////////////////////////////////////////////////////////////////////// |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 73 | |
| 74 | GrConfigConversionEffect::GrConfigConversionEffect(PMConversion pmConversion) |
| 75 | : INHERITED(kNone_OptimizationFlags) |
Brian Osman | 31f96a6 | 2017-03-24 18:27:56 +0000 | [diff] [blame] | 76 | , fPMConversion(pmConversion) { |
| 77 | this->initClassID<GrConfigConversionEffect>(); |
Robert Phillips | 757914d | 2017-01-25 15:48:30 -0500 | [diff] [blame] | 78 | } |
| 79 | |
bsalomon | 0e08fc1 | 2014-10-15 08:19:04 -0700 | [diff] [blame] | 80 | bool GrConfigConversionEffect::onIsEqual(const GrFragmentProcessor& s) const { |
joshualitt | 49586be | 2014-09-16 08:21:41 -0700 | [diff] [blame] | 81 | const GrConfigConversionEffect& other = s.cast<GrConfigConversionEffect>(); |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 82 | return other.fPMConversion == fPMConversion; |
bsalomon@google.com | 68b58c9 | 2013-01-17 16:50:08 +0000 | [diff] [blame] | 83 | } |
| 84 | |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 85 | /////////////////////////////////////////////////////////////////////////////// |
| 86 | |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 87 | GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConfigConversionEffect); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 88 | |
Hal Canary | 6f6961e | 2017-01-31 13:50:44 -0500 | [diff] [blame] | 89 | #if GR_TEST_UTILS |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 90 | sk_sp<GrFragmentProcessor> GrConfigConversionEffect::TestCreate(GrProcessorTestData* d) { |
joshualitt | 0067ff5 | 2015-07-08 14:26:19 -0700 | [diff] [blame] | 91 | PMConversion pmConv = static_cast<PMConversion>(d->fRandom->nextULessThan(kPMConversionCnt)); |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 92 | return sk_sp<GrFragmentProcessor>(new GrConfigConversionEffect(pmConv)); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 93 | } |
Hal Canary | 6f6961e | 2017-01-31 13:50:44 -0500 | [diff] [blame] | 94 | #endif |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 95 | |
| 96 | /////////////////////////////////////////////////////////////////////////////// |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 97 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 98 | void GrConfigConversionEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps, |
egdaniel | 57d3b03 | 2015-11-13 11:57:27 -0800 | [diff] [blame] | 99 | GrProcessorKeyBuilder* b) const { |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 100 | GrGLConfigConversionEffect::GenKey(*this, caps, b); |
| 101 | } |
| 102 | |
egdaniel | 57d3b03 | 2015-11-13 11:57:27 -0800 | [diff] [blame] | 103 | GrGLSLFragmentProcessor* GrConfigConversionEffect::onCreateGLSLInstance() const { |
bsalomon | 6c9cd55 | 2016-01-22 07:17:34 -0800 | [diff] [blame] | 104 | return new GrGLConfigConversionEffect(); |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 105 | } |
| 106 | |
robertphillips | e85a32d | 2015-02-10 08:16:55 -0800 | [diff] [blame] | 107 | |
| 108 | |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 109 | void GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context, |
| 110 | PMConversion* pmToUPMRule, |
| 111 | PMConversion* upmToPMRule) { |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 112 | *pmToUPMRule = kPMConversionCnt; |
| 113 | *upmToPMRule = kPMConversionCnt; |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 114 | static constexpr int kSize = 256; |
| 115 | static constexpr GrPixelConfig kConfig = kRGBA_8888_GrPixelConfig; |
| 116 | SkAutoTMalloc<uint32_t> data(kSize * kSize * 3); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 117 | uint32_t* srcData = data.get(); |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 118 | uint32_t* firstRead = data.get() + kSize * kSize; |
| 119 | uint32_t* secondRead = data.get() + 2 * kSize * kSize; |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 120 | |
| 121 | // Fill with every possible premultiplied A, color channel value. There will be 256-y duplicate |
| 122 | // values in row y. We set r,g, and b to the same value since they are handled identically. |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 123 | for (int y = 0; y < kSize; ++y) { |
| 124 | for (int x = 0; x < kSize; ++x) { |
| 125 | uint8_t* color = reinterpret_cast<uint8_t*>(&srcData[kSize*y + x]); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 126 | color[3] = y; |
commit-bot@chromium.org | 972f9cd | 2014-03-28 17:58:28 +0000 | [diff] [blame] | 127 | color[2] = SkTMin(x, y); |
| 128 | color[1] = SkTMin(x, y); |
| 129 | color[0] = SkTMin(x, y); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 130 | } |
| 131 | } |
| 132 | |
Robert Phillips | c949ce9 | 2017-01-19 16:59:04 -0500 | [diff] [blame] | 133 | const SkImageInfo ii = SkImageInfo::Make(kSize, kSize, |
| 134 | kRGBA_8888_SkColorType, kPremul_SkAlphaType); |
| 135 | |
Brian Osman | 693a540 | 2016-10-27 15:13:22 -0400 | [diff] [blame] | 136 | sk_sp<GrRenderTargetContext> readRTC(context->makeRenderTargetContext(SkBackingFit::kExact, |
| 137 | kSize, kSize, |
| 138 | kConfig, nullptr)); |
| 139 | sk_sp<GrRenderTargetContext> tempRTC(context->makeRenderTargetContext(SkBackingFit::kExact, |
| 140 | kSize, kSize, |
| 141 | kConfig, nullptr)); |
| 142 | if (!readRTC || !tempRTC) { |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 143 | return; |
| 144 | } |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame] | 145 | GrSurfaceDesc desc; |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 146 | desc.fWidth = kSize; |
| 147 | desc.fHeight = kSize; |
| 148 | desc.fConfig = kConfig; |
Robert Phillips | 757914d | 2017-01-25 15:48:30 -0500 | [diff] [blame] | 149 | |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 150 | GrResourceProvider* resourceProvider = context->resourceProvider(); |
| 151 | sk_sp<GrTextureProxy> dataProxy = GrSurfaceProxy::MakeDeferred(resourceProvider, desc, |
| 152 | SkBudgeted::kYes, data, 0); |
Robert Phillips | 2f49314 | 2017-03-02 18:18:38 -0500 | [diff] [blame] | 153 | if (!dataProxy) { |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 154 | return; |
| 155 | } |
| 156 | |
| 157 | static const PMConversion kConversionRules[][2] = { |
| 158 | {kDivByAlpha_RoundDown_PMConversion, kMulByAlpha_RoundUp_PMConversion}, |
| 159 | {kDivByAlpha_RoundUp_PMConversion, kMulByAlpha_RoundDown_PMConversion}, |
| 160 | }; |
| 161 | |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 162 | bool failed = true; |
| 163 | |
commit-bot@chromium.org | 972f9cd | 2014-03-28 17:58:28 +0000 | [diff] [blame] | 164 | for (size_t i = 0; i < SK_ARRAY_COUNT(kConversionRules) && failed; ++i) { |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 165 | *pmToUPMRule = kConversionRules[i][0]; |
| 166 | *upmToPMRule = kConversionRules[i][1]; |
| 167 | |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 168 | static const SkRect kDstRect = SkRect::MakeIWH(kSize, kSize); |
Robert Phillips | 67c18d6 | 2017-01-20 12:44:06 -0500 | [diff] [blame] | 169 | static const SkRect kSrcRect = SkRect::MakeIWH(kSize, kSize); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 170 | // We do a PM->UPM draw from dataTex to readTex and read the data. Then we do a UPM->PM draw |
| 171 | // from readTex to tempTex followed by a PM->UPM draw to readTex and finally read the data. |
| 172 | // We then verify that two reads produced the same values. |
| 173 | |
Robert Phillips | 301431d | 2017-03-29 12:08:49 -0400 | [diff] [blame] | 174 | if (!readRTC->asTextureProxy()) { |
Robert Phillips | 833dcf4 | 2016-11-18 08:44:13 -0500 | [diff] [blame] | 175 | continue; |
| 176 | } |
joshualitt | 5f10b5c | 2015-07-09 10:24:35 -0700 | [diff] [blame] | 177 | GrPaint paint1; |
| 178 | GrPaint paint2; |
| 179 | GrPaint paint3; |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 180 | sk_sp<GrFragmentProcessor> pmToUPM(new GrConfigConversionEffect(*pmToUPMRule)); |
| 181 | sk_sp<GrFragmentProcessor> upmToPM(new GrConfigConversionEffect(*upmToPMRule)); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 182 | |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 183 | paint1.addColorTextureProcessor(resourceProvider, dataProxy, nullptr, SkMatrix::I()); |
| 184 | paint1.addColorFragmentProcessor(pmToUPM); |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 185 | paint1.setPorterDuffXPFactory(SkBlendMode::kSrc); |
robertphillips | ff0ca5e | 2015-07-22 11:54:44 -0700 | [diff] [blame] | 186 | |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 187 | readRTC->fillRectToRect(GrNoClip(), std::move(paint1), GrAA::kNo, SkMatrix::I(), kDstRect, |
| 188 | kSrcRect); |
robertphillips | ff0ca5e | 2015-07-22 11:54:44 -0700 | [diff] [blame] | 189 | |
Robert Phillips | c949ce9 | 2017-01-19 16:59:04 -0500 | [diff] [blame] | 190 | if (!readRTC->readPixels(ii, firstRead, 0, 0, 0)) { |
| 191 | continue; |
| 192 | } |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 193 | |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 194 | paint2.addColorTextureProcessor(resourceProvider, readRTC->asTextureProxyRef(), nullptr, |
| 195 | SkMatrix::I()); |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 196 | paint2.addColorFragmentProcessor(std::move(upmToPM)); |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 197 | paint2.setPorterDuffXPFactory(SkBlendMode::kSrc); |
robertphillips | ff0ca5e | 2015-07-22 11:54:44 -0700 | [diff] [blame] | 198 | |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 199 | tempRTC->fillRectToRect(GrNoClip(), std::move(paint2), GrAA::kNo, SkMatrix::I(), kDstRect, |
| 200 | kSrcRect); |
commit-bot@chromium.org | 42dacab | 2013-07-13 17:24:24 +0000 | [diff] [blame] | 201 | |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 202 | paint3.addColorTextureProcessor(resourceProvider, tempRTC->asTextureProxyRef(), nullptr, |
| 203 | SkMatrix::I()); |
| 204 | paint3.addColorFragmentProcessor(std::move(pmToUPM)); |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 205 | paint3.setPorterDuffXPFactory(SkBlendMode::kSrc); |
robertphillips | ff0ca5e | 2015-07-22 11:54:44 -0700 | [diff] [blame] | 206 | |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 207 | readRTC->fillRectToRect(GrNoClip(), std::move(paint3), GrAA::kNo, SkMatrix::I(), kDstRect, |
| 208 | kSrcRect); |
robertphillips | ff0ca5e | 2015-07-22 11:54:44 -0700 | [diff] [blame] | 209 | |
Robert Phillips | c949ce9 | 2017-01-19 16:59:04 -0500 | [diff] [blame] | 210 | if (!readRTC->readPixels(ii, secondRead, 0, 0, 0)) { |
| 211 | continue; |
| 212 | } |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 213 | |
| 214 | failed = false; |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 215 | for (int y = 0; y < kSize && !failed; ++y) { |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 216 | for (int x = 0; x <= y; ++x) { |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 217 | if (firstRead[kSize * y + x] != secondRead[kSize * y + x]) { |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 218 | failed = true; |
| 219 | break; |
| 220 | } |
| 221 | } |
| 222 | } |
| 223 | } |
| 224 | if (failed) { |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 225 | *pmToUPMRule = kPMConversionCnt; |
| 226 | *upmToPMRule = kPMConversionCnt; |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 227 | } |
| 228 | } |
| 229 | |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 230 | sk_sp<GrFragmentProcessor> GrConfigConversionEffect::Make(sk_sp<GrFragmentProcessor> fp, |
| 231 | PMConversion pmConversion) { |
| 232 | if (!fp) { |
Brian Osman | 31f96a6 | 2017-03-24 18:27:56 +0000 | [diff] [blame] | 233 | return nullptr; |
| 234 | } |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame^] | 235 | sk_sp<GrFragmentProcessor> ccFP(new GrConfigConversionEffect(pmConversion)); |
| 236 | sk_sp<GrFragmentProcessor> fpPipeline[] = { fp, ccFP }; |
| 237 | return GrFragmentProcessor::RunInSeries(fpPipeline, 2); |
Robert Phillips | 757914d | 2017-01-25 15:48:30 -0500 | [diff] [blame] | 238 | } |