"Fix" for hairline corner bugs

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 10 matching lines @@
 
 #include "effects/GrBezierEffect.h"
 
 namespace {
 // quadratics are rendered as 5-sided polys in order to bound the
 // AA stroke around the center-curve. See comments in push_quad_index_buffer and
 // bloat_quad. Quadratics and conics share an index buffer
 static const int kVertsPerQuad = 5;
 static const int kIdxsPerQuad = 9;
 
+// lines are rendered as:
+//      *______________*
+//      |\ -_______   /|
+//      | \        \ / |
+//      |  *--------*  |
+//      | /  ______/ \ |
+//      */_-__________\*
+// For: 6 vertices and 18 indices (for 6 triangles)
 static const int kVertsPerLineSeg = 6;
-static const int kIdxsPerLineSeg = 12;
+static const int kIdxsPerLineSeg = 18;
 
 static const int kNumQuadsInIdxBuffer = 256;
 static const size_t kQuadIdxSBufize = kIdxsPerQuad *
                                       sizeof(uint16_t) *
                                       kNumQuadsInIdxBuffer;
 
 static const int kNumLineSegsInIdxBuffer = 256;
 static const size_t kLineSegIdxSBufize = kIdxsPerLineSeg *
                                          sizeof(uint16_t) *
                                          kNumLineSegsInIdxBuffer;
@@ skipping 40 matching lines @@
     }
 }
 
 static bool push_line_index_data(GrIndexBuffer* lIdxBuffer) {
     uint16_t* data = (uint16_t*) lIdxBuffer->lock();
     bool tempData = NULL == data;
     if (tempData) {
         data = SkNEW_ARRAY(uint16_t, kNumLineSegsInIdxBuffer * kIdxsPerLineSeg);
     }
     for (int i = 0; i < kNumLineSegsInIdxBuffer; ++i) {
-        // Each line segment is rendered as two quads, with alpha = 1 along the
-        // spine of the segment, and alpha = 0 along the outer edges, represented
-        // horizontally (i.e., the line equation is t*(p1-p0) + p0)
+        // Each line segment is rendered as two quads and two triangles.
+        // p0 and p1 have alpha = 1 while all other points have alpha = 0.
+        // The four external points are offset 1 pixel perpendicular to the
+        // line and half a pixel parallel to the line.
         //
         // p4                  p5
-        // p0                  p1
+        //      p0         p1
         // p2                  p3
         //
-        // Each is drawn as four triangles specified by these 12 indices:
+        // Each is drawn as six triangles specified by these 18 indices:
         int baseIdx = i * kIdxsPerLineSeg;
         uint16_t baseVert = (uint16_t)(i * kVertsPerLineSeg);
-        data[0 + baseIdx] = baseVert + 0; // p0
-        data[1 + baseIdx] = baseVert + 1; // p1
-        data[2 + baseIdx] = baseVert + 2; // p2
+        data[0 + baseIdx] = baseVert + 0;
+        data[1 + baseIdx] = baseVert + 1;
+        data[2 + baseIdx] = baseVert + 3;
 
-        data[3 + baseIdx] = baseVert + 2; // p2
-        data[4 + baseIdx] = baseVert + 1; // p1
-        data[5 + baseIdx] = baseVert + 3; // p3
+        data[3 + baseIdx] = baseVert + 0;
+        data[4 + baseIdx] = baseVert + 3;
+        data[5 + baseIdx] = baseVert + 2;
 
-        data[6 + baseIdx] = baseVert + 0; // p0
-        data[7 + baseIdx] = baseVert + 5; // p5
-        data[8 + baseIdx] = baseVert + 1; // p1
+        data[6 + baseIdx] = baseVert + 0;
+        data[7 + baseIdx] = baseVert + 4;
+        data[8 + baseIdx] = baseVert + 5;
 
-        data[9 + baseIdx] = baseVert + 0; // p0
-        data[10+ baseIdx] = baseVert + 4; // p4
-        data[11+ baseIdx] = baseVert + 5; // p5
+        data[9 + baseIdx] = baseVert + 0;
+        data[10+ baseIdx] = baseVert + 5;
+        data[11+ baseIdx] = baseVert + 1;
+
+        data[12 + baseIdx] = baseVert + 0;
+        data[13 + baseIdx] = baseVert + 2;
+        data[14 + baseIdx] = baseVert + 4;
+
+        data[15 + baseIdx] = baseVert + 1;
+        data[16 + baseIdx] = baseVert + 5;
+        data[17 + baseIdx] = baseVert + 3;
     }
     if (tempData) {
         bool ret = lIdxBuffer->updateData(data, kLineSegIdxSBufize);
         delete[] data;
         return ret;
     } else {
         lIdxBuffer->unlock();
         return true;
     }
 }
