Always use both a color and coverage attribute in GrAARectRenderer.

src/gpu/GrAARectRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
 #include "GrGpu.h"
 #include "gl/GrGLEffect.h"
@@ skipping 238 matching lines @@
                                    GrContext* context,
                                    const GrDrawTargetCaps&,
                                    GrTexture* textures[]) {
     return GrRectEffect::Create();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
-extern const GrVertexAttrib gAARectCoverageAttribs[] = {
-    {kVec2f_GrVertexAttribType,  0,               kPosition_GrVertexAttribBinding},
-    {kVec4ub_GrVertexAttribType, sizeof(SkPoint), kCoverage_GrVertexAttribBinding},
+extern const GrVertexAttrib gAARectAttribs[] = {
+    {kVec2f_GrVertexAttribType,  0,                                 kPosition_GrVertexAttribBinding},
+    {kVec4ub_GrVertexAttribType, sizeof(SkPoint),                   kColor_GrVertexAttribBinding},
+    {kVec4ub_GrVertexAttribType, sizeof(SkPoint) + sizeof(SkColor), kCoverage_GrVertexAttribBinding},
 };
 
-extern const GrVertexAttrib gAARectColorAttribs[] = {
-    {kVec2f_GrVertexAttribType,  0,               kPosition_GrVertexAttribBinding},
-    {kVec4ub_GrVertexAttribType, sizeof(SkPoint), kColor_GrVertexAttribBinding},
-};
-
-static void set_aa_rect_vertex_attributes(GrDrawState* drawState, bool useCoverage) {
-    if (useCoverage) {
-        drawState->setVertexAttribs<gAARectCoverageAttribs>(SK_ARRAY_COUNT(gAARectCoverageAttribs));
-    } else {
-        drawState->setVertexAttribs<gAARectColorAttribs>(SK_ARRAY_COUNT(gAARectColorAttribs));
-    }
-}
-
 static void set_inset_fan(SkPoint* pts, size_t stride,
                           const SkRect& r, SkScalar dx, SkScalar dy) {
     pts->setRectFan(r.fLeft + dx, r.fTop + dy,
                     r.fRight - dx, r.fBottom - dy, stride);
 }
 
 };
 
 void GrAARectRenderer::reset() {
     SkSafeSetNull(fAAFillRectIndexBuffer);
@@ skipping 157 matching lines @@
             }
         }
         return fAABevelStrokeRectIndexBuffer;
     }
 }
 
 void GrAARectRenderer::geometryFillAARect(GrGpu* gpu,
                                           GrDrawTarget* target,
                                           const SkRect& rect,
                                           const SkMatrix& combinedMatrix,
-                                          const SkRect& devRect,
-                                          bool useVertexCoverage) {
+                                          const SkRect& devRect) {
     GrDrawState* drawState = target->drawState();
 
-    set_aa_rect_vertex_attributes(drawState, useVertexCoverage);
+    GrColor color = drawState->getColor();
+
+    drawState->setVertexAttribs<gAARectAttribs>(SK_ARRAY_COUNT(gAARectAttribs));
+    if (GrColorIsOpaque(color)) {
+        drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true);
+    }
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 8, 0);
     if (!geo.succeeded()) {
         GrPrintf("Failed to get space for vertices!\n");
         return;
     }
 
     GrIndexBuffer* indexBuffer = this->aaFillRectIndexBuffer(gpu);
     if (NULL == indexBuffer) {
         GrPrintf("Failed to create index buffer!\n");
         return;
     }
 
     intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices());
     size_t vsize = drawState->getVertexSize();
-    SkASSERT(sizeof(SkPoint) + sizeof(GrColor) == vsize);
+    SkASSERT(sizeof(SkPoint) + 2 * sizeof(GrColor) == vsize);
 
     SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts);
     SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + 4 * vsize);
 
     SkScalar inset = SkMinScalar(devRect.width(), SK_Scalar1);
     inset = SK_ScalarHalf * SkMinScalar(inset, devRect.height());
 
     if (combinedMatrix.rectStaysRect()) {
         // Temporarily #if'ed out. We don't want to pass in the devRect but
         // right now it is computed in GrContext::apply_aa_to_rect and we don't
@@ skipping 36 matching lines @@
         // BR
         *((SkPoint*)((intptr_t)fan1Pos + 2 * vsize)) =
             *((SkPoint*)((intptr_t)fan0Pos + 2 * vsize)) - vec[0] - vec[1];
         *((SkPoint*)((intptr_t)fan0Pos + 2 * vsize)) += vec[0] + vec[1];
         // TR
         *((SkPoint*)((intptr_t)fan1Pos + 3 * vsize)) =
             *((SkPoint*)((intptr_t)fan0Pos + 3 * vsize)) - vec[0] + vec[1];
         *((SkPoint*)((intptr_t)fan0Pos + 3 * vsize)) += vec[0] - vec[1];
     }
 
