Args structs to GrPathRenderer functions

src/gpu/GrAADistanceFieldPathRenderer.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAADistanceFieldPathRenderer.h"
 
@@ skipping 44 matching lines @@
             dfpr->fPathList.remove(pathData);
             SkDELETE(pathData);
 #ifdef DF_PATH_TRACKING
             ++g_NumFreedPaths;
 #endif
         }
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-GrAADistanceFieldPathRenderer::GrAADistanceFieldPathRenderer(GrContext* context)
-    : fContext(context)
-    , fAtlas(NULL) {
-}
+GrAADistanceFieldPathRenderer::GrAADistanceFieldPathRenderer() : fAtlas(NULL) {}
 
 GrAADistanceFieldPathRenderer::~GrAADistanceFieldPathRenderer() {
     PathDataList::Iter iter;
     iter.init(fPathList, PathDataList::Iter::kHead_IterStart);
     PathData* pathData;
     while ((pathData = iter.get())) {
         iter.next();
         fPathList.remove(pathData);
         SkDELETE(pathData);
     }
     SkDELETE(fAtlas);
 
 #ifdef DF_PATH_TRACKING
     SkDebugf("Cached paths: %d, freed paths: %d\n", g_NumCachedPaths, g_NumFreedPaths);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool GrAADistanceFieldPathRenderer::canDrawPath(const GrDrawTarget* target,
-                                                const GrPipelineBuilder* pipelineBuilder,
-                                                const SkMatrix& viewMatrix,
-                                                const SkPath& path,
-                                                const GrStrokeInfo& stroke,
-                                                bool antiAlias) const {
+bool GrAADistanceFieldPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     
     // TODO: Support inverse fill
     // TODO: Support strokes
-    if (!target->caps()->shaderCaps()->shaderDerivativeSupport() || !antiAlias 
-        || path.isInverseFillType() || path.isVolatile() || !stroke.isFillStyle()) {
+    if (!args.fTarget->caps()->shaderCaps()->shaderDerivativeSupport() || !args.fAntiAlias ||
+        args.fPath->isInverseFillType() || args.fPath->isVolatile() ||
+        !args.fStroke->isFillStyle()) {
         return false;
     }
 
     // currently don't support perspective
-    if (viewMatrix.hasPerspective()) {
+    if (args.fViewMatrix->hasPerspective()) {
         return false;
     }
     
     // only support paths smaller than 64x64, scaled to less than 256x256
     // the goal is to accelerate rendering of lots of small paths that may be scaling
-    SkScalar maxScale = viewMatrix.getMaxScale();
-    const SkRect& bounds = path.getBounds();
+    SkScalar maxScale = args.fViewMatrix->getMaxScale();
+    const SkRect& bounds = args.fPath->getBounds();
     SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
     return maxDim < 64.f && maxDim * maxScale < 256.f;
 }
 
-
 GrPathRenderer::StencilSupport
 GrAADistanceFieldPathRenderer::onGetStencilSupport(const GrDrawTarget*,
                                                    const GrPipelineBuilder*,
                                                    const SkPath&,
                                                    const GrStrokeInfo&) const {
     return GrPathRenderer::kNoSupport_StencilSupport;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 405 matching lines @@
         bool fCoverageIgnored;
     };
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
     GrBatchAtlas* fAtlas;
     PathCache* fPathCache;
     PathDataList* fPathList;
 };
 
-static GrBatchAtlas* create_atlas(GrContext* context, GrBatchAtlas::EvictionFunc func, void* data) {
+static GrBatchAtlas* create_atlas(GrTextureProvider* provider, GrBatchAtlas::EvictionFunc func, void* data) {
     GrBatchAtlas* atlas;
     // Create a new atlas
     GrSurfaceDesc desc;
     desc.fFlags = kNone_GrSurfaceFlags;
     desc.fWidth = ATLAS_TEXTURE_WIDTH;
     desc.fHeight = ATLAS_TEXTURE_HEIGHT;
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
     // We don't want to flush the context so we claim we're in the middle of flushing so as to
     // guarantee we do not recieve a texture with pending IO
-    GrTexture* texture = context->textureProvider()->refScratchTexture(
+    GrTexture* texture = provider->refScratchTexture(
         desc, GrTextureProvider::kApprox_ScratchTexMatch, true);
     if (texture) {
         atlas = SkNEW_ARGS(GrBatchAtlas, (texture, NUM_PLOTS_X, NUM_PLOTS_Y));
     } else {
         return NULL;
     }
     atlas->registerEvictionCallback(func, data);
     return atlas;
 }
 
-bool GrAADistanceFieldPathRenderer::onDrawPath(GrDrawTarget* target,
-                                               GrPipelineBuilder* pipelineBuilder,
-                                               GrColor color,
-                                               const SkMatrix& viewMatrix,
-                                               const SkPath& path,
-                                               const GrStrokeInfo& stroke,
-                                               bool antiAlias) {
+bool GrAADistanceFieldPathRenderer::onDrawPath(const DrawPathArgs& args) {
     // we've already bailed on inverse filled paths, so this is safe
-    if (path.isEmpty()) {
+    if (args.fPath->isEmpty()) {
         return true;
     }
 
-    SkASSERT(fContext);
-
     if (!fAtlas) {
-        fAtlas = create_atlas(fContext, &GrAADistanceFieldPathRenderer::HandleEviction,
-                              (void*)this);
+        fAtlas = create_atlas(args.fResourceProvider,
+                              &GrAADistanceFieldPathRenderer::HandleEviction, (void*)this);
         if (!fAtlas) {
             return false;
         }
     }
 
-    AADistanceFieldPathBatch::Geometry geometry(stroke);
-    geometry.fPath = path;
-    geometry.fAntiAlias = antiAlias;
+    AADistanceFieldPathBatch::Geometry geometry(*args.fStroke);
+    geometry.fPath = *args.fPath;
+    geometry.fAntiAlias = args.fAntiAlias;
 
-    SkAutoTUnref<GrBatch> batch(AADistanceFieldPathBatch::Create(geometry, color, viewMatrix,
-                                                                 fAtlas, &fPathCache, &fPathList));
-    target->drawBatch(*pipelineBuilder, batch);
+    SkAutoTUnref<GrBatch> batch(AADistanceFieldPathBatch::Create(geometry, args.fColor,
+                                                                 *args.fViewMatrix, fAtlas,
+                                                                 &fPathCache, &fPathList));
+    args.fTarget->drawBatch(*args.fPipelineBuilder, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 struct PathTestStruct {
     typedef GrAADistanceFieldPathRenderer::PathCache PathCache;
@@ skipping 36 matching lines @@
     PathCache fPathCache;
     PathDataList fPathList;
 };
 
 BATCH_TEST_DEFINE(AADistanceFieldPathBatch) {
     static PathTestStruct gTestStruct;
 
     if (context->uniqueID() != gTestStruct.fContextID) {
         gTestStruct.fContextID = context->uniqueID();
         gTestStruct.reset();
-        gTestStruct.fAtlas = create_atlas(context, &PathTestStruct::HandleEviction,
-                                          (void*)&gTestStruct);
+        gTestStruct.fAtlas = create_atlas(context->resourceProvider(),
+                                          &PathTestStruct::HandleEviction, (void*)&gTestStruct);
     }
 
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
 
     AADistanceFieldPathBatch::Geometry geometry(GrTest::TestStrokeRec(random));
     geometry.fPath = GrTest::TestPath(random);
     geometry.fAntiAlias = random->nextBool();
 
     return AADistanceFieldPathBatch::Create(geometry, color, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList);
 }
 
 #endif