commit fd0c3b513eaceeb6f50ca12dc1e2265c5903af1c
author Robert Phillips <robertphillips@google.com> Fri Nov 01 08:44:42 2019 -0400
committer Skia Commit-Bot <skia-commit-bot@chromium.org> Fri Nov 01 14:09:43 2019 +0000
tree 74ae33d2dccb4939c4581772814d8924f35a2379
parent 2540704a38afa6a182d27601a2b2a5d0dc509101

Update GrTextureOp to use index buffer offsets for draws

This should, hopefully, be faster on GL as we will only need to update the index-range for a draw rather than the offset into an vertex buffer.

Change-Id: I09e54c37262168661443fa8bf8d3b43cd8faa9db
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/251757
Commit-Queue: Robert Phillips <robertphillips@google.com>
Reviewed-by: Michael Ludwig <michaelludwig@google.com>

src/gpu/ops/GrQuadPerEdgeAA.cpp

diff --git a/src/gpu/ops/GrQuadPerEdgeAA.cpp b/src/gpu/ops/GrQuadPerEdgeAA.cpp
index b9b2d65..8bdeeb8 100644
--- a/src/gpu/ops/GrQuadPerEdgeAA.cpp
+++ b/src/gpu/ops/GrQuadPerEdgeAA.cpp
@@ -131,50 +131,58 @@
     return vb.fPtr;
 }
 
-bool ConfigureMeshIndices(GrMeshDrawOp::Target* target, GrMesh* mesh, const VertexSpec& spec,
-                          int quadCount) {
+sk_sp<const GrBuffer> GetIndexBuffer(GrMeshDrawOp::Target* target,
+                                     IndexBufferOption indexBufferOption) {
     auto resourceProvider = target->resourceProvider();
 
-    if (spec.usesCoverageAA()) {
-        SkASSERT(spec.indexBufferOption() == IndexBufferOption::kPictureFramed);
+    switch (indexBufferOption) {
+        case IndexBufferOption::kPictureFramed: return resourceProvider->refAAQuadIndexBuffer();
+        case IndexBufferOption::kIndexedRects:  return resourceProvider->refNonAAQuadIndexBuffer();
+        case IndexBufferOption::kTriStrips:     // fall through
+        default:                                return nullptr;
+    }
+}
 
-        // AA quads use 8 vertices, basically nested rectangles
-        sk_sp<const GrGpuBuffer> ibuffer = resourceProvider->refAAQuadIndexBuffer();
-        if (!ibuffer) {
-            return false;
-        }
 
-        mesh->setPrimitiveType(GrPrimitiveType::kTriangles);
-        mesh->setIndexedPatterned(std::move(ibuffer),
-                                  GrResourceProvider::NumIndicesPerAAQuad(),
-                                  GrResourceProvider::NumVertsPerAAQuad(),
-                                  quadCount,
-                                  GrResourceProvider::MaxNumAAQuads());
-    } else {
-        // Non-AA quads use 4 vertices, and regular triangle strip layout
-        if (quadCount > 1) {
-            SkASSERT(spec.indexBufferOption() == IndexBufferOption::kIndexedRects);
+void ConfigureMesh(GrMesh* mesh, const VertexSpec& spec,
+                   int runningQuadCount, int quadsInDraw, int maxVerts,
+                   sk_sp<const GrBuffer> vertexBuffer,
+                   sk_sp<const GrBuffer> indexBuffer, int absVertBufferOffset) {
+    SkASSERT(vertexBuffer);
 
-            sk_sp<const GrGpuBuffer> ibuffer = resourceProvider->refNonAAQuadIndexBuffer();
-            if (!ibuffer) {
-                return false;
-            }
+    if (spec.indexBufferOption() == IndexBufferOption::kTriStrips) {
+        SkASSERT(!indexBuffer);
 
-            mesh->setPrimitiveType(GrPrimitiveType::kTriangles);
-            mesh->setIndexedPatterned(std::move(ibuffer),
-                                      GrResourceProvider::NumIndicesPerNonAAQuad(),
-                                      GrResourceProvider::NumVertsPerNonAAQuad(),
-                                      quadCount,
-                                      GrResourceProvider::MaxNumNonAAQuads());
-        } else {
-            SkASSERT(spec.indexBufferOption() != IndexBufferOption::kPictureFramed);
-
-            mesh->setPrimitiveType(GrPrimitiveType::kTriangleStrip);
-            mesh->setNonIndexedNonInstanced(4);
-        }
+        mesh->setPrimitiveType(GrPrimitiveType::kTriangleStrip);
+        mesh->setNonIndexedNonInstanced(4);
+        int offset = absVertBufferOffset +
+                                    runningQuadCount * GrResourceProvider::NumVertsPerNonAAQuad();
+        mesh->setVertexData(std::move(vertexBuffer), offset);
+        return;
     }
 
-    return true;
+    SkASSERT(spec.indexBufferOption() == IndexBufferOption::kPictureFramed ||
+             spec.indexBufferOption() == IndexBufferOption::kIndexedRects);
+    SkASSERT(indexBuffer);
+
+    int baseIndex, numIndicesToDraw;
+
+    if (spec.indexBufferOption() == IndexBufferOption::kPictureFramed) {
+        SkASSERT(runningQuadCount + quadsInDraw <= GrResourceProvider::MaxNumAAQuads());
+        // AA uses 8 vertices and 30 indices per quad, basically nested rectangles
+        baseIndex = runningQuadCount * GrResourceProvider::NumIndicesPerAAQuad();
+        numIndicesToDraw = quadsInDraw * GrResourceProvider::NumIndicesPerAAQuad();
+    } else {
+        SkASSERT(runningQuadCount + quadsInDraw <= GrResourceProvider::MaxNumNonAAQuads());
+        // Non-AA uses 4 vertices and 6 indices per quad
+        baseIndex = runningQuadCount * GrResourceProvider::NumIndicesPerNonAAQuad();
+        numIndicesToDraw = quadsInDraw * GrResourceProvider::NumIndicesPerNonAAQuad();
+    }
+
+    mesh->setPrimitiveType(GrPrimitiveType::kTriangles);
+    mesh->setIndexed(std::move(indexBuffer), numIndicesToDraw, baseIndex, 0, maxVerts-1,
+                     GrPrimitiveRestart::kNo);
+    mesh->setVertexData(std::move(vertexBuffer), absVertBufferOffset);
 }
 
 ////////////////// VertexSpec Implementation