From e9d6095674979a9b843c291b85746922e9ac181a Mon Sep 17 00:00:00 2001
From: joshualitt <joshualitt@chromium.org>
Date: Mon, 27 Jul 2015 12:13:14 -0700
Subject: Cleanup Default Geo Proc API

TBR=bsalomon@google.com
BUG=skia:

Review URL: https://codereview.chromium.org/1253393002
---
 src/gpu/GrDefaultGeoProcFactory.cpp | 24 ++++++++++++++++++
 src/gpu/GrDefaultGeoProcFactory.h   | 50 +++++++++++++++++++++++++++++++++++++
 src/gpu/GrRectBatch.cpp             | 26 +++++++++++--------
 3 files changed, 90 insertions(+), 10 deletions(-)

diff --git a/src/gpu/GrDefaultGeoProcFactory.cpp b/src/gpu/GrDefaultGeoProcFactory.cpp
index 48aa813182..1273a29849 100644
--- a/src/gpu/GrDefaultGeoProcFactory.cpp
+++ b/src/gpu/GrDefaultGeoProcFactory.cpp
@@ -275,3 +275,27 @@ const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(uint32_t gpTypeFlags,
                                   coverageWillBeIgnored,
                                   coverage);
 }
+
+const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(const Color& color,
+                                                           const Coverage& coverage,
+                                                           LocalCoords::Type localCoords,
+                                                           const SkMatrix& viewMatrix,
+                                                           const SkMatrix& localMatrix) {
+    uint32_t flags = 0;
+    flags |= color.fType == Color::kAttribute_Type ? kColor_GPType : 0;
+    flags |= coverage.fType == Coverage::kAttribute_Type ? kCoverage_GPType : 0;
+    flags |= localCoords == LocalCoords::kHasExplicit_Type ? kLocalCoord_GPType : 0;
+
+    uint8_t inCoverage = coverage.fCoverage;
+    bool coverageWillBeIgnored = coverage.fType == Coverage::kNone_Type;
+    bool localCoordsWillBeRead = localCoords != LocalCoords::kNone_Type;
+
+    GrColor inColor = color.fColor;
+    return DefaultGeoProc::Create(flags,
+                                  inColor,
+                                  viewMatrix,
+                                  localMatrix,
+                                  localCoordsWillBeRead,
+                                  coverageWillBeIgnored,
+                                  inCoverage);
+}
diff --git a/src/gpu/GrDefaultGeoProcFactory.h b/src/gpu/GrDefaultGeoProcFactory.h
index 00fd0bce6b..86c59c40e1 100644
--- a/src/gpu/GrDefaultGeoProcFactory.h
+++ b/src/gpu/GrDefaultGeoProcFactory.h
@@ -73,6 +73,56 @@ public:
         kLastGPType = kCoverage_GPType
     };
 
+    struct Color {
+        enum Type {
+            kNone_Type,
+            kUniform_Type,
+            kAttribute_Type,
+        };
+        Color(GrColor color) : fType(kUniform_Type), fColor(color) {}
+        Color(Type type) : fType(type), fColor(GrColor_ILLEGAL) {
+            SkASSERT(type != kUniform_Type);
+
+            // TODO This is temporary
+            if (kAttribute_Type == type) {
+                fColor = GrColor_WHITE;
+            }
+        }
+
+        Type fType;
+        GrColor fColor;
+    };
+
+    struct Coverage {
+        enum Type {
+            kNone_Type,
+            kSolid_Type,
+            kUniform_Type,
+            kAttribute_Type,
+        };
+        Coverage(uint8_t coverage) : fType(kUniform_Type), fCoverage(coverage) {}
+        Coverage(Type type) : fType(type), fCoverage(0xff) {
+            SkASSERT(type != kUniform_Type);
+        }
+
+        Type fType;
+        uint8_t fCoverage;
+    };
+
+    struct LocalCoords {
+        enum Type {
+            kNone_Type,
+            kUsePosition_Type,
+            kHasExplicit_Type,
+        };
+    };
+
+    static const GrGeometryProcessor* Create(const Color&,
+                                             const Coverage&,
+                                             LocalCoords::Type,
+                                             const SkMatrix& viewMatrix = SkMatrix::I(),
+                                             const SkMatrix& localMatrix = SkMatrix::I());
+
     /*
      * The following functions are used to create default GPs. If you just need to create
      * attributes separately from creating the default GP, use the SetAttribs function followed
diff --git a/src/gpu/GrRectBatch.cpp b/src/gpu/GrRectBatch.cpp
index 2977fdb1ce..b6c5d74ff2 100644
--- a/src/gpu/GrRectBatch.cpp
+++ b/src/gpu/GrRectBatch.cpp
@@ -25,18 +25,24 @@
  */
 static const GrGeometryProcessor* create_rect_gp(bool hasExplicitLocalCoords,
                                                  const SkMatrix* localMatrix,
-                                                 bool usesLocalCoords,
                                                  bool coverageIgnored) {
-    // TODO remove color when we have ignored color from the XP
-    uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType |
-                     GrDefaultGeoProcFactory::kColor_GPType;
-    flags |= hasExplicitLocalCoords ? GrDefaultGeoProcFactory::kLocalCoord_GPType : 0;
+    typedef GrDefaultGeoProcFactory::Color Color;
+    typedef GrDefaultGeoProcFactory::Coverage Coverage;
+    typedef GrDefaultGeoProcFactory::LocalCoords LocalCoords;
+    Color color(Color::kAttribute_Type);
+    Coverage coverage(coverageIgnored ? Coverage::kNone_Type : Coverage::kSolid_Type);
+    LocalCoords::Type localCoords;
+    if (hasExplicitLocalCoords) {
+        localCoords = LocalCoords::kHasExplicit_Type;
+    } else {
+        localCoords = LocalCoords::kUsePosition_Type;
+    }
+
     if (localMatrix) {
-        return GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords,
-                                               coverageIgnored, SkMatrix::I(), *localMatrix);
+        return GrDefaultGeoProcFactory::Create(color, coverage, localCoords, SkMatrix::I(),
+                                               *localMatrix);
     } else {
-        return GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords,
-                                               coverageIgnored, SkMatrix::I(), SkMatrix::I());
+        return GrDefaultGeoProcFactory::Create(color, coverage, localCoords);
     }
 }
 
@@ -101,7 +107,6 @@ public:
 
         SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(hasExplicitLocalCoords,
                                                                   &invert,
-                                                                  this->usesLocalCoords(),
                                                                   this->coverageIgnored()));
 
         batchTarget->initDraw(gp, pipeline);
@@ -129,6 +134,7 @@ public:
                                   geom.fRect.fRight, geom.fRect.fBottom, vertexStride);
             geom.fViewMatrix.mapPointsWithStride(positions, vertexStride, kVerticesPerQuad);
 
+            // TODO we should only do this if local coords are being read
             if (geom.fHasLocalRect) {
                 static const int kLocalOffset = sizeof(SkPoint) + sizeof(GrColor);
                 SkPoint* coords = reinterpret_cast<SkPoint*>(offset + kLocalOffset);
-- 
cgit v1.2.3