Fix hairline pathrenderer for Nexus-10. Switches to passing in an offset and using that to compute …

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 11 matching lines @@
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLSL.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;
 
-static const int kVertsPerLineSeg = 4;
-static const int kIdxsPerLineSeg = 6;
+static const int kVertsPerLineSeg = 6;
+static const int kIdxsPerLineSeg = 12;
 
 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;
+
 bool push_quad_index_data(GrIndexBuffer* qIdxBuffer) {
     uint16_t* data = (uint16_t*) qIdxBuffer->lock();
     bool tempData = NULL == data;
     if (tempData) {
         data = SkNEW_ARRAY(uint16_t, kNumQuadsInIdxBuffer * kIdxsPerQuad);
     }
     for (int i = 0; i < kNumQuadsInIdxBuffer; ++i) {
 
         // Each quadratic is rendered as a five sided polygon. This poly bounds
         // the quadratic's bounding triangle but has been expanded so that the
@@ skipping 21 matching lines @@
     }
     if (tempData) {
         bool ret = qIdxBuffer->updateData(data, kQuadIdxSBufize);
         delete[] data;
         return ret;
     } else {
         qIdxBuffer->unlock();
         return true;
     }
 }
+
+bool push_line_index_data(GrIndexBuffer* qIdxBuffer) {
+    uint16_t* data = (uint16_t*) qIdxBuffer->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 like (i.e. the line equation is t*(p1-p0) + p0)
+        //
+        // p4                  p5
+        // p0                  p1
+        // p2                  p3
+        //
+        // Each is drawn as four triangles specified by these 12 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[3 + baseIdx] = baseVert + 2; // p2
+        data[4 + baseIdx] = baseVert + 1; // p1
+        data[5 + baseIdx] = baseVert + 3; // p3
+        
+        data[6 + baseIdx] = baseVert + 0; // p0
+        data[7 + baseIdx] = baseVert + 5; // p5
+        data[8 + baseIdx] = baseVert + 1; // p1
+        
+        data[9 + baseIdx] = baseVert + 0; // p0
+        data[10+ baseIdx] = baseVert + 4; // p4
+        data[11+ baseIdx] = baseVert + 5; // p5
+    }
+    if (tempData) {
+        bool ret = qIdxBuffer->updateData(data, kLineSegIdxSBufize);
+        delete[] data;
+        return ret;
+    } else {
+        qIdxBuffer->unlock();
+        return true;
+    }
+}
 }
 
 GrPathRenderer* GrAAHairLinePathRenderer::Create(GrContext* context) {
-    const GrIndexBuffer* lIdxBuffer = context->getQuadIndexBuffer();
-    if (NULL == lIdxBuffer) {
-        return NULL;
-    }
     GrGpu* gpu = context->getGpu();
     GrIndexBuffer* qIdxBuf = gpu->createIndexBuffer(kQuadIdxSBufize, false);
     SkAutoTUnref<GrIndexBuffer> qIdxBuffer(qIdxBuf);
     if (NULL == qIdxBuf ||
         !push_quad_index_data(qIdxBuf)) {
         return NULL;
     }
+    GrIndexBuffer* lIdxBuf = gpu->createIndexBuffer(kLineSegIdxSBufize, false);
+    SkAutoTUnref<GrIndexBuffer> lIdxBuffer(lIdxBuf);
+    if (NULL == lIdxBuf ||
+        !push_line_index_data(lIdxBuf)) {
+        return NULL;
+    }
     return SkNEW_ARGS(GrAAHairLinePathRenderer,
-                      (context, lIdxBuffer, qIdxBuf));
+                      (context, lIdxBuf, qIdxBuf));
 }
 
 GrAAHairLinePathRenderer::GrAAHairLinePathRenderer(
                                         const GrContext* context,
                                         const GrIndexBuffer* linesIndexBuffer,
                                         const GrIndexBuffer* quadsIndexBuffer) {
     fLinesIndexBuffer = linesIndexBuffer;
     linesIndexBuffer->ref();
     fQuadsIndexBuffer = quadsIndexBuffer;
     quadsIndexBuffer->ref();
@@ skipping 321 matching lines @@
                 break;
             case SkPath::kDone_Verb:
                 return totalQuadCount;
         }
     }
 }
 
 struct Vertex {
     GrPoint fPos;
     union {
-        struct {
-            SkScalar fA;
-            SkScalar fB;
-            SkScalar fC;
-        } fLine;
+        SkScalar fCoverage;

[bsalomon, 2013/08/07 20:59:57]

fLineCoverage? or...
struct {
  SkScalar fCoverage;
} fLine;

It'd just be nice to keep them labeled with the edge type that uses them.

[jvanverth1, 2013/08/07 21:15:04]

Done.

         struct {
             SkScalar fK;
             SkScalar fL;
             SkScalar fM;
         } fConic;
         GrVec   fQuadCoord;
         struct {
             SkScalar fBogus[4];
         };
     };
@@ skipping 201 matching lines @@
               Vertex** vert) {
     const SkPoint& a = p[0];
     const SkPoint& b = p[1];
 
     SkVector orthVec = b;
     orthVec -= a;
 
     if (orthVec.setLength(SK_Scalar1)) {
         orthVec.setOrthog(orthVec);
 
-        SkScalar lineC = -(a.dot(orthVec));
         for (int i = 0; i < kVertsPerLineSeg; ++i) {
-            (*vert)[i].fPos = (i < 2) ? a : b;
-            if (0 == i || 3 == 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].fPos += orthVec;
+                (*vert)[i].fCoverage= SK_Scalar1;
             }
-            (*vert)[i].fLine.fA = orthVec.fX;
-            (*vert)[i].fLine.fB = orthVec.fY;
-            (*vert)[i].fLine.fC = lineC;
         }
         if (NULL != toSrc) {
             toSrc->mapPointsWithStride(&(*vert)->fPos,
                                        sizeof(Vertex),
                                        kVertsPerLineSeg);
         }
     } else {
         // just make it degenerate and likely offscreen
         (*vert)[0].fPos.set(SK_ScalarMax, SK_ScalarMax);
         (*vert)[1].fPos.set(SK_ScalarMax, SK_ScalarMax);
         (*vert)[2].fPos.set(SK_ScalarMax, SK_ScalarMax);
         (*vert)[3].fPos.set(SK_ScalarMax, SK_ScalarMax);
+        (*vert)[4].fPos.set(SK_ScalarMax, SK_ScalarMax);
+        (*vert)[5].fPos.set(SK_ScalarMax, SK_ScalarMax);
     }
 
     *vert += kVertsPerLineSeg;
 }
 
 }
 
 /**
  * Shader is based off of Loop-Blinn Quadratic GPU Rendering
  * The output of this effect is a hairline edge for conics.
@@ skipping 232 matching lines @@
                                             const GrDrawTargetCaps& caps,
                                             GrTexture*[]) {
     // Doesn't work without derivative instructions.
     return caps.shaderDerivativeSupport() ? HairQuadEdgeEffect::Create() : NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * The output of this effect is a 1-pixel wide line.
- * Input is 2D implicit device coord line eq (a*x + b*y +c = 0). 4th component unused.
+ * Input is 2D offset vector from the line. 3rd and 4th components unused.
  */
 class HairLineEdgeEffect : public GrEffect {
 public:
 
     static GrEffectRef* Create() {
         GR_CREATE_STATIC_EFFECT(gHairLineEdge, HairLineEdgeEffect, ());
         gHairLineEdge->ref();
         return gHairLineEdge;
     }
 
@@ skipping 21 matching lines @@
                               const char* outputColor,
                               const char* inputColor,
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
             const char *vsName, *fsName;
             const SkString* attrName =
                 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
             builder->fsCodeAppendf("\t\tfloat edgeAlpha;\n");
 
             builder->addVarying(kVec4f_GrSLType, "HairLineEdge", &vsName, &fsName);
 
-            builder->fsCodeAppendf("\t\tedgeAlpha = abs(dot(vec3(%s.xy,1), %s.xyz));\n",
-                                   builder->fragmentPosition(), fsName);
-            builder->fsCodeAppendf("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
+            builder->fsCodeAppendf("\t\tedgeAlpha = %s.x;\n", fsName);
 
             SkString modulate;
             GrGLSLModulatef<4>(&modulate, inputColor, "edgeAlpha");
             builder->fsCodeAppendf("\t%s = %s;\n", outputColor, modulate.c_str());
 
             builder->vsCodeAppendf("\t%s = %s;\n", vsName, attrName->c_str());
         }
 
         static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
             return 0x0;
@@ skipping 193 matching lines @@
     }
     if (!first) {
         GrAssert(tolDevBounds.contains(actualBounds));
     }
 #endif
 
     {
         GrDrawState::AutoRestoreEffects are(drawState);
         target->setIndexSourceToBuffer(fLinesIndexBuffer);
         int lines = 0;
-        int nBufLines = fLinesIndexBuffer->maxQuads();
         drawState->addCoverageEffect(hairLineEffect, kEdgeAttrIndex)->unref();
         while (lines < lineCnt) {
-            int n = GrMin(lineCnt - lines, nBufLines);
+            int n = GrMin(lineCnt - lines, kNumLineSegsInIdxBuffer);
             target->drawIndexed(kTriangles_GrPrimitiveType,
                                 kVertsPerLineSeg*lines,     // startV
                                 0,                          // startI
                                 kVertsPerLineSeg*n,         // vCount
                                 kIdxsPerLineSeg*n,
                                 &devBounds);                // iCount
             lines += n;
         }
     }
 
@@ skipping 27 matching lines @@
                                 kVertsPerQuad*n,                   // vCount
                                 kIdxsPerQuad*n,                    // iCount
                                 &devBounds);
             conics += n;
         }
     }
     target->resetIndexSource();
 
     return true;
 }