Send coverage VA as floats instead of bytes

src/gpu/GrAAHairLinePathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 405 matching lines @@
             case SkPath::kClose_Verb:
                 break;
             case SkPath::kDone_Verb:
                 return totalQuadCount;
         }
     }
 }
 
 struct LineVertex {
     SkPoint fPos;
-    GrColor fCoverage;
+    float fCoverage;
 };
 
 struct BezierVertex {
     SkPoint fPos;
     union {
         struct {
             SkScalar fK;
             SkScalar fL;
             SkScalar fM;
         } fConic;
@@ skipping 150 matching lines @@
         add_quads(newP + 2, subdiv-1, toDevice, toSrc, vert, devBounds);
     } else {
         bloat_quad(p, toDevice, toSrc, *vert, devBounds);
         set_uv_quad(p, *vert);
         *vert += kQuadNumVertices;
     }
 }
 
 void add_line(const SkPoint p[2],
               const SkMatrix* toSrc,
-              GrColor coverage,
+              uint8_t coverage,
               LineVertex** vert) {
     const SkPoint& a = p[0];
     const SkPoint& b = p[1];
 
     SkVector ortho, vec = b;
     vec -= a;
 
     if (vec.setLength(SK_ScalarHalf)) {
         // Create a vector orthogonal to 'vec' and of unit length
         ortho.fX = 2.0f * vec.fY;
         ortho.fY = -2.0f * vec.fX;
 
+        float floatCoverage = GrNormalizeByteToFloat(coverage);
+
         (*vert)[0].fPos = a;
-        (*vert)[0].fCoverage = coverage;
+        (*vert)[0].fCoverage = floatCoverage;
         (*vert)[1].fPos = b;
-        (*vert)[1].fCoverage = coverage;
+        (*vert)[1].fCoverage = floatCoverage;
         (*vert)[2].fPos = a - vec + ortho;
         (*vert)[2].fCoverage = 0;
         (*vert)[3].fPos = b + vec + ortho;
         (*vert)[3].fCoverage = 0;
         (*vert)[4].fPos = a - vec - ortho;
         (*vert)[4].fCoverage = 0;
         (*vert)[5].fPos = b + vec - ortho;
         (*vert)[5].fCoverage = 0;
 
         if (toSrc) {
@@ skipping 19 matching lines @@
 
 // position + edge
 extern const GrVertexAttrib gHairlineBezierAttribs[] = {
     {kVec2f_GrVertexAttribType, 0,                  kPosition_GrVertexAttribBinding},
     {kVec4f_GrVertexAttribType, sizeof(SkPoint),    kGeometryProcessor_GrVertexAttribBinding}
 };
 
 // position + coverage
 extern const GrVertexAttrib gHairlineLineAttribs[] = {
     {kVec2f_GrVertexAttribType,  0,               kPosition_GrVertexAttribBinding},
-    {kUByte_GrVertexAttribType, sizeof(SkPoint), kCoverage_GrVertexAttribBinding},
+    {kFloat_GrVertexAttribType, sizeof(SkPoint), kCoverage_GrVertexAttribBinding},
 };
 
 };
 
 bool GrAAHairLinePathRenderer::createLineGeom(const SkPath& path,
                                               GrDrawTarget* target,
                                               const PtArray& lines,
                                               int lineCnt,
                                               GrDrawTarget::AutoReleaseGeometry* arg,
                                               SkRect* devBounds) {
@@ skipping 15 matching lines @@
     const SkMatrix* toSrc = NULL;
     SkMatrix ivm;
 
     if (viewM.hasPerspective()) {
         if (viewM.invert(&ivm)) {
             toSrc = &ivm;
         }
     }
     devBounds->set(lines.begin(), lines.count());
     for (int i = 0; i < lineCnt; ++i) {
-        add_line(&lines[2*i], toSrc, drawState->getCoverageColor(), &verts);
+        add_line(&lines[2*i], toSrc, drawState->getCoverage(), &verts);
     }
     // All the verts computed by add_line are within sqrt(1^2 + 0.5^2) of the end points.
     static const SkScalar kSqrtOfOneAndAQuarter = 1.118f;
     // Add a little extra to account for vector normalization precision.
     static const SkScalar kOutset = kSqrtOfOneAndAQuarter + SK_Scalar1 / 20;
     devBounds->outset(kOutset, kOutset);
 
     return true;
 }
 
@@ skipping 267 matching lines @@
                                     &devBounds);
                 conics += n;
             }
         }
     }
 
     target->resetIndexSource();
 
     return true;
 }