Batch multiple single NVPR draw paths to instanced draws

src/gpu/batches/GrDrawPathBatch.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 "GrDrawPathBatch.h"
 
 static void pre_translate_transform_values(const float* xforms,
                                            GrPathRendering::PathTransformType type, int count,
                                            SkScalar x, SkScalar y, float* dst);
 
 SkString GrDrawPathBatch::dumpInfo() const {
     SkString string;
-    string.printf("PATH: 0x%p", fPath.get());
+    string.printf("Color: 0x%08x Fill: %x Path count: %d Paths: ", this->color(), this->fillType(),
+                  fTotalPathCount);
+    const GrDrawPathBatch* batch = this;
+    do {
+        string.appendf("0x%p", batch->fPath.get());
+        batch = batch->fNext.get();
+    } while (batch);
+    string.append("\n");
     return string;
 }
 
+bool GrDrawPathBatch::ListBoundsIntersects(const GrDrawPathBatch* a, const GrDrawPathBatch* b) {
+    if (!SkRect::Intersects(a->fBounds, b->fBounds)) {
+        return false;
+    }
+    if (!a->fNext && !b->fNext) {
+        return true;
+    }
+    const GrDrawPathBatch* firstA = a;
+    do {
+        do {
+            if (SkRect::Intersects(a->fPathBounds, b->fPathBounds)) {
+                return true;
+            }
+            a = a->fNext.get();
+        } while (a);
+        a = firstA;
+        b = b->fNext.get();
+    } while (b);
+    return false;
+}
+
+bool GrDrawPathBatch::onCombineIfPossible(GrBatch* t, const GrCaps& caps) {
+    GrDrawPathBatch* that = t->cast<GrDrawPathBatch>();
+    if (this->color() != that->color() ||
+        !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
+        return false;
+    }
+    if (!GrPipeline::AreEqual(*this->pipeline(), *that->pipeline(), false)) {
+        return false;
+    }
+    if (that->fillType() != this->fillType() ||
+        this->stencilSettings() != that->stencilSettings()) {
+        return false;
+    }
+    if (ListBoundsIntersects(this, that)) {
+        return false;
+    }
+    if (!fPath.get()->canCombineDrawPathBatchWith(*that->fPath.get())) {
+        return false;
+    }
+    SkASSERT(!*fLastSlot);
+    fLastSlot->reset(SkRef(that));
+    fLastSlot = that->fLastSlot;
+    fTotalPathCount += that->fTotalPathCount;
+    this->joinBounds(that->fBounds);
+    return true;
+}
+
 void GrDrawPathBatch::onDraw(GrBatchFlushState* state) {
-    GrProgramDesc  desc;
-
     SkAutoTUnref<GrPathProcessor> pathProc(GrPathProcessor::Create(this->color(),
                                                                    this->overrides(),
                                                                    this->viewMatrix()));
-    state->gpu()->pathRendering()->drawPath(*this->pipeline(), *pathProc, this->stencilSettings(),
-                                            fPath.get());
+    if (fTotalPathCount > 1) {
+        SkAutoSTMalloc<32, const GrPath*> paths(fTotalPathCount);
+        GrDrawPathBatch* batch = this;
+        int i = 0;
+        do {
+            paths[i++] = batch->fPath.get();
+            batch = batch->fNext.get();
+        } while (batch);
+        state->gpu()->pathRendering()->drawPaths(*this->pipeline(), *pathProc,
+                                                 this->stencilSettings(), paths, fTotalPathCount);
+    } else {
+        const GrPath* path = fPath.get();
+        state->gpu()->pathRendering()->drawPaths(*this->pipeline(), *pathProc,
+                                                 this->stencilSettings(), &path, 1);
+    }
 }
 
 SkString GrDrawPathRangeBatch::dumpInfo() const {
     SkString string;
     string.printf("RANGE: 0x%p COUNTS: [", fPathRange.get());
     for (DrawList::Iter iter(fDraws); iter.get(); iter.next()) {
         string.appendf("%d, ", iter.get()->fInstanceData->count());
     }
     string.remove(string.size() - 2, 2);
     string.append("]");
@@ skipping 164 matching lines @@
                 dst[i + 3] = xforms[i + 3];
                 dst[i + 4] = xforms[i + 4];
                 dst[i + 5] = xforms[i + 3] * x + xforms[i + 4] * y + xforms[i + 5];
             }
             break;
         default:
             SkFAIL("Unknown transform type.");
             break;
     }
 }