Add constant color GrFP.

include/gpu/GrInvariantOutput.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrInvariantOutput_DEFINED
 #define GrInvariantOutput_DEFINED
 
@@ skipping 98 matching lines @@
     void mulByKnownSingleComponent(uint8_t alpha) {
         if (this->hasZeroAlpha() || 0 == alpha) {
             this->internalSetToTransparentBlack();
         } else {
             if (alpha != 255) {
                 // Multiply color by alpha
                 fColor = GrColorPackRGBA(SkMulDiv255Round(GrColorUnpackR(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackG(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackB(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackA(fColor), alpha));
+                // We don't need to change fIsSingleComponent in this case
             }
         }
     }
 
+    void mulByKnownFourComponents(GrColor color) {
+        GrColor a = GrColorUnpackA(color);
+        if (a == GrColorUnpackR(color) &&
+            a == GrColorUnpackG(color) &&
+            a == GrColorUnpackB(color)) {
+            this->mulByKnownSingleComponent(a);
+        } else if (0 == color) {

[egdaniel, 2015/03/04 20:22:34]

we definitely don't need the 0 check here since it would get caught above

[bsalomon, 2015/03/31 19:33:42]

Done.

+            this->internalSetToTransparentBlack();
+        } else {
+            if (color != 0xffffffff) {
+                fColor = GrColorPackRGBA(
+                    SkMulDiv255Round(GrColorUnpackR(fColor), GrColorUnpackR(color)),
+                    SkMulDiv255Round(GrColorUnpackG(fColor), GrColorUnpackG(color)),
+                    SkMulDiv255Round(GrColorUnpackB(fColor), GrColorUnpackB(color)),
+                    SkMulDiv255Round(GrColorUnpackA(fColor), GrColorUnpackA(color)));
+                    if (kRGBA_GrColorComponentFlags == fValidFlags) {
+                        GrColor a = GrColorUnpackA(fColor);
+                        fIsSingleComponent = a == GrColorUnpackR(fColor) &&
+                                             a == GrColorUnpackG(fColor) &&
+                                             a == GrColorUnpackB(fColor);
+                    }
+            }
+        }
+    }
+
+    // Ignores the incoming color's RGB and muls its alpha by color.
+    void mulAlphaByKnownFourComponents(GrColor color) {
+        GrColor a = GrColorUnpackA(color);
+        if (a == GrColorUnpackR(color) &&
+            a == GrColorUnpackG(color) &&
+            a == GrColorUnpackB(color)) {
+            this->mulAlphaByKnownSingleComponent(a);
+        } else if (0 == color) {

[egdaniel, 2015/03/04 20:22:34]

same as above.

[bsalomon, 2015/03/31 19:33:42]

Done.

+            this->internalSetToTransparentBlack();
+        } else if (fValidFlags & kA_GrColorComponentFlag) {
+            GrColor alpha = GrColorUnpackA(fColor);
+            if (0 == alpha) {
+                this->internalSetToTransparentBlack();
+            } else {
+                fColor = GrColorPackRGBA(
+                    SkMulDiv255Round(alpha, GrColorUnpackR(color)),
+                    SkMulDiv255Round(alpha, GrColorUnpackG(color)),
+                    SkMulDiv255Round(alpha, GrColorUnpackB(color)),
+                    SkMulDiv255Round(alpha, GrColorUnpackA(color)));
+                fValidFlags = kRGBA_GrColorComponentFlags;
+            }
+        } else {
+            fValidFlags = 0;
+        }
+    }
+
+    // Ignores the incoming color's RGB and muls its alpha by the alpha param and sets all channels
+    // equal to that value.
+    void mulAlphaByKnownSingleComponent(uint8_t alpha) {
+        if (0 == alpha || 0 == this->hasZeroAlpha()) {
+            this->internalSetToTransparentBlack();
+        } else {
+            if (fValidFlags & kA_GrColorComponentFlag) {
+                GrColor a = GrColorUnpackA(fColor);
+                a = SkMulDiv255Round(alpha, a);
+                fColor = GrColorPackRGBA(a, a, a, a);
+                fValidFlags = kRGBA_GrColorComponentFlags;
+            } else {
+                fValidFlags = 0;
+            }
+            fIsSingleComponent = true;
+        }
+    }
+
     void invalidateComponents(uint8_t invalidateFlags, ReadInput readsInput) {
         fValidFlags &= ~invalidateFlags;
         fIsSingleComponent = false;
         fNonMulStageFound = true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
     }
 
     void setToOther(uint8_t validFlags, GrColor color, ReadInput readsInput) {
@@ skipping 92 matching lines @@
     uint32_t fValidFlags;
     bool fIsSingleComponent;
     bool fNonMulStageFound;
     bool fWillUseInputColor;
     bool fIsLCDCoverage; // Temorary data member until texture pixel configs are updated
 
 };
 
 #endif