Initial CL to move color / coverage off of drawstate

src/gpu/GrContext.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 "GrContext.h"
 
@@ skipping 297 matching lines @@
         // if filtering is not desired then we want to ensure all
         // texels in the resampled image are copies of texels from
         // the original.
         GrTextureParams params(SkShader::kClamp_TileMode,
                                filter ? GrTextureParams::kBilerp_FilterMode :
                                         GrTextureParams::kNone_FilterMode);
         drawState.addColorTextureProcessor(clampedTexture, SkMatrix::I(), params);
 
         uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType |
                          GrDefaultGeoProcFactory::kLocalCoord_GPType;
-        const GrGeometryProcessor* gp = GrDefaultGeoProcFactory::Create(flags);
+        const GrGeometryProcessor* gp = GrDefaultGeoProcFactory::Create(GrColor_WHITE, flags);
         drawState.setGeometryProcessor(gp)->unref();
 
         GrDrawTarget::AutoReleaseGeometry arg(fDrawBuffer, 4, gp->getVertexStride(),  0);
         SkASSERT(gp->getVertexStride() == 2 * sizeof(SkPoint));
 
         if (arg.succeeded()) {
             SkPoint* verts = (SkPoint*) arg.vertices();
             verts[0].setIRectFan(0, 0, texture->width(), texture->height(), 2 * sizeof(SkPoint));
             verts[1].setIRectFan(0, 0, 1, 1, 2 * sizeof(SkPoint));
             fDrawBuffer->drawNonIndexed(&drawState, kTriangleFan_GrPrimitiveType, 0, 4);
@@ skipping 286 matching lines @@
 static inline bool is_irect(const SkRect& r) {
   return SkScalarIsInt(r.fLeft)  && SkScalarIsInt(r.fTop) &&
          SkScalarIsInt(r.fRight) && SkScalarIsInt(r.fBottom);
 }
 
 static bool apply_aa_to_rect(GrDrawTarget* target,
                              GrDrawState* ds,
                              SkRect* devBoundRect,
                              const SkRect& rect,
                              SkScalar strokeWidth,
-                             const SkMatrix& combinedMatrix) {
-    if (!ds->canTweakAlphaForCoverage() && !ds->couldApplyCoverage(*target->caps())) {
+                             const SkMatrix& combinedMatrix,
+                             GrColor color) {
+    if (!ds->canTweakAlphaForCoverage() && !ds->canUseFracCoveragePrimProc(color,
+                                                                           *target->caps())) {
 #ifdef SK_DEBUG
         //SkDebugf("Turning off AA to correctly apply blend.\n");
 #endif
         return false;
     }
 
     if (ds->getRenderTarget()->isMultisampled()) {
         return false;
     }
 
@@ skipping 78 matching lines @@
                 // Will it blend?
                 GrColor clearColor;
                 if (paint.isOpaqueAndConstantColor(&clearColor)) {
                     target->clear(NULL, clearColor, true, fRenderTarget);
                     return;
                 }
             }
         }
     }
 
+    GrColor color = paint.getColor();
     SkRect devBoundRect;
     bool needAA = paint.isAntiAlias() && !drawState.getRenderTarget()->isMultisampled();