@@ skipping 513 matching lines @@
         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,
               GrColor coverage,
               LineVertex** vert) {
     const SkPoint& a = p[0];
     const SkPoint& b = p[1];
 
-    SkVector orthVec = b;
-    orthVec -= a;
+    SkVector ortho, vec = b;
+    vec -= a;
 
-    if (orthVec.setLength(SK_Scalar1)) {
-        orthVec.setOrthog(orthVec);
+    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;
 
-        for (int i = 0; i < kVertsPerLineSeg; ++i) {
-            (*vert)[i].fPos = (i & 0x1) ? b : a;
-            if (i & 0x2) {
-                (*vert)[i].fPos += orthVec;
-                (*vert)[i].fCoverage = 0;
-            } else if (i & 0x4) {
-                (*vert)[i].fPos -= orthVec;
-                (*vert)[i].fCoverage = 0;
-            } else {
-                (*vert)[i].fCoverage = coverage;
-            }
-        }
+        (*vert)[0].fPos = a;
+        (*vert)[0].fCoverage = coverage;
+        (*vert)[1].fPos = b;
+        (*vert)[1].fCoverage = coverage;
+        (*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 (NULL != toSrc) {
             toSrc->mapPointsWithStride(&(*vert)->fPos,
                                        sizeof(LineVertex),
                                        kVertsPerLineSeg);
         }
     } else {
         // just make it degenerate and likely offscreen
         for (int i = 0; i < kVertsPerLineSeg; ++i) {
             (*vert)[i].fPos.set(SK_ScalarMax, SK_ScalarMax);
         }
@@ skipping 15 matching lines @@
 };
 
 // position + coverage
 extern const GrVertexAttrib gHairlineLineAttribs[] = {
     {kVec2f_GrVertexAttribType,  0,               kPosition_GrVertexAttribBinding},
     {kVec4ub_GrVertexAttribType, sizeof(GrPoint), kCoverage_GrVertexAttribBinding},
 };
 
 };
 
-bool GrAAHairLinePathRenderer::createLineGeom(
-            const SkPath& path,
-            GrDrawTarget* target,
-            const PtArray& lines,
-            int lineCnt,
-            GrDrawTarget::AutoReleaseGeometry* arg,
-            SkRect* devBounds) {
+bool GrAAHairLinePathRenderer::createLineGeom(const SkPath& path,
+                                              GrDrawTarget* target,
+                                              const PtArray& lines,
+                                              int lineCnt,
+                                              GrDrawTarget::AutoReleaseGeometry* arg,
+                                              SkRect* devBounds) {
     GrDrawState* drawState = target->drawState();
-    int rtHeight = drawState->getRenderTarget()->height();
 
     const SkMatrix& viewM = drawState->getViewMatrix();
 
     devBounds->outset(SK_Scalar1, SK_Scalar1);
 
     int vertCnt = kVertsPerLineSeg * lineCnt;
 
-    target->drawState()->setVertexAttribs<gHairlineLineAttribs>(SK_ARRAY_COUNT(gHairlineLineAttribs));
-    SkASSERT(sizeof(LineVertex) == target->getDrawState().getVertexSize());
+    drawState->setVertexAttribs<gHairlineLineAttribs>(SK_ARRAY_COUNT(gHairlineLineAttribs));
+    SkASSERT(sizeof(LineVertex) == drawState->getVertexSize());
 
     if (!arg->set(target, vertCnt, 0)) {
         return false;
     }
 
     LineVertex* verts = reinterpret_cast<LineVertex*>(arg->vertices());
 
     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], rtHeight, toSrc, drawState->getCoverage(), &verts);
+        add_line(&lines[2*i], toSrc, drawState->getCoverage(), &verts);
     }
     // All the verts computed by add_line are within unit distance of the end points. Add a little
     // extra to account for vector normalization precision.
     static const SkScalar kOutset = SK_Scalar1 + SK_Scalar1 / 20;
     devBounds->outset(kOutset, kOutset);
 
     return true;
 }
 
 bool GrAAHairLinePathRenderer::createBezierGeom(
@@ skipping 145 matching lines @@
                                   target,
                                   lines,
                                   lineCnt,
                                   &arg,
                                   &devBounds)) {
             return false;
         }
 
         GrDrawTarget::AutoStateRestore asr;
 
-        // createGeom transforms the geometry to device space when the matrix does not have
+        // createLineGeom transforms the geometry to device space when the matrix does not have
         // perspective.
         if (target->getDrawState().getViewMatrix().hasPerspective()) {
             asr.set(target, GrDrawTarget::kPreserve_ASRInit);
         } else if (!asr.setIdentity(target, GrDrawTarget::kPreserve_ASRInit)) {
             return false;
         }
         GrDrawState* drawState = target->drawState();
 
         // Check devBounds
         SkASSERT(check_bounds<LineVertex>(drawState, devBounds, arg.vertices(),
                                           kVertsPerLineSeg * lineCnt));
 
         {
             GrDrawState::AutoRestoreEffects are(drawState);
             target->setIndexSourceToBuffer(fLinesIndexBuffer);
             int lines = 0;
             while (lines < lineCnt) {
                 int n = GrMin(lineCnt - lines, kNumLineSegsInIdxBuffer);
                 target->drawIndexed(kTriangles_GrPrimitiveType,
                                     kVertsPerLineSeg*lines,     // startV
                                     0,                          // startI
                                     kVertsPerLineSeg*n,         // vCount
-                                    kIdxsPerLineSeg*n,
-                                    &devBounds);                // iCount
+                                    kIdxsPerLineSeg*n,          // iCount
+                                    &devBounds);
                 lines += n;
             }
         }
     }
 
     // then quadratics/conics
     if (quadCnt || conicCnt) {
         GrDrawTarget::AutoReleaseGeometry arg;
         SkRect devBounds;
 
@@ skipping 64 matching lines @@
                                     &devBounds);
                 conics += n;
             }
         }
     }
 
     target->resetIndexSource();
 
     return true;
 }