Add constant color GrFP.

Committed: https://skia.googlesource.com/skia/+/dfbbec436cbcacc3270d4b28357c8393e67d6494

Review URL: https://codereview.chromium.org/978713002

3 files changed, 167 insertions, 2 deletions

diff --git a/include/gpu/GrInvariantOutput.h b/include/gpu/GrInvariantOutput.h
index 4977333de4..5bf929f2ae 100644
--- a/include/gpu/GrInvariantOutput.h
+++ b/include/gpu/GrInvariantOutput.h
@@ -79,6 +79,7 @@ public:
     };
 
     void mulByUnknownOpaqueFourComponents() {
+        SkDEBUGCODE(this->validate());
         if (this->isOpaque()) {
             fValidFlags = kA_GrColorComponentFlag;
             fIsSingleComponent = false;
@@ -87,26 +88,32 @@ public:
             // multiplied is opaque.
             this->mulByUnknownFourComponents();
         }
+        SkDEBUGCODE(this->validate());
     }
 
     void mulByUnknownFourComponents() {
+        SkDEBUGCODE(this->validate());
         if (this->hasZeroAlpha()) {
             this->internalSetToTransparentBlack();
         } else {
             this->internalSetToUnknown();
         }
+        SkDEBUGCODE(this->validate());
     }
 
     void mulByUnknownSingleComponent() {
+        SkDEBUGCODE(this->validate());
         if (this->hasZeroAlpha()) {
             this->internalSetToTransparentBlack();
         } else {
             // We don't need to change fIsSingleComponent in this case
             fValidFlags = 0;
         }
+        SkDEBUGCODE(this->validate());
     }
 
     void mulByKnownSingleComponent(uint8_t alpha) {
+        SkDEBUGCODE(this->validate());
         if (this->hasZeroAlpha() || 0 == alpha) {
             this->internalSetToTransparentBlack();
         } else {
@@ -116,20 +123,92 @@ public:
                                          SkMulDiv255Round(GrColorUnpackG(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackB(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackA(fColor), alpha));
+                // We don't need to change fIsSingleComponent in this case
             }
         }
+        SkDEBUGCODE(this->validate());
+    }
+
+    void mulByKnownFourComponents(GrColor color) {
+        SkDEBUGCODE(this->validate());
+        uint32_t a;
+        if (GetAlphaAndCheckSingleChannel(color, &a)) {
+            this->mulByKnownSingleComponent(a);
+        } else {
+            if (color != 0xffffffff) {
+                fColor = GrColorPackRGBA(
+                    SkMulDiv255Round(GrColorUnpackR(fColor), GrColorUnpackR(color)),
+                    SkMulDiv255Round(GrColorUnpackG(fColor), GrColorUnpackG(color)),
+                    SkMulDiv255Round(GrColorUnpackB(fColor), GrColorUnpackB(color)),
+                    SkMulDiv255Round(GrColorUnpackA(fColor), a));
+                if (kRGBA_GrColorComponentFlags == fValidFlags) {
+                    fIsSingleComponent = GetAlphaAndCheckSingleChannel(fColor, &a);
+                }
+            }
+        }
+        SkDEBUGCODE(this->validate());
+    }
+
+    // Ignores the incoming color's RGB and muls its alpha by color.
+    void mulAlphaByKnownFourComponents(GrColor color) {
+        SkDEBUGCODE(this->validate());
+        uint32_t a;
+        if (GetAlphaAndCheckSingleChannel(color, &a)) {
+            this->mulAlphaByKnownSingleComponent(a);
+        } else if (fValidFlags & kA_GrColorComponentFlag) {
+            GrColor preAlpha = GrColorUnpackA(fColor);
+            if (0 == preAlpha) {
+                this->internalSetToTransparentBlack();
+            } else {
+                // We know that color has different component values
+                fIsSingleComponent = false;
+                fColor = GrColorPackRGBA(
+                    SkMulDiv255Round(preAlpha, GrColorUnpackR(color)),
+                    SkMulDiv255Round(preAlpha, GrColorUnpackG(color)),
+                    SkMulDiv255Round(preAlpha, GrColorUnpackB(color)),
+                    SkMulDiv255Round(preAlpha, a));
+                fValidFlags = kRGBA_GrColorComponentFlags;
+            }
+        } else {
+            fIsSingleComponent = false;
+            fValidFlags = 0;
+        }
+        SkDEBUGCODE(this->validate());
+    }
+
+    // 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) {
+        SkDEBUGCODE(this->validate());
+        if (0 == alpha || 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;
+        }
+        SkDEBUGCODE(this->validate());
     }
 
     void invalidateComponents(uint8_t invalidateFlags, ReadInput readsInput) {
+        SkDEBUGCODE(this->validate());
         fValidFlags &= ~invalidateFlags;
         fIsSingleComponent = false;
         fNonMulStageFound = true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
+        SkDEBUGCODE(this->validate());
     }
 
     void setToOther(uint8_t validFlags, GrColor color, ReadInput readsInput) {
+        SkDEBUGCODE(this->validate());
         fValidFlags = validFlags;
         fColor = color;
         fIsSingleComponent = false;
@@ -137,14 +216,28 @@ public:
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
+        if (kRGBA_GrColorComponentFlags == fValidFlags) {
+            uint32_t a;
+            if (GetAlphaAndCheckSingleChannel(color, &a)) {
+                fIsSingleComponent = true;
+            }
+        } else if (kA_GrColorComponentFlag & fValidFlags) {
+            // Assuming fColor is premul means if a is 0 the color must be all 0s.
+            if (!GrColorUnpackA(fColor)) {
+                this->internalSetToTransparentBlack();
+            }
+        }
+        SkDEBUGCODE(this->validate());
     }
 
     void setToUnknown(ReadInput readsInput) {
+        SkDEBUGCODE(this->validate());
         this->internalSetToUnknown();
         fNonMulStageFound= true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
+        SkDEBUGCODE(this->validate());
     }
 
     // Temporary setter to handle LCD text correctly until we improve texture pixel config queries
