Make SkGpuDevice::drawVertices perform color byte order swap and premul step using vertex shader.

Change-Id: I8153ba8c6bb48d8b15d524fbfafbe3c6d83f39c5
Reviewed-on: https://skia-review.googlesource.com/7727
Reviewed-by: Jim Van Verth <jvanverth@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>

1 files changed, 45 insertions, 36 deletions

diff --git a/src/gpu/GrDefaultGeoProcFactory.cpp b/src/gpu/GrDefaultGeoProcFactory.cpp
index 9da0ffee3f..ab57c0b7b5 100644
--- a/src/gpu/GrDefaultGeoProcFactory.cpp
+++ b/src/gpu/GrDefaultGeoProcFactory.cpp
@@ -23,19 +23,20 @@
  */
 
 enum GPFlag {
-    kColor_GPFlag =                 0x1,
-    kLocalCoord_GPFlag =            0x2,
-    kCoverage_GPFlag=               0x4,
+    kColorAttribute_GPFlag          = 0x1,
+    kColorAttributeIsSkColor_GPFlag = 0x2,
+    kLocalCoordAttribute_GPFlag     = 0x4,
+    kCoverageAttribute_GPFlag       = 0x8,
 };
 
 class DefaultGeoProc : public GrGeometryProcessor {
 public:
     static sk_sp<GrGeometryProcessor> Make(uint32_t gpTypeFlags,
-                                             GrColor color,
-                                             const SkMatrix& viewMatrix,
-                                             const SkMatrix& localMatrix,
-                                             bool localCoordsWillBeRead,
-                                             uint8_t coverage) {
+                                           GrColor color,
+                                           const SkMatrix& viewMatrix,
+                                           const SkMatrix& localMatrix,
+                                           bool localCoordsWillBeRead,
+                                           uint8_t coverage) {
         return sk_sp<GrGeometryProcessor>(new DefaultGeoProc(
                 gpTypeFlags, color, viewMatrix, localMatrix, coverage, localCoordsWillBeRead));
     }
@@ -71,7 +72,17 @@ public:
 
             // Setup pass through color
             if (gp.hasVertexColor()) {
-                varyingHandler->addPassThroughAttribute(gp.inColor(), args.fOutputColor);
+                GrGLSLVertToFrag varying(kVec4f_GrSLType);
+                varyingHandler->addVarying("color", &varying);
+                if (gp.fFlags & kColorAttributeIsSkColor_GPFlag) {
+                    // Do a red/blue swap and premul the color.
+                    vertBuilder->codeAppendf("%s = vec4(%s.a*%s.bgr, %s.a);", varying.vsOut(),
+                                             gp.inColor()->fName, gp.inColor()->fName,
+                                             gp.inColor()->fName);
+                } else {
+                    vertBuilder->codeAppendf("%s = %s;\n", varying.vsOut(), gp.inColor()->fName);
+                }
+                fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, varying.fsIn());
             } else {
                 this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor,
                                         &fColorUniform);
@@ -128,12 +139,9 @@ public:
                                   GrProcessorKeyBuilder* b) {
             const DefaultGeoProc& def = gp.cast<DefaultGeoProc>();
             uint32_t key = def.fFlags;
-            key |= def.hasVertexColor() << 8;
-            key |= def.hasVertexCoverage() << 9;
-            key |= (def.coverage() == 0xff) ? (0x1 << 10) : 0;
-            key |= (def.localCoordsWillBeRead() && def.localMatrix().hasPerspective()) ? (0x1 << 24)
-                                                                                       : 0x0;
-            key |= ComputePosKey(def.viewMatrix()) << 25;
+            key |= (def.coverage() == 0xff) ? 0x10 : 0;
+            key |= (def.localCoordsWillBeRead() && def.localMatrix().hasPerspective()) ? 0x20 : 0x0;
+            key |= ComputePosKey(def.viewMatrix()) << 20;
             b->add32(key);
         }
 
@@ -189,39 +197,32 @@ private:
                    const SkMatrix& localMatrix,
                    uint8_t coverage,
                    bool localCoordsWillBeRead)
