Use GrOvalOpFactory ops to draw non-AA rrects, ovals, and arcs.

This improves performance.

Bug: skia:
Change-Id: Ie01170ec084be66ea166b2baffcdb415583aa523
Reviewed-on: https://skia-review.googlesource.com/93321
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>

1 files changed, 55 insertions, 20 deletions

diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index b0b117f914..16d8e1bbbd 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -99,6 +99,7 @@ private:
 //////////////////////////////////////////////////////////////////////////////
 
 GrAAType GrChooseAAType(GrAA aa, GrFSAAType fsaaType, GrAllowMixedSamples allowMixedSamples,
+                        GrAllowNonAABinaryCoverage allowNonAABinaryCoverage, const GrPaint* paint,
                         const GrCaps& caps) {
     if (GrAA::kNo == aa) {
         // On some devices we cannot disable MSAA if it is enabled so we make the AA type reflect
@@ -106,6 +107,34 @@ GrAAType GrChooseAAType(GrAA aa, GrFSAAType fsaaType, GrAllowMixedSamples allowM
         if (fsaaType == GrFSAAType::kUnifiedMSAA && !caps.multisampleDisableSupport()) {
             return GrAAType::kMSAA;
         }
+        if (GrAllowNonAABinaryCoverage::kYes == allowNonAABinaryCoverage) {
+            SkASSERT(paint);
+            // If we already have a coverage FP then we won't make anything worse.
+            if (paint->numCoverageFragmentProcessors()) {
+                return GrAAType::kCoverage;
+            }
+            // Shader based blending isn't so expensive with these extensions.
+            if (caps.shaderCaps()->fbFetchSupport() || caps.textureBarrierSupport()) {
+                return GrAAType::kCoverage;
+            }
+            SkBlendMode mode;
+            if (GrXPFactory::AsBlendMode(paint->getXPFactory(), &mode)) {
+                // If we have dual source blending then all Porter-Duff modes can use HW blending
+                // with coverage.
+                if (mode <= SkBlendMode::kLastCoeffMode &&
+                    caps.shaderCaps()->dualSourceBlendingSupport()) {
+                    return GrAAType::kCoverage;
+                }
+                if (SkBlendMode_SupportsCoverageAsAlpha(mode)) {
+                    return GrAAType::kCoverage;
+                }
+                // If the mode is "advanced" then either we will already be doing dst copies or we
+                // have advanced blending support and it is ok to conflate coverage with alpha.
+                if (mode > SkBlendMode::kLastCoeffMode) {
+                    return GrAAType::kCoverage;
+                }
+            }
+        }
         return GrAAType::kNone;
     }
     switch (fsaaType) {
@@ -915,14 +944,16 @@ void GrRenderTargetContext::drawRRect(const GrClip& origClip,
     AutoCheckFlush acf(this->drawingManager());
     const SkStrokeRec stroke = style.strokeRec();
 
-    GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
+    GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo,
+                                         GrAllowNonAABinaryCoverage::kYes, &paint);
     if (GrAAType::kCoverage == aaType) {
         const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-        std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeRRectOp(std::move(paint),
-                                                                    viewMatrix,
-                                                                    rrect,
-                                                                    stroke,
-                                                                    shaderCaps);
+        std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeCoverageRRectOp(std::move(paint),
+                                                                            aa,
+                                                                            viewMatrix,
+                                                                            rrect,
+                                                                            stroke,
+                                                                            shaderCaps);
         if (op) {
             this->addDrawOp(*clip, std::move(op));
             return;
@@ -1186,8 +1217,9 @@ bool GrRenderTargetContext::drawFilledDRRect(const GrClip& clip,
             auto circleBounds = SkRect::MakeLTRB(cx - avgR, cy - avgR, cx + avgR, cy + avgR);
             SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
             stroke.setStrokeStyle(outerR - innerR);
-            auto op = GrOvalOpFactory::MakeOvalOp(std::move(paint), viewMatrix, circleBounds,
-                                                  stroke, this->caps()->shaderCaps());
+            auto op = GrOvalOpFactory::MakeCoverageOvalOp(std::move(paint), aa, viewMatrix,
+                                                          circleBounds, stroke,
+                                                          this->caps()->shaderCaps());
             if (op) {
                 this->addDrawOp(clip, std::move(op));
                 return true;
@@ -1328,11 +1360,12 @@ void GrRenderTargetContext::drawOval(const GrClip& clip,
     AutoCheckFlush acf(this->drawingManager());
     const SkStrokeRec& stroke = style.strokeRec();
 
-    GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
+    GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo,
+                                         GrAllowNonAABinaryCoverage::kYes, &paint);
     if (GrAAType::kCoverage == aaType) {
         const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-        std::unique_ptr<GrDrawOp> op =
-                GrOvalOpFactory::MakeOvalOp(std::move(paint), viewMatrix, oval, stroke, shaderCaps);
+        std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeCoverageOvalOp(
+                std::move(paint), aa, viewMatrix, oval, stroke, shaderCaps);
         if (op) {
             this->addDrawOp(clip, std::move(op));
             return;
@@ -1359,17 +1392,19 @@ void GrRenderTargetContext::drawArc(const GrClip& clip,
 
     AutoCheckFlush acf(this->drawingManager());
 
-    GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
+    GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo,
+                                         GrAllowNonAABinaryCoverage::kYes, &paint);
     if (GrAAType::kCoverage == aaType) {
         const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-        std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeArcOp(std::move(paint),
-                                                                  viewMatrix,
-                                                                  oval,
-                                                                  startAngle,
-                                                                  sweepAngle,
-                                                                  useCenter,
-                                                                  style,
-                                                                  shaderCaps);
+        std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeCoverageArcOp(std::move(paint),
+                                                                          aa,
+                                                                          viewMatrix,
+                                                                          oval,
+                                                                          startAngle,
+                                                                          sweepAngle,
+                                                                          useCenter,
+                                                                          style,
+                                                                          shaderCaps);
         if (op) {
             this->addDrawOp(clip, std::move(op));
             return;