@@ -165,6 +258,13 @@ public:
 private:
     friend class GrProcOptInfo;
 
+    /** Extracts the alpha channel and returns true if r,g,b == a. */
+    static bool GetAlphaAndCheckSingleChannel(GrColor color, uint32_t* alpha) {
+        *alpha = GrColorUnpackA(color);
+        return *alpha == GrColorUnpackR(color) && *alpha == GrColorUnpackG(color) &&
+               *alpha == GrColorUnpackB(color);
+    }
+
     void reset(GrColor color, GrColorComponentFlags flags, bool isSingleComponent) {
         fColor = color;
         fValidFlags = flags;
diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
index 7cb614dd4c..026b25685e 100644
--- a/include/gpu/SkGr.h
+++ b/include/gpu/SkGr.h
@@ -78,8 +78,9 @@ GrTexture* GrRefCachedBitmapTexture(GrContext*, const SkBitmap&, const GrTexture
 // Sets the color of GrPaint to the value of the parameter paintColor
 // Callers may subsequently modify the GrPaint. Setting constantColor indicates
 // that the final paint will draw the same color at every pixel. This allows
-// an optimization where the the color filter can be applied to the SkPaint's
-// color once while converting to GrPaint and then ignored.
+// an optimization where the color filter can be applied to the SkPaint's
+// color once while converting to GrPaint and then ignored. TODO: Remove this
+// bool and use the invariant info to automatically apply the color filter.
 void SkPaint2GrPaintNoShader(GrContext* context, GrRenderTarget*, const SkPaint& skPaint,
                              GrColor paintColor, bool constantColor, GrPaint* grPaint);
 
diff --git a/include/gpu/effects/GrConstColorProcessor.h b/include/gpu/effects/GrConstColorProcessor.h
new file mode 100644
index 0000000000..27ee0dfd08
--- /dev/null
+++ b/include/gpu/effects/GrConstColorProcessor.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrColorProcessor_DEFINED
+#define GrColorProcessor_DEFINED
+
+#include "GrFragmentProcessor.h"
+
+class GrInvariantOutput;
+
+/**
+ * This is a simple GrFragmentProcessor that outputs a constant color. It may do one of the
+ * following with its input color: ignore it, or multiply it by the constant color, multiply its
+ * alpha by the constant color and ignore the input color's r, g, and b.
+ */
+class GrConstColorProcessor : public GrFragmentProcessor {
+public:
+    enum InputMode {
+        kIgnore_InputMode,
+        kModulateRGBA_InputMode,
+        kModulateA_InputMode,
+
+        kLastInputMode = kModulateA_InputMode
+    };
+    static const int kInputModeCnt = kLastInputMode + 1;
+
+    static GrFragmentProcessor* Create(GrColor color, InputMode mode) {
+        return SkNEW_ARGS(GrConstColorProcessor, (color, mode));
+    }
+
+    ~GrConstColorProcessor() override {}
+
+    const char* name() const override { return "Color"; }
+
+    void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
+
+    GrGLFragmentProcessor* createGLInstance() const override;
+
+    GrColor color() const { return fColor; }
+
+    InputMode inputMode() const { return fMode; }
+
+private:
+    GrConstColorProcessor(GrColor color, InputMode mode) : fColor(color), fMode(mode) {
+        this->initClassID<GrConstColorProcessor>();
+    }
+
+    bool onIsEqual(const GrFragmentProcessor&) const override;
+
+    void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
+
+    GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
+
+    GrColor     fColor;
+    InputMode   fMode;
+
+    typedef GrFragmentProcessor INHERITED;
+};
+
+#endif