-            : fInPosition(nullptr)
-            , fInColor(nullptr)
-            , fInLocalCoords(nullptr)
-            , fInCoverage(nullptr)
-            , fColor(color)
+            : fColor(color)
             , fViewMatrix(viewMatrix)
             , fLocalMatrix(localMatrix)
             , fCoverage(coverage)
             , fFlags(gpTypeFlags)
             , fLocalCoordsWillBeRead(localCoordsWillBeRead) {
         this->initClassID<DefaultGeoProc>();
-        bool hasColor = SkToBool(gpTypeFlags & kColor_GPFlag);
-        bool hasExplicitLocalCoords = SkToBool(gpTypeFlags & kLocalCoord_GPFlag);
-        bool hasCoverage = SkToBool(gpTypeFlags & kCoverage_GPFlag);
         fInPosition = &this->addVertexAttrib("inPosition", kVec2f_GrVertexAttribType,
                                              kHigh_GrSLPrecision);
-        if (hasColor) {
+        if (fFlags & kColorAttribute_GPFlag) {
             fInColor = &this->addVertexAttrib("inColor", kVec4ub_GrVertexAttribType);
         }
-        if (hasExplicitLocalCoords) {
+        if (fFlags & kLocalCoordAttribute_GPFlag) {
             fInLocalCoords = &this->addVertexAttrib("inLocalCoord", kVec2f_GrVertexAttribType,
                                                     kHigh_GrSLPrecision);
             this->setHasExplicitLocalCoords();
         }
-        if (hasCoverage) {
+        if (fFlags & kCoverageAttribute_GPFlag) {
             fInCoverage = &this->addVertexAttrib("inCoverage", kFloat_GrVertexAttribType);
         }
     }
 
-    const Attribute* fInPosition;
-    const Attribute* fInColor;
-    const Attribute* fInLocalCoords;
-    const Attribute* fInCoverage;
+    const Attribute* fInPosition = nullptr;
+    const Attribute* fInColor = nullptr;
+    const Attribute* fInLocalCoords = nullptr;
+    const Attribute* fInCoverage = nullptr;
     GrColor fColor;
     SkMatrix fViewMatrix;
     SkMatrix fLocalMatrix;
@@ -239,19 +240,23 @@ GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc);
 sk_sp<GrGeometryProcessor> DefaultGeoProc::TestCreate(GrProcessorTestData* d) {
     uint32_t flags = 0;
     if (d->fRandom->nextBool()) {
-        flags |= kColor_GPFlag;
+        flags |= kColorAttribute_GPFlag;
     }
     if (d->fRandom->nextBool()) {
-        flags |= kCoverage_GPFlag;
+        flags |= kColorAttributeIsSkColor_GPFlag;
     }
     if (d->fRandom->nextBool()) {
-        flags |= kLocalCoord_GPFlag;
+        flags |= kCoverageAttribute_GPFlag;
+    }
+    if (d->fRandom->nextBool()) {
+        flags |= kLocalCoordAttribute_GPFlag;
     }
 
     return DefaultGeoProc::Make(flags,
                                 GrRandomColor(d->fRandom),
                                 GrTest::TestMatrix(d->fRandom),
                                 GrTest::TestMatrix(d->fRandom),
+
                                 d->fRandom->nextBool(),
                                 GrRandomCoverage(d->fRandom));
 }
@@ -261,9 +266,13 @@ sk_sp<GrGeometryProcessor> GrDefaultGeoProcFactory::Make(const Color& color,
                                                          const LocalCoords& localCoords,
                                                          const SkMatrix& viewMatrix) {
     uint32_t flags = 0;
-    flags |= color.fType == Color::kAttribute_Type ? kColor_GPFlag : 0;
-    flags |= coverage.fType == Coverage::kAttribute_Type ? kCoverage_GPFlag : 0;
-    flags |= localCoords.fType == LocalCoords::kHasExplicit_Type ? kLocalCoord_GPFlag : 0;
+    if (Color::kPremulGrColorAttribute_Type == color.fType) {
+        flags |= kColorAttribute_GPFlag;
+    } else if (Color::kUnpremulSkColorAttribute_Type == color.fType) {
+        flags |= kColorAttribute_GPFlag | kColorAttributeIsSkColor_GPFlag;
+    }
+    flags |= coverage.fType == Coverage::kAttribute_Type ? kCoverageAttribute_GPFlag : 0;
+    flags |= localCoords.fType == LocalCoords::kHasExplicit_Type ? kLocalCoordAttribute_GPFlag : 0;
 
     uint8_t inCoverage = coverage.fCoverage;
     bool localCoordsWillBeRead = localCoords.fType != LocalCoords::kUnused_Type;