Implement vertex buffer caching in the tessellated path renderer.

src/gpu/GrTessellatingPathRenderer.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 "GrTessellatingPathRenderer.h"
 
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
 #include "GrBatchTest.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrPathUtils.h"
 #include "GrVertices.h"
+#include "GrResourceCache.h"
+#include "GrResourceProvider.h"
 #include "SkChunkAlloc.h"
 #include "SkGeometry.h"
 
 #include <stdio.h>
 
 /*
  * This path renderer tessellates the path into triangles, uploads the triangles to a
  * vertex buffer, and renders them with a single draw call. It does not currently do
  * antialiasing, so it must be used in conjunction with multisampling.
  *
@@ skipping 505 matching lines @@
     const SkPoint s = { SkScalarAve(r[0].fX, r[1].fX), SkScalarAve(r[0].fY, r[1].fY) };
     pointsLeft >>= 1;
     prev = generate_cubic_points(p0, q[0], r[0], s, tolSqd, prev, head, pointsLeft, alloc);
     prev = generate_cubic_points(s, r[1], q[2], p3, tolSqd, prev, head, pointsLeft, alloc);
     return prev;
 }
 
 // Stage 1: convert the input path to a set of linear contours (linked list of Vertices).
 
 void path_to_contours(const SkPath& path, SkScalar tolerance, const SkRect& clipBounds,
-                      Vertex** contours, SkChunkAlloc& alloc) {
+                      Vertex** contours, SkChunkAlloc& alloc, bool *isLinear) {
 
     SkScalar toleranceSqd = tolerance * tolerance;
 
     SkPoint pts[4];
     bool done = false;
+    *isLinear = true;
     SkPath::Iter iter(path, false);
     Vertex* prev = NULL;
     Vertex* head = NULL;
     if (path.isInverseFillType()) {
         SkPoint quad[4];
         clipBounds.toQuad(quad);
         for (int i = 3; i >= 0; i--) {
             prev = append_point_to_contour(quad[i], prev, &head, alloc);
         }
         head->fPrev = prev;
         prev->fNext = head;
         *contours++ = head;
         head = prev = NULL;
     }
     SkAutoConicToQuads converter;
     while (!done) {
         SkPath::Verb verb = iter.next(pts);
         switch (verb) {
             case SkPath::kConic_Verb: {
                 SkScalar weight = iter.conicWeight();
                 const SkPoint* quadPts = converter.computeQuads(pts, weight, toleranceSqd);
                 for (int i = 0; i < converter.countQuads(); ++i) {
                     int pointsLeft = GrPathUtils::quadraticPointCount(quadPts, tolerance);
                     prev = generate_quadratic_points(quadPts[0], quadPts[1], quadPts[2],
                                                      toleranceSqd, prev, &head, pointsLeft, alloc);
                     quadPts += 2;
                 }
+                *isLinear = false;
                 break;
             }
             case SkPath::kMove_Verb:
                 if (head) {
                     head->fPrev = prev;
                     prev->fNext = head;
                     *contours++ = head;
                 }
                 head = prev = NULL;
                 prev = append_point_to_contour(pts[0], prev, &head, alloc);
                 break;
             case SkPath::kLine_Verb: {
                 prev = append_point_to_contour(pts[1], prev, &head, alloc);
                 break;
             }
             case SkPath::kQuad_Verb: {
                 int pointsLeft = GrPathUtils::quadraticPointCount(pts, tolerance);
                 prev = generate_quadratic_points(pts[0], pts[1], pts[2], toleranceSqd, prev,
                                                  &head, pointsLeft, alloc);
+                *isLinear = false;
                 break;
             }
             case SkPath::kCubic_Verb: {
                 int pointsLeft = GrPathUtils::cubicPointCount(pts, tolerance);
                 prev = generate_cubic_points(pts[0], pts[1], pts[2], pts[3],
                                 toleranceSqd, prev, &head, pointsLeft, alloc);
+                *isLinear = false;
                 break;
             }
             case SkPath::kClose_Verb:
                 if (head) {
                     head->fPrev = prev;
                     prev->fNext = head;
                     *contours++ = head;
                 }
                 head = prev = NULL;
                 break;
@@ skipping 713 matching lines @@
 SkPoint* polys_to_triangles(Poly* polys, SkPath::FillType fillType, SkPoint* data) {
     SkPoint* d = data;
     for (Poly* poly = polys; poly; poly = poly->fNext) {
         if (apply_fill_type(fillType, poly->fWinding)) {
             d = poly->emit(d);
         }
     }
     return d;
 }
 
+bool cacheMatch(GrVertexBuffer* vertexBuffer, const SkMatrix& newMatrix) {
+    if (!vertexBuffer) {
+        return false;
+    }
+    const SkData* data = vertexBuffer->getCustomData();
+    if (!data || !data->data()) { // path is linear; matches any scale
+        return true;
+    }
+    const SkSize* cachedScale = static_cast<const SkSize*>(data->data());

[bsalomon, 2015/07/28 14:55:48]

Rather than use the data on the VB, can we canonicalize the tessellation levels
and include the scales in the key?

The rules around data on cached objects are a bit nebulous and I'd just as soon
remove the data if we can.

[Stephen White, 2015/07/28 15:10:28]

I could do that, but then a single path with an animated scale will quickly fill
up the cache with lots of copies of the same path at different scales. This way,
we only have a single cached copy of a given path, with I think is a better use
of cache resources.

[bsalomon, 2015/07/28 21:23:30]

That makes sense. I wonder if there is an efficient way of accomplishing the
same goal without stashing it in the SkData. Otherwise, I'd like to see if we
can alter the cache to excise the data when a content resource is recycled as a
scratch resource.

[Stephen White, 2015/07/28 22:11:23]

I've done the latter (I think..)

+    SkASSERT(cachedScale);
+    SkSize newScale;
+    if (!newMatrix.decomposeScale(&newScale)) {
+        return false;
+    }
+    if (newScale.width() > 0.01f * cachedScale->width() && newScale.width() < 3.0f * cachedScale->width()
+     && newScale.height() > 0.01f * cachedScale->height() && newScale.height() < 3.0f * cachedScale->height()) {
+        return true;
+    }
+    return false;
+}
+
 };
 
-GrTessellatingPathRenderer::GrTessellatingPathRenderer() {
+GrTessellatingPathRenderer::GrTessellatingPathRenderer(GrContext* context) : fContext(context) {
 }
 
 GrPathRenderer::StencilSupport GrTessellatingPathRenderer::onGetStencilSupport(
                                                             const GrDrawTarget*,
                                                             const GrPipelineBuilder*,
                                                             const SkPath&,
                                                             const GrStrokeInfo&) const {
     return GrPathRenderer::kNoSupport_StencilSupport;
 }
 
+namespace {
+
+// When the SkPathRef genID changes, invalidate a corresponding GrResource described by key.
+class PathInvalidator : public SkPathRef::GenIDChangeListener {
+public:
+    explicit PathInvalidator(const GrUniqueKey& key) : fMsg(key) {}
+private:
+    GrUniqueKeyInvalidatedMessage fMsg;
+
+    void onChange() override {
+        SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(fMsg);
+    }
+};
+
+}  // namespace
+
+
 bool GrTessellatingPathRenderer::canDrawPath(const GrDrawTarget* target,
                                              const GrPipelineBuilder* pipelineBuilder,
                                              const SkMatrix& viewMatrix,
                                              const SkPath& path,
                                              const GrStrokeInfo& stroke,
                                              bool antiAlias) const {
     // This path renderer can draw all fill styles, but does not do antialiasing. It can do convex
     // and concave paths, but we'll leave the convex ones to simpler algorithms.
     return stroke.isFillStyle() && !antiAlias && !path.isConvex();
 }
 
 class TessellatingPathBatch : public GrBatch {
 public:
 
     static GrBatch* Create(const GrColor& color,
                            const SkPath& path,
                            const SkMatrix& viewMatrix,
-                           SkRect clipBounds) {
-        return SkNEW_ARGS(TessellatingPathBatch, (color, path, viewMatrix, clipBounds));
+                           SkRect clipBounds,
+                           GrContext* context) {
+        return SkNEW_ARGS(TessellatingPathBatch, (color, path, viewMatrix, clipBounds, context));
     }
 
     const char* name() const override { return "TessellatingPathBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         out->setKnownFourComponents(fColor);
     }
 
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
         out->setUnknownSingleComponent();
     }
 
     void initBatchTracker(const GrPipelineInfo& init) override {
         // Handle any color overrides
         if (!init.readsColor()) {
             fColor = GrColor_ILLEGAL;
         }
         init.getOverrideColorIfSet(&fColor);
         fPipelineInfo = init;
     }
 
-    void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
+    int tessellate(const GrUniqueKey& key, SkAutoTUnref<GrVertexBuffer>& vertexBuffer) {
         SkRect pathBounds = fPath.getBounds();
         Comparator c;
         if (pathBounds.width() > pathBounds.height()) {
             c.sweep_lt = sweep_lt_horiz;
             c.sweep_gt = sweep_gt_horiz;
         } else {
             c.sweep_lt = sweep_lt_vert;
             c.sweep_gt = sweep_gt_vert;
         }
         SkScalar screenSpaceTol = GrPathUtils::kDefaultTolerance;
         SkScalar tol = GrPathUtils::scaleToleranceToSrc(screenSpaceTol, fViewMatrix, pathBounds);
         int contourCnt;
         int maxPts = GrPathUtils::worstCasePointCount(fPath, &contourCnt, tol);
         if (maxPts <= 0) {
-            return;
+            return 0;
         }
         if (maxPts > ((int)SK_MaxU16 + 1)) {
             SkDebugf("Path not rendered, too many verts (%d)\n", maxPts);
-            return;
+            return 0;
         }
         SkPath::FillType fillType = fPath.getFillType();
         if (SkPath::IsInverseFillType(fillType)) {
             contourCnt++;
         }
 
         LOG("got %d pts, %d contours\n", maxPts, contourCnt);
-        uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType;
-        SkAutoTUnref<const GrGeometryProcessor> gp(
-            GrDefaultGeoProcFactory::Create(flags, fColor, fPipelineInfo.readsLocalCoords(),
-                                            !fPipelineInfo.readsCoverage(), fViewMatrix,
-                                            SkMatrix::I()));
-        batchTarget->initDraw(gp, pipeline);
-
         SkAutoTDeleteArray<Vertex*> contours(SkNEW_ARRAY(Vertex *, contourCnt));
 
         // For the initial size of the chunk allocator, estimate based on the point count:
         // one vertex per point for the initial passes, plus two for the vertices in the
         // resulting Polys, since the same point may end up in two Polys.  Assume minimal
         // connectivity of one Edge per Vertex (will grow for intersections).
         SkChunkAlloc alloc(maxPts * (3 * sizeof(Vertex) + sizeof(Edge)));
-        path_to_contours(fPath, tol, fClipBounds, contours.get(), alloc);
+        bool isLinear;
+        path_to_contours(fPath, tol, fClipBounds, contours.get(), alloc, &isLinear);
         Poly* polys;
         polys = contours_to_polys(contours.get(), contourCnt, c, alloc);
         int count = 0;
         for (Poly* poly = polys; poly; poly = poly->fNext) {
             if (apply_fill_type(fillType, poly->fWinding) && poly->fCount >= 3) {
                 count += (poly->fCount - 2) * (WIREFRAME ? 6 : 3);
             }
         }
         if (0 == count) {
-            return;
+            return 0;
         }
 
-        size_t stride = gp->getVertexStride();
-        SkASSERT(stride == sizeof(SkPoint));
-        const GrVertexBuffer* vertexBuffer;
-        int firstVertex;
-        SkPoint* verts = static_cast<SkPoint*>(
-            batchTarget->makeVertSpace(stride, count, &vertexBuffer, &firstVertex));
-        if (!verts) {
+        vertexBuffer.reset(fContext->getGpu()->createVertexBuffer(count * sizeof(SkPoint), false));
+        if (!vertexBuffer.get()) {
             SkDebugf("Could not allocate vertices\n");
-            return;
+            return 0;
         }
-
+        SkPoint* verts = static_cast<SkPoint*>(vertexBuffer->map());
         LOG("emitting %d verts\n", count);
         SkPoint* end = polys_to_triangles(polys, fillType, verts);
+        vertexBuffer->unmap();
         int actualCount = static_cast<int>(end - verts);
         LOG("actual count: %d\n", actualCount);
         SkASSERT(actualCount <= count);
 
+        if (!fPath.isVolatile()) {
+            SkSize scale;
+            if (!isLinear && fViewMatrix.decomposeScale(&scale)) {
+                vertexBuffer->setCustomData(SkData::NewWithCopy(&scale, sizeof(scale)));
+            }
+            fContext->resourceProvider()->assignUniqueKeyToResource(key, vertexBuffer.get());
+            fPath.pathRef()->addGenIDChangeListener(SkNEW(PathInvalidator(key)));
+        }
+        return actualCount;
+    }
+
+    void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
+        // construct a cache key from the path's genID and the view matrix
+        static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
+        GrUniqueKey key;
+        GrUniqueKey::Builder builder(&key, kDomain, 1);
+        builder[0] = fPath.getGenerationID();
+        builder.finish();
+        SkAutoTUnref<GrVertexBuffer> vertexBuffer(fContext->resourceProvider()->findAndRefTByUniqueKey<GrVertexBuffer>(key));
+        int actualCount;
+        if (cacheMatch(vertexBuffer.get(), fViewMatrix)) {
+            actualCount = vertexBuffer->gpuMemorySize() / sizeof(SkPoint);
+        } else {
+            actualCount = tessellate(key, vertexBuffer);
+        }
+
+        if (actualCount == 0) {
+            return;
+        }
+
+        uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType;
+        SkAutoTUnref<const GrGeometryProcessor> gp(
+            GrDefaultGeoProcFactory::Create(flags, fColor, fPipelineInfo.readsLocalCoords(),
+                                            !fPipelineInfo.readsCoverage(), fViewMatrix,
+                                            SkMatrix::I()));
+        batchTarget->initDraw(gp, pipeline);
+        SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
+
         GrPrimitiveType primitiveType = WIREFRAME ? kLines_GrPrimitiveType
                                                   : kTriangles_GrPrimitiveType;
         GrVertices vertices;
-        vertices.init(primitiveType, vertexBuffer, firstVertex, actualCount);
+        vertices.init(primitiveType, vertexBuffer.get(), 0, actualCount);
         batchTarget->draw(vertices);
-
-        batchTarget->putBackVertices((size_t)(count - actualCount), stride);
-        return;
     }
 
     bool onCombineIfPossible(GrBatch*) override {
         return false;
     }
 
 private:
     TessellatingPathBatch(const GrColor& color,
                           const SkPath& path,
                           const SkMatrix& viewMatrix,
-                          const SkRect& clipBounds)
+                          const SkRect& clipBounds,
+                          GrContext* context)
       : fColor(color)
       , fPath(path)
       , fViewMatrix(viewMatrix)
-      , fClipBounds(clipBounds) {
+      , fClipBounds(clipBounds)
+      , fContext(context) {
         this->initClassID<TessellatingPathBatch>();
 
         fBounds = path.getBounds();
         viewMatrix.mapRect(&fBounds);
     }
 
     GrColor        fColor;
     SkPath         fPath;
     SkMatrix       fViewMatrix;
     SkRect         fClipBounds; // in source space
+    GrContext*     fContext;
     GrPipelineInfo fPipelineInfo;
 };
 
 bool GrTessellatingPathRenderer::onDrawPath(GrDrawTarget* target,
                                             GrPipelineBuilder* pipelineBuilder,
                                             GrColor color,
                                             const SkMatrix& viewM,
                                             const SkPath& path,
                                             const GrStrokeInfo&,
                                             bool antiAlias) {
     SkASSERT(!antiAlias);
     const GrRenderTarget* rt = pipelineBuilder->getRenderTarget();
     if (NULL == rt) {
         return false;
     }
 
     SkIRect clipBoundsI;
     pipelineBuilder->clip().getConservativeBounds(rt, &clipBoundsI);
     SkRect clipBounds = SkRect::Make(clipBoundsI);
     SkMatrix vmi;
     if (!viewM.invert(&vmi)) {
         return false;
     }
     vmi.mapRect(&clipBounds);
-    SkAutoTUnref<GrBatch> batch(TessellatingPathBatch::Create(color, path, viewM, clipBounds));
+    SkAutoTUnref<GrBatch> batch(TessellatingPathBatch::Create(color, path, viewM, clipBounds, fContext));
     target->drawBatch(*pipelineBuilder, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 BATCH_TEST_DEFINE(TesselatingPathBatch) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkPath path = GrTest::TestPath(random);
     SkRect clipBounds = GrTest::TestRect(random);
     SkMatrix vmi;
     bool result = viewMatrix.invert(&vmi);
     if (!result) {
         SkFAIL("Cannot invert matrix\n");
     }
     vmi.mapRect(&clipBounds);
-    return TessellatingPathBatch::Create(color, path, viewMatrix, clipBounds);
+    return TessellatingPathBatch::Create(color, path, viewMatrix, clipBounds, context);
 }
 
 #endif