8 #ifndef GrInvariantOutput_DEFINED
9 #define GrInvariantOutput_DEFINED
15 : fValidFlags(kNone_GrColorComponentFlags)
17 , fIsSingleComponent(
false)
18 , fIsLCDCoverage(
false) {}
20 void setKnownFourComponents(GrColor color) {
22 fValidFlags = kRGBA_GrColorComponentFlags;
23 fIsSingleComponent =
false;
26 void setUnknownFourComponents() {
27 fValidFlags = kNone_GrColorComponentFlags;
28 fIsSingleComponent =
false;
31 void setUnknownOpaqueFourComponents() {
32 fColor = 0xffU << GrColor_SHIFT_A;
33 fValidFlags = kA_GrColorComponentFlag;
34 fIsSingleComponent =
false;
37 void setKnownSingleComponent(uint8_t alpha) {
38 fColor = GrColorPackRGBA(alpha, alpha, alpha, alpha);
39 fValidFlags = kRGBA_GrColorComponentFlags;
40 fIsSingleComponent =
true;
43 void setUnknownSingleComponent() {
44 fValidFlags = kNone_GrColorComponentFlags;
45 fIsSingleComponent =
true;
48 void setUsingLCDCoverage() { fIsLCDCoverage =
true; }
50 GrColorComponentFlags fValidFlags;
52 bool fIsSingleComponent;
59 GrInvariantOutput(GrColor color, GrColorComponentFlags flags,
bool isSingleComponent)
62 , fIsSingleComponent(isSingleComponent)
63 , fNonMulStageFound(
false)
64 , fWillUseInputColor(
true)
65 , fIsLCDCoverage(
false) {}
69 , fValidFlags(io.fValidFlags)
70 , fIsSingleComponent(io.fIsSingleComponent)
71 , fNonMulStageFound(
false)
72 , fWillUseInputColor(
false)
73 , fIsLCDCoverage(io.fIsLCDCoverage) {}
82 void mulByUnknownOpaqueFourComponents() {
84 if (this->isOpaque()) {
85 fValidFlags = kA_GrColorComponentFlag;
86 fIsSingleComponent =
false;
90 this->mulByUnknownFourComponents();
95 void mulByUnknownFourComponents() {
97 if (this->hasZeroAlpha()) {
98 this->internalSetToTransparentBlack();
100 this->internalSetToUnknown();
105 void mulByUnknownSingleComponent() {
107 if (this->hasZeroAlpha()) {
108 this->internalSetToTransparentBlack();
111 fValidFlags = kNone_GrColorComponentFlags;
116 void mulByKnownSingleComponent(uint8_t alpha) {
118 if (this->hasZeroAlpha() || 0 == alpha) {
119 this->internalSetToTransparentBlack();
123 fColor = GrColorPackRGBA(SkMulDiv255Round(GrColorUnpackR(fColor), alpha),
124 SkMulDiv255Round(GrColorUnpackG(fColor), alpha),
125 SkMulDiv255Round(GrColorUnpackB(fColor), alpha),
126 SkMulDiv255Round(GrColorUnpackA(fColor), alpha));
133 void mulByKnownFourComponents(GrColor color) {
136 if (GetAlphaAndCheckSingleChannel(color, &a)) {
137 this->mulByKnownSingleComponent(a);
139 if (color != 0xffffffff) {
140 fColor = GrColorPackRGBA(
141 SkMulDiv255Round(GrColorUnpackR(fColor), GrColorUnpackR(color)),
142 SkMulDiv255Round(GrColorUnpackG(fColor), GrColorUnpackG(color)),
143 SkMulDiv255Round(GrColorUnpackB(fColor), GrColorUnpackB(color)),
144 SkMulDiv255Round(GrColorUnpackA(fColor), a));
145 if (kRGBA_GrColorComponentFlags == fValidFlags) {
146 fIsSingleComponent = GetAlphaAndCheckSingleChannel(fColor, &a);
154 void mulAlphaByKnownFourComponents(GrColor color) {
157 if (GetAlphaAndCheckSingleChannel(color, &a)) {
158 this->mulAlphaByKnownSingleComponent(a);
159 }
else if (fValidFlags & kA_GrColorComponentFlag) {
160 GrColor preAlpha = GrColorUnpackA(fColor);
162 this->internalSetToTransparentBlack();
165 fIsSingleComponent =
false;
166 fColor = GrColorPackRGBA(
167 SkMulDiv255Round(preAlpha, GrColorUnpackR(color)),
168 SkMulDiv255Round(preAlpha, GrColorUnpackG(color)),
169 SkMulDiv255Round(preAlpha, GrColorUnpackB(color)),
170 SkMulDiv255Round(preAlpha, a));
171 fValidFlags = kRGBA_GrColorComponentFlags;
174 fIsSingleComponent =
false;
175 fValidFlags = kNone_GrColorComponentFlags;
182 void mulAlphaByKnownSingleComponent(uint8_t alpha) {
184 if (0 == alpha || this->hasZeroAlpha()) {
185 this->internalSetToTransparentBlack();
187 if (fValidFlags & kA_GrColorComponentFlag) {
188 GrColor a = GrColorUnpackA(fColor);
189 a = SkMulDiv255Round(alpha, a);
190 fColor = GrColorPackRGBA(a, a, a, a);
191 fValidFlags = kRGBA_GrColorComponentFlags;
193 fValidFlags = kNone_GrColorComponentFlags;
195 fIsSingleComponent =
true;
200 void premulFourChannelColor() {
202 SkASSERT(!fIsSingleComponent);
203 fNonMulStageFound =
true;
204 if (!(fValidFlags & kA_GrColorComponentFlag)) {
205 fValidFlags = kNone_GrColorComponentFlags;
207 fColor = GrPremulColor(fColor);
212 void invalidateComponents(GrColorComponentFlags invalidateFlags, ReadInput readsInput) {
214 fValidFlags = (fValidFlags & ~invalidateFlags);
215 fIsSingleComponent =
false;
216 fNonMulStageFound =
true;
217 if (kWillNot_ReadInput == readsInput) {
218 fWillUseInputColor =
false;
223 void setToOther(GrColorComponentFlags validFlags, GrColor color, ReadInput readsInput) {
225 fValidFlags = validFlags;
227 fIsSingleComponent =
false;
228 fNonMulStageFound =
true;
229 if (kWillNot_ReadInput == readsInput) {
230 fWillUseInputColor =
false;
232 if (kRGBA_GrColorComponentFlags == fValidFlags) {
234 if (GetAlphaAndCheckSingleChannel(color, &a)) {
235 fIsSingleComponent =
true;
241 void setToUnknown(ReadInput readsInput) {
243 this->internalSetToUnknown();
244 fNonMulStageFound=
true;
245 if (kWillNot_ReadInput == readsInput) {
246 fWillUseInputColor =
false;
253 void setUsingLCDCoverage() {
254 fIsLCDCoverage =
true;
257 GrColor color()
const {
return fColor; }
258 GrColorComponentFlags validFlags()
const {
return fValidFlags; }
259 bool willUseInputColor()
const {
return fWillUseInputColor; }
268 friend class GrProcOptInfo;
271 static bool GetAlphaAndCheckSingleChannel(GrColor color, uint32_t* alpha) {
272 *alpha = GrColorUnpackA(color);
273 return *alpha == GrColorUnpackR(color) && *alpha == GrColorUnpackG(color) &&
274 *alpha == GrColorUnpackB(color);
277 void reset(GrColor color, GrColorComponentFlags flags,
bool isSingleComponent) {
280 fIsSingleComponent = isSingleComponent;
281 fNonMulStageFound =
false;
282 fWillUseInputColor =
true;
287 fValidFlags = io.fValidFlags;
288 fIsSingleComponent = io.fIsSingleComponent;
289 fNonMulStageFound =
false;
290 fWillUseInputColor =
true;
291 fIsLCDCoverage = io.fIsLCDCoverage;
294 void internalSetToTransparentBlack() {
295 fValidFlags = kRGBA_GrColorComponentFlags;
297 fIsSingleComponent =
true;
300 void internalSetToUnknown() {
301 fValidFlags = kNone_GrColorComponentFlags;
302 fIsSingleComponent =
false;
305 bool hasZeroAlpha()
const {
306 return ((fValidFlags & kA_GrColorComponentFlag) && 0 == GrColorUnpackA(fColor));
309 bool isOpaque()
const {
310 return ((fValidFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(fColor));
313 bool isSolidWhite()
const {
314 return (fValidFlags == kRGBA_GrColorComponentFlags && 0xFFFFFFFF == fColor);
317 bool isSingleComponent()
const {
return fIsSingleComponent; }
319 void resetWillUseInputColor() { fWillUseInputColor =
true; }
321 bool allStagesMulInput()
const {
return !fNonMulStageFound; }
322 void resetNonMulStageFound() { fNonMulStageFound =
false; }
324 bool isLCDCoverage()
const {
return fIsLCDCoverage; }
333 GrColorComponentFlags fValidFlags;
334 bool fIsSingleComponent;
335 bool fNonMulStageFound;
336 bool fWillUseInputColor;
Definition: GrInvariantOutput.h:13
Definition: GrInvariantOutput.h:57
SkDEBUGCODE(bool colorComponentsAllEqual() const ;) SkDEBUGCODE(bool validPreMulColor() const
If alpha is valid, check that any valid R,G,B values are <= A.
Definition: GrInvariantOutput.h:271