Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / skia / 52cb1d059dac1267d2625dce916404e1003008f5 / . / tests / GrPorterDuffTest.cpp
blob: ab458d6af57c82c82aeb0fe3e70829730fba3dbe [file] [log] [blame]
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1/*
2 * Copyright 2015 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
Mike Kleinc0bd9f92019-04-23 12:05:21 -0500[diff] [blame]8#include "tests/Test.h"
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]9
Mike Kleinc0bd9f92019-04-23 12:05:21 -0500[diff] [blame]10#include "include/gpu/GrBackendSurface.h"
11#include "include/gpu/GrContextOptions.h"
Robert Phillips6d344c32020-07-06 10:56:46 -0400[diff] [blame]12#include "include/gpu/GrDirectContext.h"
Adlai Hollera0693042020-10-14 11:23:11 -0400[diff] [blame]13#include "src/gpu/GrDirectContextPriv.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -0500[diff] [blame]14#include "src/gpu/GrGpu.h"
15#include "src/gpu/GrProxyProvider.h"
16#include "src/gpu/GrXferProcessor.h"
17#include "src/gpu/effects/GrPorterDuffXferProcessor.h"
18#include "src/gpu/gl/GrGLCaps.h"
19#include "src/gpu/ops/GrMeshDrawOp.h"
20#include "tools/gpu/GrContextFactory.h"
Brian Salomon72050802020-10-12 20:45:06 -0400[diff] [blame]21#include "tools/gpu/ManagedBackendTexture.h"
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]22
23////////////////////////////////////////////////////////////////////////////////
24
25static void test_color_unknown_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]26static void test_color_not_opaque_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]27static void test_color_opaque_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
28static void test_color_opaque_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
29static void test_lcd_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]30static void test_lcd_coverage_fallback_case(skiatest::Reporter* reporter, const GrCaps& caps);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]31
Brian Osmand2ca3122019-03-26 11:31:16 -0400[diff] [blame]32DEF_GPUTEST(GrPorterDuff, reporter, /*ctxInfo*/) {
33 GrMockOptions mockOptions;
34 mockOptions.fDualSourceBlendingSupport = true;
Robert Phillipsf4f80112020-07-13 16:13:31 -0400[diff] [blame]35 sk_sp<GrDirectContext> context = GrDirectContext::MakeMock(&mockOptions, GrContextOptions());
Brian Osmand2ca3122019-03-26 11:31:16 -0400[diff] [blame]36 const GrCaps& caps = *context->priv().getGpu()->caps();
37
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]38 if (!caps.shaderCaps()->dualSourceBlendingSupport()) {
Ben Wagnerb4aab9a2017-08-16 10:53:04 -0400[diff] [blame]39 SK_ABORT("Null context does not support dual source blending.");
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]40 }
41
42 test_color_unknown_with_coverage(reporter, caps);
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]43 test_color_not_opaque_no_coverage(reporter, caps);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]44 test_color_opaque_with_coverage(reporter, caps);
45 test_color_opaque_no_coverage(reporter, caps);
46 test_lcd_coverage(reporter, caps);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]47 test_lcd_coverage_fallback_case(reporter, caps);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]48}
49
50////////////////////////////////////////////////////////////////////////////////
51
52#define TEST_ASSERT(...) REPORTER_ASSERT(reporter, __VA_ARGS__)
53
54enum {
55 kNone_OutputType,
56 kCoverage_OutputType,
57 kModulate_OutputType,
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]58 kSAModulate_OutputType,
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]59 kISAModulate_OutputType,
60 kISCModulate_OutputType
61};
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]62static const int kInvalid_OutputType = -1;
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]63
Brian Salomon48d1b4c2017-04-08 07:38:53 -0400[diff] [blame]64static GrProcessorSet::Analysis do_analysis(const GrXPFactory* xpf,
65 const GrProcessorAnalysisColor& colorInput,
66 GrProcessorAnalysisCoverage coverageInput,
67 const GrCaps& caps) {
68 GrPaint paint;
69 paint.setXPFactory(xpf);
70 GrProcessorSet procs(std::move(paint));
Brian Osmancf860852018-10-31 14:04:39 -0400[diff] [blame]71 SkPMColor4f overrideColor;
Chris Daltonb8fff0d2019-03-05 10:11:58 -0700[diff] [blame]72 GrProcessorSet::Analysis analysis = procs.finalize(
Chris Dalton57ab06c2021-04-22 12:57:28 -0600[diff] [blame]73 colorInput, coverageInput, nullptr, &GrUserStencilSettings::kUnused, caps,
74 GrClampType::kAuto, &overrideColor);
Brian Salomon48d1b4c2017-04-08 07:38:53 -0400[diff] [blame]75 return analysis;
76}
77
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]78class GrPorterDuffTest {
79public:
80 struct XPInfo {
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]81 XPInfo(skiatest::Reporter* reporter, SkBlendMode xfermode, const GrCaps& caps,
Brian Salomona811b122017-03-30 08:21:32 -0400[diff] [blame]82 GrProcessorAnalysisColor inputColor, GrProcessorAnalysisCoverage inputCoverage) {
Brian Salomona1633922017-01-09 11:46:10 -0500[diff] [blame]83 const GrXPFactory* xpf = GrPorterDuffXPFactory::Get(xfermode);
Brian Salomon48d1b4c2017-04-08 07:38:53 -0400[diff] [blame]84
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]85 bool isLCD = GrProcessorAnalysisCoverage::kLCD == inputCoverage;
86
Brian Salomon48d1b4c2017-04-08 07:38:53 -0400[diff] [blame]87 GrProcessorSet::Analysis analysis = do_analysis(xpf, inputColor, inputCoverage, caps);
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]88 fCompatibleWithCoverageAsAlpha = analysis.isCompatibleWithCoverageAsAlpha();
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]89 fUnaffectedByDstValue = analysis.unaffectedByDstValue();
Brian Salomon48d1b4c2017-04-08 07:38:53 -0400[diff] [blame]90 fIgnoresInputColor = analysis.inputColorIsIgnored();
Brian Salomond61c9d92017-04-10 10:54:25 -0400[diff] [blame]91 sk_sp<const GrXferProcessor> xp(
Chris Dalton57ab06c2021-04-22 12:57:28 -0600[diff] [blame]92 GrXPFactory::MakeXferProcessor(xpf, inputColor, inputCoverage, caps,
Brian Osman5ced0bf2019-03-15 10:15:29 -0400[diff] [blame]93 GrClampType::kAuto));
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]94 TEST_ASSERT(!analysis.requiresDstTexture() ||
95 (isLCD &&
96 !caps.shaderCaps()->dstReadInShaderSupport() &&
97 (SkBlendMode::kSrcOver != xfermode ||
98 !inputColor.isOpaque())));
Chris Dalton945ee652019-01-23 09:10:36 -0700[diff] [blame]99 // Porter Duff modes currently only use fixed-function or shader blending, and Ganesh
100 // doesn't yet make use of framebuffer fetches that require a barrier
101 // (e.g., QCOM_shader_framebuffer_fetch_noncoherent). So dst textures and xfer barriers
102 // should always go hand in hand for Porter Duff modes.
103 TEST_ASSERT(analysis.requiresDstTexture() == analysis.requiresNonOverlappingDraws());
Hal Canary342b7ac2016-11-04 11:49:42 -0400[diff] [blame]104 GetXPOutputTypes(xp.get(), &fPrimaryOutputType, &fSecondaryOutputType);
Chris Daltonbbb3f642019-07-24 12:25:08 -0400[diff] [blame]105 fBlendInfo = xp->getBlendInfo();
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]106 TEST_ASSERT(!xp->willReadDstColor() ||
107 (isLCD && (SkBlendMode::kSrcOver != xfermode ||
108 !inputColor.isOpaque())));
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]109 TEST_ASSERT(xp->hasSecondaryOutput() == GrBlendCoeffRefsSrc2(fBlendInfo.fDstBlend));
110 }
111
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]112 bool fCompatibleWithCoverageAsAlpha;
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]113 bool fUnaffectedByDstValue;
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]114 bool fIgnoresInputColor;
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]115 int fPrimaryOutputType;
116 int fSecondaryOutputType;
117 GrXferProcessor::BlendInfo fBlendInfo;
118 };
119
120 static void GetXPOutputTypes(const GrXferProcessor* xp, int* outPrimary, int* outSecondary) {
egdanielf2342722015-11-20 15:12:59 -0800[diff] [blame]121 GrPorterDuffXPFactory::TestGetXPOutputTypes(xp, outPrimary, outSecondary);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]122 }
123};
124
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]125static void test_lcd_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
Greg Daniel6ebe4b92017-05-19 10:56:46 -0400[diff] [blame]126 GrProcessorAnalysisColor inputColor = GrProcessorAnalysisColor::Opaque::kYes;
Brian Salomona811b122017-03-30 08:21:32 -0400[diff] [blame]127 GrProcessorAnalysisCoverage inputCoverage = GrProcessorAnalysisCoverage::kLCD;
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]128
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]129 for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
130 SkBlendMode xfermode = static_cast<SkBlendMode>(m);
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]131 const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, inputColor, inputCoverage);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]132 switch (xfermode) {
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]133 case SkBlendMode::kClear:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]134 TEST_ASSERT(xpi.fIgnoresInputColor);
135 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]136 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]137 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
138 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
139 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
140 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
141 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]142 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
143 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]144 case SkBlendMode::kSrc:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]145 TEST_ASSERT(!xpi.fIgnoresInputColor);
146 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]147 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]148 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
149 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]150 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
151 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]152 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]153 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
154 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]155 case SkBlendMode::kDst:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]156 TEST_ASSERT(xpi.fIgnoresInputColor);
157 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]158 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]159 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
160 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]161 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]162 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
163 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
164 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]165 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]166 case SkBlendMode::kSrcOver:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]167 TEST_ASSERT(!xpi.fIgnoresInputColor);
168 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]169 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]170 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
171 TEST_ASSERT(kSAModulate_OutputType == xpi.fSecondaryOutputType);
172 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
173 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
174 TEST_ASSERT(kIS2C_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
175 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
176 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]177 case SkBlendMode::kDstOver:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]178 TEST_ASSERT(!xpi.fIgnoresInputColor);
179 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]180 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]181 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
182 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]183 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]184 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
185 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]186 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
187 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]188 case SkBlendMode::kSrcIn:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]189 TEST_ASSERT(!xpi.fIgnoresInputColor);
190 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]191 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]192 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
193 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]194 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]195 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
196 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]197 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
198 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]199 case SkBlendMode::kDstIn:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]200 TEST_ASSERT(!xpi.fIgnoresInputColor);
201 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]202 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]203 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
204 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
205 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
206 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
207 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]208 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
209 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]210 case SkBlendMode::kSrcOut:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]211 TEST_ASSERT(!xpi.fIgnoresInputColor);
212 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]213 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]214 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
215 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]216 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]217 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
218 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]219 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
220 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]221 case SkBlendMode::kDstOut:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]222 TEST_ASSERT(!xpi.fIgnoresInputColor);
223 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]224 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]225 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
226 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]227 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]228 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
229 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]230 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
231 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]232 case SkBlendMode::kSrcATop:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]233 TEST_ASSERT(!xpi.fIgnoresInputColor);
234 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]235 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]236 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
237 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]238 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]239 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
240 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]241 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
242 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]243 case SkBlendMode::kDstATop:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]244 TEST_ASSERT(!xpi.fIgnoresInputColor);
245 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]246 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]247 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
248 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]249 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]250 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
251 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]252 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
253 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]254 case SkBlendMode::kXor:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]255 TEST_ASSERT(!xpi.fIgnoresInputColor);
256 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]257 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]258 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
259 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]260 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]261 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
262 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]263 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
264 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]265 case SkBlendMode::kPlus:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]266 TEST_ASSERT(!xpi.fIgnoresInputColor);
267 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]268 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]269 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
270 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]271 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
272 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]273 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]274 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
275 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]276 case SkBlendMode::kModulate:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]277 TEST_ASSERT(!xpi.fIgnoresInputColor);
278 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]279 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]280 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
281 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
282 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
283 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
284 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]285 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
286 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]287 case SkBlendMode::kScreen:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]288 TEST_ASSERT(!xpi.fIgnoresInputColor);
289 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]290 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]291 TEST_ASSERT(kInvalid_OutputType == xpi.fPrimaryOutputType);
292 TEST_ASSERT(kInvalid_OutputType == xpi.fSecondaryOutputType);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]293 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
294 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
Greg Daniel79cdf282017-05-22 15:56:22 -0400[diff] [blame]295 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]296 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
297 break;
298 default:
299 ERRORF(reporter, "Invalid xfermode.");
300 break;
301 }
302 }
303}
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]304static void test_color_unknown_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
Brian Salomona811b122017-03-30 08:21:32 -0400[diff] [blame]305 GrProcessorAnalysisColor inputColor = GrProcessorAnalysisColor::Opaque::kNo;
306 GrProcessorAnalysisCoverage inputCoverage = GrProcessorAnalysisCoverage::kSingleChannel;
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]307
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]308 for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
309 SkBlendMode xfermode = static_cast<SkBlendMode>(m);
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]310 const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, inputColor, inputCoverage);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]311 switch (xfermode) {
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]312 case SkBlendMode::kClear:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]313 TEST_ASSERT(xpi.fIgnoresInputColor);
314 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]315 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]316 TEST_ASSERT(kCoverage_OutputType == xpi.fPrimaryOutputType);
317 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
318 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.fEquation);
319 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
320 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
321 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
322 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]323 case SkBlendMode::kSrc:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]324 TEST_ASSERT(!xpi.fIgnoresInputColor);
325 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]326 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]327 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
328 TEST_ASSERT(kCoverage_OutputType == xpi.fSecondaryOutputType);
329 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
330 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
331 TEST_ASSERT(kIS2A_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
332 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
333 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]334 case SkBlendMode::kDst:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]335 TEST_ASSERT(xpi.fIgnoresInputColor);
336 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]337 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]338 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);
339 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
340 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
341 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
342 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
343 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
344 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]345 case SkBlendMode::kSrcOver:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]346 TEST_ASSERT(!xpi.fIgnoresInputColor);
347 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]348 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]349 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
350 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
351 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
352 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
353 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
354 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
355 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]356 case SkBlendMode::kDstOver:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]357 TEST_ASSERT(!xpi.fIgnoresInputColor);
358 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]359 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]360 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
361 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
362 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
363 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
364 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
365 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
366 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]367 case SkBlendMode::kSrcIn:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]368 TEST_ASSERT(!xpi.fIgnoresInputColor);
369 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]370 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]371 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
372 TEST_ASSERT(kCoverage_OutputType == xpi.fSecondaryOutputType);
373 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
374 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
375 TEST_ASSERT(kIS2A_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
376 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
377 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]378 case SkBlendMode::kDstIn:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]379 TEST_ASSERT(!xpi.fIgnoresInputColor);
380 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]381 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]382 TEST_ASSERT(kISAModulate_OutputType == xpi.fPrimaryOutputType);
383 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
384 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.fEquation);
385 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
386 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
387 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
388 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]389 case SkBlendMode::kSrcOut:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]390 TEST_ASSERT(!xpi.fIgnoresInputColor);
391 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]392 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]393 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
394 TEST_ASSERT(kCoverage_OutputType == xpi.fSecondaryOutputType);
395 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
396 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
397 TEST_ASSERT(kIS2A_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
398 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
399 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]400 case SkBlendMode::kDstOut:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]401 TEST_ASSERT(!xpi.fIgnoresInputColor);
402 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]403 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]404 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
405 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
406 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
407 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
408 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
409 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
410 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]411 case SkBlendMode::kSrcATop:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]412 TEST_ASSERT(!xpi.fIgnoresInputColor);
413 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]414 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]415 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
416 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
417 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
418 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
419 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
420 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
421 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]422 case SkBlendMode::kDstATop:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]423 TEST_ASSERT(!xpi.fIgnoresInputColor);
424 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]425 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]426 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
427 TEST_ASSERT(kISAModulate_OutputType == xpi.fSecondaryOutputType);
428 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
429 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
430 TEST_ASSERT(kIS2C_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
431 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
432 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]433 case SkBlendMode::kXor:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]434 TEST_ASSERT(!xpi.fIgnoresInputColor);
435 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]436 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]437 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
438 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
439 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
440 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
441 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
442 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
443 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]444 case SkBlendMode::kPlus:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]445 TEST_ASSERT(!xpi.fIgnoresInputColor);
446 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]447 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]448 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
449 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
450 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
451 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
452 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
453 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
454 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]455 case SkBlendMode::kModulate:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]456 TEST_ASSERT(!xpi.fIgnoresInputColor);
457 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]458 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]459 TEST_ASSERT(kISCModulate_OutputType == xpi.fPrimaryOutputType);
460 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
461 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.fEquation);
462 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
463 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
464 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
465 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]466 case SkBlendMode::kScreen:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]467 TEST_ASSERT(!xpi.fIgnoresInputColor);
468 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]469 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]470 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
471 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
472 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
473 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
474 TEST_ASSERT(kISC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
475 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
476 break;
477 default:
478 ERRORF(reporter, "Invalid xfermode.");
479 break;
480 }
481 }
482}
483
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]484static void test_color_not_opaque_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
Brian Osmancf860852018-10-31 14:04:39 -0400[diff] [blame]485 GrProcessorAnalysisColor inputColor(
486 SkPMColor4f::FromBytes_RGBA(GrColorPackRGBA(229, 0, 154, 240)));
Brian Salomona811b122017-03-30 08:21:32 -0400[diff] [blame]487 GrProcessorAnalysisCoverage inputCoverage = GrProcessorAnalysisCoverage::kNone;
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]488
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]489 for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
490 SkBlendMode xfermode = static_cast<SkBlendMode>(m);
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]491 const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, inputColor, inputCoverage);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]492 switch (xfermode) {
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]493 case SkBlendMode::kClear:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]494 TEST_ASSERT(xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]495 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]496 TEST_ASSERT(xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]497 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);
498 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
499 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
500 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
501 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
502 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
503 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]504 case SkBlendMode::kSrc:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]505 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]506 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]507 TEST_ASSERT(xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]508 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
509 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
510 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
511 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
512 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
513 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
514 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]515 case SkBlendMode::kDst:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]516 TEST_ASSERT(xpi.fIgnoresInputColor);
517 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]518 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]519 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);
520 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
521 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
522 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
523 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
524 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
525 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]526 case SkBlendMode::kSrcOver:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]527 TEST_ASSERT(!xpi.fIgnoresInputColor);
528 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]529 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]530 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
531 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
532 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
533 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
534 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
535 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
536 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]537 case SkBlendMode::kDstOver:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]538 TEST_ASSERT(!xpi.fIgnoresInputColor);
539 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]540 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]541 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
542 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
543 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
544 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
545 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
546 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
547 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]548 case SkBlendMode::kSrcIn:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]549 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]550 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]551 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]552 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
553 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
554 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
555 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
556 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
557 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
558 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]559 case SkBlendMode::kDstIn:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]560 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]561 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]562 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]563 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
564 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
565 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
566 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
567 TEST_ASSERT(kSA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
568 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
569 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]570 case SkBlendMode::kSrcOut:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]571 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]572 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]573 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]574 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
575 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
576 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
577 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
578 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
579 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
580 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]581 case SkBlendMode::kDstOut:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]582 TEST_ASSERT(!xpi.fIgnoresInputColor);
583 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]584 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]585 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
586 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
587 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
588 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
589 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
590 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
591 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]592 case SkBlendMode::kSrcATop:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]593 TEST_ASSERT(!xpi.fIgnoresInputColor);
594 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]595 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]596 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
597 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
598 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
599 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
600 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
601 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
602 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]603 case SkBlendMode::kDstATop:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]604 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]605 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]606 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]607 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
608 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
609 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
610 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
611 TEST_ASSERT(kSA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
612 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
613 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]614 case SkBlendMode::kXor:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]615 TEST_ASSERT(!xpi.fIgnoresInputColor);
616 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]617 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]618 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
619 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
620 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
621 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
622 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
623 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
624 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]625 case SkBlendMode::kPlus:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]626 TEST_ASSERT(!xpi.fIgnoresInputColor);
627 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]628 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]629 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
630 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
631 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
632 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
633 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
634 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
635 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]636 case SkBlendMode::kModulate:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]637 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]638 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]639 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]640 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
641 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
642 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
643 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
644 TEST_ASSERT(kSC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
645 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
646 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]647 case SkBlendMode::kScreen:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]648 TEST_ASSERT(!xpi.fIgnoresInputColor);
649 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]650 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]651 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
652 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
653 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
654 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
655 TEST_ASSERT(kISC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
656 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
657 break;
658 default:
659 ERRORF(reporter, "Invalid xfermode.");
660 break;
661 }
662 }
663}
664
665static void test_color_opaque_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
Brian Salomona811b122017-03-30 08:21:32 -0400[diff] [blame]666 GrProcessorAnalysisColor inputColor = GrProcessorAnalysisColor::Opaque::kYes;
667 GrProcessorAnalysisCoverage inputCoverage = GrProcessorAnalysisCoverage::kSingleChannel;
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]668
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]669 for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
670 SkBlendMode xfermode = static_cast<SkBlendMode>(m);
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]671 const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, inputColor, inputCoverage);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]672 switch (xfermode) {
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]673 case SkBlendMode::kClear:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]674 TEST_ASSERT(xpi.fIgnoresInputColor);
675 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]676 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]677 TEST_ASSERT(kCoverage_OutputType == xpi.fPrimaryOutputType);
678 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
679 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.fEquation);
680 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
681 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
682 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
683 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]684 case SkBlendMode::kSrc:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]685 TEST_ASSERT(!xpi.fIgnoresInputColor);
686 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]687 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]688 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
689 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
690 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
691 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
692 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
693 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
694 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]695 case SkBlendMode::kDst:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]696 TEST_ASSERT(xpi.fIgnoresInputColor);
697 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]698 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]699 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);
700 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
701 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
702 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
703 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
704 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
705 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]706 case SkBlendMode::kSrcOver:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]707 TEST_ASSERT(!xpi.fIgnoresInputColor);
708 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]709 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]710 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
711 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
712 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
713 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
714 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
715 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
716 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]717 case SkBlendMode::kDstOver:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]718 TEST_ASSERT(!xpi.fIgnoresInputColor);
719 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]720 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]721 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
722 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
723 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
724 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
725 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
726 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
727 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]728 case SkBlendMode::kSrcIn:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]729 TEST_ASSERT(!xpi.fIgnoresInputColor);
730 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]731 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]732 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
733 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
734 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
735 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
736 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
737 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
738 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]739 case SkBlendMode::kDstIn:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]740 TEST_ASSERT(xpi.fIgnoresInputColor);
741 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]742 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]743 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);
744 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
745 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
746 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
747 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
748 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
749 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]750 case SkBlendMode::kSrcOut:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]751 TEST_ASSERT(!xpi.fIgnoresInputColor);
752 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]753 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]754 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
755 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
756 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
757 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
758 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
759 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
760 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]761 case SkBlendMode::kDstOut:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]762 TEST_ASSERT(xpi.fIgnoresInputColor);
763 TEST_ASSERT(!xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]764 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]765 TEST_ASSERT(kCoverage_OutputType == xpi.fPrimaryOutputType);
766 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
767 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.fEquation);
768 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
769 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
770 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
771 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]772 case SkBlendMode::kSrcATop:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]773 TEST_ASSERT(!xpi.fIgnoresInputColor);
774 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]775 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]776 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
777 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
778 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
779 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
780 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
781 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
782 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]783 case SkBlendMode::kDstATop:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]784 TEST_ASSERT(!xpi.fIgnoresInputColor);
785 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]786 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]787 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
788 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
789 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
790 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
791 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
792 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
793 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]794 case SkBlendMode::kXor:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]795 TEST_ASSERT(!xpi.fIgnoresInputColor);
796 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]797 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]798 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
799 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
800 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
801 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
802 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
803 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
804 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]805 case SkBlendMode::kPlus:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]806 TEST_ASSERT(!xpi.fIgnoresInputColor);
807 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]808 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]809 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
810 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
811 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
812 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
813 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
814 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
815 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]816 case SkBlendMode::kModulate:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]817 TEST_ASSERT(!xpi.fIgnoresInputColor);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]818 TEST_ASSERT(kISCModulate_OutputType == xpi.fPrimaryOutputType);
819 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
820 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.fEquation);
821 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
822 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
823 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
824 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]825 case SkBlendMode::kScreen:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]826 TEST_ASSERT(!xpi.fIgnoresInputColor);
827 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]828 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]829 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
830 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
831 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
832 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
833 TEST_ASSERT(kISC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
834 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
835 break;
836 default:
837 ERRORF(reporter, "Invalid xfermode.");
838 break;
839 }
840 }
841}
842
843static void test_color_opaque_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
Brian Salomona811b122017-03-30 08:21:32 -0400[diff] [blame]844 GrProcessorAnalysisColor inputColor = GrProcessorAnalysisColor::Opaque::kYes;
845 GrProcessorAnalysisCoverage inputCoverage = GrProcessorAnalysisCoverage::kNone;
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]846
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]847 for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
848 SkBlendMode xfermode = static_cast<SkBlendMode>(m);
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]849 const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, inputColor, inputCoverage);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]850
851 switch (xfermode) {
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]852 case SkBlendMode::kClear:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]853 TEST_ASSERT(xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]854 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]855 TEST_ASSERT(xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]856 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);
857 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
858 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
859 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
860 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
861 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
862 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]863 case SkBlendMode::kSrc:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]864 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]865 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]866 TEST_ASSERT(xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]867 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
868 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
869 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
870 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
871 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
872 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
873 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]874 case SkBlendMode::kDst:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]875 TEST_ASSERT(xpi.fIgnoresInputColor);
876 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]877 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]878 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);
879 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
880 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
881 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
882 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
883 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
884 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]885 case SkBlendMode::kSrcOver:
Brian Salomon28207df2017-06-05 12:25:13 -0400[diff] [blame]886 // We don't specialize opaque src-over. See note in GrPorterDuffXferProcessor.cpp
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]887 TEST_ASSERT(!xpi.fIgnoresInputColor);
Brian Salomon28207df2017-06-05 12:25:13 -0400[diff] [blame]888 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]889 TEST_ASSERT(xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]890 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
891 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
892 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
893 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
Greg Danielf6d60d32020-01-08 13:39:16 -0500[diff] [blame]894 if (caps.shouldCollapseSrcOverToSrcWhenAble()) {
895 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
896 } else {
897 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
898 }
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]899 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
900 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]901 case SkBlendMode::kDstOver:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]902 TEST_ASSERT(!xpi.fIgnoresInputColor);
903 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]904 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]905 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
906 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
907 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
908 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
909 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
910 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
911 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]912 case SkBlendMode::kSrcIn:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]913 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]914 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]915 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]916 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
917 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
918 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
919 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
920 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
921 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
922 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]923 case SkBlendMode::kDstIn:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]924 TEST_ASSERT(xpi.fIgnoresInputColor);
925 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]926 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]927 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);
928 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
929 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
930 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
931 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
932 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);
933 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]934 case SkBlendMode::kSrcOut:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]935 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]936 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]937 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]938 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
939 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
940 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
941 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
942 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
943 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
944 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]945 case SkBlendMode::kDstOut:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]946 TEST_ASSERT(xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]947 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]948 TEST_ASSERT(xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]949 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);
950 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
951 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
952 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
953 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
954 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
955 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]956 case SkBlendMode::kSrcATop:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]957 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]958 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]959 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]960 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
961 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
962 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
963 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
964 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
965 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
966 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]967 case SkBlendMode::kDstATop:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]968 TEST_ASSERT(!xpi.fIgnoresInputColor);
969 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]970 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]971 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
972 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
973 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
974 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
975 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
976 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
977 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]978 case SkBlendMode::kXor:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]979 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]980 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]981 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]982 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
983 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
984 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
985 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
986 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
987 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
988 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]989 case SkBlendMode::kPlus:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]990 TEST_ASSERT(!xpi.fIgnoresInputColor);
991 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]992 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]993 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
994 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
995 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
996 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
997 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
998 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
999 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]1000 case SkBlendMode::kModulate:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]1001 TEST_ASSERT(!xpi.fIgnoresInputColor);
Greg Danielc5296812020-02-28 13:06:02 -0500[diff] [blame]1002 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]1003 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1004 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
1005 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
1006 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
1007 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
1008 TEST_ASSERT(kSC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
1009 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
1010 break;
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]1011 case SkBlendMode::kScreen:
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]1012 TEST_ASSERT(!xpi.fIgnoresInputColor);
1013 TEST_ASSERT(xpi.fCompatibleWithCoverageAsAlpha);
Chris Daltonf2fb80f2020-12-03 12:37:59 -0700[diff] [blame]1014 TEST_ASSERT(!xpi.fUnaffectedByDstValue);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1015 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);
1016 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);
1017 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);
1018 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);
1019 TEST_ASSERT(kISC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
1020 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
1021 break;
1022 default:
1023 ERRORF(reporter, "Invalid xfermode.");
1024 break;
1025 }
1026 }
1027}
1028
egdaniel723b0502015-09-15 09:31:40 -0700[diff] [blame]1029static void test_lcd_coverage_fallback_case(skiatest::Reporter* reporter, const GrCaps& caps) {
Brian Osman5ced0bf2019-03-15 10:15:29 -0400[diff] [blame]1030 constexpr GrClampType autoClamp = GrClampType::kAuto;
Brian Salomon31853842017-03-28 16:32:05 -0400[diff] [blame]1031 const GrXPFactory* xpf = GrPorterDuffXPFactory::Get(SkBlendMode::kSrcOver);
Brian Osmancf860852018-10-31 14:04:39 -0400[diff] [blame]1032 GrProcessorAnalysisColor color = SkPMColor4f::FromBytes_RGBA(GrColorPackRGBA(123, 45, 67, 255));
Brian Salomona811b122017-03-30 08:21:32 -0400[diff] [blame]1033 GrProcessorAnalysisCoverage coverage = GrProcessorAnalysisCoverage::kLCD;
Chris Dalton57ab06c2021-04-22 12:57:28 -0600[diff] [blame]1034 TEST_ASSERT(!(GrXPFactory::GetAnalysisProperties(xpf, color, coverage, caps, autoClamp) &
Greg Daniel6ebe4b92017-05-19 10:56:46 -0400[diff] [blame]1035 GrXPFactory::AnalysisProperties::kRequiresDstTexture));
1036 sk_sp<const GrXferProcessor> xp_opaque(
Chris Dalton57ab06c2021-04-22 12:57:28 -0600[diff] [blame]1037 GrXPFactory::MakeXferProcessor(xpf, color, coverage, caps, autoClamp));
Greg Daniel6ebe4b92017-05-19 10:56:46 -0400[diff] [blame]1038 if (!xp_opaque) {
1039 ERRORF(reporter, "Failed to create an XP with LCD coverage.");
1040 return;
1041 }
1042
Chris Daltonbbb3f642019-07-24 12:25:08 -0400[diff] [blame]1043 GrXferProcessor::BlendInfo blendInfo = xp_opaque->getBlendInfo();
Greg Daniel6ebe4b92017-05-19 10:56:46 -0400[diff] [blame]1044 TEST_ASSERT(blendInfo.fWriteColor);
1045
1046 // Test with non-opaque alpha
Brian Osmancf860852018-10-31 14:04:39 -0400[diff] [blame]1047 color = SkPMColor4f::FromBytes_RGBA(GrColorPackRGBA(123, 45, 67, 221));
Greg Daniel6ebe4b92017-05-19 10:56:46 -0400[diff] [blame]1048 coverage = GrProcessorAnalysisCoverage::kLCD;
Chris Dalton57ab06c2021-04-22 12:57:28 -0600[diff] [blame]1049 TEST_ASSERT(!(GrXPFactory::GetAnalysisProperties(xpf, color, coverage, caps, autoClamp) &
Greg Danield7b11592017-06-14 13:37:12 -0400[diff] [blame]1050 GrXPFactory::AnalysisProperties::kRequiresDstTexture));
Brian Salomond61c9d92017-04-10 10:54:25 -0400[diff] [blame]1051 sk_sp<const GrXferProcessor> xp(
Chris Dalton57ab06c2021-04-22 12:57:28 -0600[diff] [blame]1052 GrXPFactory::MakeXferProcessor(xpf, color, coverage, caps, autoClamp));
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1053 if (!xp) {
1054 ERRORF(reporter, "Failed to create an XP with LCD coverage.");
1055 return;
1056 }
1057
Chris Daltonbbb3f642019-07-24 12:25:08 -0400[diff] [blame]1058 blendInfo = xp->getBlendInfo();
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1059 TEST_ASSERT(blendInfo.fWriteColor);
1060}
1061
Brian Salomondcfca432017-11-15 15:48:03 -0500[diff] [blame]1062DEF_GPUTEST(PorterDuffNoDualSourceBlending, reporter, options) {
1063 GrContextOptions opts = options;
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1064 opts.fSuppressDualSourceBlending = true;
bsalomon3724e572016-03-30 18:56:19 -0700[diff] [blame]1065 sk_gpu_test::GrContextFactory mockFactory(opts);
Robert Phillips6d344c32020-07-06 10:56:46 -0400[diff] [blame]1066 auto ctx = mockFactory.get(sk_gpu_test::GrContextFactory::kMock_ContextType);
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1067 if (!ctx) {
Brian Osman7c597742019-03-26 11:10:11 -0400[diff] [blame]1068 SK_ABORT("Failed to create mock context without ARB_blend_func_extended.");
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1069 }
1070
Robert Phillips9da87e02019-02-04 13:26:26 -0500[diff] [blame]1071 GrProxyProvider* proxyProvider = ctx->priv().proxyProvider();
1072 const GrCaps& caps = *ctx->priv().caps();
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1073 if (caps.shaderCaps()->dualSourceBlendingSupport()) {
Brian Osman7c597742019-03-26 11:10:11 -0400[diff] [blame]1074 SK_ABORT("Mock context failed to honor request for no ARB_blend_func_extended.");
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1075 }
1076
Brian Salomon72050802020-10-12 20:45:06 -0400[diff] [blame]1077 auto mbet = sk_gpu_test::ManagedBackendTexture::MakeWithoutData(
1078 ctx, 100, 100, kRGBA_8888_SkColorType, GrMipmapped::kNo, GrRenderable::kNo);
Brian Salomon88d7e622020-11-05 11:11:20 -0500[diff] [blame]1079 if (!mbet) {
1080 ERRORF(reporter, "Could not make texture.");
1081 return;
1082 }
John Stiles52cb1d02021-06-02 11:58:05 -0400[diff] [blame^]1083 GrDstProxyView fakeDstProxyView;
Robert Phillipsbb581ce2017-05-29 15:05:15 -0400[diff] [blame]1084 {
Brian Salomonc67c31c2018-12-06 10:00:03 -0500[diff] [blame]1085 sk_sp<GrTextureProxy> proxy = proxyProvider->wrapBackendTexture(
Brian Salomon72050802020-10-12 20:45:06 -0400[diff] [blame]1086 mbet->texture(), kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRead_GrIOType,
1087 mbet->refCountedCallback());
1088 GrSwizzle swizzle =
1089 caps.getReadSwizzle(mbet->texture().getBackendFormat(), GrColorType::kRGBA_8888);
Greg Daniel524e28b2019-11-01 11:48:53 -0400[diff] [blame]1090 fakeDstProxyView.setProxyView({std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle});
Robert Phillipsbb581ce2017-05-29 15:05:15 -0400[diff] [blame]1091 }
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1092
Brian Salomona811b122017-03-30 08:21:32 -0400[diff] [blame]1093 static const GrProcessorAnalysisColor colorInputs[] = {
1094 GrProcessorAnalysisColor::Opaque::kNo, GrProcessorAnalysisColor::Opaque::kYes,
Brian Osmancf860852018-10-31 14:04:39 -0400[diff] [blame]1095 GrProcessorAnalysisColor(SkPMColor4f::FromBytes_RGBA(GrColorPackRGBA(0, 82, 17, 100))),
1096 GrProcessorAnalysisColor(SkPMColor4f::FromBytes_RGBA(GrColorPackRGBA(0, 82, 17, 255)))};
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1097
Brian Salomonc6b71462017-02-14 11:33:01 -0500[diff] [blame]1098 for (const auto& colorInput : colorInputs) {
Brian Salomona811b122017-03-30 08:21:32 -0400[diff] [blame]1099 for (GrProcessorAnalysisCoverage coverageType :
1100 {GrProcessorAnalysisCoverage::kSingleChannel, GrProcessorAnalysisCoverage::kNone}) {
Mike Reed7d954ad2016-10-28 15:42:34 -0400[diff] [blame]1101 for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
1102 SkBlendMode xfermode = static_cast<SkBlendMode>(m);
Brian Salomona1633922017-01-09 11:46:10 -0500[diff] [blame]1103 const GrXPFactory* xpf = GrPorterDuffXPFactory::Get(xfermode);
Brian Salomond61c9d92017-04-10 10:54:25 -0400[diff] [blame]1104 sk_sp<const GrXferProcessor> xp(
Chris Dalton57ab06c2021-04-22 12:57:28 -0600[diff] [blame]1105 GrXPFactory::MakeXferProcessor(xpf, colorInput, coverageType, caps,
Brian Osman5ced0bf2019-03-15 10:15:29 -0400[diff] [blame]1106 GrClampType::kAuto));
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1107 if (!xp) {
1108 ERRORF(reporter, "Failed to create an XP without dual source blending.");
1109 return;
1110 }
1111 TEST_ASSERT(!xp->hasSecondaryOutput());
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1112 }
1113 }
1114 }
cdalton6fd158e2015-05-27 15:08:33 -0700[diff] [blame]1115}