-    bool doAA = needAA && apply_aa_to_rect(target, &drawState, &devBoundRect, rect, width, matrix);
+    bool doAA = needAA && apply_aa_to_rect(target, &drawState, &devBoundRect, rect, width, matrix,
+                                           color);
 
     if (doAA) {
         GrDrawState::AutoViewMatrixRestore avmr;
         if (!avmr.setIdentity(&drawState)) {
             return;
         }
 
         if (width >= 0) {
             const SkStrokeRec& strokeRec = strokeInfo->getStrokeRec();
             fAARectRenderer->strokeAARect(target,
                                           &drawState,
+                                          color,
                                           rect,
                                           matrix,
                                           devBoundRect,
                                           strokeRec);
         } else {
             // filled AA rect
-            fAARectRenderer->fillAARect(target, &drawState, rect, matrix, devBoundRect);
+            fAARectRenderer->fillAARect(target, &drawState, color, rect, matrix, devBoundRect);
         }
         return;
     }
 
     if (width >= 0) {
         // TODO: consider making static vertex buffers for these cases.
         // Hairline could be done by just adding closing vertex to
         // unitSquareVertexBuffer()
 
         static const int worstCaseVertCount = 10;
-        const GrGeometryProcessor* gp = GrDefaultGeoProcFactory::Create();
+        const GrGeometryProcessor* gp = GrDefaultGeoProcFactory::Create(color);
         drawState.setGeometryProcessor(gp)->unref();
         GrDrawTarget::AutoReleaseGeometry geo(target,
                                               worstCaseVertCount,
                                               gp->getVertexStride(),
                                               0);
         SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
 
         if (!geo.succeeded()) {
             SkDebugf("Failed to get space for vertices!\n");
             return;
@@ skipping 14 matching lines @@
             vertex[0].set(rect.fLeft, rect.fTop);
             vertex[1].set(rect.fRight, rect.fTop);
             vertex[2].set(rect.fRight, rect.fBottom);
             vertex[3].set(rect.fLeft, rect.fBottom);
             vertex[4].set(rect.fLeft, rect.fTop);
         }
 
         target->drawNonIndexed(&drawState, primType, 0, vertCount);
     } else {
         // filled BW rect
-        target->drawSimpleRect(&drawState, rect);
+        target->drawSimpleRect(&drawState, color, rect);
     }
 }
 
 void GrContext::drawRectToRect(const GrPaint& paint,
                                const SkRect& dstRect,
                                const SkRect& localRect,
                                const SkMatrix* localMatrix) {
     AutoCheckFlush acf(this);
     GrDrawState drawState;
     GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRectToRect", target);
 
-    target->drawRect(&drawState, dstRect, &localRect, localMatrix);
+    target->drawRect(&drawState, paint.getColor(), dstRect, &localRect, localMatrix);
 }
 
 static void set_vertex_attributes(GrDrawState* drawState,
                                   const SkPoint* texCoords,
                                   const GrColor* colors,
                                   int* colorOffset,
-                                  int* texOffset) {
+                                  int* texOffset,
+                                  GrColor color) {
     *texOffset = -1;
     *colorOffset = -1;
 
     uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType;
     if (texCoords && colors) {
         *colorOffset = sizeof(SkPoint);
         *texOffset = sizeof(SkPoint) + sizeof(GrColor);
         flags |= GrDefaultGeoProcFactory::kColor_GPType |
                  GrDefaultGeoProcFactory::kLocalCoord_GPType;
     } else if (texCoords) {
         *texOffset = sizeof(SkPoint);
         flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType;
     } else if (colors) {
         *colorOffset = sizeof(SkPoint);
         flags |= GrDefaultGeoProcFactory::kColor_GPType;
     }
-    drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(flags))->unref();
+    drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(color, flags))->unref();
 }
 
 void GrContext::drawVertices(const GrPaint& paint,
                              GrPrimitiveType primitiveType,
                              int vertexCount,
                              const SkPoint positions[],
                              const SkPoint texCoords[],
                              const GrColor colors[],
                              const uint16_t indices[],
                              int indexCount) {
     AutoCheckFlush acf(this);
     GrDrawState drawState;
     GrDrawTarget::AutoReleaseGeometry geo; // must be inside AutoCheckFlush scope
 
     GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawVertices", target);
 
     int colorOffset = -1, texOffset = -1;
-    set_vertex_attributes(&drawState, texCoords, colors, &colorOffset, &texOffset);
+    set_vertex_attributes(&drawState, texCoords, colors, &colorOffset, &texOffset,
+                          paint.getColor());
 
     size_t vertexStride = drawState.getGeometryProcessor()->getVertexStride();
     SkASSERT(vertexStride == sizeof(SkPoint) + (SkToBool(texCoords) ? sizeof(SkPoint) : 0)
                                              + (SkToBool(colors) ? sizeof(GrColor) : 0));
     if (!geo.set(target, vertexCount, vertexStride, indexCount)) {
         SkDebugf("Failed to get space for vertices!\n");
         return;
     }
     void* curVertex = geo.vertices();
 
@@ skipping 42 matching lines @@
     GrDrawState drawState;
     GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRRect", target);
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
-    if (!fOvalRenderer->drawRRect(target, &drawState, this, paint.isAntiAlias(), rrect,
+    GrColor color = paint.getColor();
+    if (!fOvalRenderer->drawRRect(target, &drawState, color, this, paint.isAntiAlias(), rrect,
                                   strokeRec)) {
         SkPath path;
         path.addRRect(rrect);
-        this->internalDrawPath(target, &drawState, paint.isAntiAlias(), path, strokeInfo);
+        this->internalDrawPath(target, &drawState, color, paint.isAntiAlias(), path, strokeInfo);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawDRRect(const GrPaint& paint,
                            const SkRRect& outer,
                            const SkRRect& inner) {
     if (outer.isEmpty()) {
        return;
     }
 
     AutoCheckFlush acf(this);
     GrDrawState drawState;
     GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
 
     GR_CREATE_TRACE_MARKER("GrContext::drawDRRect", target);
 
-    if (!fOvalRenderer->drawDRRect(target, &drawState, this, paint.isAntiAlias(), outer, inner)) {
+    GrColor color = paint.getColor();
+    if (!fOvalRenderer->drawDRRect(target, &drawState, color, this, paint.isAntiAlias(), outer,
+                                   inner)) {
         SkPath path;
         path.addRRect(inner);
         path.addRRect(outer);
         path.setFillType(SkPath::kEvenOdd_FillType);
 
         GrStrokeInfo fillRec(SkStrokeRec::kFill_InitStyle);
-        this->internalDrawPath(target, &drawState, paint.isAntiAlias(), path, fillRec);
+        this->internalDrawPath(target, &drawState, color, paint.isAntiAlias(), path, fillRec);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawOval(const GrPaint& paint,
                          const SkRect& oval,
                          const GrStrokeInfo& strokeInfo) {
     if (oval.isEmpty()) {
        return;
@@ skipping 10 matching lines @@
     GrDrawState drawState;
     GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawOval", target);
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
-
-    if (!fOvalRenderer->drawOval(target, &drawState, this, paint.isAntiAlias(), oval, strokeRec)) {
+    GrColor color = paint.getColor();
+    if (!fOvalRenderer->drawOval(target, &drawState, color, this, paint.isAntiAlias(), oval,
+                                 strokeRec)) {
         SkPath path;
         path.addOval(oval);
-        this->internalDrawPath(target, &drawState, paint.isAntiAlias(), path, strokeInfo);
+        this->internalDrawPath(target, &drawState, color, paint.isAntiAlias(), path, strokeInfo);
     }
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
 static bool is_nested_rects(GrDrawTarget* target,
                             GrDrawState* drawState,
+                            GrColor color,
                             const SkPath& path,
                             const SkStrokeRec& stroke,
                             SkRect rects[2]) {
     SkASSERT(stroke.isFillStyle());
 
     if (path.isInverseFillType()) {
         return false;
     }
 
     // TODO: this restriction could be lifted if we were willing to apply
     // the matrix to all the points individually rather than just to the rect
     if (!drawState->getViewMatrix().preservesAxisAlignment()) {
         return false;
     }
 
-    if (!drawState->canTweakAlphaForCoverage() && !drawState->couldApplyCoverage(*target->caps())) {
+    if (!drawState->canTweakAlphaForCoverage() &&
+        !drawState->canUseFracCoveragePrimProc(color, *target->caps())) {
         return false;
     }
 
     SkPath::Direction dirs[2];
     if (!path.isNestedRects(rects, dirs)) {
         return false;
     }
 
     if (SkPath::kWinding_FillType == path.getFillType() && dirs[0] == dirs[1]) {
         // The two rects need to be wound opposite to each other
@@ skipping 25 matching lines @@
 
 void GrContext::drawPath(const GrPaint& paint, const SkPath& path, const GrStrokeInfo& strokeInfo) {
 
     if (path.isEmpty()) {
        if (path.isInverseFillType()) {
            this->drawPaint(paint);
        }
        return;
     }
 
+    GrColor color = paint.getColor();
     if (strokeInfo.isDashed()) {
         SkPoint pts[2];
         if (path.isLine(pts)) {
             AutoCheckFlush acf(this);
             GrDrawState drawState;
             GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
             if (NULL == target) {
                 return;
             };
 
             SkMatrix origViewMatrix = drawState.getViewMatrix();
             GrDrawState::AutoViewMatrixRestore avmr;
             if (avmr.setIdentity(&drawState)) {
-                if (GrDashingEffect::DrawDashLine(fGpu, target, &drawState, pts, paint,
+                if (GrDashingEffect::DrawDashLine(fGpu, target, &drawState, color, pts, paint,
                                                   strokeInfo, origViewMatrix)) {
                     return;
                 }
             }
         }
 
         // Filter dashed path into new path with the dashing applied
         const SkPathEffect::DashInfo& info = strokeInfo.getDashInfo();
         SkTLazy<SkPath> effectPath;
         GrStrokeInfo newStrokeInfo(strokeInfo, false);
@@ skipping 22 matching lines @@
     GR_CREATE_TRACE_MARKER1("GrContext::drawPath", target, "Is Convex", path.isConvex());
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
     bool useCoverageAA = paint.isAntiAlias() && !drawState.getRenderTarget()->isMultisampled();
 
     if (useCoverageAA && strokeRec.getWidth() < 0 && !path.isConvex()) {
         // Concave AA paths are expensive - try to avoid them for special cases
         SkRect rects[2];
 
-        if (is_nested_rects(target, &drawState, path, strokeRec, rects)) {
+        if (is_nested_rects(target, &drawState, color, path, strokeRec, rects)) {
             SkMatrix origViewMatrix = drawState.getViewMatrix();
             GrDrawState::AutoViewMatrixRestore avmr;
             if (!avmr.setIdentity(&drawState)) {
                 return;
             }
 
-            fAARectRenderer->fillAANestedRects(target, &drawState, rects, origViewMatrix);
+            fAARectRenderer->fillAANestedRects(target, &drawState, color, rects, origViewMatrix);
             return;
         }
     }
 
     SkRect ovalRect;
     bool isOval = path.isOval(&ovalRect);
 
     if (!isOval || path.isInverseFillType()
-        || !fOvalRenderer->drawOval(target, &drawState, this, paint.isAntiAlias(), ovalRect,
+        || !fOvalRenderer->drawOval(target, &drawState, color, this, paint.isAntiAlias(), ovalRect,
                                     strokeRec)) {
-        this->internalDrawPath(target, &drawState, paint.isAntiAlias(), path, strokeInfo);
+        this->internalDrawPath(target, &drawState, color, paint.isAntiAlias(), path, strokeInfo);
     }
 }
 
 void GrContext::internalDrawPath(GrDrawTarget* target,
                                  GrDrawState* drawState,
+                                 GrColor color,
                                  bool useAA,
                                  const SkPath& path,
                                  const GrStrokeInfo& strokeInfo) {
     SkASSERT(!path.isEmpty());
 
     GR_CREATE_TRACE_MARKER("GrContext::internalDrawPath", target);
 
 
     // An Assumption here is that path renderer would use some form of tweaking
     // the src color (either the input alpha or in the frag shader) to implement
     // aa. If we have some future driver-mojo path AA that can do the right
     // thing WRT to the blend then we'll need some query on the PR.
     bool useCoverageAA = useAA &&
         !drawState->getRenderTarget()->isMultisampled() &&
-        drawState->couldApplyCoverage(*target->caps());
+        drawState->canUseFracCoveragePrimProc(color, *target->caps());
 
 
     GrPathRendererChain::DrawType type =
         useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType :
                         GrPathRendererChain::kColor_DrawType;
 
     const SkPath* pathPtr = &path;
     SkTLazy<SkPath> tmpPath;
     SkTCopyOnFirstWrite<SkStrokeRec> stroke(strokeInfo.getStrokeRec());
 
@@ skipping 16 matching lines @@
         pr = this->getPathRenderer(target, drawState, *pathPtr, *stroke, true, type);
     }
 
     if (NULL == pr) {
 #ifdef SK_DEBUG
         SkDebugf("Unable to find path renderer compatible with path.\n");
 #endif
         return;
     }
 
-    pr->drawPath(target, drawState, *pathPtr, *stroke, useCoverageAA);
+    pr->drawPath(target, drawState, color, *pathPtr, *stroke, useCoverageAA);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::flush(int flagsBitfield) {
     if (NULL == fDrawBuffer) {
         return;
     }
 
     if (kDiscard_FlushBit & flagsBitfield) {
@@ skipping 120 matching lines @@
     // SW-rasterized clip while issuing a draw). So we push the current geometry state before
     // drawing a rect to the render target.
     // The bracket ensures we pop the stack if we wind up flushing below.
     {
         GrDrawTarget* drawTarget = this->prepareToDraw(NULL, NULL, NULL);
         GrDrawTarget::AutoGeometryPush agp(drawTarget);
 
         GrDrawState drawState(matrix);
         drawState.addColorProcessor(fp);
         drawState.setRenderTarget(renderTarget);
-        drawTarget->drawSimpleRect(&drawState, SkRect::MakeWH(SkIntToScalar(width),
-                                                              SkIntToScalar(height)));
+        drawTarget->drawSimpleRect(&drawState, GrColor_WHITE,SkRect::MakeWH(SkIntToScalar(width),
+                                                                            SkIntToScalar(height)));
     }
 
     if (kFlushWrites_PixelOp & pixelOpsFlags) {
         this->flushSurfaceWrites(surface);
     }
 
     return true;
 }
 
 // toggles between RGBA and BGRA
@@ skipping 100 matching lines @@
                 // clear to the caller that a draw operation (i.e., drawSimpleRect)
                 // can be invoked in this method
                 {
                     GrDrawTarget::AutoGeometryPush agp(fDrawBuffer);
                     GrDrawState drawState;
                     SkASSERT(fp);
                     drawState.addColorProcessor(fp);
 
                     drawState.setRenderTarget(tempTexture->asRenderTarget());
                     SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
-                    fDrawBuffer->drawSimpleRect(&drawState, rect);
+                    fDrawBuffer->drawSimpleRect(&drawState, GrColor_WHITE, rect);
                     // we want to read back from the scratch's origin
                     left = 0;
                     top = 0;
                     target = tempTexture->asRenderTarget();
                 }
                 this->flushSurfaceWrites(target);
             }
         }
     }
 
@@ skipping 80 matching lines @@
     if (NULL == fGpu) {
         return NULL;
     }
 
     ASSERT_OWNED_RESOURCE(fRenderTarget.get());
     if (ds) {
         if (paint) {
             SkASSERT(acf);
             ds->setFromPaint(*paint, fViewMatrix, fRenderTarget.get());
 #if GR_DEBUG_PARTIAL_COVERAGE_CHECK
-            if ((paint->hasMask() || 0xff != paint->fCoverage) &&
-                !fDrawState->couldApplyCoverage(fGpu->caps())) {
+            if ((paint->hasMask()) &&
+                !fDrawState->canUseFracCoveragePrimProc(paint.getColor(), fGpu->caps())) {
                 SkDebugf("Partial pixel coverage will be incorrectly blended.\n");
             }
 #endif
         } else {
             ds->reset(fViewMatrix);
             ds->setRenderTarget(fRenderTarget.get());
         }
         ds->setState(GrDrawState::kClip_StateBit, fClip && !fClip->fClipStack->isWideOpen());
     }
     fDrawBuffer->setClip(fClip);
@@ skipping 154 matching lines @@
     fResourceCache2->printStats();
 }
 #endif
 
 #if GR_GPU_STATS
 const GrContext::GPUStats* GrContext::gpuStats() const {
     return fGpu->gpuStats();
 }
 #endif