Cleanup Default Geo Proc API

src/gpu/GrDefaultGeoProcFactory.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 GrDefaultGeoProcFactory_DEFINED
 #define GrDefaultGeoProcFactory_DEFINED
 
@@ skipping 55 matching lines @@
     };
 
     enum GPType {
         kPosition_GPType = 0x0, // we ALWAYS have position
         kColor_GPType = 0x01,
         kLocalCoord_GPType = 0x02,
         kCoverage_GPType= 0x04,
         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) {

[bsalomon, 2015/07/27 16:19:24]

??

[joshualitt, 2015/07/27 17:21:51]

This really is just temporary.  I have to do this until
GrDefaultGeoProcFactory's class takes the color struct itself

+                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 {

[bsalomon, 2015/07/27 16:19:24]

Why a struct?

[joshualitt, 2015/07/27 17:21:51]

For one, just to have consistency with Color and Coverage.  I could also just do
a namespace.  For another, just in case we want to do something like add a count
for the number of transforms applied on the CPU.

If you prefer just the enum I can change it.

+        enum Type {
+            kNone_Type,
+            kUsePosition_Type,
+            kHasExplicit_Type,

[bsalomon, 2015/07/27 16:19:24]

Is this where we'd add another option, something like kPreTransformed for the
case where we applied CTs on the CPU? I guess we'd need a count too so that the
GP knows how many CTs there are. 

[joshualitt, 2015/07/27 17:21:51]

Yea, exactly.  I think we could either do a count or have kPreTransformed1, 2,
etc enums.  Probably be a bit clunky though, I prefer the explicit count.

+        };
+    };
+
+    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
      * by the Create function. Otherwise use CreateAndSetAttribs to do both at once.
      *
      * You must unref the return from Create.
      */
     // TODO clean this up
     static const GrGeometryProcessor* Create(uint32_t gpTypeFlags,
                                              GrColor,
                                              bool localCoordsWillBeRead,
                                              bool coverageWillBeIgnored,
                                              const SkMatrix& viewMatrix = SkMatrix::I(),
                                              const SkMatrix& localMatrix = SkMatrix::I(),
                                              uint8_t coverage = 0xff);
 
     static size_t DefaultVertexStride() { return sizeof(PositionAttr); }
 };
 
 #endif