Implement caching in the tessellating path renderer, including strokes.

src/gpu/GrDrawContext.cpp

 
 /*
  * Copyright 2015 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 "GrAtlasTextContext.h"
@@ skipping 1040 matching lines @@
     }
 
     return allEq || allGoE1;
 }
 
 void GrDrawContext::drawPath(GrRenderTarget* rt,
                              const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkPath& path,
-                             const GrStrokeInfo& strokeInfo) {
+                             const GrStrokeInfo& strokeInfo,
+                             const SkPath* origSrcPath,
+                             const GrStrokeInfo* origStrokeInfo) {
     RETURN_IF_ABANDONED
     if (path.isEmpty()) {
        if (path.isInverseFillType()) {
            this->drawPaint(rt, clip, paint, viewMatrix);
        }
        return;
     }
 
     GrColor color = paint.getColor();
 
@@ skipping 31 matching lines @@
                                          color,
                                          viewMatrix,
                                          paint.isAntiAlias(),
                                          ovalRect,
                                          strokeInfo)) {
                 return;
             }
         }
     }
     this->internalDrawPath(fDrawTarget, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
-                           path, strokeInfo);
+                           path, strokeInfo, origSrcPath, origStrokeInfo);
 }
 
 void GrDrawContext::internalDrawPath(GrDrawTarget* target,
                                      GrPipelineBuilder* pipelineBuilder,
                                      const SkMatrix& viewMatrix,
                                      GrColor color,
                                      bool useAA,
                                      const SkPath& path,
-                                     const GrStrokeInfo& strokeInfo) {
+                                     const GrStrokeInfo& strokeInfo,
+                                     const SkPath* origSrcPath,
+                                     const GrStrokeInfo* origStrokeInfo) {
     RETURN_IF_ABANDONED
     SkASSERT(!path.isEmpty());
 
 
     // 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 &&
         !pipelineBuilder->getRenderTarget()->isUnifiedMultisampled();
@@ skipping 59 matching lines @@
 
     GrPathRenderer::DrawPathArgs args;
     args.fTarget = target;
     args.fResourceProvider = fContext->resourceProvider();
     args.fPipelineBuilder = pipelineBuilder;
     args.fColor = color;
     args.fViewMatrix = &viewMatrix;
     args.fPath = pathPtr;
     args.fStroke = strokeInfoPtr;
     args.fAntiAlias = useCoverageAA;
+    args.fOrigSrcPath = origSrcPath;
+    args.fOrigStrokeInfo = origStrokeInfo;
     pr->drawPath(args);
 }
 
 bool GrDrawContext::prepareToDraw(GrRenderTarget* rt) {
     RETURN_FALSE_IF_ABANDONED
 
     ASSERT_OWNED_RESOURCE(rt);
     SkASSERT(rt);
     return true;
 }
@@ skipping 122 matching lines @@
     return DrawVerticesBatch::Create(geometry, type, viewMatrix,
                                      positions.begin(), vertexCount,
                                      indices.begin(), hasIndices ? vertexCount : 0,
                                      colors.begin(),
                                      texCoords.begin(),
                                      bounds);
 }
 
 #endif