Line data Source code
1 :
2 : /*
3 : * Copyright 2013 Google Inc.
4 : *
5 : * Use of this source code is governed by a BSD-style license that can be
6 : * found in the LICENSE file.
7 : */
8 :
9 : #ifndef GrBlend_DEFINED
10 : #define GrBlend_DEFINED
11 :
12 : #include "GrColor.h"
13 : #include "../private/SkTLogic.h"
14 :
15 : /**
16 : * Equations for alpha-blending.
17 : */
18 : enum GrBlendEquation {
19 : // Basic blend equations.
20 : kAdd_GrBlendEquation, //<! Cs*S + Cd*D
21 : kSubtract_GrBlendEquation, //<! Cs*S - Cd*D
22 : kReverseSubtract_GrBlendEquation, //<! Cd*D - Cs*S
23 :
24 : // Advanced blend equations. These are described in the SVG and PDF specs.
25 : kScreen_GrBlendEquation,
26 : kOverlay_GrBlendEquation,
27 : kDarken_GrBlendEquation,
28 : kLighten_GrBlendEquation,
29 : kColorDodge_GrBlendEquation,
30 : kColorBurn_GrBlendEquation,
31 : kHardLight_GrBlendEquation,
32 : kSoftLight_GrBlendEquation,
33 : kDifference_GrBlendEquation,
34 : kExclusion_GrBlendEquation,
35 : kMultiply_GrBlendEquation,
36 : kHSLHue_GrBlendEquation,
37 : kHSLSaturation_GrBlendEquation,
38 : kHSLColor_GrBlendEquation,
39 : kHSLLuminosity_GrBlendEquation,
40 :
41 : kFirstAdvancedGrBlendEquation = kScreen_GrBlendEquation,
42 : kLast_GrBlendEquation = kHSLLuminosity_GrBlendEquation
43 : };
44 :
45 : static const int kGrBlendEquationCnt = kLast_GrBlendEquation + 1;
46 :
47 :
48 : /**
49 : * Coefficients for alpha-blending.
50 : */
51 : enum GrBlendCoeff {
52 : kZero_GrBlendCoeff, //<! 0
53 : kOne_GrBlendCoeff, //<! 1
54 : kSC_GrBlendCoeff, //<! src color
55 : kISC_GrBlendCoeff, //<! one minus src color
56 : kDC_GrBlendCoeff, //<! dst color
57 : kIDC_GrBlendCoeff, //<! one minus dst color
58 : kSA_GrBlendCoeff, //<! src alpha
59 : kISA_GrBlendCoeff, //<! one minus src alpha
60 : kDA_GrBlendCoeff, //<! dst alpha
61 : kIDA_GrBlendCoeff, //<! one minus dst alpha
62 : kConstC_GrBlendCoeff, //<! constant color
63 : kIConstC_GrBlendCoeff, //<! one minus constant color
64 : kConstA_GrBlendCoeff, //<! constant color alpha
65 : kIConstA_GrBlendCoeff, //<! one minus constant color alpha
66 : kS2C_GrBlendCoeff,
67 : kIS2C_GrBlendCoeff,
68 : kS2A_GrBlendCoeff,
69 : kIS2A_GrBlendCoeff,
70 :
71 : kLast_GrBlendCoeff = kIS2A_GrBlendCoeff
72 : };
73 :
74 : static const int kGrBlendCoeffCnt = kLast_GrBlendCoeff + 1;
75 :
76 0 : static constexpr bool GrBlendCoeffRefsSrc(const GrBlendCoeff coeff) {
77 0 : return kSC_GrBlendCoeff == coeff || kISC_GrBlendCoeff == coeff || kSA_GrBlendCoeff == coeff ||
78 0 : kISA_GrBlendCoeff == coeff;
79 : }
80 :
81 : static constexpr bool GrBlendCoeffRefsDst(const GrBlendCoeff coeff) {
82 : return kDC_GrBlendCoeff == coeff || kIDC_GrBlendCoeff == coeff || kDA_GrBlendCoeff == coeff ||
83 : kIDA_GrBlendCoeff == coeff;
84 : }
85 :
86 0 : static constexpr bool GrBlendCoeffRefsSrc2(const GrBlendCoeff coeff) {
87 0 : return kS2C_GrBlendCoeff == coeff || kIS2C_GrBlendCoeff == coeff ||
88 0 : kS2A_GrBlendCoeff == coeff || kIS2A_GrBlendCoeff == coeff;
89 : }
90 :
91 0 : static constexpr bool GrBlendCoeffsUseSrcColor(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff) {
92 0 : return kZero_GrBlendCoeff != srcCoeff || GrBlendCoeffRefsSrc(dstCoeff);
93 : }
94 :
95 : static constexpr bool GrBlendCoeffsUseDstColor(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff) {
96 : return GrBlendCoeffRefsDst(srcCoeff) || kZero_GrBlendCoeff != dstCoeff;
97 : }
98 :
99 0 : static constexpr bool GrBlendEquationIsAdvanced(GrBlendEquation equation) {
100 0 : return equation >= kFirstAdvancedGrBlendEquation;
101 : }
102 :
103 : static constexpr bool GrBlendModifiesDst(GrBlendEquation equation, GrBlendCoeff srcCoeff,
104 : GrBlendCoeff dstCoeff) {
105 : return (kAdd_GrBlendEquation != equation && kReverseSubtract_GrBlendEquation != equation) ||
106 : kZero_GrBlendCoeff != srcCoeff || kOne_GrBlendCoeff != dstCoeff;
107 : }
108 :
109 : /**
110 : * Advanced blend equations can always tweak alpha for coverage. (See GrCustomXfermode.cpp)
111 : *
112 : * For "add" and "reverse subtract" the blend equation with f=coverage is:
113 : *
114 : * D' = f * (S * srcCoeff + D * dstCoeff) + (1-f) * D
115 : * = f * S * srcCoeff + D * (f * dstCoeff + (1 - f))
116 : *
117 : * (Let srcCoeff be negative for reverse subtract.) We can tweak alpha for coverage when the
118 : * following relationship holds:
119 : *
120 : * (f*S) * srcCoeff' + D * dstCoeff' == f * S * srcCoeff + D * (f * dstCoeff + (1 - f))
121 : *
122 : * (Where srcCoeff' and dstCoeff' have any reference to S pre-multiplied by f.)
123 : *
124 : * It's easy to see this works for the src term as long as srcCoeff' == srcCoeff (meaning srcCoeff
125 : * does not reference S). For the dst term, this will work as long as the following is true:
126 : *|
127 : * dstCoeff' == f * dstCoeff + (1 - f)
128 : * dstCoeff' == 1 - f * (1 - dstCoeff)
129 : *
130 : * By inspection we can see this will work as long as dstCoeff has a 1, and any other term in
131 : * dstCoeff references S.
132 : *
133 : * Moreover, if the blend doesn't modify the dst at all then it is ok to arbitrarily modify the src
134 : * color so folding in coverage is allowed.
135 : */
136 : static constexpr bool GrBlendAllowsCoverageAsAlpha(GrBlendEquation equation,
137 : GrBlendCoeff srcCoeff,
138 : GrBlendCoeff dstCoeff) {
139 : return GrBlendEquationIsAdvanced(equation) ||
140 : !GrBlendModifiesDst(equation, srcCoeff, dstCoeff) ||
141 : ((kAdd_GrBlendEquation == equation || kReverseSubtract_GrBlendEquation == equation) &&
142 : !GrBlendCoeffRefsSrc(srcCoeff) &&
143 : (kOne_GrBlendCoeff == dstCoeff || kISC_GrBlendCoeff == dstCoeff ||
144 : kISA_GrBlendCoeff == dstCoeff));
145 : }
146 :
147 : #endif
|
