Separate quad UV calculation from bloat_quad

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 454 matching lines @@
         SkScalarMul(normA.fY, normB.fX);
     wInv = SkScalarInvert(wInv);
 
     result->fX = SkScalarMul(normA.fY, lineBW) - SkScalarMul(lineAW, normB.fY);
     result->fX = SkScalarMul(result->fX, wInv);
 
     result->fY = SkScalarMul(lineAW, normB.fX) - SkScalarMul(normA.fX, lineBW);
     result->fY = SkScalarMul(result->fY, wInv);
 }
 
+void set_uv_quad(const SkPoint qpts[3], Vertex verts[kVertsPerQuad]) {
+    // this should be in the src space, not dev coords, when we have perspective
+    GrPathUtils::QuadUVMatrix DevToUV(qpts);
+    DevToUV.apply<kVertsPerQuad, sizeof(Vertex), sizeof(GrPoint)>(verts);
+}
+
 void bloat_quad(const SkPoint qpts[3], const SkMatrix* toDevice,
                 const SkMatrix* toSrc, Vertex verts[kVertsPerQuad],
                 SkRect* devBounds) {
     GrAssert(!toDevice == !toSrc);
     // original quad is specified by tri a,b,c
     SkPoint a = qpts[0];
     SkPoint b = qpts[1];
     SkPoint c = qpts[2];
 
-    // this should be in the src space, not dev coords, when we have perspective
-    GrPathUtils::QuadUVMatrix DevToUV(qpts);
-
     if (toDevice) {
         toDevice->mapPoints(&a, 1);
         toDevice->mapPoints(&b, 1);
         toDevice->mapPoints(&c, 1);
     }
     // make a new poly where we replace a and c by a 1-pixel wide edges orthog
     // to edges ab and bc:
     //
     //   before       |        after
     //                |              b0
@@ skipping 45 matching lines @@
     c1.fPos -= cbN;
 
     // This point may not be within 1 pixel of a control point. We update the bounding box to
     // include it.
     intersect_lines(a0.fPos, abN, c0.fPos, cbN, &b0.fPos);
     devBounds->growToInclude(b0.fPos.fX, b0.fPos.fY);
 
     if (toSrc) {
         toSrc->mapPointsWithStride(&verts[0].fPos, sizeof(Vertex), kVertsPerQuad);
     }
-    DevToUV.apply<kVertsPerQuad, sizeof(Vertex), sizeof(GrPoint)>(verts);
 }
 
 // Input:
 // Three control points: p[0], p[1], p[2] and weight: w
 // Output:
 // Let:
 // l = (2*w * (y1 - y0), 2*w * (x0 - x1), 2*w * (x1*y0 - x0*y1))
 // m = (2*w * (y2 - y1), 2*w * (x1 - x2), 2*w * (x2*y1 - x1*y2))
 // k = (y2 - y0, x0 - x2, (x2 - x0)*y0 - (y2 - y0)*x0 )
 void calc_conic_klm(const SkPoint p[3], const SkScalar weight,
@@ skipping 71 matching lines @@
                Vertex** vert,
                SkRect* devBounds) {
     GrAssert(subdiv >= 0);
     if (subdiv) {
         SkPoint newP[5];
         SkChopQuadAtHalf(p, newP);
         add_quads(newP + 0, subdiv-1, toDevice, toSrc, vert, devBounds);
         add_quads(newP + 2, subdiv-1, toDevice, toSrc, vert, devBounds);
     } else {
         bloat_quad(p, toDevice, toSrc, *vert, devBounds);
+        set_uv_quad(p, *vert);
         *vert += kVertsPerQuad;
     }
 }
 
 void add_line(const SkPoint p[2],
               int rtHeight,
               const SkMatrix* toSrc,
               Vertex** vert) {
     const SkPoint& a = p[0];
     const SkPoint& b = p[1];
@@ skipping 581 matching lines @@
                                 kVertsPerQuad*n,                   // vCount
                                 kIdxsPerQuad*n,                    // iCount
                                 &devBounds);
             conics += n;
         }
     }
     target->resetIndexSource();
 
     return true;
 }