+    // Make verts point to vertex color and then set all the color and coverage vertex attrs values.
     verts += sizeof(SkPoint);
     for (int i = 0; i < 4; ++i) {
-        *reinterpret_cast<GrColor*>(verts + i * vsize) = 0;
+        *reinterpret_cast<GrColor*>(verts + i * vsize) = color;
+        *reinterpret_cast<GrColor*>(verts + i * vsize + sizeof(GrColor)) = 0;
     }
 
     int scale;
     if (inset < SK_ScalarHalf) {
         scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf));
         SkASSERT(scale >= 0 && scale <= 255);
     } else {
         scale = 0xff;
     }
 
-    GrColor innerColor;
-    if (useVertexCoverage) {
-        innerColor = GrColorPackRGBA(scale, scale, scale, scale);
-    } else {
-        if (0xff == scale) {
-            innerColor = target->getDrawState().getColor();
-        } else {
-            innerColor = SkAlphaMulQ(target->getDrawState().getColor(), scale);
-        }
-    }
-
-    verts += 4 * vsize;
+    GrColor innerCoverage;
+    innerCoverage = GrColorPackRGBA(scale, scale, scale, scale);    verts += 4 * vsize;
     for (int i = 0; i < 4; ++i) {
-        *reinterpret_cast<GrColor*>(verts + i * vsize) = innerColor;
+        *reinterpret_cast<GrColor*>(verts + i * vsize) = color;
+        *reinterpret_cast<GrColor*>(verts + i * vsize + sizeof(GrColor)) = innerCoverage;
     }
 
     target->setIndexSourceToBuffer(indexBuffer);
     target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1,
                                  kVertsPerAAFillRect,
                                  kIndicesPerAAFillRect);
     target->resetIndexSource();
 }
 
 namespace {
@@ skipping 148 matching lines @@
     target->setIndexSourceToBuffer(gpu->getContext()->getQuadIndexBuffer());
     target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1, 4, 6);
     target->resetIndexSource();
 }
 
 void GrAARectRenderer::strokeAARect(GrGpu* gpu,
                                     GrDrawTarget* target,
                                     const SkRect& rect,
                                     const SkMatrix& combinedMatrix,
                                     const SkRect& devRect,
-                                    const SkStrokeRec& stroke,
-                                    bool useVertexCoverage) {
+                                    const SkStrokeRec& stroke) {
     SkVector devStrokeSize;
     SkScalar width = stroke.getWidth();
     if (width > 0) {
         devStrokeSize.set(width, width);
         combinedMatrix.mapVectors(&devStrokeSize, 1);
         devStrokeSize.setAbs(devStrokeSize);
     } else {
         devStrokeSize.set(SK_Scalar1, SK_Scalar1);
     }
 
@@ skipping 22 matching lines @@
 
     bool miterStroke = true;
     // For hairlines, make bevel and round joins appear the same as mitered ones.
     // small miter limit means right angles show bevel...
     if ((width > 0) && (stroke.getJoin() != SkPaint::kMiter_Join ||
                         stroke.getMiter() < SK_ScalarSqrt2)) {
         miterStroke = false;
     }
 
     if (spare <= 0 && miterStroke) {
-        this->fillAARect(gpu, target, devOutside, SkMatrix::I(),
-                         devOutside, useVertexCoverage);
+        this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside);
         return;
     }
 
     SkRect devInside(devRect);
     devInside.inset(rx, ry);
 
     SkRect devOutsideAssist(devRect);
 
     // For bevel-stroke, use 2 SkRect instances(devOutside and devOutsideAssist)
     // to draw the outer of the rect. Because there are 8 vertices on the outer
     // edge, while vertex number of inner edge is 4, the same as miter-stroke.
     if (!miterStroke) {
         devOutside.inset(0, ry);
         devOutsideAssist.outset(0, ry);
     }
 
-    this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist,
-                               devInside, useVertexCoverage, miterStroke);
+    this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist, devInside, miterStroke);
 }
 
 void GrAARectRenderer::geometryStrokeAARect(GrGpu* gpu,
                                             GrDrawTarget* target,
                                             const SkRect& devOutside,
                                             const SkRect& devOutsideAssist,
                                             const SkRect& devInside,
-                                            bool useVertexCoverage,
                                             bool miterStroke) {
     GrDrawState* drawState = target->drawState();
 
-    set_aa_rect_vertex_attributes(drawState, useVertexCoverage);
+    drawState->setVertexAttribs<gAARectAttribs>(SK_ARRAY_COUNT(gAARectAttribs));
+
+    GrColor color = drawState->getColor();
+    if (GrColorIsOpaque(color)) {
+        drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true);
+    }
 
     int innerVertexNum = 4;
     int outerVertexNum = miterStroke ? 4 : 8;
     int totalVertexNum = (outerVertexNum + innerVertexNum) * 2;
 
     GrDrawTarget::AutoReleaseGeometry geo(target, totalVertexNum, 0);
     if (!geo.succeeded()) {
         GrPrintf("Failed to get space for vertices!\n");
         return;
     }
     GrIndexBuffer* indexBuffer = this->aaStrokeRectIndexBuffer(gpu, miterStroke);
     if (NULL == indexBuffer) {
         GrPrintf("Failed to create index buffer!\n");
         return;
     }
 
     intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices());
     size_t vsize = drawState->getVertexSize();
