drawVertices bug on gpu side

src/gpu/SkGpuDevice.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 "SkGpuDevice.h"
 
 #include "effects/GrBicubicEffect.h"
@@ skipping 1594 matching lines @@
 
 void SkGpuDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
                               int vertexCount, const SkPoint vertices[],
                               const SkPoint texs[], const SkColor colors[],
                               SkXfermode* xmode,
                               const uint16_t indices[], int indexCount,
                               const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw, false);
 
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawVertices", fContext);
+    
+    uint16_t* idx;
+    GrPrimitiveType primType;
+    SkPaint copy(paint);

[jvanverth1, 2014/07/14 14:29:19]

I don't think we'd want to copy the paint all the time if we don't have to.
Maybe move the declaration of grPaint here, create the copy only in the hairline
case, and put the  specific SkPaint2GrPaintNoShader calls inside the 'if' and
the 'else' blocks.

[dandov, 2014/07/14 15:31:33]

Done.

+    
     // If both textures and vertex-colors are NULL, strokes hairlines with the paint's color.
     if ((NULL == texs || NULL == paint.getShader()) && NULL == colors) {
+        
         texs = NULL;
-        SkPaint copy(paint);
+        
         copy.setStyle(SkPaint::kStroke_Style);
         copy.setStrokeWidth(0);
 
+        primType = kLines_GrPrimitiveType;
+        int triangleCount = 0;
+        switch (vmode) {
+            case SkCanvas::kTriangles_VertexMode:
+                triangleCount = indexCount / 3;
+                break;
+            case SkCanvas::kTriangleStrip_VertexMode:
+            case SkCanvas::kTriangleFan_VertexMode:
+                triangleCount = indexCount - 2;
+                break;
+        }
+        
         VertState       state(vertexCount, indices, indexCount);
         VertState::Proc vertProc = state.chooseProc(vmode);
-
-        SkPoint* pts = new SkPoint[vertexCount * 6];
+        
+        //number of lines per triangle with kLines
+        indexCount = triangleCount * 6;
+        idx = SkNEW_ARRAY(uint16_t, indexCount);
         int i = 0;
         while (vertProc(&state)) {
-            pts[i] = vertices[state.f0];
-            pts[i + 1] = vertices[state.f1];
-            pts[i + 2] = vertices[state.f1];
-            pts[i + 3] = vertices[state.f2];
-            pts[i + 4] = vertices[state.f2];
-            pts[i + 5] = vertices[state.f0];
+            idx[i]     = state.f0;
+            idx[i + 1] = state.f1;
+            idx[i + 2] = state.f1;
+            idx[i + 3] = state.f2;
+            idx[i + 4] = state.f2;
+            idx[i + 5] = state.f0;
             i += 6;
         }
-        draw.drawPoints(SkCanvas::kLines_PointMode, i, pts, copy, true);
-        return;
+    } else {
+        idx = SkNEW_ARRAY(uint16_t, indexCount);
+        memcpy(idx, indices, indexCount * sizeof(uint16_t));
+        primType = gVertexMode2PrimitiveType[vmode];
     }
 
+    
+    // we ignore the shader if texs is null.
     GrPaint grPaint;
-    // we ignore the shader if texs is null.
     if (NULL == texs) {
-        SkPaint2GrPaintNoShader(this->context(), paint, SkColor2GrColor(paint.getColor()),
+        SkPaint2GrPaintNoShader(this->context(), copy, SkColor2GrColor(copy.getColor()),
                                 NULL == colors, &grPaint);
     } else {
-        SkPaint2GrPaintShader(this->context(), paint, NULL == colors, &grPaint);
+        SkPaint2GrPaintShader(this->context(), copy, NULL == colors, &grPaint);
     }
 
 #if 0
     if (NULL != xmode && NULL != texs && NULL != colors) {
         if (!SkXfermode::IsMode(xmode, SkXfermode::kModulate_Mode)) {
             SkDebugf("Unsupported vertex-color/texture xfer mode.\n");
             return;
         }
     }
 #endif
 
     SkAutoSTMalloc<128, GrColor> convertedColors(0);
     if (NULL != colors) {
         // need to convert byte order and from non-PM to PM
         convertedColors.reset(vertexCount);
         SkColor color;
         for (int i = 0; i < vertexCount; ++i) {
             color = colors[i];
-            if (paint.getAlpha() != 255) {
-                color = SkColorSetA(color, SkMulDiv255Round(SkColorGetA(color), paint.getAlpha()));
+            if (copy.getAlpha() != 255) {

[jvanverth1, 2014/07/14 14:29:20]

The paint color doesn't change in the hairline case, so you could use the
original paint here.

[dandov, 2014/07/14 15:31:33]

Done.

+                color = SkColorSetA(color, SkMulDiv255Round(SkColorGetA(color), copy.getAlpha()));
             }
             convertedColors[i] = SkColor2GrColor(color);
         }
         colors = convertedColors.get();
     }
     fContext->drawVertices(grPaint,
-                           gVertexMode2PrimitiveType[vmode],
+                           primType,
                            vertexCount,
                            vertices,
                            texs,
                            colors,
-                           indices,
+                           idx,
                            indexCount);
+    
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawText(const SkDraw& draw, const void* text,
                           size_t byteLength, SkScalar x, SkScalar y,
                           const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw, false);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawText", fContext);
 
@@ skipping 341 matching lines @@
     playback.draw(canvas, NULL);
 
     // unlock the layers
     for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
         GrCachedLayer* layer = fContext->getLayerCache()->findLayer(picture, i);
         fContext->getLayerCache()->unlock(layer);
     }
 
     return true;
 }