Update how we send draws to gpu backend to reduce state setting.

src/gpu/vk/GrVkGpu.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 "GrVkGpu.h"
 
 #include "GrContextOptions.h"
@@ skipping 663 matching lines @@
                                VK_ACCESS_HOST_WRITE_BIT,
                                VK_ACCESS_INDEX_READ_BIT,
                                VK_PIPELINE_STAGE_HOST_BIT,
                                VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
                                false);
 
         fCurrentCmdBuffer->bindIndexBuffer(this, ibuf);
     }
 }
 
-void GrVkGpu::buildProgramDesc(GrProgramDesc* desc,
-                               const GrPrimitiveProcessor& primProc,
-                               const GrPipeline& pipeline) const {
-    if (!GrVkProgramDescBuilder::Build(desc, primProc, pipeline, *this->vkCaps().glslCaps())) {
-        SkDEBUGFAIL("Failed to generate GL program descriptor");
-    }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 
 GrStencilAttachment* GrVkGpu::createStencilAttachmentForRenderTarget(const GrRenderTarget* rt,
                                                                      int width,
                                                                      int height) {
     SkASSERT(rt->asTexture());
     SkASSERT(width >= rt->width());
     SkASSERT(height >= rt->height());
 
     int samples = rt->numStencilSamples();
@@ skipping 614 matching lines @@
             memcpy(top, bottom, tightRowBytes);
             memcpy(bottom, tmpRow, tightRowBytes);
             top += rowBytes;
             bottom -= rowBytes;
         }
     }
 
     return true;
 }
 
-void GrVkGpu::onDraw(const DrawArgs& args, const GrNonInstancedVertices& vertices) {
-    GrRenderTarget* rt = args.fPipeline->getRenderTarget();
+void GrVkGpu::onDraw(const GrPipeline& pipeline,
+                     const GrPrimitiveProcessor& primProc,
+                     GrPrimitiveType primitiveType,
+                     const GrVertices* vertArray,
+                     int drawCount) {
+    GrRenderTarget* rt = pipeline.getRenderTarget();
     GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(rt);
     const GrVkRenderPass* renderPass = vkRT->simpleRenderPass();
     SkASSERT(renderPass);
 
-    GrVkProgram* program = GrVkProgramBuilder::CreateProgram(this, args,
-                                                             vertices.primitiveType(),
+
+    // Get GrGLProgramDesc

[bsalomon, 2016/03/16 20:07:22]

?

[egdaniel, 2016/03/17 15:09:36]

Done.

+    GrVkProgramDesc desc;
+    if (!GrVkProgramDescBuilder::Build(&desc, primProc, pipeline, *this->vkCaps().glslCaps())) {
+        GrCapsDebugf(this->caps(), "Failed to vk program descriptor!\n");
+        return;
+    }
+    GrVkProgram* program = GrVkProgramBuilder::CreateProgram(this,
+                                                             pipeline,
+                                                             primProc,
+                                                             primitiveType,
+                                                             desc,
                                                              *renderPass);
 
     if (!program) {
         return;
     }
 
-    program->setData(this, *args.fPrimitiveProcessor, *args.fPipeline);
-
-    fCurrentCmdBuffer->beginRenderPass(this, renderPass, *vkRT);
+    program->setData(this, primProc, pipeline);
 
     program->bind(this, fCurrentCmdBuffer);
 
-    this->bindGeometry(*args.fPrimitiveProcessor, vertices);
-
     // Change layout of our render target so it can be used as the color attachment
     VkImageLayout layout = vkRT->currentLayout();
     // Our color attachment is purely a destination and won't be read so don't need to flush or
     // invalidate any caches
     VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(layout);
     VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
     VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(layout);
     VkAccessFlags dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
     vkRT->setImageLayout(this,
                          VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                          srcAccessMask,
                          dstAccessMask,
                          srcStageMask,
                          dstStageMask,
                          false);
 
     // If we are using a stencil attachment we also need to update its layout
-    if (!args.fPipeline->getStencil().isDisabled()) {
+    if (!pipeline.getStencil().isDisabled()) {
         GrStencilAttachment* stencil = vkRT->renderTargetPriv().getStencilAttachment();
         GrVkStencilAttachment* vkStencil = (GrVkStencilAttachment*)stencil;
         VkImageLayout origDstLayout = vkStencil->currentLayout();
         VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
         VkAccessFlags dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
-                                      VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
         VkPipelineStageFlags srcStageMask =
             GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
         VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
         vkStencil->setImageLayout(this,
                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
                                   srcAccessMask,
                                   dstAccessMask,
                                   srcStageMask,
                                   dstStageMask,
                                   false);
     }
 
-    if (vertices.isIndexed()) {
-        fCurrentCmdBuffer->drawIndexed(this,
-                                       vertices.indexCount(),
-                                       1,
-                                       vertices.startIndex(),
-                                       vertices.startVertex(),
-                                       0);
-    } else {
-        fCurrentCmdBuffer->draw(this, vertices.vertexCount(), 1, vertices.startVertex(),  0);
+    fCurrentCmdBuffer->beginRenderPass(this, renderPass, *vkRT);
+
+    for (int i = 0; i < drawCount; ++i) {
+        if (GrXferBarrierType barrierType = pipeline.xferBarrierType(*this->caps())) {
+            this->xferBarrier(pipeline.getRenderTarget(), barrierType);
+        }
+
+        const GrVertices& vertices = vertArray[i];
+        GrVertices::Iterator iter;
+        const GrNonInstancedVertices* verts = iter.init(vertices);
+        do {
+
+            this->bindGeometry(primProc, *verts);
+
+            if (vertices.isIndexed()) {
+                fCurrentCmdBuffer->drawIndexed(this,
+                                               verts->indexCount(),
+                                               1,
+                                               verts->startIndex(),
+                                               verts->startVertex(),
+                                               0);
+            } else {
+                fCurrentCmdBuffer->draw(this, verts->vertexCount(), 1, verts->startVertex(), 0);
+            }
+
+            fStats.incNumDraws();
+        } while ((verts = iter.next()));
     }
 
     fCurrentCmdBuffer->endRenderPass(this);
 
     // Technically we don't have to call this here (since there is a safety check in program:setData
     // but this will allow for quicker freeing of resources if the program sits in a cache for a
     // while.
     program->freeTempResources(this);
     // This free will go away once we setup a program cache, and then the cache will be responsible
     // for call freeGpuResources.
     program->freeGPUResources(this);
     program->unref();
 
 #if SWAP_PER_DRAW
     glFlush();
 #if defined(SK_BUILD_FOR_MAC)
     aglSwapBuffers(aglGetCurrentContext());
     int set_a_break_pt_here = 9;
     aglSwapBuffers(aglGetCurrentContext());
 #elif defined(SK_BUILD_FOR_WIN32)
     SwapBuf();
     int set_a_break_pt_here = 9;
     SwapBuf();
 #endif
 #endif
 }