-    SkASSERT(sizeof(SkPoint) + sizeof(GrColor) == vsize);
 
     // We create vertices for four nested rectangles. There are two ramps from 0 to full
     // coverage, one on the exterior of the stroke and the other on the interior.
     // The following pointers refer to the four rects, from outermost to innermost.
     SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts);
     SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + outerVertexNum * vsize);
     SkPoint* fan2Pos = reinterpret_cast<SkPoint*>(verts + 2 * outerVertexNum * vsize);
     SkPoint* fan3Pos = reinterpret_cast<SkPoint*>(verts + (2 * outerVertexNum + innerVertexNum) * vsize);
 
 #ifndef SK_IGNORE_THIN_STROKED_RECT_FIX
@@ skipping 28 matching lines @@
         set_inset_fan(fan0AssistPos, vsize, devOutsideAssist, -SK_ScalarHalf, -SK_ScalarHalf);
         // outer one of the inner two
         set_inset_fan(fan1Pos, vsize, devOutside,  inset,  inset);
         set_inset_fan(fan1AssistPos, vsize, devOutsideAssist,  inset,  inset);
         // inner one of the inner two
         set_inset_fan(fan2Pos, vsize, devInside,  -inset, -inset);
         // innermost
         set_inset_fan(fan3Pos, vsize, devInside,   SK_ScalarHalf,  SK_ScalarHalf);
     }
 
+    // Make verts point to vertex color and then set all the color and coverage vertex attrs values.
     // The outermost rect has 0 coverage
     verts += sizeof(SkPoint);
     for (int i = 0; i < outerVertexNum; ++i) {
-        *reinterpret_cast<GrColor*>(verts + i * vsize) = 0;
+        *reinterpret_cast<GrColor*>(verts + i * vsize) = color;
+        *reinterpret_cast<GrColor*>(verts + i * vsize + sizeof(GrColor)) = 0;
     }
 
+    // scale is the coverage for the the inner two rects.
     int scale;
     if (inset < SK_ScalarHalf) {
         scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf));
         SkASSERT(scale >= 0 && scale <= 255);
     } else {
         scale = 0xff;
     }
 
-    // The inner two rects have full coverage
-    GrColor innerColor;
-    if (useVertexCoverage) {
-        innerColor = GrColorPackRGBA(scale, scale, scale, scale);
-    } else {
-        if (0xff == scale) {
-            innerColor = target->getDrawState().getColor();
-        } else {
-            innerColor = SkAlphaMulQ(target->getDrawState().getColor(), scale);
-        }
-    }
-
     verts += outerVertexNum * vsize;
+    GrColor innerCoverage = GrColorPackRGBA(scale, scale, scale, scale);
     for (int i = 0; i < outerVertexNum + innerVertexNum; ++i) {
-        *reinterpret_cast<GrColor*>(verts + i * vsize) = innerColor;
+        *reinterpret_cast<GrColor*>(verts + i * vsize) = color;
+        *reinterpret_cast<GrColor*>(verts + i * vsize + sizeof(GrColor)) = innerCoverage;
     }
 
     // The innermost rect has 0 coverage
     verts += (outerVertexNum + innerVertexNum) * vsize;
     for (int i = 0; i < innerVertexNum; ++i) {
-        *reinterpret_cast<GrColor*>(verts + i * vsize) = 0;
+        *reinterpret_cast<GrColor*>(verts + i * vsize) = color;
+        *reinterpret_cast<GrColor*>(verts + i * vsize + sizeof(GrColor)) = 0;
     }
 
     target->setIndexSourceToBuffer(indexBuffer);
     target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0,
                         totalVertexNum, aaStrokeRectIndexCount(miterStroke));
 }
 
 void GrAARectRenderer::fillAANestedRects(GrGpu* gpu,
                                          GrDrawTarget* target,
                                          const SkRect rects[2],
-                                         const SkMatrix& combinedMatrix,
-                                         bool useVertexCoverage) {
+                                         const SkMatrix& combinedMatrix) {
     SkASSERT(combinedMatrix.rectStaysRect());
     SkASSERT(!rects[1].isEmpty());
 
     SkRect devOutside, devOutsideAssist, devInside;
     combinedMatrix.mapRect(&devOutside, rects[0]);
     // can't call mapRect for devInside since it calls sort
     combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
-        this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside, useVertexCoverage);
+        this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside);
         return;
     }
 
-    this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist,
-                               devInside, useVertexCoverage, true);
+    this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist, devInside, true);
 }